hardhat 3.4.4 → 3.5.0

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

@@ -1,4 +1,3 @@
-import "../../../types/config.js";
 import type {
   SensitiveString,
   ResolvedConfigurationVariable,
@@ -15,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;
@@ -27,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;
@@ -51,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/builtin-plugins/test/index.ts

@@ -3,7 +3,7 @@ import type { HardhatPlugin } from "../../../types/plugins.js";
 import { ArgumentType } from "../../../types/arguments.js";
 import { task } from "../../core/config.js";
 
-import "./type-extensions.js";
+export type * from "./type-extensions.js";
 
 const hardhatPlugin: HardhatPlugin = {
   id: "builtin:test",

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

@@ -1,4 +1,3 @@
-import "../../../types/hooks.js";
 import type {
   HardhatTestConfig,
   HardhatTestUserConfig,

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

package/src/types/builtin-plugin-type-extensions.ts

@@ -0,0 +1,15 @@
+// This is an internal file that needs to be imported by every top-level type
+// file, so that they load the builtin plugin type extensions.
+//
+// The trade-off here is that we end up with one unnecessary runtime import of
+// an empty file (this one) if a `src/types/*` file is imported without the
+// `type` annotation (e.g. the CLI's indirectly importing task-related enums),
+// in exchange for better DX.
+//
+// The reason we can't just use the `export type *` from the other files instead
+// is that in some cases that leads to a circular export of types that TS can't
+// handle.
+//
+// The reason we can't use `import type` is that those get erased during
+// compilation.
+export type * from "../internal/builtin-plugins/index.js";

package/src/types/config.ts

@@ -1,6 +1,4 @@
-// NOTE: We import the builtin plugins in this module, so that their
-// type-extensions are loaded when the user imports `hardhat/types/config`.
-import "../internal/builtin-plugins/index.js";
+import "./builtin-plugin-type-extensions.js";
 
 /**
  * A configuration variable to be fetched at runtime from

package/src/types/global-options.ts

@@ -1,5 +1,7 @@
 import type { GlobalOptionDefinition } from "./arguments.js";
 
+import "./builtin-plugin-type-extensions.js";
+
 /**
  * The values of each global option for a certain instance of the Hardhat
  * Runtime Environment are defined here. This interface can be extended through

package/src/types/hooks.ts

@@ -14,6 +14,8 @@ import type {
   Return,
 } from "./utils.js";
 
+import "./builtin-plugin-type-extensions.js";
+
 // We add the HookManager to the HRE with a module augmentation to avoid
 // introducing a circular dependency that would look like this:
 // hre.ts -> hooks.ts -> hre.ts

package/src/types/hre.ts

@@ -2,6 +2,8 @@ import type { GlobalOptions } from "./global-options.js";
 import type { UserInterruptionManager } from "./user-interruptions.js";
 import type { HardhatConfig, HardhatUserConfig } from "../types/config.js";
 
+import "./builtin-plugin-type-extensions.js";
+
 /**
  * The Hardhat Runtime Environment (HRE) is an object that exposes
  * all the functionality available through Hardhat.

package/src/types/index.ts

@@ -1,3 +1,5 @@
+import "./builtin-plugin-type-extensions.js";
+
 export * from "./arguments.js";
 export * from "./artifacts.js";
 export * from "./config.js";

package/src/types/network.ts

@@ -1,6 +1,8 @@
 import type { NetworkConfig, NetworkConfigOverride } from "./config.js";
 import type { EthereumProvider } from "./providers.js";
 
+import "./builtin-plugin-type-extensions.js";
+
 /**
  * Represents the possible chain types for the network. The options are:
  * - `GenericNetworkType`: Represents the most generic type of network.

package/src/types/plugins.ts

@@ -2,9 +2,7 @@ import type { GlobalOptionDefinition } from "./arguments.js";
 import type { HardhatHooks } from "./hooks.js";
 import type { TaskDefinition } from "./tasks.js";
 
-// NOTE: We import the builtin plugins in this module, so that their
-// type-extensions are loaded when the user imports `hardhat/types/plugins`.
-import "../internal/builtin-plugins/index.js";
+import "./builtin-plugin-type-extensions.js";
 
 // We add the plugins to the config types with a module augmentation to avoid
 // introducing a circular dependency that would look like this:

package/src/types/providers.ts

@@ -1,5 +1,7 @@
 import type EventEmitter from "node:events";
 
+import "./builtin-plugin-type-extensions.js";
+
 export interface RequestArguments {
   readonly method: string;
   readonly params?: readonly unknown[] | object;

package/src/types/solidity.ts

@@ -1,3 +1,5 @@
+import "./builtin-plugin-type-extensions.js";
+
 export * from "./solidity/build-system.js";
 export * from "./solidity/compilation-job.js";
 export * from "./solidity/compiler.js";

package/src/types/tasks.ts

@@ -8,6 +8,8 @@ import type { HardhatRuntimeEnvironment } from "./hre.js";
 /* eslint-disable-next-line @typescript-eslint/no-unused-vars -- used in JSDoc {@link} */
 import type { Result } from "./utils.js";
 
+import "./builtin-plugin-type-extensions.js";
+
 // We add the TaskManager to the HRE with a module augmentation to avoid
 // introducing a circular dependency that would look like this:
 // hre.ts -> tasks.ts -> hre.ts

package/src/types/test.ts

@@ -1,3 +1,5 @@
+import "./builtin-plugin-type-extensions.js";
+
 /* eslint-disable-next-line @typescript-eslint/no-empty-interface -- Empty
 interface allow plugins to extend the Test user configuration for Hardhat. */
 export interface HardhatTestUserConfig {}