hardhat 3.8.0 → 3.9.1

package/src/internal/builtin-plugins/hhu/tasks/convert/pad.ts

@@ -0,0 +1,61 @@
+import type { NewUtilsTaskActionFunction } from "../../types.js";
+
+import { HardhatError } from "@nomicfoundation/hardhat-errors";
+import {
+  getUnprefixedHexString,
+  isHexString,
+} from "@nomicfoundation/hardhat-utils/hex";
+
+interface PadActionArguments {
+  value: string;
+  length: number;
+  left: boolean;
+  right: boolean;
+}
+
+const padAction: NewUtilsTaskActionFunction<PadActionArguments> = async ({
+  value,
+  length,
+  left,
+  right,
+}) => {
+  if (left && right) {
+    throw new HardhatError(
+      HardhatError.ERRORS.CORE.ARGUMENTS.MUTUALLY_EXCLUSIVE_OPTIONS,
+      { optionA: "left", optionB: "right" },
+    );
+  }
+
+  if (length < 0) {
+    throw new HardhatError(HardhatError.ERRORS.CORE.ARGUMENTS.INVALID_VALUE, {
+      value: length,
+      name: "length",
+      reason: "it must be a non-negative integer",
+    });
+  }
+
+  if (!isHexString(value)) {
+    throw new HardhatError(
+      HardhatError.ERRORS.CORE.GENERAL.INVALID_HEX_STRING,
+      { value },
+    );
+  }
+
+  const unprefixedHexString = getUnprefixedHexString(value);
+
+  if (unprefixedHexString.length > length * 2) {
+    throw new HardhatError(HardhatError.ERRORS.CORE.ARGUMENTS.INVALID_VALUE, {
+      value,
+      name: "value",
+      reason: `it's longer than the target length of ${length} bytes`,
+    });
+  }
+
+  const paddedHexString = right
+    ? unprefixedHexString.padEnd(length * 2, "0")
+    : unprefixedHexString.padStart(length * 2, "0");
+
+  console.log(`0x${paddedHexString}`);
+};
+
+export default padAction;

package/src/internal/builtin-plugins/hhu/tasks/fetch/block-number.ts

@@ -0,0 +1,28 @@
+import type { NewUtilsTaskActionFunction } from "../../types.js";
+
+import { assertHardhatInvariant } from "@nomicfoundation/hardhat-errors";
+import { hexStringToBigInt } from "@nomicfoundation/hardhat-utils/hex";
+
+const fetchBlockNumberAction: NewUtilsTaskActionFunction = async (
+  _taskArguments,
+  hre,
+) => {
+  const connection = await hre.network.create();
+
+  try {
+    const blockNumber = await connection.provider.request({
+      method: "eth_blockNumber",
+    });
+
+    assertHardhatInvariant(
+      typeof blockNumber === "string",
+      "eth_blockNumber should return a string",
+    );
+
+    console.log(hexStringToBigInt(blockNumber).toString());
+  } finally {
+    await connection.close();
+  }
+};
+
+export default fetchBlockNumberAction;

package/src/internal/builtin-plugins/hhu/tasks/fetch/index.ts

@@ -0,0 +1,18 @@
+import type { UtilsTaskDefinition } from "../../types.js";
+
+import { emptyTask, task } from "../../../../core/config.js";
+import { buildUtilsTask } from "../utils-task.js";
+
+export function fetch(prefix: string[]): UtilsTaskDefinition[] {
+  const fetchTask = emptyTask(
+    [...prefix, "fetch"],
+    "Fetch on-chain data",
+  ).build();
+
+  const blockNumberTask = buildUtilsTask(
+    task([...prefix, "fetch", "block-number"], "Print the latest block number"),
+    async () => await import("./block-number.js"),
+  );
+
+  return [fetchTask, blockNumberTask];
+}

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

