hardhat 3.2.0 → 3.4.0

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

@@ -1,26 +1,4 @@
-import type {
-  LogTrace,
-  ArtifactId,
-  CallTrace,
-  DecodedTraceParameters,
-} from "@nomicfoundation/edr";
-
-import { LogKind, CallKind } from "@nomicfoundation/edr";
-import { assertHardhatInvariant } from "@nomicfoundation/hardhat-errors";
-import { bytesToHexString } from "@nomicfoundation/hardhat-utils/hex";
-import chalk from "chalk";
-
-export interface Colorizer {
-  blue: (text: string) => string;
-  green: (text: string) => string;
-  red: (text: string) => string;
-  cyan: (text: string) => string;
-  yellow: (text: string) => string;
-  grey: (text: string) => string;
-  dim: (text: string) => string;
-}
-
-type NestedArray<T> = Array<T | NestedArray<T>>;
+import type { ArtifactId } from "@nomicfoundation/edr";
 
 export function formatArtifactId(
   artifactId: ArtifactId,
@@ -31,193 +9,3 @@ export function formatArtifactId(
 
   return `${sourceName}:${artifactId.name}`;
 }
-
-export function formatLogs(
-  logs: string[],
-  indent: number,
-  colorizer: Colorizer,
-): string {
-  return colorizer.grey(
-    logs.map((log) => `${" ".repeat(indent)}${log}`).join("\n"),
-  );
-}
-
-function formatInputs(
-  inputs: DecodedTraceParameters | Uint8Array,
-  color?: (text: string) => string,
-): string | undefined {
-  if (inputs instanceof Uint8Array) {
-    return inputs.length > 0 ? bytesToHexString(inputs) : undefined;
-  } else {
-    const formattedName =
-      color !== undefined ? color(inputs.name) : inputs.name;
-    return `${formattedName}(${inputs.arguments.join(", ")})`;
-  }
-}
-
-function formatOutputs(outputs: string | Uint8Array): string | undefined {
-  if (outputs instanceof Uint8Array) {
-    return outputs.length > 0 ? bytesToHexString(outputs) : undefined;
-  } else {
-    return outputs;
-  }
-}
-
-function formatLog(log: LogTrace, colorizer: Colorizer = chalk): string[] {
-  const { parameters } = log;
-  const lines = [];
-  if (Array.isArray(parameters)) {
-    const topics = parameters.map((topic) => bytesToHexString(topic));
-    if (topics.length > 0) {
-      lines.push(`emit topic 0: ${colorizer.cyan(topics[0])}`);
-    }
-    for (let i = 1; i < topics.length - 1; i++) {
-      lines.push(`     topic ${i}: ${colorizer.cyan(topics[i])}`);
-    }
-    if (topics.length > 1) {
-      lines.push(`        data: ${colorizer.cyan(topics[topics.length - 1])}`);
-    }
-  } else {
-    lines.push(
-      `emit ${parameters.name}(${colorizer.cyan(parameters.arguments.join(", "))})`,
-    );
-  }
-  return lines;
-}
-
-function formatKind(kind: CallKind): string | undefined {
-  assertHardhatInvariant(
-    kind !== CallKind.Create,
-    "Unexpected call kind 'Create'",
-  );
-
-  switch (kind) {
-    case CallKind.Call:
-      return undefined;
-    case CallKind.CallCode:
-      return "callcode";
-    case CallKind.DelegateCall:
-      return "delegatecall";
-    case CallKind.StaticCall:
-      return "staticcall";
-  }
-}
-
-function formatTrace(
-  trace: CallTrace,
-  colorizer: Colorizer,
-): NestedArray<string> {
-  const {
-    success,
-    address,
-    contract,
-    inputs,
-    gasUsed,
-    value,
-    kind,
-    isCheatcode,
-    outputs,
-  } = trace;
-  let color;
-  if (isCheatcode) {
-    color = colorizer.blue;
-  } else if (success) {
-    color = colorizer.green;
-  } else {
-    color = colorizer.red;
-  }
-
-  const formattedInputs = formatInputs(inputs, color);
-  const formattedOutputs = formatOutputs(outputs);
-
-  let openingLine: string;
-  let closingLine: string | undefined;
-  if (kind === CallKind.Create) {
-    openingLine = `[${gasUsed}] ${colorizer.yellow("→ new")} ${contract ?? "<unknown>"}@${address}`;
-    // TODO: Uncomment this when the formattedInputs starts containing
-    // the address of where the contract was deployed instead of the code.
-    // if (formattedInputs !== undefined) {
-    //   openingLine = `${openingLine}@${formattedInputs}`;
-    // }
-  } else {
-    const formattedKind = formatKind(kind);
-    openingLine = `[${gasUsed}] ${color(contract ?? address)}`;
-    if (formattedInputs !== undefined) {
-      openingLine = `${openingLine}::${formattedInputs}`;
-    }
-    if (value !== BigInt(0)) {
-      openingLine = `${openingLine} {value: ${value}}`;
-    }
-    if (formattedKind !== undefined) {
-      openingLine = `${openingLine} ${colorizer.yellow(`[${formattedKind}]`)}`;
-    }
-  }
-  if (formattedOutputs !== undefined) {
-    if (
-      formattedOutputs === "EvmError: Revert" ||
-      formattedOutputs.startsWith("revert:")
-    ) {
-      closingLine = `${color("←")} ${color("[Revert]")} ${formattedOutputs}`;
-    } else {
-      closingLine = `${color("←")} ${formattedOutputs}`;
-    }
-  }
-
-  const lines = [];
-  lines.push(openingLine);
-  for (const child of trace.children) {
-    if (child.kind === LogKind.Log) {
-      lines.push(formatLog(child));
-    } else {
-      lines.push(formatTrace(child, colorizer));
-    }
-  }
-  if (closingLine !== undefined) {
-    lines.push([closingLine]);
-  }
-  return lines;
-}
-
-function formatNestedArray(
-  data: NestedArray<string>,
-  prefix = "",
-  isTopLevel = true,
-): string {
-  let output = "";
-
-  for (let i = 0; i < data.length; i++) {
-    const item = data[i];
-
-    if (Array.isArray(item) && typeof item[0] === "string") {
-      const [label, ...children] = item;
-
-      if (isTopLevel) {
-        output += `${prefix}${label}\n`;
-        output += formatNestedArray(children, prefix, false);
-      } else {
-        const isLast = i === data.length - 1;
-        const connector = isLast ? "  └─ " : "  ├─ ";
-        const childPrefix = isLast ? "     " : "  │  ";
-        output += `${prefix}${connector}${label}\n`;
-        output += formatNestedArray(children, prefix + childPrefix, false);
-      }
-    } else if (typeof item === "string") {
-      const isLast = i === data.length - 1;
-      const connector = isLast ? "  └─ " : "  ├─ ";
-      output += `${prefix}${connector}${item}\n`;
-    }
-  }
-
-  return output;
-}
-
-export function formatTraces(
-  traces: CallTrace[],
-  prefix: string,
-  colorizer: Colorizer,
-): string {
-  const lines = traces.map((trace) => formatTrace(trace, colorizer));
-  const formattedTraces = formatNestedArray(lines, prefix);
-  // Remove the trailing newline
-  return formattedTraces.slice(0, -1);
-}

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

@@ -1,18 +1,18 @@
-import type { RunOptions } from "./runner.js";
 import type { Abi } from "../../../types/artifacts.js";
 import type { ChainType } from "../../../types/network.js";
 import type { SolidityTestConfig } from "../../../types/test.js";
+import type { Colorizer } from "../../utils/colorizer.js";
 import type {
   SolidityTestRunnerConfigArgs,
   PathPermission,
   Artifact,
   ObservabilityConfig,
+  TestFunctionOverride,
 } from "@nomicfoundation/edr";
 
 import {
   opGenesisState,
   l1GenesisState,
-  IncludeTraces,
   FsAccessPermission,
   CollectStackTraces,
   opHardforkFromString,
@@ -24,8 +24,9 @@ import chalk from "chalk";
 import { DEFAULT_VERBOSITY, OPTIMISM_CHAIN_TYPE } from "../../constants.js";
 import { resolveHardfork } from "../network-manager/config-resolution.js";
 import { hardhatHardforkToEdrSpecId } from "../network-manager/edr/utils/convert-to-edr.js";
+import { verbosityToIncludeTraces } from "../network-manager/edr/utils/trace-formatters.js";
 
-import { type Colorizer, formatArtifactId } from "./formatters.js";
+import { formatArtifactId } from "./formatters.js";
 
 interface SolidityTestConfigParams {
   chainType: ChainType;
@@ -36,12 +37,7 @@ interface SolidityTestConfigParams {
   observability?: ObservabilityConfig;
   testPattern?: string;
   generateGasReport: boolean;
-}
-
-export function solidityTestConfigToRunOptions(
-  config: SolidityTestConfig,
-): RunOptions {
-  return config;
+  testFunctionOverrides?: TestFunctionOverride[];
 }
 
 export async function solidityTestConfigToSolidityTestRunnerConfigArgs({
@@ -53,6 +49,7 @@ export async function solidityTestConfigToSolidityTestRunnerConfigArgs({
   observability,
   testPattern,
   generateGasReport,
+  testFunctionOverrides,
 }: SolidityTestConfigParams): Promise<SolidityTestRunnerConfigArgs> {
   const fsPermissions: PathPermission[] | undefined = [
     config.fsPermissions?.readWriteFile?.map((p) => ({
@@ -98,12 +95,7 @@ export async function solidityTestConfigToSolidityTestRunnerConfigArgs({
       ? opGenesisState(opHardforkFromString(resolvedHardfork))
       : l1GenesisState(l1HardforkFromString(resolvedHardfork));
 
-  let includeTraces: IncludeTraces = IncludeTraces.None;
-  if (verbosity >= 5) {
-    includeTraces = IncludeTraces.All;
-  } else if (verbosity >= 3) {
-    includeTraces = IncludeTraces.Failing;
-  }
+  const includeTraces = verbosityToIncludeTraces(verbosity);
 
   const blockGasLimit =
     config.blockGasLimit === false ? undefined : config.blockGasLimit;
@@ -152,6 +144,7 @@ export async function solidityTestConfigToSolidityTestRunnerConfigArgs({
     collectStackTraces: shouldAlwaysCollectStackTraces
       ? CollectStackTraces.Always
       : CollectStackTraces.OnFailure,
+    testFunctionOverrides,
   };
 }
 

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

@@ -2,7 +2,6 @@ import type { HardhatPlugin } from "../../../types/plugins.js";
 
 import { ArgumentType } from "hardhat/types/arguments";
 
-import { DEFAULT_VERBOSITY } from "../../constants.js";
 import { task } from "../../core/config.js";
 
 import "./type-extensions.js";
@@ -35,12 +34,6 @@ const hardhatPlugin: HardhatPlugin = {
         name: "noCompile",
         description: "Don't compile the project before running the tests",
       })
-      .addLevel({
-        name: "verbosity",
-        shortName: "v",
-        description: "Verbosity level of the test output",
-        defaultValue: DEFAULT_VERBOSITY,
-      })
       .addOption({
         name: "testSummaryIndex",
         description:

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

@@ -0,0 +1,21 @@
+export const HARDHAT_CONFIG_PREFIX = "hardhat-config:";
+export const FORGE_CONFIG_PREFIX = "forge-config:";
+
+/** All supported inline config keys and their expected value types. */
+export const KEY_TYPES: Record<string, "number" | "boolean"> = {
+  "fuzz.runs": "number",
+  "fuzz.maxTestRejects": "number",
+  "fuzz.showLogs": "boolean",
+  "fuzz.timeout": "number",
+  "invariant.runs": "number",
+  "invariant.depth": "number",
+  "invariant.failOnRevert": "boolean",
+  "invariant.callOverride": "boolean",
+  "invariant.timeout": "number",
+  allowInternalExpectRevert: "boolean",
+};
+
+/** Top-level key categories (e.g. "fuzz", "invariant", "allowInternalExpectRevert"). */
+export const TOP_LEVEL_KEYS: string[] = [
+  ...new Set(Object.keys(KEY_TYPES).map((k) => k.split(".")[0])),
+];

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

@@ -0,0 +1,99 @@
+import type { RawInlineOverride } from "./types.js";
+import type { TestFunctionConfigOverride } from "@nomicfoundation/edr";
+
+import { bytesIncludesUtf8String } from "@nomicfoundation/hardhat-utils/bytes";
+
+import { getFullyQualifiedName } from "../../../../utils/contract-names.js";
+
+import {
+  HARDHAT_CONFIG_PREFIX,
+  FORGE_CONFIG_PREFIX,
+  KEY_TYPES,
+} from "./constants.js";
+
+/**
+ * Returns true if the build info bytes contain either of the inline config
+ * prefixes.
+ */
+export function buildInfoContainsInlineConfig(
+  buildInfoBytes: Uint8Array,
+): boolean {
+  return (
+    bytesIncludesUtf8String(buildInfoBytes, HARDHAT_CONFIG_PREFIX) ||
+    bytesIncludesUtf8String(buildInfoBytes, FORGE_CONFIG_PREFIX)
+  );
+}
+
+/**
+ * Finds the function selector for a given function name in the methodIdentifiers
+ * map. Matches the first entry whose signature starts with `functionName(`.
+ * Returns the selector prefixed with "0x".
+ */
+export function resolveFunctionSelector(
+  methodIdentifiers: Record<string, string>,
+  functionName: string,
+): string | undefined {
+  const prefix = `${functionName}(`;
+
+  for (const [signature, selector] of Object.entries(methodIdentifiers)) {
+    if (signature.startsWith(prefix)) {
+      return `0x${selector}`;
+    }
+  }
+
+  return undefined;
+}
+
+/**
+ * Converts a validated set of raw overrides into a TestFunctionConfigOverride
+ * object.
+ */
+export function buildConfigOverride(
+  overrides: RawInlineOverride[],
+): TestFunctionConfigOverride {
+  const config: Record<string, unknown> = {};
+  const fuzz: Record<string, unknown> = {};
+  const invariant: Record<string, unknown> = {};
+
+  for (const override of overrides) {
+    const expectedType = KEY_TYPES[override.key];
+    const parsed =
+      expectedType === "number"
+        ? Number(override.rawValue)
+        : override.rawValue.toLowerCase() === "true";
+
+    const dotIndex = override.key.indexOf(".");
+    if (dotIndex === -1) {
+      // Top-level key, like "allowInternalExpectRevert"
+      config[override.key] = parsed;
+    } else {
+      const section = override.key.slice(0, dotIndex);
+      const field = override.key.slice(dotIndex + 1);
+      const target = section === "fuzz" ? fuzz : invariant;
+      target[field] = field === "timeout" ? { time: parsed } : parsed;
+    }
+  }
+
+  if (Object.keys(fuzz).length > 0) {
+    config.fuzz = fuzz;
+  }
+  if (Object.keys(invariant).length > 0) {
+    config.invariant = invariant;
+  }
+
+  /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions --
+  Cast is safe because we have validated all keys and value types in the previous step. */
+  return config as TestFunctionConfigOverride;
+}
+
+/**
+ * Constructs a fully qualified function name, in the format
+ * "source.sol:ContractName#functionName".
+ */
+export function getFunctionFqn(
+  inputSourceName: string,
+  contractName: string,
+  functionName: string,
+): string {
+  return `${getFullyQualifiedName(inputSourceName, contractName)}#${functionName}`;
+}