hardhatjs 2.22.15

package/src/internal/cli/prompt.ts

@@ -0,0 +1,141 @@
+import { Dependencies, PackageManager } from "./types";
+
+function createConfirmationPrompt(name: string, message: string) {
+  return {
+    type: "confirm",
+    name,
+    message,
+    initial: "y",
+    default: "(Y/n)",
+    isTrue(input: string | boolean) {
+      if (typeof input === "string") {
+        return input.toLowerCase() === "y";
+      }
+
+      return input;
+    },
+    isFalse(input: string | boolean) {
+      if (typeof input === "string") {
+        return input.toLowerCase() === "n";
+      }
+
+      return input;
+    },
+    format(): string {
+      const that = this as any;
+      const value = that.value === true ? "y" : "n";
+
+      if (that.state.submitted === true) {
+        return that.styles.submitted(value);
+      }
+
+      return value;
+    },
+  };
+}
+
+export async function confirmRecommendedDepsInstallation(
+  depsToInstall: Dependencies,
+  packageManager: PackageManager
+): Promise<boolean> {
+  const { default: enquirer } = await import("enquirer");
+
+  let responses: {
+    shouldInstallPlugin: boolean;
+  };
+
+  try {
+    responses = await enquirer.prompt<typeof responses>([
+      createConfirmationPrompt(
+        "shouldInstallPlugin",
+        `Do you want to install this sample project's dependencies with ${packageManager} (${Object.keys(
+          depsToInstall
+        ).join(" ")})?`
+      ),
+    ]);
+  } catch (e) {
+    if (e === "") {
+      return false;
+    }
+
+    // eslint-disable-next-line @nomicfoundation/hardhat-internal-rules/only-hardhat-error
+    throw e;
+  }
+
+  return responses.shouldInstallPlugin;
+}
+
+export async function confirmProjectCreation(): Promise<{
+  projectRoot: string;
+  shouldAddGitIgnore: boolean;
+}> {
+  const enquirer = require("enquirer");
+  return enquirer.prompt([
+    {
+      name: "projectRoot",
+      type: "input",
+      initial: process.cwd(),
+      message: "Hardhat project root:",
+    },
+    createConfirmationPrompt(
+      "shouldAddGitIgnore",
+      "Do you want to add a .gitignore?"
+    ),
+  ]);
+}
+
+export async function confirmTelemetryConsent(): Promise<boolean | undefined> {
+  return confirmationPromptWithTimeout(
+    "telemetryConsent",
+    "Help us improve Hardhat with anonymous crash reports & basic usage data?"
+  );
+}
+
+/**
+ * true = install ext
+ * false = don't install and don't ask again
+ * undefined = we couldn't confirm if the extension is installed or not
+ */
+export async function confirmHHVSCodeInstallation(): Promise<
+  boolean | undefined
+> {
+  return confirmationPromptWithTimeout(
+    "shouldInstallExtension",
+    "Would you like to install the Hardhat for Visual Studio Code extension? It adds advanced editing assistance for Solidity to VSCode"
+  );
+}
+
+async function confirmationPromptWithTimeout(
+  name: string,
+  message: string,
+  timeoutMilliseconds: number = 10_000
+): Promise<boolean | undefined> {
+  try {
+    const enquirer = require("enquirer");
+
+    const prompt = new enquirer.prompts.Confirm(
+      createConfirmationPrompt(name, message)
+    );
+
+    let timeout;
+    const timeoutPromise = new Promise((resolve) => {
+      timeout = setTimeout(resolve, timeoutMilliseconds);
+    });
+
+    const result = await Promise.race([prompt.run(), timeoutPromise]);
+    clearTimeout(timeout);
+
+    if (result === undefined) {
+      await prompt.cancel();
+    }
+
+    return result;
+  } catch (e: any) {
+    if (e === "") {
+      return undefined;
+    }
+
+    // eslint-disable-next-line @nomicfoundation/hardhat-internal-rules/only-hardhat-error
+    throw e;
+  }
+}

package/src/internal/cli/types.ts

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

package/src/internal/cli/vars.ts