@@ -0,0 +1,36 @@
+import type { UtilsTaskDefinition } from "../types.js";
+
+import { emptyTask } from "../../../core/config.js";
+
+import { constants } from "./constants/index.js";
+import { convert } from "./convert/index.js";
+import { fetch } from "./fetch/index.js";
+
+export interface GenerateTasksOptions {
+  /**
+   * Whether to nest every task under a top-level `utils` task. Used by the
+   * Hardhat CLI (`hardhat utils constants ...`) but not by the standalone hhu
+   * binary (`hhu constants ...`).
+   */
+  prefixWithUtils: boolean;
+}
+
+/**
+ * The category builders that contribute the utils tasks. Each one receives the
+ * id prefix to nest its tasks under and returns its task definitions. Adding a
+ * new category is a single entry here.
+ */
+const CATEGORIES = [constants, convert, fetch];
+
+export function generateTasks(
+  options: GenerateTasksOptions,
+): UtilsTaskDefinition[] {
+  const prefix = options.prefixWithUtils ? ["utils"] : [];
+
+  return [
+    ...(prefix.length > 0
+      ? [emptyTask(prefix, "Utilities for common Ethereum tasks").build()]
+      : []),
+    ...CATEGORIES.flatMap((category) => category(prefix)),
+  ];
+}

package/src/internal/builtin-plugins/hhu/tasks/utils-task.ts

@@ -0,0 +1,29 @@
+import type {
+  LazyActionObject,
+  NewTaskDefinitionBuilder,
+  TaskArguments,
+} from "../../../../types/tasks.js";
+import type {
+  NewUtilsTaskActionFunction,
+  NewUtilsTaskDefinition,
+} from "../types.js";
+
+/**
+ * Builds a utils task from a configured task builder and a lazily-loaded action.
+ *
+ * The standard builder's `setAction`/`build` are hardcoded to
+ * `NewTaskActionFunction`, so it can't produce a `NewUtilsTaskDefinition` on its
+ * own. This helper requires the action to be a `NewUtilsTaskActionFunction`
+ * (rejecting wider actions at the call site), which is what makes re-narrowing
+ * the built definition sound.
+ */
+export function buildUtilsTask<TaskArgumentsT extends TaskArguments>(
+  builder: NewTaskDefinitionBuilder<TaskArgumentsT>,
+  action: LazyActionObject<NewUtilsTaskActionFunction<TaskArgumentsT>>,
+): NewUtilsTaskDefinition {
+  // The narrower action is assignable to the builder's `NewTaskActionFunction`,
+  // and since `action` is statically a `NewUtilsTaskActionFunction`, re-narrowing
+  // the result is safe.
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- see above
+  return builder.setAction(action).build() as NewUtilsTaskDefinition;
+}

package/src/internal/builtin-plugins/hhu/types.ts

@@ -0,0 +1,57 @@
+import type { HardhatRuntimeEnvironment } from "../../../types/hre.js";
+import type { NetworkManager } from "../../../types/network.js";
+import type {
+  BaseTaskDefinition,
+  EmptyTaskDefinition,
+  LazyActionObject,
+  TaskArguments,
+} from "../../../types/tasks.js";
+
+/**
+ * The subset of the HRE that utils tasks are allowed to use.
+ *
+ * It is narrowed to what the hhu binary can provide without always creating
+ * a real HRE.
+ */
+export interface UtilsHardhatRuntimeEnvironment {
+  network: Pick<NetworkManager, "create">;
+}
+
+/**
+ * The fake HRE that the hhu binary builds so it can parse and run utils without
+ * creating a real one. It's the surface utils actions use
+ * ({@link UtilsHardhatRuntimeEnvironment}) plus the `config` that
+ * `TaskManagerImplementation` needs to build the task map.
+ */
+export interface FakeHhuHardhatRuntimeEnvironment
+  extends UtilsHardhatRuntimeEnvironment {
+  config: Pick<HardhatRuntimeEnvironment["config"], "tasks" | "plugins">;
+}
+
+/**
+ * The type of a utils task's action function.
+ *
+ * It mirrors `NewTaskActionFunction`, but the HRE passed as the second argument
+ * is narrowed to `UtilsHardhatRuntimeEnvironment` so that utils tasks only
+ * depend on the small surface that both the Hardhat CLI and the hhu binary can
+ * provide.
+ */
+export type NewUtilsTaskActionFunction<
+  TaskArgumentsT extends TaskArguments = TaskArguments,
+> = (taskArguments: TaskArgumentsT, hre: UtilsHardhatRuntimeEnvironment) => any;
+
+/**
+ * The definition of a utils task.
+ *
+ * It mirrors `NewTaskDefinition`, but narrows that action to a
+ * `NewUtilsTaskActionFunction`.
+ */
+export type NewUtilsTaskDefinition = BaseTaskDefinition & {
+  action: LazyActionObject<NewUtilsTaskActionFunction>;
+};
+
+/**
+ * The subset of `TaskDefinition` that utils tasks produce: either an empty task
+ * (a namespace placeholder) or a utils task. Override tasks are not supported.
+ */
+export type UtilsTaskDefinition = EmptyTaskDefinition | NewUtilsTaskDefinition;

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/edr/genesis-state.ts

