hardhat 2.13.0-dev.1 → 2.13.0-dev.3

package/src/internal/cli/bootstrap.ts

@@ -1,38 +1,16 @@
-import { fork } from "child_process";
-
-import { getEnvHardhatArguments } from "../core/params/env-variables";
-import { HARDHAT_PARAM_DEFINITIONS } from "../core/params/hardhat-params";
-
-import { ArgumentsParser } from "./ArgumentsParser";
-
-const nodeArgs = [...process.execArgv];
-
-if (process.env.DISABLE_HARDHAT_NETWORK_OPTIMIZATIONS === undefined) {
-  nodeArgs.push("--max-semi-space-size=100");
-}
-
-const envVariableArguments = getEnvHardhatArguments(
-  HARDHAT_PARAM_DEFINITIONS,
-  process.env
-);
-
-const argumentsParser = new ArgumentsParser();
-
-const { hardhatArguments } = argumentsParser.parseHardhatArguments(
-  HARDHAT_PARAM_DEFINITIONS,
-  envVariableArguments,
-  process.argv.slice(2)
-);
-
-if (hardhatArguments.maxMemory !== undefined) {
-  nodeArgs.push(`--max-old-space-size=${hardhatArguments.maxMemory}`);
+#!/usr/bin/env node
+import semver from "semver";
+import chalk from "chalk";
+
+const SUPPORTED_NODE_VERSIONS = ["^14.0.0", "^16.0.0", "^18.0.0"];
+
+if (!semver.satisfies(process.version, SUPPORTED_NODE_VERSIONS.join(" || "))) {
+  console.warn(
+    chalk.yellow.bold(`WARNING:`),
+    `You are using a version of Node.js that is not supported, and it may work incorrectly, or not work at all. See https://hardhat.org/nodejs-versions`
+  );
+  console.log();
+  console.log();
 }
 
-const childProcess = fork(`${__dirname}/cli`, process.argv.slice(2), {
-  stdio: "inherit" as any, // There's an error in the TS definition of ForkOptions
-  execArgv: nodeArgs,
-});
-
-childProcess.once("close", (status) => {
-  process.exit(status as number);
-});
+require("./cli");

package/src/internal/cli/cli.ts

@@ -1,7 +1,5 @@
-#!/usr/bin/env node
 import chalk from "chalk";
 import debug from "debug";
-import semver from "semver";
 import "source-map-support/register";
 
 import {
@@ -9,10 +7,13 @@ import {
   TASK_HELP,
   TASK_TEST,
 } from "../../builtin-tasks/task-names";
-import { TaskArguments } from "../../types";
+import { HardhatConfig, TaskArguments } from "../../types";
 import { HARDHAT_NAME } from "../constants";
 import { HardhatContext } from "../context";
-import { loadConfigAndTasks } from "../core/config/config-loading";
+import {
+  getConfiguredCompilers,
+  loadConfigAndTasks,
+} from "../core/config/config-loading";
 import {
   assertHardhatInvariant,
   HardhatError,
@@ -33,7 +34,7 @@ import {
   writePromptedForHHVSCode,
   writeTelemetryConsent,
 } from "../util/global-dir";
-import { getPackageJson, PackageJson } from "../util/packageInfo";
+import { getPackageJson } from "../util/packageInfo";
 
 import { saveFlamegraph } from "../core/flamegraph";
 import { Analytics } from "./analytics";
@@ -52,25 +53,11 @@ const log = debug("hardhat:core:cli");
 const ANALYTICS_SLOW_TASK_THRESHOLD = 300;
 const SHOULD_SHOW_STACK_TRACES_BY_DEFAULT = isRunningOnCiServer();
 
-async function printVersionMessage(packageJson: PackageJson) {
+async function printVersionMessage() {
+  const packageJson = await getPackageJson();
   console.log(packageJson.version);
 }
 
-function printWarningAboutNodeJsVersionIfNecessary(packageJson: PackageJson) {
-  const requirement = packageJson.engines.node;
-  if (!semver.satisfies(process.version, requirement)) {
-    console.warn(
-      chalk.yellow(
-        `You are using a version of Node.js that is not supported by Hardhat, and it may work incorrectly, or not work at all.
-
-Please, make sure you are using a supported version of Node.js.
-
-To learn more about which versions of Node.js are supported go to https://hardhat.org/nodejs-versions`
-      )
-    );
-  }
-}
-
 async function suggestInstallingHardhatVscode() {
   const alreadyPrompted = hasPromptedForHHVSCode();
   if (alreadyPrompted) {
@@ -104,6 +91,24 @@ async function suggestInstallingHardhatVscode() {
   }
 }
 
+function showViaIRWarning(resolvedConfig: HardhatConfig) {
+  const configuredCompilers = getConfiguredCompilers(resolvedConfig.solidity);
+  const viaIREnabled = configuredCompilers.some(
+    (compiler) => compiler.settings?.viaIR === true
+  );
+
+  if (viaIREnabled) {
+    console.warn();
+    console.warn(
+      chalk.yellow(
+        `Your solidity settings have viaIR enabled, which is not fully supported yet. You can still use Hardhat, but some features, like stack traces, might not work correctly.
+
+Learn more at https://hardhat.org/solc-viair`
+      )
+    );
+  }
+}
+
 async function main() {
   // We first accept this argument anywhere, so we know if the user wants
   // stack traces before really parsing the arguments.
@@ -112,10 +117,6 @@ async function main() {
     SHOULD_SHOW_STACK_TRACES_BY_DEFAULT;
 
   try {
-    const packageJson = await getPackageJson();
-
-    printWarningAboutNodeJsVersionIfNecessary(packageJson);
-
     const envVariableArguments = getEnvHardhatArguments(
       HARDHAT_PARAM_DEFINITIONS,
       process.env
@@ -146,7 +147,7 @@ async function main() {
 
     // --version is a special case
     if (hardhatArguments.version) {
-      await printVersionMessage(packageJson);
+      await printVersionMessage();
       return;
     }
 
@@ -171,7 +172,11 @@ async function main() {
       }
     }
 
-    if (!isHardhatInstalledLocallyOrLinked()) {
+    if (
+      process.env.HARDHAT_EXPERIMENTAL_ALLOW_NON_LOCAL_INSTALLATION !==
+        "true" &&
+      !isHardhatInstalledLocallyOrLinked()
+    ) {
       throw new HardhatError(ERRORS.GENERAL.NON_LOCAL_INSTALLATION);
     }
 
@@ -223,7 +228,7 @@ async function main() {
       Reporter.setEnabled(true);
     }
 
-    const envExtenders = ctx.extendersManager.getEnvironmentExtenders();
+    const envExtenders = ctx.extendersManager.getExtenders();
     const taskDefinitions = ctx.tasksDSL.getTaskDefinitions();
 
     const [abortAnalytics, hitPromise] = await analytics.sendTaskHit(taskName);
@@ -255,16 +260,11 @@ async function main() {
       );
     }
 
-    const artifactsExtensions = ctx.extendersManager
-      .getArtifactsExtenders()
-      .map((artifactsExtender) => artifactsExtender(resolvedConfig));
-
     const env = new Environment(
       resolvedConfig,
       hardhatArguments,
       taskDefinitions,
       envExtenders,
-      artifactsExtensions,
       ctx.experimentalHardhatNetworkMessageTraceHooks,
       userConfig
     );
@@ -306,6 +306,11 @@ async function main() {
       process.stdout.isTTY === true
     ) {
       await suggestInstallingHardhatVscode();
+
+      // we show the viaIR warning only if the tests failed
+      if (process.exitCode !== 0) {
+        showViaIRWarning(resolvedConfig);
+      }
     }
 
     log(`Killing Hardhat after successfully running task ${taskName}`);
@@ -314,11 +319,15 @@ async function main() {
 
     if (HardhatError.isHardhatError(error)) {
       isHardhatError = true;
-      console.error(chalk.red(`Error ${error.message}`));
+      console.error(
+        chalk.red.bold("Error"),
+        error.message.replace(/^\w+:/, (t) => chalk.red.bold(t))
+      );
     } else if (HardhatPluginError.isHardhatPluginError(error)) {
       isHardhatError = true;
       console.error(
-        chalk.red(`Error in plugin ${error.pluginName}: ${error.message}`)
+        chalk.red.bold(`Error in plugin ${error.pluginName}:`),
+        error.message
       );
     } else if (error instanceof Error) {
       console.error(chalk.red("An unexpected error occurred:"));

package/src/internal/cli/project-creation.ts

@@ -4,15 +4,20 @@ import os from "os";
 import path from "path";
 
 import { HARDHAT_NAME } from "../constants";
-import { HardhatError } from "../core/errors";
+import { assertHardhatInvariant, HardhatError } from "../core/errors";
 import { ERRORS } from "../core/errors-list";
 import { getRecommendedGitIgnore } from "../core/project-structure";
+import { getAllFilesMatching } from "../util/fs-utils";
 import {
   hasConsentedTelemetry,
   writeTelemetryConsent,
 } from "../util/global-dir";
 import { fromEntries } from "../util/lang";
-import { getPackageJson, getPackageRoot } from "../util/packageInfo";
+import {
+  getPackageJson,
+  getPackageRoot,
+  PackageJson,
+} from "../util/packageInfo";
 import { pluralize } from "../util/strings";
 import {
   confirmRecommendedDepsInstallation,
@@ -20,7 +25,7 @@ import {
   confirmProjectCreation,
 } from "./prompt";
 import { emoji } from "./emoji";
-import { Dependencies } from "./types";
+import { Dependencies, PackageManager } from "./types";
 
 enum Action {
   CREATE_JAVASCRIPT_PROJECT_ACTION = "Create a JavaScript project",
@@ -60,7 +65,7 @@ const TYPESCRIPT_DEPENDENCIES: Dependencies = {};
 
 const TYPESCRIPT_PEER_DEPENDENCIES: Dependencies = {
   "@types/chai": "^4.2.0",
-  "@types/mocha": "^9.1.0",
+  "@types/mocha": ">=9.1.0",
   "@types/node": ">=12.0.0",
   "ts-node": ">=8.0.0",
   typescript: ">=4.5.0",
@@ -109,14 +114,28 @@ async function printWelcomeMessage() {
 
 async function copySampleProject(
   projectRoot: string,
-  projectType: SampleProjectTypeCreationAction
+  projectType: SampleProjectTypeCreationAction,
+  isEsm: boolean
 ) {
   const packageRoot = getPackageRoot();
 
-  const sampleProjectName =
-    projectType === Action.CREATE_JAVASCRIPT_PROJECT_ACTION
-      ? "javascript"
-      : "typescript";
+  let sampleProjectName: string;
+  if (projectType === Action.CREATE_JAVASCRIPT_PROJECT_ACTION) {
+    if (isEsm) {
+      sampleProjectName = "javascript-esm";
+    } else {
+      sampleProjectName = "javascript";
+    }
+  } else {
+    if (isEsm) {
+      assertHardhatInvariant(
+        false,
+        "Shouldn't try to create a TypeScript project in an ESM based project"
+      );
+    } else {
+      sampleProjectName = "typescript";
+    }
+  }
 
   await fsExtra.ensureDir(projectRoot);
 
@@ -126,11 +145,23 @@ async function copySampleProject(
     sampleProjectName
   );
 
-  const sampleProjectRootFiles = fsExtra.readdirSync(sampleProjectPath);
-  const existingFiles = sampleProjectRootFiles
-    .map((f) => path.join(projectRoot, f))
-    .filter((f) => fsExtra.pathExistsSync(f))
-    .map((f) => path.relative(process.cwd(), f));
+  // relative paths to all the sample project files
+  const sampleProjectFiles = (await getAllFilesMatching(sampleProjectPath)).map(
+    (file) => path.relative(sampleProjectPath, file)
+  );
+
+  // check if the target directory already has files that clash with the sample
+  // project files
+  const existingFiles: string[] = [];
+  for (const file of sampleProjectFiles) {
+    const targetProjectFile = path.resolve(projectRoot, file);
+
+    // if the project already has a README.md file, we'll skip it when
+    // we copy the files
+    if (file !== "README.md" && fsExtra.existsSync(targetProjectFile)) {
+      existingFiles.push(file);
+    }
+  }
 
   if (existingFiles.length > 0) {
     const errorMsg = `We couldn't initialize the sample project because ${pluralize(
@@ -138,18 +169,33 @@ async function copySampleProject(
       "this file already exists",
       "these files already exist"
     )}: ${existingFiles.join(", ")}
-    
-Please delete or move them and try again.`;
+
+Please delete or rename ${pluralize(
+      existingFiles.length,
+      "it",
+      "them"
+    )} and try again.`;
     console.log(chalk.red(errorMsg));
     process.exit(1);
   }
 
-  await fsExtra.copy(
-    path.join(packageRoot, "sample-projects", sampleProjectName),
-    projectRoot
-  );
+  // copy the files
+  for (const file of sampleProjectFiles) {
+    const sampleProjectFile = path.resolve(sampleProjectPath, file);
+    const targetProjectFile = path.resolve(projectRoot, file);
 
-  await fsExtra.remove(path.join(projectRoot, "LICENSE.md"));
+    if (file === "README.md" && fsExtra.existsSync(targetProjectFile)) {
+      // we don't override the readme if it exists
+      continue;
+    }
+
+    if (file === "LICENSE.md") {
+      // we don't copy the license
+      continue;
+    }
+
+    fsExtra.copySync(sampleProjectFile, targetProjectFile);
+  }
 }
 
 async function addGitIgnore(projectRoot: string) {
@@ -183,15 +229,23 @@ async function printRecommendedDepsInstallationInstructions(
 // exported so we can test that it uses the latest supported version of solidity
 export const EMPTY_HARDHAT_CONFIG = `/** @type import('hardhat/config').HardhatUserConfig */
 module.exports = {
-  solidity: "0.8.17",
+  solidity: "0.8.18",
 };
 `;
 
-async function writeEmptyHardhatConfig() {
-  return fsExtra.writeFile("hardhat.config.js", EMPTY_HARDHAT_CONFIG, "utf-8");
+async function writeEmptyHardhatConfig(isEsm: boolean) {
+  const hardhatConfigFilename = isEsm
+    ? "hardhat.config.cjs"
+    : "hardhat.config.js";
+
+  return fsExtra.writeFile(
+    hardhatConfigFilename,
+    EMPTY_HARDHAT_CONFIG,
+    "utf-8"
+  );
 }
 
-async function getAction(): Promise<Action> {
+async function getAction(isEsm: boolean): Promise<Action> {
   if (
     process.env.HARDHAT_CREATE_JAVASCRIPT_PROJECT_WITH_DEFAULTS !== undefined
   ) {
@@ -211,7 +265,24 @@ async function getAction(): Promise<Action> {
         message: "What do you want to do?",
         initial: 0,
         choices: Object.values(Action).map((a: Action) => {
-          return { name: a, message: a, value: a };
+          let message: string;
+          if (isEsm) {
+            if (a === Action.CREATE_EMPTY_HARDHAT_CONFIG_ACTION) {
+              message = a.replace(".js", ".cjs");
+            } else if (a === Action.CREATE_TYPESCRIPT_PROJECT_ACTION) {
+              message = `${a} (not available for ESM projects)`;
+            } else {
+              message = a;
+            }
+          } else {
+            message = a;
+          }
+
+          return {
+            name: a,
+            message,
+            value: a,
+          };
         }),
       },
     ]);
@@ -257,18 +328,28 @@ export async function createProject() {
 
   await printWelcomeMessage();
 
-  const action = await getAction();
+  let packageJson: PackageJson | undefined;
+  if (await fsExtra.pathExists("package.json")) {
+    packageJson = await fsExtra.readJson("package.json");
+  }
+  const isEsm = packageJson?.type === "module";
+
+  const action = await getAction(isEsm);
 
   if (action === Action.QUIT_ACTION) {
     return;
   }
 
-  if (!(await fsExtra.pathExists("package.json"))) {
+  if (isEsm && action === Action.CREATE_TYPESCRIPT_PROJECT_ACTION) {
+    throw new HardhatError(ERRORS.GENERAL.ESM_TYPESCRIPT_PROJECT_CREATION);
+  }
+
+  if (packageJson === undefined) {
     await createPackageJson();
   }
 
   if (action === Action.CREATE_EMPTY_HARDHAT_CONFIG_ACTION) {
-    await writeEmptyHardhatConfig();
+    await writeEmptyHardhatConfig(isEsm);
     console.log(
       `${emoji("✨ ")}${chalk.cyan(`Config file created`)}${emoji(" ✨")}`
     );
@@ -332,7 +413,7 @@ export async function createProject() {
     }
   }
 
-  await copySampleProject(projectRoot, action);
+  await copySampleProject(projectRoot, action, isEsm);
 
   let shouldShowInstallationInstructions = true;
 
@@ -357,7 +438,7 @@ export async function createProject() {
         useDefaultPromptResponses ||
         (await confirmRecommendedDepsInstallation(
           dependenciesToInstall,
-          await isYarnProject()
+          await getProjectPackageManager()
         ));
       if (shouldInstall) {
         const installed = await installRecommendedDependencies(
@@ -414,6 +495,16 @@ async function isYarnProject() {
   return fsExtra.pathExists("yarn.lock");
 }
 
+async function isPnpmProject() {
+  return fsExtra.pathExists("pnpm-lock.yaml");
+}
+
+async function getProjectPackageManager(): Promise<PackageManager> {
+  if (await isYarnProject()) return "yarn";
+  if (await isPnpmProject()) return "pnpm";
+  return "npm";
+}
+
 async function doesNpmAutoInstallPeerDependencies() {
   const { execSync } = require("child_process");
   try {
@@ -480,6 +571,10 @@ async function getRecommendedDependenciesInstallationCommand(
     return ["yarn", "add", "--dev", ...deps];
   }
 
+  if (await isPnpmProject()) {
+    return ["pnpm", "add", "-D", ...deps];
+  }
+
   return ["npm", "install", "--save-dev", ...deps];
 }
 
@@ -487,7 +582,9 @@ async function getDependencies(
   projectType: SampleProjectTypeCreationAction
 ): Promise<Dependencies> {
   const shouldInstallPeerDependencies =
-    (await isYarnProject()) || !(await doesNpmAutoInstallPeerDependencies());
+    (await isYarnProject()) ||
+    (await isPnpmProject()) ||
+    !(await doesNpmAutoInstallPeerDependencies());
 
   const shouldInstallTypescriptDependencies =
     projectType === Action.CREATE_TYPESCRIPT_PROJECT_ACTION;

package/src/internal/cli/prompt.ts

@@ -1,4 +1,4 @@
-import { Dependencies } from "./types";
+import { Dependencies, PackageManager } from "./types";
 
 function createConfirmationPrompt(name: string, message: string) {
   return {
@@ -36,7 +36,7 @@ function createConfirmationPrompt(name: string, message: string) {
 
 export async function confirmRecommendedDepsInstallation(
   depsToInstall: Dependencies,
-  useYarn: boolean
+  packageManager: PackageManager
 ): Promise<boolean> {
   const { default: enquirer } = await import("enquirer");
 
@@ -44,8 +44,6 @@ export async function confirmRecommendedDepsInstallation(
     shouldInstallPlugin: boolean;
   };
 
-  const packageManager = useYarn ? "yarn" : "npm";
-
   try {
     responses = await enquirer.prompt<typeof responses>([
       createConfirmationPrompt(

package/src/internal/cli/types.ts

@@ -1,3 +1,5 @@
 export interface Dependencies {
   [name: string]: string;
 }
+
+export type PackageManager = "npm" | "yarn" | "pnpm";

package/src/internal/core/config/config-env.ts

@@ -1,6 +1,5 @@
 import {
   ActionType,
-  ArtifactsExtender,
   ConfigExtender,
   ConfigurableTaskDefinition,
   EnvironmentExtender,
@@ -20,10 +19,10 @@ import * as argumentTypes from "../params/argumentTypes";
  * @param action The task's action.
  * @returns A task definition.
  */
-export function task<ArgsT extends TaskArguments>(
+export function task<TaskArgumentsT extends TaskArguments>(
   name: string,
   description?: string,
-  action?: ActionType<ArgsT>
+  action?: ActionType<TaskArgumentsT>
 ): ConfigurableTaskDefinition;
 
 /**
@@ -37,15 +36,15 @@ export function task<ArgsT extends TaskArguments>(
  *
  * @returns A task definition.
  */
-export function task<ArgsT extends TaskArguments>(
+export function task<TaskArgumentsT extends TaskArguments>(
   name: string,
-  action: ActionType<ArgsT>
+  action: ActionType<TaskArgumentsT>
 ): ConfigurableTaskDefinition;
 
-export function task<ArgsT extends TaskArguments>(
+export function task<TaskArgumentsT extends TaskArguments>(
   name: string,
-  descriptionOrAction?: string | ActionType<ArgsT>,
-  action?: ActionType<ArgsT>
+  descriptionOrAction?: string | ActionType<TaskArgumentsT>,
+  action?: ActionType<TaskArgumentsT>
 ): ConfigurableTaskDefinition {
   const ctx = HardhatContext.getHardhatContext();
   const dsl = ctx.tasksDSL;
@@ -72,10 +71,10 @@ export function task<ArgsT extends TaskArguments>(
  * @param action The task's action.
  * @returns A task definition.
  */
-export function subtask<ArgsT extends TaskArguments>(
+export function subtask<TaskArgumentsT extends TaskArguments>(
   name: string,
   description?: string,
-  action?: ActionType<ArgsT>
+  action?: ActionType<TaskArgumentsT>
 ): ConfigurableTaskDefinition;
 
 /**
@@ -89,15 +88,15 @@ export function subtask<ArgsT extends TaskArguments>(
  * @param action The task's action.
  * @returns A task definition.
  */
-export function subtask<ArgsT extends TaskArguments>(
+export function subtask<TaskArgumentsT extends TaskArguments>(
   name: string,
-  action: ActionType<ArgsT>
+  action: ActionType<TaskArgumentsT>
 ): ConfigurableTaskDefinition;
 
-export function subtask<ArgsT extends TaskArguments>(
+export function subtask<TaskArgumentsT extends TaskArguments>(
   name: string,
-  descriptionOrAction?: string | ActionType<ArgsT>,
-  action?: ActionType<ArgsT>
+  descriptionOrAction?: string | ActionType<TaskArgumentsT>,
+  action?: ActionType<TaskArgumentsT>
 ): ConfigurableTaskDefinition {
   const ctx = HardhatContext.getHardhatContext();
   const dsl = ctx.tasksDSL;
@@ -128,7 +127,7 @@ export const types = argumentTypes;
 export function extendEnvironment(extender: EnvironmentExtender) {
   const ctx = HardhatContext.getHardhatContext();
   const extenderManager = ctx.extendersManager;
-  extenderManager.addEnvironmentExtender(extender);
+  extenderManager.add(extender);
 }
 
 export function extendConfig(extender: ConfigExtender) {
@@ -136,17 +135,6 @@ export function extendConfig(extender: ConfigExtender) {
   ctx.configExtenders.push(extender);
 }
 
-/**
- * Accepts a function that receives the resolved configuration and returns an
- * extra source of artifacts. This source has to implement the ArtifactsSource
- * interface.
- */
-export function extendArtifacts(artifactsExtender: ArtifactsExtender) {
-  const ctx = HardhatContext.getHardhatContext();
-  const extenderManager = ctx.extendersManager;
-  extenderManager.addArtifactsExtender(artifactsExtender);
-}
-
 // NOTE: This is experimental and will be removed. Please contact our team
 // if you are planning to use it.
 export function experimentalAddHardhatNetworkMessageTraceHook(