hardhat 3.4.5 → 3.5.0

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

@@ -1,6 +1,6 @@
 import type { Abi } from "../../../types/artifacts.js";
 import type { ChainType } from "../../../types/network.js";
-import type { SolidityTestConfig } from "../../../types/test.js";
+import type { SolidityTestProfileConfig } from "../../../types/test.js";
 import type {
   SolidityTestRunnerConfigArgs,
   PathPermission,
@@ -19,6 +19,7 @@ import {
   opHardforkFromString,
   l1HardforkFromString,
 } from "@nomicfoundation/edr";
+import { toBigInt } from "@nomicfoundation/hardhat-utils/bigint";
 import { hexStringToBytes } from "@nomicfoundation/hardhat-utils/hex";
 
 import { DEFAULT_VERBOSITY, OPTIMISM_CHAIN_TYPE } from "../../constants.js";
@@ -32,12 +33,13 @@ interface SolidityTestConfigParams {
   chainType: ChainType;
   projectRoot: string;
   hardfork?: string;
-  config: SolidityTestConfig;
+  config: Omit<SolidityTestProfileConfig, "eip712Types">;
   verbosity: number;
   observability?: ObservabilityConfig;
   testPattern?: string;
   generateGasReport: boolean;
   testFunctionOverrides?: TestFunctionOverride[];
+  eip712CanonicalTypes?: string[];
 }
 
 export async function solidityTestConfigToSolidityTestRunnerConfigArgs({
@@ -50,6 +52,7 @@ export async function solidityTestConfigToSolidityTestRunnerConfigArgs({
   testPattern,
   generateGasReport,
   testFunctionOverrides,
+  eip712CanonicalTypes,
 }: SolidityTestConfigParams): Promise<SolidityTestRunnerConfigArgs> {
   const fsPermissions: PathPermission[] | undefined = [
     config.fsPermissions?.readWriteFile?.map((p) => ({
@@ -98,8 +101,18 @@ export async function solidityTestConfigToSolidityTestRunnerConfigArgs({
   const includeTraces = verbosityToIncludeTraces(verbosity);
 
   const blockGasLimit =
-    config.blockGasLimit === false ? undefined : config.blockGasLimit;
-  const disableBlockGasLimit = config.blockGasLimit === false;
+    typeof config.blockGasLimit === "number" ||
+    typeof config.blockGasLimit === "bigint"
+      ? toBigInt(config.blockGasLimit)
+      : undefined;
+  const disableBlockGasLimit = blockGasLimit === undefined;
+
+  const transactionGasCap =
+    typeof config.transactionGasCap === "number" ||
+    typeof config.transactionGasCap === "bigint"
+      ? toBigInt(config.transactionGasCap)
+      : undefined;
+  const disableTransactionGasCap = transactionGasCap === undefined;
 
   const blockDifficulty = config.prevRandao;
 
@@ -136,6 +149,8 @@ export async function solidityTestConfigToSolidityTestRunnerConfigArgs({
     includeTraces,
     blockGasLimit,
     disableBlockGasLimit,
+    transactionGasCap,
+    disableTransactionGasCap,
     blockDifficulty,
     ethRpcUrl,
     forkBlockNumber,
@@ -145,15 +160,24 @@ export async function solidityTestConfigToSolidityTestRunnerConfigArgs({
       ? CollectStackTraces.Always
       : CollectStackTraces.OnFailure,
     testFunctionOverrides,
+    eip712CanonicalTypes,
   };
 }
 
 export function isTestSuiteArtifact(artifact: Artifact): boolean {
+  const bytecode = artifact.contract.bytecode;
+
+  // Skip abstract contracts and interfaces i.e. those with no bytecode
+  if (bytecode === "" || bytecode === "0x" || bytecode === undefined) {
+    return false;
+  }
+
   const abi: Abi = JSON.parse(artifact.contract.abi);
   return abi.some(({ type, name }) => {
     if (type === "function" && typeof name === "string") {
       return name.startsWith("test") || name.startsWith("invariant");
     }
+
     return false;
   });
 }

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

@@ -35,6 +35,7 @@ import {
   buildEdrArtifactsWithMetadata,
   getBuildInfosAndOutputs,
 } from "./edr-artifacts.js";
+import { collectEip712CanonicalTypes } from "./eip712/index.js";
 import {
   isTestSuiteArtifact,
   warnDeprecatedTestFail,
@@ -43,6 +44,7 @@ import {
 import { getTestFunctionOverrides } from "./inline-config/index.js";
 import { testReporter } from "./reporter.js";
 import { run } from "./runner.js";
+import { DEFAULT_TEST_PROFILE } from "./test-profiles.js";
 
 interface TestActionArguments {
   testFiles: string[];
@@ -200,7 +202,9 @@ const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
   let includesFailures = false;
   let includesErrors = false;
 
-  const solidityTestConfig = hre.config.test.solidity;
+  const { eip712Types, ...solidityTestConfig } =
+    hre.config.test.solidity.profiles[DEFAULT_TEST_PROFILE];
+
   let observabilityConfig: ObservabilityConfig | undefined;
   if (hre.globalOptions.coverage) {
     const coverage = getCoverageManager(hre);
@@ -232,6 +236,12 @@ const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
     allBuildInfosAndOutputs,
   );
 
+  const eip712CanonicalTypes = collectEip712CanonicalTypes(
+    allBuildInfosAndOutputs,
+    sourceNameToUserSourceName,
+    eip712Types,
+  );
+
   const testRunnerConfig =
     await solidityTestConfigToSolidityTestRunnerConfigArgs({
       chainType,
@@ -245,6 +255,7 @@ const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
         hre.globalOptions.gasStats ||
         hre.globalOptions.gasStatsJson !== undefined,
       testFunctionOverrides,
+      eip712CanonicalTypes,
     });
   const tracingConfig: TracingConfigWithBuffers = {
     buildInfos: allBuildInfosAndOutputs.map(({ buildInfo, output }) => ({

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

@@ -0,0 +1 @@
+export const DEFAULT_TEST_PROFILE = "default";

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

@@ -14,7 +14,28 @@ declare module "../../../types/config.js" {
 }
 
 declare module "../../../types/test.js" {
-  export interface SolidityTestFuzzConfigBase {
+  export interface SolidityTestFsPermissionsUserConfig {
+    readWriteFile?: string[];
+    readFile?: string[];
+    writeFile?: string[];
+    dangerouslyReadWriteDirectory?: string[];
+    readDirectory?: string[];
+    dangerouslyWriteDirectory?: string[];
+  }
+
+  export interface SolidityTestInvariantUserConfig {
+    failurePersistDir?: string;
+    runs?: number;
+    depth?: number;
+    failOnRevert?: boolean;
+    callOverride?: boolean;
+    dictionaryWeight?: number;
+    includeStorage?: boolean;
+    includePushBytes?: boolean;
+    shrinkRunLimit?: number;
+  }
+
+  export interface SolidityTestFuzzUserConfig {
     failurePersistDir?: string;
     failurePersistFile?: string;
     runs?: number;
@@ -26,19 +47,14 @@ declare module "../../../types/test.js" {
     showLogs?: boolean;
   }
 
-  export interface SolidityTestFuzzConfig extends SolidityTestFuzzConfigBase {
-    seed: string;
+  export interface SolidityTestForkingUserConfig {
+    url?: SensitiveString;
+    blockNumber?: number | bigint;
+    rpcEndpoints?: Record<string, SensitiveString>;
   }
 
-  export interface SolidityTestConfigBase {
-    fsPermissions?: {
-      readWriteFile?: string[];
-      readFile?: string[];
-      writeFile?: string[];
-      dangerouslyReadWriteDirectory?: string[];
-      readDirectory?: string[];
-      dangerouslyWriteDirectory?: string[];
-    };
+  export interface SolidityTestProfileUserConfig {
+    fsPermissions?: SolidityTestFsPermissionsUserConfig;
     isolate?: boolean;
     ffi?: boolean;
     allowInternalExpectRevert?: boolean;
@@ -50,46 +66,97 @@ declare module "../../../types/test.js" {
     blockTimestamp?: bigint;
     prevRandao?: bigint;
     gasLimit?: bigint;
-    blockGasLimit?: bigint | false;
-
-    fuzz?: SolidityTestFuzzConfigBase;
-    invariant?: {
-      failurePersistDir?: string;
-      runs?: number;
-      depth?: number;
-      failOnRevert?: boolean;
-      callOverride?: boolean;
-      dictionaryWeight?: number;
-      includeStorage?: boolean;
-      includePushBytes?: boolean;
-      shrinkRunLimit?: number;
+    blockGasLimit?: number | bigint | false;
+    transactionGasCap?: number | bigint | false;
+    fuzz?: SolidityTestFuzzUserConfig;
+    invariant?: SolidityTestInvariantUserConfig;
+    forking?: SolidityTestForkingUserConfig;
+    eip712Types?: {
+      include?: string[];
+      exclude?: string[];
     };
   }
 
-  export interface SolidityTestForkingUserConfig {
-    url?: SensitiveString;
-    blockNumber?: number | bigint;
-    rpcEndpoints?: Record<string, SensitiveString>;
+  export interface SolidityTestProfilesUserConfig {
+    profiles: Record<string, SolidityTestProfileUserConfig>;
   }
 
-  export interface SolidityTestUserConfig extends SolidityTestConfigBase {
-    forking?: SolidityTestForkingUserConfig;
-  }
+  export type SolidityTestUserConfig =
+    | SolidityTestProfileUserConfig
+    | SolidityTestProfilesUserConfig;
 
   export interface HardhatTestUserConfig {
     solidity?: SolidityTestUserConfig;
   }
 
+  export interface SolidityTestFsPermissionsConfig {
+    readWriteFile?: string[];
+    readFile?: string[];
+    writeFile?: string[];
+    dangerouslyReadWriteDirectory?: string[];
+    readDirectory?: string[];
+    dangerouslyWriteDirectory?: string[];
+  }
+
+  export interface SolidityTestInvariantConfig {
+    failurePersistDir?: string;
+    runs?: number;
+    depth?: number;
+    failOnRevert?: boolean;
+    callOverride?: boolean;
+    dictionaryWeight?: number;
+    includeStorage?: boolean;
+    includePushBytes?: boolean;
+    shrinkRunLimit?: number;
+  }
+
+  export interface SolidityTestFuzzConfig {
+    failurePersistDir?: string;
+    failurePersistFile?: string;
+    runs?: number;
+    maxTestRejects?: number;
+    seed: string;
+    dictionaryWeight?: number;
+    includeStorage?: boolean;
+    includePushBytes?: boolean;
+    showLogs?: boolean;
+  }
+
   export interface SolidityTestForkingConfig {
     url?: ResolvedConfigurationVariable;
     blockNumber?: bigint;
     rpcEndpoints?: Record<string, ResolvedConfigurationVariable>;
   }
 
-  export interface SolidityTestConfig extends SolidityTestConfigBase {
+  export interface SolidityTestProfileConfig {
+    rpcCachePath: string;
+    fsPermissions?: SolidityTestFsPermissionsConfig;
+    isolate?: boolean;
+    ffi?: boolean;
+    allowInternalExpectRevert?: boolean;
+    from?: string; // 0x-prefixed hex string
+    txOrigin?: string; // 0x-prefixed hex string
+    initialBalance?: bigint;
+    blockBaseFeePerGas?: bigint;
+    coinbase?: string; // 0x-prefixed hex string
+    blockTimestamp?: bigint;
+    prevRandao?: bigint;
+    gasLimit?: bigint;
+    blockGasLimit?: number | bigint | false;
+    transactionGasCap?: number | bigint | false;
     fuzz: SolidityTestFuzzConfig;
+    invariant?: SolidityTestInvariantConfig;
     forking?: SolidityTestForkingConfig;
+    eip712Types: {
+      include: string[];
+      exclude: string[];
+    };
   }
+
+  export interface SolidityTestConfig {
+    profiles: Record<string, SolidityTestProfileConfig>;
+  }
+
   export interface HardhatTestConfig {
     solidity: SolidityTestConfig;
   }

package/src/internal/cli/init/init.ts

@@ -49,6 +49,10 @@ import {
 import { spawn } from "./subprocess.js";
 import { getTemplates } from "./template.js";
 
+export interface NonInteractiveInitHardhat3Options {
+  template: string;
+}
+
 export interface InitHardhatOptions {
   hardhatVersion?: "hardhat-2" | "hardhat-3";
   workspace?: string;
@@ -60,6 +64,61 @@ export interface InitHardhatOptions {
 
 const log = createDebug("hardhat:core:cli:init");
 
+export async function initHardhat3NonInteractive(
+  options: NonInteractiveInitHardhat3Options,
+): Promise<void> {
+  const [template, projectTypeAnalyticsPromise] = await getTemplate(
+    "hardhat-3",
+    options.template,
+    true,
+  );
+
+  const workspace = process.cwd();
+
+  try {
+    const configFilePath = await findClosestHardhatConfig(workspace);
+
+    throw new HardhatError(
+      HardhatError.ERRORS.CORE.GENERAL.HARDHAT_PROJECT_ALREADY_CREATED,
+      {
+        hardhatProjectRootPath: configFilePath,
+      },
+    );
+  } catch (err) {
+    if (
+      !HardhatError.isHardhatError(
+        err,
+        HardhatError.ERRORS.CORE.GENERAL.NO_CONFIG_FILE_FOUND,
+      )
+    ) {
+      throw err;
+    }
+  }
+
+  await assertNoNonInteractiveClashes(workspace, template);
+
+  console.log("Initializing project...");
+
+  await validatePackageJson(workspace, template.packageJson, true);
+
+  await copyProjectFilesNonInteractive(workspace, template);
+
+  console.log("Installing dependencies...");
+
+  await Promise.all([
+    installProjectDependencies({
+      workspace,
+      template,
+      install: true,
+      update: true,
+      formatSuccessMessage: false,
+    }),
+    projectTypeAnalyticsPromise,
+  ]);
+
+  console.log("Project initialized");
+}
+
 /**
  * initHardhat implements the project initialization wizard flow.
  *
@@ -126,7 +185,11 @@ export async function initHardhat(options?: InitHardhatOptions): Promise<void> {
     // Run them only if the user opts-in to it
     // Concurrently, await the analytics hit
     await Promise.all([
-      installProjectDependencies(workspace, template, options?.install),
+      installProjectDependencies({
+        workspace,
+        template,
+        install: options?.install,
+      }),
       projectTypeAnalyticsPromise,
     ]);
 
@@ -270,12 +333,17 @@ export async function getWorkspace(workspace?: string): Promise<string> {
  *
  * NOTE: This function is exported for testing purposes
  *
+ * @param hardhatVersion The version of Hardhat whose templates should be considered.
  * @param template The name of the template to use for the project initialization.
+ * @param includeAvailableTemplatesInErrors When true, a missing template throws
+ *   `TEMPLATE_NOT_FOUND_WITH_LIST_OF_OPTIONS` (which lists the available
+ *   templates) instead of the bare `TEMPLATE_NOT_FOUND`.
  * @returns A tuple with two elements: the template and a promise with the analytics hit.
  */
 export async function getTemplate(
   hardhatVersion: "hardhat-2" | "hardhat-3",
   template?: string,
+  includeAvailableTemplatesInErrors = false,
 ): Promise<[Template, Promise<boolean>]> {
   const templates = await getTemplates(hardhatVersion);
 
@@ -299,9 +367,38 @@ export async function getTemplate(
   // we wait for the GA hit before throwing
   await projectTypeAnalyticsPromise;
 
-  throw new HardhatError(HardhatError.ERRORS.CORE.GENERAL.TEMPLATE_NOT_FOUND, {
-    template,
-  });
+  if (!includeAvailableTemplatesInErrors) {
+    throw new HardhatError(
+      HardhatError.ERRORS.CORE.GENERAL.TEMPLATE_NOT_FOUND,
+      {
+        template,
+      },
+    );
+  }
+
+  const availableTemplates = templates.map((t) => `  - ${t.name}`).join("\n");
+  throw new HardhatError(
+    HardhatError.ERRORS.CORE.GENERAL.TEMPLATE_NOT_FOUND_WITH_LIST_OF_OPTIONS,
+    {
+      template,
+      availableTemplates,
+    },
+  );
+}
+
+/**
+ * Prints the list of available templates for the specified Hardhat version.
+ *
+ * @param hardhatVersion The version of Hardhat whose templates should be
+ *  printed.
+ */
+export async function printTemplatesList(
+  hardhatVersion: "hardhat-2" | "hardhat-3",
+  print: (message: string) => void = console.log,
+): Promise<void> {
+  const templates = await getTemplates(hardhatVersion);
+  const lines = templates.map((t) => `  - ${t.name}`).join("\n");
+  print(`Available templates:\n${lines}`);
 }
 
 /**
@@ -496,23 +593,100 @@ export async function copyProjectFiles(
   console.log(`✨ ${styleText("cyan", `Template files copied`)} ✨`);
 }
 
+// NOTE: This function is exported for testing purposes
+export async function assertNoNonInteractiveClashes(
+  workspace: string,
+  template: Template,
+): Promise<void> {
+  const clashes: string[] = [];
+
+  for (const relativeTemplatePath of template.files) {
+    const relativeWorkspacePath =
+      relativeTemplateToWorkspacePath(relativeTemplatePath);
+
+    if (
+      relativeWorkspacePath === "package.json" ||
+      relativeWorkspacePath === "README.md" ||
+      path.basename(relativeWorkspacePath) === ".gitignore"
+    ) {
+      continue;
+    }
+
+    if (await exists(path.join(workspace, relativeWorkspacePath))) {
+      clashes.push(relativeWorkspacePath);
+    }
+  }
+
+  if (clashes.length === 0) {
+    return;
+  }
+
+  throw new HardhatError(
+    HardhatError.ERRORS.CORE.GENERAL.NON_INTERACTIVE_INIT_WOULD_OVERWRITE_FILES,
+    {
+      files: clashes.map((f) => `  - ${f}`).join("\n"),
+    },
+  );
+}
+
+// NOTE: This function is exported for testing purposes
+export async function copyProjectFilesNonInteractive(
+  workspace: string,
+  template: Template,
+): Promise<void> {
+  for (const relativeTemplatePath of template.files) {
+    const relativeWorkspacePath =
+      relativeTemplateToWorkspacePath(relativeTemplatePath);
+    let absoluteWorkspacePath = path.join(workspace, relativeWorkspacePath);
+
+    if (path.basename(relativeWorkspacePath) === ".gitignore") {
+      if (await exists(absoluteWorkspacePath)) {
+        continue;
+      }
+    } else if (
+      relativeWorkspacePath === "README.md" &&
+      (await exists(absoluteWorkspacePath))
+    ) {
+      absoluteWorkspacePath = path.join(workspace, "HARDHAT.md");
+      if (await exists(absoluteWorkspacePath)) {
+        continue;
+      }
+    }
+
+    await ensureDir(path.dirname(absoluteWorkspacePath));
+    await copy(
+      path.join(template.path, relativeTemplatePath),
+      absoluteWorkspacePath,
+    );
+  }
+}
+
 /**
  * installProjectDependencies prints the commands to install the project dependencies
  * and runs them if the install option is true or if the user opts-in to it.
  *
  * NOTE: This function is exported for testing purposes
  *
- * @param workspace The path to the workspace to initialize the project in.
- * @param template The template to use for the project initialization.
- * @param install Whether to install the project dependencies.
- * @param update Whether to update the project dependencies.
+ * @param options The installation options.
+ * @param options.workspace The path to the workspace to initialize the project in.
+ * @param options.template The template to use for the project initialization.
+ * @param options.install Whether to install the project dependencies.
+ * @param options.update Whether to update the project dependencies.
+ * @param options.formatSuccessMessage Whether to format the success message or not.
  */
-export async function installProjectDependencies(
-  workspace: string,
-  template: Template,
-  install?: boolean,
-  update?: boolean,
-): Promise<void> {
+export async function installProjectDependencies({
+  workspace,
+  template,
+  install,
+  update,
+  formatSuccessMessage = true,
+}: {
+  workspace: string;
+  template: Template;
+  install?: boolean;
+  update?: boolean;
+  formatSuccessMessage?: boolean;
+}): Promise<void> {
   const pathToWorkspacePackageJson = path.join(workspace, "package.json");
 
   const workspacePkg: PackageJson = await readJsonFile(
@@ -587,7 +761,11 @@ export async function installProjectDependencies(
         );
       }
 
-      console.log(`✨ ${styleText("cyan", `Dependencies installed`)} ✨`);
+      if (formatSuccessMessage) {
+        console.log(`✨ ${styleText("cyan", `Dependencies installed`)} ✨`);
+      } else {
+        console.log(`Dependencies installed`);
+      }
     }
   }
 
@@ -640,7 +818,11 @@ export async function installProjectDependencies(
         );
       }
 
-      console.log(`✨ ${styleText("cyan", `Dependencies updated`)} ✨`);
+      if (formatSuccessMessage) {
+        console.log(`✨ ${styleText("cyan", `Dependencies updated`)} ✨`);
+      } else {
+        console.log("Dependencies updated");
+      }
     }
   }
 }

package/src/internal/cli/main.ts

@@ -96,7 +96,70 @@ export async function main(
     }
 
     if (builtinGlobalOptions.init) {
-      const { initHardhat } = await import("./init/init.js");
+      const { initHardhat, initHardhat3NonInteractive, printTemplatesList } =
+        await import("./init/init.js");
+
+      let templateName: string | undefined;
+      let listTemplates = false;
+
+      for (let i = 0; i < cliArguments.length; i++) {
+        if (usedCliArguments[i]) {
+          continue;
+        }
+
+        if (cliArguments[i] === "--templates") {
+          usedCliArguments[i] = true;
+          listTemplates = true;
+        }
+      }
+
+      for (let i = 0; i < cliArguments.length; i++) {
+        if (usedCliArguments[i]) {
+          continue;
+        }
+
+        if (cliArguments[i] === "--template") {
+          usedCliArguments[i] = true;
+
+          if (templateName !== undefined) {
+            throw new HardhatError(
+              HardhatError.ERRORS.CORE.ARGUMENTS.DUPLICATED_NAME,
+              { name: "--template" },
+            );
+          }
+
+          if (listTemplates) {
+            throw new HardhatError(
+              HardhatError.ERRORS.CORE.ARGUMENTS.CANNOT_COMBINE_TEMPLATE_AND_TEMPLATES,
+            );
+          }
+
+          if (
+            usedCliArguments[i + 1] === undefined ||
+            usedCliArguments[i + 1] === true ||
+            cliArguments[i + 1] === undefined ||
+            cliArguments[i + 1].startsWith("-")
+          ) {
+            throw new HardhatError(
+              HardhatError.ERRORS.CORE.ARGUMENTS.MISSING_VALUE_FOR_ARGUMENT,
+              { argument: "--template" },
+            );
+          }
+
+          templateName = cliArguments[i + 1];
+          i++;
+          usedCliArguments[i] = true;
+        }
+      }
+
+      if (listTemplates) {
+        return await printTemplatesList("hardhat-3", print);
+      }
+
+      if (templateName !== undefined) {
+        return await initHardhat3NonInteractive({ template: templateName });
+      }
+
       return await initHardhat();
     }
 

package/src/types/arguments.ts

@@ -1,3 +1,5 @@
+import "./builtin-plugin-type-extensions.js";
+
 /**
  * The possible types of a global or task option.
  */

package/src/types/artifacts.ts

@@ -1,6 +1,8 @@
 import type { SolidityBuildInfo } from "./solidity/solidity-artifacts.js";
 import type { NonNeverKeys } from "./utils.js";
 
+import "./builtin-plugin-type-extensions.js";
+
 /**
  * A map of bare contract names and fully qualified contract names to their
  * artifacts that will be completed by Hardhat's build system using module