hardhat 3.0.5 → 3.0.7

package/src/internal/builtin-plugins/solidity/tasks/build.ts

@@ -1,3 +1,5 @@
+import type { HardhatRuntimeEnvironment } from "../../../../types/hre.js";
+import type { BuildScope } from "../../../../types/solidity.js";
 import type { NewTaskActionFunction } from "../../../../types/tasks.js";
 
 import { resolveFromRoot } from "@nomicfoundation/hardhat-utils/path";
@@ -5,27 +7,65 @@ import { resolveFromRoot } from "@nomicfoundation/hardhat-utils/path";
 import { throwIfSolidityBuildFailed } from "../build-results.js";
 import { isNpmRootPath } from "../build-system/root-paths-utils.js";
 
-interface CompileActionArguments {
+interface BuildActionArguments {
   force: boolean;
   files: string[];
   quiet: boolean;
   defaultBuildProfile: string | undefined;
+  noTests: boolean;
+  noContracts: boolean;
 }
 
-const buildAction: NewTaskActionFunction<CompileActionArguments> = async (
-  { force, files, quiet, defaultBuildProfile },
-  { solidity, globalOptions },
+const buildAction: NewTaskActionFunction<BuildActionArguments> = async (
+  args: BuildActionArguments,
+  hre,
 ) => {
-  const rootPaths =
-    files.length === 0
-      ? await solidity.getRootFilePaths()
-      : files.map((file) => {
-          if (isNpmRootPath(file)) {
-            return file;
-          }
+  const contractRootPaths = [];
+  const testRootPaths = [];
 
-          return resolveFromRoot(process.cwd(), file);
-        });
+  if (args.noContracts === false) {
+    contractRootPaths.push(...(await buildForScope("contracts", args, hre)));
+  }
+
+  if (args.noTests === false) {
+    testRootPaths.push(...(await buildForScope("tests", args, hre)));
+  }
+
+  return { contractRootPaths, testRootPaths };
+};
+
+async function buildForScope(
+  scope: BuildScope,
+  { force, files, quiet, defaultBuildProfile }: BuildActionArguments,
+  { solidity, globalOptions }: HardhatRuntimeEnvironment,
+) {
+  // If no specific files are passed, it means a full compilation, i.e. all source files
+  const isFullCompilation = files.length === 0;
+
+  const rootPaths = [];
+
+  if (isFullCompilation) {
+    rootPaths.push(...(await solidity.getRootFilePaths({ scope })));
+  } else {
+    for (const file of files) {
+      if (isNpmRootPath(file)) {
+        rootPaths.push(file);
+      }
+
+      const rootPath = resolveFromRoot(process.cwd(), file);
+
+      if ((await solidity.getScope(rootPath)) !== scope) {
+        continue;
+      }
+
+      rootPaths.push(rootPath);
+    }
+
+    // If a file list has been passed but none match this scope, we don't run the build
+    if (rootPaths.length === 0) {
+      return [];
+    }
+  }
 
   const buildProfile = globalOptions.buildProfile ?? defaultBuildProfile;
 
@@ -33,14 +73,17 @@ const buildAction: NewTaskActionFunction<CompileActionArguments> = async (
     force,
     buildProfile,
     quiet,
+    scope,
   });
 
   throwIfSolidityBuildFailed(results);
 
   // If we recompiled the entire project we cleanup the artifacts
-  if (files.length === 0) {
-    await solidity.cleanupArtifacts(rootPaths);
+  if (isFullCompilation) {
+    await solidity.cleanupArtifacts(rootPaths, { scope });
   }
-};
+
+  return rootPaths;
+}
 
 export default buildAction;

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

@@ -1,6 +1,14 @@
 import type { HardhatUserConfig } from "../../../config.js";
-import type { HardhatConfig } from "../../../types/config.js";
+import type {
+  ConfigurationVariableResolver,
+  HardhatConfig,
+  ResolvedConfigurationVariable,
+} from "../../../types/config.js";
 import type { HardhatUserConfigValidationError } from "../../../types/hooks.js";
+import type {
+  SolidityTestForkingConfig,
+  SolidityTestUserConfig,
+} from "../../../types/test.js";
 
 import path from "node:path";
 
@@ -8,6 +16,8 @@ import { isObject } from "@nomicfoundation/hardhat-utils/lang";
 import { resolveFromRoot } from "@nomicfoundation/hardhat-utils/path";
 import {
   conditionalUnionType,
+  sensitiveStringSchema,
+  sensitiveUrlSchema,
   validateUserConfigZodType,
 } from "@nomicfoundation/hardhat-zod-utils";
 import { z } from "zod";
@@ -49,9 +59,9 @@ const solidityTestUserConfigType = z.object({
     .optional(),
   forking: z
     .object({
-      url: z.string().optional(),
+      url: z.optional(sensitiveUrlSchema),
       blockNumber: z.bigint().optional(),
-      rpcEndpoints: z.record(z.string()).optional(),
+      rpcEndpoints: z.record(sensitiveStringSchema).optional(),
     })
     .optional(),
   invariant: z
@@ -88,6 +98,32 @@ const userConfigType = z.object({
     .optional(),
 });
 
+export function resolveSolidityTestForkingConfig(
+  forkingUserConfig: SolidityTestUserConfig["forking"],
+  resolveConfigurationVariable: ConfigurationVariableResolver,
+): SolidityTestForkingConfig | undefined {
+  if (forkingUserConfig === undefined) {
+    return undefined;
+  }
+
+  const resolvedRpcEndpoints: Record<string, ResolvedConfigurationVariable> =
+    {};
+  if (forkingUserConfig.rpcEndpoints !== undefined) {
+    for (const [name, url] of Object.entries(forkingUserConfig.rpcEndpoints)) {
+      resolvedRpcEndpoints[name] = resolveConfigurationVariable(url);
+    }
+  }
+
+  return {
+    ...forkingUserConfig,
+    url:
+      forkingUserConfig.url !== undefined
+        ? resolveConfigurationVariable(forkingUserConfig.url)
+        : undefined,
+    rpcEndpoints: resolvedRpcEndpoints,
+  };
+}
+
 export function validateSolidityTestUserConfig(
   userConfig: unknown,
 ): HardhatUserConfigValidationError[] {
@@ -97,6 +133,7 @@ export function validateSolidityTestUserConfig(
 export async function resolveSolidityTestUserConfig(
   userConfig: HardhatUserConfig,
   resolvedConfig: HardhatConfig,
+  resolveConfigurationVariable: ConfigurationVariableResolver,
 ): Promise<HardhatConfig> {
   let testsPath = userConfig.paths?.tests;
 
@@ -106,9 +143,15 @@ export async function resolveSolidityTestUserConfig(
 
   const defaultRpcCachePath = path.join(resolvedConfig.paths.cache, "edr");
 
+  const resolvedForking = resolveSolidityTestForkingConfig(
+    userConfig.test?.solidity?.forking,
+    resolveConfigurationVariable,
+  );
+
   const solidityTest = {
     rpcCachePath: defaultRpcCachePath,
     ...userConfig.test?.solidity,
+    forking: resolvedForking,
   };
 
   return {

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

@@ -18,9 +18,12 @@ import {
   FsAccessPermission,
 } from "@nomicfoundation/edr";
 import { hexStringToBytes } from "@nomicfoundation/hardhat-utils/hex";
+import chalk from "chalk";
 
 import { OPTIMISM_CHAIN_TYPE } from "../../constants.js";
 
+import { type Colorizer, formatArtifactId } from "./formatters.js";
+
 function hexStringToBuffer(hexString: string): Buffer {
   return Buffer.from(hexStringToBytes(hexString));
 }
@@ -31,14 +34,14 @@ export function solidityTestConfigToRunOptions(
   return config;
 }
 
-export function solidityTestConfigToSolidityTestRunnerConfigArgs(
+export async function solidityTestConfigToSolidityTestRunnerConfigArgs(
   chainType: ChainType,
   projectRoot: string,
   config: SolidityTestConfig,
   verbosity: number,
   observability?: ObservabilityConfig,
   testPattern?: string,
-): SolidityTestRunnerConfigArgs {
+): Promise<SolidityTestRunnerConfigArgs> {
   const fsPermissions: PathPermission[] | undefined = [
     config.fsPermissions?.readWriteFile?.map((p) => ({
       access: FsAccessPermission.ReadWriteFile,
@@ -95,9 +98,22 @@ export function solidityTestConfigToSolidityTestRunnerConfigArgs(
 
   const blockDifficulty = config.prevRandao;
 
-  const ethRpcUrl = config.forking?.url;
+  let ethRpcUrl: string | undefined;
+  if (config.forking?.url !== undefined) {
+    ethRpcUrl = await config.forking.url.get();
+  }
+
   const forkBlockNumber = config.forking?.blockNumber;
-  const rpcEndpoints = config.forking?.rpcEndpoints;
+
+  let rpcEndpoints: Record<string, string> | undefined;
+  if (config.forking?.rpcEndpoints !== undefined) {
+    rpcEndpoints = {};
+    for (const [name, configValue] of Object.entries(
+      config.forking.rpcEndpoints,
+    )) {
+      rpcEndpoints[name] = await configValue.get();
+    }
+  }
 
   return {
     projectRoot,
@@ -128,3 +144,27 @@ export function isTestSuiteArtifact(artifact: Artifact): boolean {
     return false;
   });
 }
+
+export function warnDeprecatedTestFail(
+  artifact: Artifact,
+  sourceNameToUserSourceName: Map<string, string>,
+  colorizer: Colorizer = chalk,
+): void {
+  const abi: Abi = JSON.parse(artifact.contract.abi);
+
+  abi.forEach(({ type, name }) => {
+    if (
+      type === "function" &&
+      typeof name === "string" &&
+      name.startsWith("testFail")
+    ) {
+      const formattedLocation = formatArtifactId(
+        artifact.id,
+        sourceNameToUserSourceName,
+      );
+      const warningMessage = `${colorizer.yellow("Warning")}: ${name} The support for the prefix \`testFail*\` has been removed. Consider using \`vm.expectRevert()\` for testing reverts in ${formattedLocation}\n`;
+
+      console.warn(warningMessage);
+    }
+  });
+}

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

@@ -19,7 +19,11 @@ export default async (): Promise<Partial<ConfigHooks>> => {
         resolveConfigurationVariable,
       );
 
-      return resolveSolidityTestUserConfig(userConfig, resolvedConfig);
+      return resolveSolidityTestUserConfig(
+        userConfig,
+        resolvedConfig,
+        resolveConfigurationVariable,
+      );
     },
   };
 

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

@@ -1,6 +1,5 @@
 import type { RunOptions } from "./runner.js";
 import type { TestEvent } from "./types.js";
-import type { BuildOptions } from "../../../types/solidity/build-system.js";
 import type { NewTaskActionFunction } from "../../../types/tasks.js";
 import type {
   ObservabilityConfig,
@@ -14,22 +13,22 @@ import {
   assertHardhatInvariant,
   HardhatError,
 } from "@nomicfoundation/hardhat-errors";
-import { getAllFilesMatching } from "@nomicfoundation/hardhat-utils/fs";
 import { resolveFromRoot } from "@nomicfoundation/hardhat-utils/path";
 import { createNonClosingWriter } from "@nomicfoundation/hardhat-utils/stream";
 
 import { HardhatRuntimeEnvironmentImplementation } from "../../core/hre.js";
 import { isSupportedChainType } from "../../edr/chain-type.js";
+import { ArtifactManagerImplementation } from "../artifacts/artifact-manager.js";
 import {
   markTestRunDone,
   markTestRunStart,
   markTestWorkerDone,
 } from "../coverage/helpers.js";
-import { throwIfSolidityBuildFailed } from "../solidity/build-results.js";
 
 import { getEdrArtifacts, getBuildInfos } from "./edr-artifacts.js";
 import {
   isTestSuiteArtifact,
+  warnDeprecatedTestFail,
   solidityTestConfigToRunOptions,
   solidityTestConfigToSolidityTestRunnerConfigArgs,
 } from "./helpers.js";
@@ -48,8 +47,6 @@ const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
   { testFiles, chainType, grep, noCompile, verbosity },
   hre,
 ) => {
-  let rootFilePaths: string[];
-
   if (!isSupportedChainType(chainType)) {
     throw new HardhatError(
       HardhatError.ERRORS.CORE.ARGUMENTS.INVALID_VALUE_FOR_TYPE,
@@ -61,52 +58,47 @@ const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
     );
   }
 
-  // NOTE: We run the compile task first to ensure all the artifacts for them are generated
-  // Then, we compile just the test sources. We don't do it in one go because the user
-  // is likely to use different compilation options for the tests and the sources.
-  if (noCompile === false) {
-    await hre.tasks.getTask("compile").run();
-  }
+  // Run the compile task for test files
 
-  if (testFiles.length > 0) {
-    rootFilePaths = testFiles.map((f) =>
-      resolveFromRoot(hre.config.paths.root, f),
-    );
-  } else {
-    // NOTE: A test file is either a file with a `.sol` extension in the `tests.solidity`
-    // directory or a file with a `.t.sol` extension in the `sources.solidity` directory
-    rootFilePaths = (
-      await Promise.all([
-        getAllFilesMatching(hre.config.paths.tests.solidity, (f) =>
-          f.endsWith(".sol"),
-        ),
-        ...hre.config.paths.sources.solidity.map(async (dir) => {
-          return getAllFilesMatching(dir, (f) => f.endsWith(".t.sol"));
-        }),
-      ])
-    ).flat(1);
-  }
-  // NOTE: We remove duplicates in case there is an intersection between
-  // the tests.solidity paths and the sources paths
-  rootFilePaths = Array.from(new Set(rootFilePaths));
-
-  // NOTE: We are not skipping the test compilation even if the noCompile flag is set
-  // because the user cannot run test compilation outside of the test task yet.
-  // TODO: Allow users to run test compilation outside of the test task.
-  const buildOptions: BuildOptions = {
-    force: false,
-    buildProfile: hre.globalOptions.buildProfile ?? "default",
-    quiet: true,
-  };
-  const results = await hre.solidity.build(rootFilePaths, buildOptions);
-  throwIfSolidityBuildFailed(results);
+  const { testRootPaths }: { testRootPaths: string[] } = await hre.tasks
+    .getTask("compile")
+    .run({
+      quiet: true,
+      force: false,
+      files: testFiles,
+      noContracts: noCompile,
+    });
+
+  const artifactsDirectory = await hre.solidity.getArtifactsDirectory("tests");
+
+  const artifactsManager = new ArtifactManagerImplementation(
+    artifactsDirectory,
+  );
+
+  const buildInfos = await getBuildInfos(artifactsManager);
+  const edrArtifacts = await getEdrArtifacts(artifactsManager);
+
+  const sourceNameToUserSourceName = new Map(
+    edrArtifacts.map(({ userSourceName, edrAtifact }) => [
+      edrAtifact.id.source,
+      userSourceName,
+    ]),
+  );
 
-  const buildInfos = await getBuildInfos(hre.artifacts);
-  const edrArtifacts = await getEdrArtifacts(hre.artifacts);
+  edrArtifacts.forEach(({ userSourceName, edrAtifact }) => {
+    if (
+      testRootPaths.includes(
+        resolveFromRoot(hre.config.paths.root, userSourceName),
+      ) &&
+      isTestSuiteArtifact(edrAtifact)
+    ) {
+      warnDeprecatedTestFail(edrAtifact, sourceNameToUserSourceName);
+    }
+  });
 
   const testSuiteIds = edrArtifacts
     .filter(({ userSourceName }) =>
-      rootFilePaths.includes(
+      testRootPaths.includes(
         resolveFromRoot(hre.config.paths.root, userSourceName),
       ),
     )
@@ -141,7 +133,7 @@ const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
   }
 
   const config: SolidityTestRunnerConfigArgs =
-    solidityTestConfigToSolidityTestRunnerConfigArgs(
+    await solidityTestConfigToSolidityTestRunnerConfigArgs(
       chainType,
       hre.config.paths.root,
       solidityTestConfig,
@@ -156,13 +148,6 @@ const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
   const options: RunOptions =
     solidityTestConfigToRunOptions(solidityTestConfig);
 
-  const sourceNameToUserSourceName = new Map(
-    edrArtifacts.map(({ userSourceName, edrAtifact }) => [
-      edrAtifact.id.source,
-      userSourceName,
-    ]),
-  );
-
   await markTestRunStart("solidity");
 
   const runStream = run(

package/src/internal/builtin-plugins/solidity-test/type-extensions.ts

@@ -1,4 +1,8 @@
 import "../../../types/config.js";
+import type {
+  SensitiveString,
+  ResolvedConfigurationVariable,
+} from "../../../types/config.js";
 
 declare module "../../../types/config.js" {
   export interface TestPathsUserConfig {
@@ -11,7 +15,7 @@ declare module "../../../types/config.js" {
 }
 
 declare module "../../../types/test.js" {
-  export interface SolidityTestUserConfig {
+  export interface SolidityTestConfigBase {
     timeout?: number;
     fsPermissions?: {
       readWriteFile?: string[];
@@ -33,12 +37,6 @@ declare module "../../../types/test.js" {
     prevRandao?: bigint;
     blockGasLimit?: bigint | false;
 
-    forking?: {
-      url?: string;
-      blockNumber?: bigint;
-      rpcEndpoints?: Record<string, string>;
-    };
-
     fuzz?: {
       failurePersistDir?: string;
       failurePersistFile?: string;
@@ -62,13 +60,29 @@ declare module "../../../types/test.js" {
     };
   }
 
+  export interface SolidityTestForkingUserConfig {
+    url?: SensitiveString;
+    blockNumber?: bigint;
+    rpcEndpoints?: Record<string, SensitiveString>;
+  }
+
+  export interface SolidityTestUserConfig extends SolidityTestConfigBase {
+    forking?: SolidityTestForkingUserConfig;
+  }
+
   export interface HardhatTestUserConfig {
     solidity?: SolidityTestUserConfig;
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-empty-interface -- This could be an extension point
-  export interface SolidityTestConfig extends SolidityTestUserConfig {}
+  export interface SolidityTestForkingConfig {
+    url?: ResolvedConfigurationVariable;
+    blockNumber?: bigint;
+    rpcEndpoints?: Record<string, ResolvedConfigurationVariable>;
+  }
 
+  export interface SolidityTestConfig extends SolidityTestConfigBase {
+    forking?: SolidityTestForkingConfig;
+  }
   export interface HardhatTestConfig {
     solidity: SolidityTestConfig;
   }