@@ -0,0 +1,301 @@
+import chalk from "chalk";
+import debug from "debug";
+import { HardhatError, assertHardhatInvariant } from "../core/errors";
+import { ERRORS } from "../core/errors-list";
+import { HardhatContext } from "../context";
+import { VarsManagerSetup } from "../core/vars/vars-manager-setup";
+import {
+  importCsjOrEsModule,
+  resolveConfigPath,
+} from "../core/config/config-loading";
+import { getVarsFilePath } from "../util/global-dir";
+import { ArgumentsParser } from "./ArgumentsParser";
+import { emoji } from "./emoji";
+
+const log = debug("hardhat:cli:vars");
+
+export async function handleVars(
+  allUnparsedCLAs: string[],
+  configPath: string | undefined
+): Promise<number> {
+  const { taskDefinition, taskArguments } =
+    await getTaskDefinitionAndTaskArguments(allUnparsedCLAs);
+
+  switch (taskDefinition.name) {
+    case "set":
+      return set(taskArguments.var, taskArguments.value);
+    case "get":
+      return get(taskArguments.var);
+    case "list":
+      return list();
+    case "delete":
+      return del(taskArguments.var);
+    case "path":
+      return path();
+    case "setup":
+      return setup(configPath);
+    default:
+      console.error(chalk.red(`Invalid task '${taskDefinition.name}'`));
+      return 1; // Error code
+  }
+}
+
+async function set(key: string, value?: string): Promise<number> {
+  const varsManager = HardhatContext.getHardhatContext().varsManager;
+
+  varsManager.validateKey(key);
+
+  varsManager.set(key, value ?? (await getVarValue()));
+
+  if (process.stdout.isTTY) {
+    console.warn(
+      `The configuration variable has been stored in ${varsManager.getStoragePath()}`
+    );
+  }
+
+  return 0;
+}
+
+function get(key: string): number {
+  const value = HardhatContext.getHardhatContext().varsManager.get(key);
+
+  if (value !== undefined) {
+    console.log(value);
+    return 0;
+  }
+
+  console.warn(
+    chalk.yellow(
+      `The configuration variable '${key}' is not set in ${HardhatContext.getHardhatContext().varsManager.getStoragePath()}`
+    )
+  );
+  return 1;
+}
+
+function list(): number {
+  const keys = HardhatContext.getHardhatContext().varsManager.list();
+  const varsStoragePath =
+    HardhatContext.getHardhatContext().varsManager.getStoragePath();
+
+  if (keys.length > 0) {
+    keys.forEach((k) => console.log(k));
+
+    if (process.stdout.isTTY) {
+      console.warn(
+        `\nAll configuration variables are stored in ${varsStoragePath}`
+      );
+    }
+  } else {
+    if (process.stdout.isTTY) {
+      console.warn(
+        chalk.yellow(
+          `There are no configuration variables stored in ${varsStoragePath}`
+        )
+      );
+    }
+  }
+
+  return 0;
+}
+
+function del(key: string): number {
+  const varsStoragePath =
+    HardhatContext.getHardhatContext().varsManager.getStoragePath();
+
+  if (HardhatContext.getHardhatContext().varsManager.delete(key)) {
+    if (process.stdout.isTTY) {
+      console.warn(
+        `The configuration variable was deleted from ${varsStoragePath}`
+      );
+    }
+    return 0;
+  }
+
+  console.warn(
+    chalk.yellow(
+      `There is no configuration variable '${key}' to delete from ${varsStoragePath}`
+    )
+  );
+
+  return 1;
+}
+
+function path() {
+  console.log(HardhatContext.getHardhatContext().varsManager.getStoragePath());
+  return 0;
+}
+
+function setup(configPath: string | undefined) {
+  log("Switching to SetupVarsManager to collect vars");
+
+  const varsManagerSetup = new VarsManagerSetup(getVarsFilePath());
+
+  HardhatContext.getHardhatContext().varsManager = varsManagerSetup;
+
+  try {
+    log("Loading config and tasks to trigger vars collection");
+    loadConfigFile(configPath);
+  } catch (err: any) {
+    console.error(
+      chalk.red(
+        "There is an error in your Hardhat configuration file. Please double check it.\n"
+      )
+    );
+
+    // eslint-disable-next-line @nomicfoundation/hardhat-internal-rules/only-hardhat-error
+    throw err;
+  }
+
+  listVarsToSetup(varsManagerSetup);
+
+  return 0;
+}
+
+// The code below duplicates a section from the 'loadConfigAndTasks' function.
+// While we could have refactored the 'config-loading.ts' module to make this logic reusable,
+// it would have added complexity and potentially made the code harder to understand.
+function loadConfigFile(configPath: string | undefined) {
+  const configEnv = require(`../core/config/config-env`);
+
+  // Load all the functions and objects exported by the 'config-env' file in a global scope
+  const globalAsAny: any = global;
+  Object.entries(configEnv).forEach(
+    ([key, value]) => (globalAsAny[key] = value)
+  );
+
+  const resolvedConfigPath = resolveConfigPath(configPath);
+  importCsjOrEsModule(resolvedConfigPath);
+}
+
+async function getVarValue(): Promise<string> {
+  const { default: enquirer } = await import("enquirer");
+
+  const response: { value: string } = await enquirer.prompt({
+    type: "password",
+    name: "value",
+    message: "Enter value:",
+  });
+
+  return response.value;
+}
+
+function listVarsToSetup(varsManagerSetup: VarsManagerSetup) {
+  const HH_SET_COMMAND = "npx hardhat vars set";
+
+  const requiredKeysToSet = varsManagerSetup.getRequiredVarsToSet();
+  const optionalKeysToSet = varsManagerSetup.getOptionalVarsToSet();
+
+  if (requiredKeysToSet.length === 0 && optionalKeysToSet.length === 0) {
+    console.log(
+      chalk.green(
+        "There are no configuration variables that need to be set for this project"
+      )
+    );
+    console.log();
+    printAlreadySetKeys(varsManagerSetup);
+    return;
+  }
+
+  if (requiredKeysToSet.length > 0) {
+    console.log(
+      chalk.bold(
+        `${emoji("❗ ")}The following configuration variables need to be set:\n`
+      )
+    );
+    console.log(
+      requiredKeysToSet.map((k) => `  ${HH_SET_COMMAND} ${k}`).join("\n")
+    );
+    console.log();
+  }
+
+  if (optionalKeysToSet.length > 0) {
+    console.log(
+      chalk.bold(
+        `${emoji("💡 ")}The following configuration variables are optional:\n`
+      )
+    );
+    console.log(
+      optionalKeysToSet.map((k) => `  ${HH_SET_COMMAND} ${k}`).join("\n")
+    );
+    console.log();
+  }
+
+  printAlreadySetKeys(varsManagerSetup);
+}
+
+function printAlreadySetKeys(varsManagerSetup: VarsManagerSetup) {
+  const requiredKeysAlreadySet = varsManagerSetup.getRequiredVarsAlreadySet();
+  const optionalKeysAlreadySet = varsManagerSetup.getOptionalVarsAlreadySet();
+  const envVars = varsManagerSetup.getEnvVars();
+
+  if (
+    requiredKeysAlreadySet.length === 0 &&
+    optionalKeysAlreadySet.length === 0 &&
+    envVars.length === 0
+  ) {
+    return;
+  }
+
+  console.log(
+    `${chalk.bold(`${emoji("✔️  ")}Configuration variables already set:`)}`
+  );
+  console.log();
+
+  if (requiredKeysAlreadySet.length > 0) {
+    console.log("  Mandatory:");
+    console.log(requiredKeysAlreadySet.map((x) => `    ${x}`).join("\n"));
+    console.log();
+  }
+
+  if (optionalKeysAlreadySet.length > 0) {
+    console.log("  Optional:");
+    console.log(optionalKeysAlreadySet.map((x) => `    ${x}`).join("\n"));
+    console.log();
+  }
+
+  if (envVars.length > 0) {
+    console.log("  Set via environment variables:");
+    console.log(envVars.map((x) => `    ${x}`).join("\n"));
+    console.log();
+  }
+}
+
+async function getTaskDefinitionAndTaskArguments(allUnparsedCLAs: string[]) {
+  const ctx = HardhatContext.getHardhatContext();
+  ctx.setConfigLoadingAsStarted();
+  require("../../builtin-tasks/vars");
+  ctx.setConfigLoadingAsFinished();
+
+  const argumentsParser = new ArgumentsParser();
+
+  const taskDefinitions = ctx.tasksDSL.getTaskDefinitions();
+  const scopesDefinitions = ctx.tasksDSL.getScopesDefinitions();
+
+  const { scopeName, taskName, unparsedCLAs } =
+    argumentsParser.parseScopeAndTaskNames(
+      allUnparsedCLAs,
+      taskDefinitions,
+      scopesDefinitions
+    );
+
+  assertHardhatInvariant(
+    scopeName === "vars",
+    "This function should only be called to handle tasks under the 'vars' scope"
+  );
+
+  const taskDefinition = ctx.tasksDSL.getTaskDefinition(scopeName, taskName);
+
+  if (taskDefinition === undefined) {
+    throw new HardhatError(ERRORS.ARGUMENTS.UNRECOGNIZED_SCOPED_TASK, {
+      scope: scopeName,
+      task: taskName,
+    });
+  }
+
+  const taskArguments = argumentsParser.parseTaskArguments(
+    taskDefinition,
+    unparsedCLAs
+  );
+
+  return { taskDefinition, taskArguments };
+}