@@ -12,6 +12,7 @@ import {
   opHardforkFromString,
   type AccountOverride,
 } from "@nomicfoundation/edr";
+import { bytesToHexString } from "@nomicfoundation/hardhat-utils/hex";
 import { AsyncMutex } from "@nomicfoundation/hardhat-utils/synchronization";
 import { hexToBytes } from "ethereum-cryptography/utils";
 
@@ -50,7 +51,7 @@ const genesisStateAndAccountsCache: WeakMap<
       Map<
         string,
         {
-          genesisState: Map<Uint8Array, AccountOverride>;
+          genesisState: Map<string, AccountOverride>;
           ownedAccounts: Array<{ secretKey: string; balance: bigint }>;
         }
       >
@@ -66,7 +67,7 @@ export async function getGenesisStateAndOwnedAccounts(
   chainType: ChainType,
   specId: string,
 ): Promise<{
-  genesisState: Map<Uint8Array, AccountOverride>;
+  genesisState: Map<string, AccountOverride>;
   ownedAccounts: Array<{ secretKey: string; balance: bigint }>;
 }> {
   const cached = genesisStateAndAccountsCache
@@ -131,7 +132,7 @@ async function createGenesisStateAndOwnedAccounts(
   chainType: ChainType,
   specId: string,
 ): Promise<{
-  genesisState: Map<Uint8Array, AccountOverride>;
+  genesisState: Map<string, AccountOverride>;
   ownedAccounts: Array<{ secretKey: string; balance: bigint }>;
 }> {
   if (microEthSignerAddress === undefined) {
@@ -142,7 +143,7 @@ async function createGenesisStateAndOwnedAccounts(
 
   const ownedAccounts = await hardhatAccountsToEdrOwnedAccounts(accountsConfig);
 
-  const genesisState: Map<Uint8Array, AccountOverride> = new Map(
+  const genesisState: Map<string, AccountOverride> = new Map(
     ownedAccounts.map(({ secretKey, balance }) => {
       const address = hexToBytes(addr.fromPrivateKey(secretKey));
       const accountOverride: AccountOverride = {
@@ -151,7 +152,7 @@ async function createGenesisStateAndOwnedAccounts(
         code: new Uint8Array(), // Empty account code, removing potential delegation code when forking
       };
 
-      return [address, accountOverride];
+      return [bytesToHexString(address), accountOverride];
     }),
   );
 
@@ -162,18 +163,25 @@ async function createGenesisStateAndOwnedAccounts(
         ? opGenesisState(opHardforkFromString(specId))
         : l1GenesisState(l1HardforkFromString(specId));
 
+  mergeGenesisState(genesisState, chainGenesisState);
+
+  return { genesisState, ownedAccounts };
+}
+
+export function mergeGenesisState(
+  genesisState: Map<string, AccountOverride>,
+  chainGenesisState: readonly AccountOverride[],
+): void {
   for (const account of chainGenesisState) {
-    const existingOverride = genesisState.get(account.address);
+    const addressKey = bytesToHexString(account.address);
+    const existingOverride = genesisState.get(addressKey);
     if (existingOverride !== undefined) {
       // Favor the genesis state specified by the user
-      account.balance = account.balance ?? existingOverride.balance;
-      account.nonce = account.nonce ?? existingOverride.nonce;
-      account.code = account.code ?? existingOverride.code;
-      account.storage = account.storage ?? existingOverride.storage;
-    } else {
-      genesisState.set(account.address, account);
+      account.balance = existingOverride.balance ?? account.balance;
+      account.nonce = existingOverride.nonce ?? account.nonce;
+      account.code = existingOverride.code ?? account.code;
+      account.storage = existingOverride.storage ?? account.storage;
     }
+    genesisState.set(addressKey, account);
   }
-
-  return { genesisState, ownedAccounts };
 }

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/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/network-manager/type-validation.ts

@@ -322,7 +322,20 @@ const edrNetworkUserConfigSchema = z.object({
   hardfork: z.optional(z.string()),
   initialBaseFeePerGas: z.optional(gasUnitUserConfigSchema),
   initialDate: z.optional(
-    unionType([z.string(), z.instanceof(Date)], "Expected a string or a Date"),
+    unionType(
+      [z.string(), z.instanceof(Date)],
+      "Expected a string or a Date",
+    ).refine(
+      (val) => {
+        if (typeof val === "string") return !Number.isNaN(Date.parse(val));
+        if (val instanceof Date) return !Number.isNaN(val.getTime());
+        // already union of string/Date, all types are exhausted
+        return true;
+      },
+      {
+        message: "initialDate must be a parseable date string or a valid Date",
+      },
+    ),
   ),
   loggingEnabled: z.optional(z.boolean()),
   minGasPrice: z.optional(gasUnitUserConfigSchema),

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

@@ -8,6 +8,7 @@ export const SPDX_WARNING = "SPDX license identifier not provided";
 export const PRAGMA_WARNING =
   "Source file does not specify required compiler version";
 const CONTRACT_SIZE_WARNING = "Contract code size is";
+const INIT_CODE_SIZE_WARNING = "Contract initcode size is";
 
 // Suppression rules are grouped by scope. Each array has its own match logic
 // in `shouldSuppressWarning` function; add new entries to the array that fits, or add
@@ -32,6 +33,7 @@ const TEST_FILE_WARNING_MESSAGES: readonly string[] = [
   SPDX_WARNING,
   PRAGMA_WARNING,
   CONTRACT_SIZE_WARNING,
+  INIT_CODE_SIZE_WARNING,
 ];
 
 // Warnings suppressed only when running with `--coverage`. An entry with no
@@ -44,6 +46,7 @@ const COVERAGE_MODE_RULES: ReadonlyArray<{
   filePath?: string;
 }> = [
   { message: CONTRACT_SIZE_WARNING },
+  { message: INIT_CODE_SIZE_WARNING },
   {
     message: NATSPEC_MEMORY_SAFE_ASSEMBLY_WARNING,
     filePath: COVERAGE_LIBRARY_FILE_NAME,

package/src/internal/builtin-plugins/solidity/source-names.ts

@@ -0,0 +1,19 @@
+import { HARDHAT_PROJECT_INPUT_SOURCE_NAME_ROOT } from "./constants.js";
+
+const PROJECT_INPUT_SOURCE_NAME_PREFIX = `${HARDHAT_PROJECT_INPUT_SOURCE_NAME_ROOT}/`;
+
+/**
+ * Recovers the user-facing source name from a solc input source name by
+ * stripping the Hardhat project prefix.
+ *
+ * Project files have an input source name like `project/contracts/Foo.sol`,
+ * whereas the user writes paths — and config globs — against the
+ * project-relative `contracts/Foo.sol`. npm package input source names
+ * (`npm/<pkg>@<version>/...`) don't carry the project prefix and are returned
+ * unchanged.
+ */
+export function toUserSourceName(inputSourceName: string): string {
+  return inputSourceName.startsWith(PROJECT_INPUT_SOURCE_NAME_PREFIX)
+    ? inputSourceName.slice(PROJECT_INPUT_SOURCE_NAME_PREFIX.length)
+    : inputSourceName;
+}

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

@@ -55,10 +55,7 @@ const solidityTestProfileUserConfigType = z.object({
   prevRandao: z.bigint().optional(),
   gasLimit: z.bigint().optional(),
   blockGasLimit: z.number().or(z.bigint()).or(z.literal(false)).optional(),
-  // TODO: widen back to .number().or(z.bigint()).or(z.literal(false))
-  // once Solidity test runner no longer breaks setUp() when
-  // disableTransactionGasCap is false. See PR #8301.
-  transactionGasCap: z.literal(false).optional(),
+  transactionGasCap: z.number().or(z.bigint()).or(z.literal(false)).optional(),
   fuzz: z
     .object({
       failurePersistDir: z.string().optional(),

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

@@ -7,25 +7,20 @@ import {
   bytesToUtf8String,
 } from "@nomicfoundation/hardhat-utils/bytes";
 
-import { HARDHAT_PROJECT_INPUT_SOURCE_NAME_ROOT } from "../../solidity/constants.js";
+import { isPathSelected } from "../../../utils/glob.js";
+import { toUserSourceName } from "../../solidity/source-names.js";
 
 import {
   buildUserDefinedValueTypeIndex,
   extractStructsFromAst,
 } from "./ast-walker.js";
 import { canonicalizeStructs } from "./canonicalize.js";
-import { isPathSelected } from "./glob.js";
 
 export interface Eip712TypesConfig {
   include: string[];
   exclude: string[];
 }
 
-// When a transitive project file doesn't produce an artifact — and so is
-// missing from `inputToUserSource` — stripping this prefix recovers the
-// user-facing path that the user's include/exclude globs are written against.
-const PROJECT_INPUT_SOURCE_NAME_PREFIX = `${HARDHAT_PROJECT_INPUT_SOURCE_NAME_ROOT}/`;
-
 /**
  * Walks every compiled source's AST, extracts every struct definition, and
  * returns the flat list of canonical EIP-712 type strings expected by EDR's
@@ -89,15 +84,12 @@ export function collectEip712CanonicalTypes(
     );
 
     for (const [inputSourceName, source] of Object.entries(sources)) {
-      let userSourceName = inputToUserSource.get(inputSourceName);
-
-      if (userSourceName === undefined) {
-        userSourceName = inputSourceName.startsWith(
-          PROJECT_INPUT_SOURCE_NAME_PREFIX,
-        )
-          ? inputSourceName.slice(PROJECT_INPUT_SOURCE_NAME_PREFIX.length)
-          : inputSourceName;
-      }
+      // A transitive project file that doesn't produce an artifact is missing
+      // from `inputToUserSource`; recovering the user source name from the
+      // input source name covers that case.
+      const userSourceName =
+        inputToUserSource.get(inputSourceName) ??
+        toUserSourceName(inputSourceName);
 
       // Collect every source so non-selected files can serve as dep targets;
       // selection is enforced at emit time via `selectedNames`.

package/src/internal/builtin-plugins/solidity-test/stack-trace-solidity-errors.ts

@@ -6,6 +6,7 @@ import {
   StackTraceEntryType,
   CheatcodeErrorCode,
 } from "../network-manager/edr/stack-traces/solidity-stack-trace.js";
+import { getCheatcodeSuggestion } from "../network-manager/edr/stack-traces/stack-trace-solidity-errors.js";
 
 export function getMessageFromLastStackTraceEntry(
   stackTraceEntry: SolidityStackTraceEntry,
@@ -71,7 +72,11 @@ export function getMessageFromLastStackTraceEntry(
       if (stackTraceEntry.details !== undefined) {
         switch (stackTraceEntry.details.code) {
           case CheatcodeErrorCode.UnsupportedCheatcode:
-            return `Cheatcode '${stackTraceEntry.details.cheatcode}' is not supported by Hardhat.`;
+            const suggestion = getCheatcodeSuggestion(
+              stackTraceEntry.details.cheatcode,
+            );
+
+            return `Cheatcode '${stackTraceEntry.details.cheatcode}' is not supported by Hardhat.${suggestion.length > 0 ? " " + suggestion : ""}`;
           case CheatcodeErrorCode.MissingCheatcode:
             return `Cheatcode '${stackTraceEntry.details.cheatcode}' is not yet available in this version of Hardhat.`;
         }