package/src/internal/cli/version-notifier.ts

@@ -0,0 +1,268 @@
+import boxen from "boxen";
+import chalk from "chalk";
+import fsExtra from "fs-extra";
+import { join } from "node:path";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import semver from "semver";
+
+import { getCacheDir } from "../util/global-dir";
+import { getHardhatVersion } from "../util/packageInfo";
+
+const GITHUB_API_URL = "https://api.github.com";
+const GITHUB_OWNER = "NomicFoundation";
+const GITHUB_REPO = "hardhat";
+const V3_RELEASE_TAG = "hardhat@3.0.0";
+const V3_RELEASE_VERSION_NOTIFIER_ASSET_NAME = "version-notifier-message.txt";
+const V3_RELEASE_MAX_TIMES_SHOWN = 5;
+const CURRENT_HARDHAT_MAJOR_VERSION = 2;
+
+const boxenOptions = {
+  padding: 1,
+  borderStyle: "round",
+  borderColor: "yellow",
+} as const;
+
+interface VersionNotifierCache {
+  lastCheck: string | 0;
+  v3TimesShown: number;
+  v3Release?: Release;
+  v3ReleaseMessage?: string;
+}
+
+/* eslint-disable @typescript-eslint/naming-convention */
+interface Release {
+  name: string;
+  tag_name: string;
+  draft: boolean;
+  prerelease: boolean;
+  published_at: string;
+  html_url: string;
+  assets: Array<{
+    name: string;
+    browser_download_url: string;
+  }>;
+  body: string; // release notes
+}
+/* eslint-enable @typescript-eslint/naming-convention */
+
+export async function showNewVersionNotification() {
+  const cache = await readCache();
+
+  const lastCheckDate = new Date(cache.lastCheck);
+  const now = new Date();
+  const oneDay = 1000 * 60 * 60 * 24;
+
+  if (now.getTime() - lastCheckDate.getTime() < oneDay) {
+    return;
+  }
+
+  const hardhatVersion = getHardhatVersion();
+
+  const releases = await getReleases();
+
+  const sortedV2Versions = releases
+    // filter and map releases to versions
+    .flatMap((release) => {
+      const [packageName, rawPackageVersion] = release.tag_name.split("@");
+
+      const packageVersion = semver.valid(rawPackageVersion);
+
+      // filter out a release if:
+      // - it's not a hardhat-core release
+      // - it's a draft or a prerelease
+      // - the version is invalid
+      // - the major version is not the current major
+      if (
+        packageName !== GITHUB_REPO ||
+        release.draft ||
+        release.prerelease ||
+        packageVersion === null ||
+        semver.major(packageVersion) !== CURRENT_HARDHAT_MAJOR_VERSION
+      ) {
+        return [];
+      }
+
+      return [packageVersion];
+    })
+    // sort in descending order by version
+    .sort((releaseAVersion, releaseBVersion) => {
+      return semver.rcompare(releaseAVersion, releaseBVersion);
+    });
+
+  const latestV2Version: string | undefined = sortedV2Versions[0];
+
+  const v3Release = cache.v3Release ?? (await getV3Release());
+
+  if (latestV2Version === undefined && v3Release === undefined) {
+    // this should never happen unless the github api is down
+    return;
+  }
+
+  if (
+    latestV2Version !== undefined &&
+    semver.gt(latestV2Version, hardhatVersion)
+  ) {
+    let installationCommand = "npm install";
+    if (await fsExtra.pathExists("yarn.lock")) {
+      installationCommand = "yarn add";
+    } else if (await fsExtra.pathExists("pnpm-lock.yaml")) {
+      installationCommand = "pnpm install";
+    }
+
+    console.log(
+      boxen(
+        `New Hardhat release available! ${chalk.red(
+          hardhatVersion
+        )} -> ${chalk.green(latestV2Version)}.
+
+Changelog: https://hardhat.org/release/${latestV2Version}
+
+Run "${installationCommand} hardhat@latest" to update.`,
+        boxenOptions
+      )
+    );
+  }
+
+  if (
+    v3Release !== undefined &&
+    cache.v3TimesShown < V3_RELEASE_MAX_TIMES_SHOWN
+  ) {
+    const releaseVersion = semver.valid(v3Release.tag_name.split("@")[1]);
+
+    if (releaseVersion !== null) {
+      cache.v3ReleaseMessage ??= await getV3ReleaseMessage(v3Release);
+      if (cache.v3ReleaseMessage !== undefined) {
+        console.log(boxen(cache.v3ReleaseMessage, boxenOptions));
+        cache.v3TimesShown++;
+      }
+    }
+  }
+
+  await writeCache({
+    ...cache,
+    lastCheck: now.toISOString(),
+    v3Release,
+  });
+}
+
+async function readCache(): Promise<VersionNotifierCache> {
+  const cacheDir = await getCacheDir();
+  const versionNotifierCachePath = join(cacheDir, "version-notifier.json");
+
+  let cache: VersionNotifierCache = {
+    lastCheck: 0, // new Date(0) represents the unix epoch
+    v3TimesShown: 0,
+  };
+  try {
+    const fileContents = await readFile(versionNotifierCachePath, "utf-8");
+    const { lastCheck, v3TimesShown } = JSON.parse(fileContents);
+
+    cache = {
+      lastCheck: typeof lastCheck === "string" ? lastCheck : 0,
+      v3TimesShown: typeof v3TimesShown === "number" ? v3TimesShown : 0,
+    };
+  } catch (error: any) {
+    // We don't care if it fails
+  }
+
+  return cache;
+}
+
+async function writeCache(cache: VersionNotifierCache) {
+  const cacheDir = await getCacheDir();
+  const versionNotifierCachePath = join(cacheDir, "version-notifier.json");
+
+  try {
+    await mkdir(cacheDir, { recursive: true });
+    await writeFile(versionNotifierCachePath, JSON.stringify(cache, null, 2));
+  } catch (error) {
+    // We don't care if it fails
+  }
+}
+
+async function getReleases(): Promise<Release[]> {
+  const { request } = await import("undici");
+  let releases: Release[] = [];
+
+  try {
+    const githubResponse = await request(
+      `${GITHUB_API_URL}/repos/${GITHUB_OWNER}/${GITHUB_REPO}/releases`,
+      {
+        method: "GET",
+        headers: {
+          "User-Agent": "Hardhat",
+          "X-GitHub-Api-Version": "2022-11-28",
+        },
+        query: {
+          per_page: 100,
+        },
+      }
+    );
+    releases = (await githubResponse.body.json()) as Release[];
+  } catch (error: any) {
+    // We don't care if it fails
+  }
+
+  return releases;
+}
+
+async function getV3Release(): Promise<Release | undefined> {
+  const { request } = await import("undici");
+  let v3Release: Release | undefined;
+
+  try {
+    const githubResponse = await request(
+      `${GITHUB_API_URL}/repos/${GITHUB_OWNER}/${GITHUB_REPO}/releases/tags/${V3_RELEASE_TAG}`,
+      {
+        method: "GET",
+        headers: {
+          "User-Agent": "Hardhat",
+          "X-GitHub-Api-Version": "2022-11-28",
+        },
+      }
+    );
+
+    const jsonResponse = (await githubResponse.body.json()) as any;
+    if (jsonResponse.message === "Not Found") {
+      // eslint-disable-next-line @nomicfoundation/hardhat-internal-rules/only-hardhat-error
+      throw new Error("Not Found");
+    }
+
+    v3Release = jsonResponse as Release;
+  } catch (error: any) {
+    // We don't care if it fails
+  }
+
+  return v3Release;
+}
+
+async function getV3ReleaseMessage(
+  v3Release: Release
+): Promise<string | undefined> {
+  const { request } = await import("undici");
+
+  const versionNotifierAsset = v3Release.assets.find(
+    ({ name }) => name === V3_RELEASE_VERSION_NOTIFIER_ASSET_NAME
+  );
+
+  if (versionNotifierAsset === undefined) {
+    return;
+  }
+
+  let v3ReleaseMessage;
+  try {
+    const githubResponse = await request(
+      versionNotifierAsset.browser_download_url,
+      {
+        method: "GET",
+        maxRedirections: 10,
+      }
+    );
+
+    v3ReleaseMessage = await githubResponse.body.text();
+  } catch (error: any) {
+    // We don't care if it fails
+  }
+
+  return v3ReleaseMessage;
+}