hardhat 2.19.3 → 2.19.5

package/src/internal/cli/cli.ts

@@ -1,6 +1,7 @@
 import chalk from "chalk";
 import debug from "debug";
 import "source-map-support/register";
+
 import {
   TASK_COMPILE,
   TASK_HELP,
@@ -34,16 +35,14 @@ import {
   hasConsentedTelemetry,
   hasPromptedForHHVSCode,
   writePromptedForHHVSCode,
-  writeTelemetryConsent,
 } from "../util/global-dir";
 import { getPackageJson } from "../util/packageInfo";
-
 import { saveFlamegraph } from "../core/flamegraph";
-import { Analytics } from "./analytics";
+import { Analytics, requestTelemetryConsent } from "./analytics";
 import { ArgumentsParser } from "./ArgumentsParser";
 import { enableEmoji } from "./emoji";
 import { createProject, showSoliditySurveyMessage } from "./project-creation";
-import { confirmHHVSCodeInstallation, confirmTelemetryConsent } from "./prompt";
+import { confirmHHVSCodeInstallation } from "./prompt";
 import {
   InstallationState,
   installHardhatVSCode,
@@ -247,11 +246,7 @@ async function main() {
       process.stdout.isTTY === true &&
       process.env.HARDHAT_DISABLE_TELEMETRY_PROMPT !== "true"
     ) {
-      telemetryConsent = await confirmTelemetryConsent();
-
-      if (telemetryConsent !== undefined) {
-        writeTelemetryConsent(telemetryConsent);
-      }
+      telemetryConsent = await requestTelemetryConsent();
     }
 
     const analytics = await Analytics.getInstance(telemetryConsent);
@@ -372,6 +367,18 @@ async function main() {
       if (process.exitCode !== 0) {
         showViaIRWarning(resolvedConfig);
       }
+
+      // we notify of new versions only if the tests failed
+      if (process.exitCode !== 0) {
+        try {
+          const { showNewVersionNotification } = await import(
+            "./version-notifier"
+          );
+          await showNewVersionNotification();
+        } catch {
+          // ignore possible version notifier errors
+        }
+      }
     }
 
     log(`Killing Hardhat after successfully running task ${taskName}`);

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

@@ -7,10 +7,7 @@ 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 { hasConsentedTelemetry } from "../util/global-dir";
 import { fromEntries } from "../util/lang";
 import {
   getPackageJson,
@@ -18,13 +15,14 @@ import {
   PackageJson,
 } from "../util/packageInfo";
 import { pluralize } from "../util/strings";
+import { isRunningOnCiServer } from "../util/ci-detection";
 import {
   confirmRecommendedDepsInstallation,
-  confirmTelemetryConsent,
   confirmProjectCreation,
 } from "./prompt";
 import { emoji } from "./emoji";
 import { Dependencies, PackageManager } from "./types";
+import { requestTelemetryConsent } from "./analytics";
 
 enum Action {
   CREATE_JAVASCRIPT_PROJECT_ACTION = "Create a JavaScript project",
@@ -463,13 +461,10 @@ export async function createProject() {
 
   if (
     process.env.HARDHAT_DISABLE_TELEMETRY_PROMPT !== "true" &&
+    !isRunningOnCiServer() &&
     hasConsentedTelemetry() === undefined
   ) {
-    const telemetryConsent = await confirmTelemetryConsent();
-
-    if (telemetryConsent !== undefined) {
-      writeTelemetryConsent(telemetryConsent);
-    }
+    await requestTelemetryConsent();
   }
 
   await copySampleProject(projectRoot, action, isEsm);
@@ -573,12 +568,8 @@ async function doesNpmAutoInstallPeerDependencies() {
 async function installRecommendedDependencies(dependencies: Dependencies) {
   console.log("");
 
-  // The reason we don't quote the dependencies here is because they are going
-  // to be used in child_process.spawn, which doesn't require escaping string,
-  // and can actually fail if you do.
   const installCmd = await getRecommendedDependenciesInstallationCommand(
-    dependencies,
-    false
+    dependencies
   );
   return installDependencies(installCmd[0], installCmd.slice(1));
 }
@@ -616,11 +607,10 @@ async function installDependencies(
 }
 
 async function getRecommendedDependenciesInstallationCommand(
-  dependencies: Dependencies,
-  quoteDependencies = true
+  dependencies: Dependencies
 ): Promise<string[]> {
-  const deps = Object.entries(dependencies).map(([name, version]) =>
-    quoteDependencies ? `"${name}@${version}"` : `${name}@${version}`
+  const deps = Object.entries(dependencies).map(
+    ([name, version]) => `"${name}@${version}"`
   );
 
   if (await isYarnProject()) {

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;
+}

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

@@ -20,7 +20,6 @@ import { getUserConfigPath } from "../project-structure";
 
 import { SUPPORTED_SOLIDITY_VERSION_RANGE } from "../../hardhat-network/stack-traces/constants";
 import { resolveConfig } from "./config-resolution";
-import { validateConfig, validateResolvedConfig } from "./config-validation";
 import { DEFAULT_SOLC_VERSION } from "./default-config";
 
 const log = debug("hardhat:core:config");
@@ -68,6 +67,8 @@ export function loadConfigAndTasks(
     showSolidityConfigWarnings: false,
   }
 ): { resolvedConfig: HardhatConfig; userConfig: HardhatUserConfig } {
+  const { validateConfig, validateResolvedConfig } =
+    require("./config-validation") as typeof import("./config-validation");
   let configPath =
     hardhatArguments !== undefined ? hardhatArguments.config : undefined;
 

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

@@ -1,4 +1,5 @@
-import cloneDeep from "lodash/cloneDeep";
+import type { LoDashStatic } from "lodash";
+
 import path from "path";
 import semver from "semver";
 
@@ -62,6 +63,7 @@ export function resolveConfig(
   userConfigPath: string,
   userConfig: HardhatUserConfig
 ): HardhatConfig {
+  const cloneDeep = require("lodash/cloneDeep") as LoDashStatic["cloneDeep"];
   userConfig = cloneDeep(userConfig);
 
   return {
@@ -77,6 +79,7 @@ export function resolveConfig(
 function resolveNetworksConfig(
   networksConfig: NetworksUserConfig = {}
 ): NetworksConfig {
+  const cloneDeep = require("lodash/cloneDeep") as LoDashStatic["cloneDeep"];
   const hardhatNetworkConfig = networksConfig[HARDHAT_NETWORK_NAME];
 
   const localhostNetworkConfig =
@@ -128,6 +131,7 @@ function normalizeHexString(str: string): string {
 function resolveHardhatNetworkConfig(
   hardhatNetworkConfig: HardhatNetworkUserConfig = {}
 ): HardhatNetworkConfig {
+  const cloneDeep = require("lodash/cloneDeep") as LoDashStatic["cloneDeep"];
   const clonedDefaultHardhatNetworkParams = cloneDeep(
     defaultHardhatNetworkParams
   );
@@ -246,6 +250,7 @@ function isHdAccountsConfig(
 function resolveHttpNetworkConfig(
   networkConfig: HttpNetworkUserConfig
 ): HttpNetworkConfig {
+  const cloneDeep = require("lodash/cloneDeep") as LoDashStatic["cloneDeep"];
   const accounts: HttpNetworkAccountsConfig =
     networkConfig.accounts === undefined
       ? defaultHttpNetworkParams.accounts
@@ -427,6 +432,7 @@ function resolveCompiler(compiler: SolcUserConfig): SolcConfig {
 }
 
 function resolveMochaConfig(userConfig: HardhatUserConfig): Mocha.MochaOptions {
+  const cloneDeep = require("lodash/cloneDeep") as LoDashStatic["cloneDeep"];
   return {
     ...cloneDeep(defaultMochaOptions),
     ...userConfig.mocha,

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

@@ -1,8 +1,12 @@
 import type { HardhatConfig as HardhatConfigT } from "../../../types";
+import type {
+  Context,
+  ValidationError,
+  getFunctionName as getFunctionNameT,
+} from "io-ts/lib";
+import type { Reporter } from "io-ts/lib/Reporter";
 
 import * as t from "io-ts";
-import { Context, getFunctionName, ValidationError } from "io-ts/lib";
-import { Reporter } from "io-ts/lib/Reporter";
 
 import {
   HARDHAT_MEMPOOL_SUPPORTED_ORDERS,
@@ -19,6 +23,9 @@ import { defaultHardhatNetworkParams } from "./default-config";
 
 function stringify(v: any): string {
   if (typeof v === "function") {
+    const { getFunctionName } = require("io-ts/lib") as {
+      getFunctionName: typeof getFunctionNameT;
+    };
     return getFunctionName(v);
   }
   if (typeof v === "number" && !isFinite(v)) {

package/src/internal/core/providers/gas-providers.ts

@@ -273,6 +273,14 @@ export class AutomaticGasPriceProvider extends ProviderWrapper {
         }
       }
 
+      // If after all of these we still have a 0 wei maxPriorityFeePerGas, we
+      // use 1 wei. This is to improve the UX of the automatic gas price
+      // on chains that are very empty (i.e local testnets). This will be very
+      // unlikely to trigger on a live chain.
+      if (maxPriorityFeePerGas === 0n) {
+        maxPriorityFeePerGas = 1n;
+      }
+
       return {
         // Each block increases the base fee by 1/8 at most, when full.
         // We have the next block's base fee, so we compute a cap for the

package/src/internal/hardhat-network/stack-traces/panic-errors.ts

@@ -13,7 +13,7 @@ function panicErrorCodeToReason(errorCode: bigint): string | undefined {
     case 0x1n:
       return "Assertion error";
     case 0x11n:
-      return "Arithmetic operation underflowed or overflowed outside of an unchecked block";
+      return "Arithmetic operation overflowed outside of an unchecked block";
     case 0x12n:
       return "Division or modulo division by zero";
     case 0x21n:

package/src/internal/hardhat-network/stack-traces/solidity-errors.ts

@@ -391,7 +391,7 @@ class SolidityCallSite implements NodeJS.CallSite {
   }
 
   public getScriptNameOrSourceURL() {
-    return null;
+    return "";
   }
 
   public getThis() {
@@ -425,4 +425,20 @@ class SolidityCallSite implements NodeJS.CallSite {
   public isToplevel() {
     return false;
   }
+
+  public getScriptHash(): string {
+    return "";
+  }
+
+  public getEnclosingColumnNumber(): number {
+    return 0;
+  }
+
+  public getEnclosingLineNumber(): number {
+    return 0;
+  }
+
+  public toString(): string {
+    return "[SolidityCallSite]";
+  }
 }

package/src/internal/sentry/transport.ts

@@ -1,4 +1,4 @@
-import { Event, Response } from "@sentry/node";
+import type { Event, Response } from "@sentry/node";
 import { spawn } from "child_process";
 import * as path from "path";
 

package/src/internal/solidity/compiler/downloader.ts

@@ -8,7 +8,7 @@ import { promisify } from "util";
 import { download } from "../../util/download";
 import { assertHardhatInvariant, HardhatError } from "../../core/errors";
 import { ERRORS } from "../../core/errors-list";
-import { Mutex } from "../../vendor/await-semaphore";
+import { MultiProcessMutex } from "../../util/multi-process-mutex";
 
 const log = debug("hardhat:core:solidity:downloader");
 
@@ -126,7 +126,7 @@ export class CompilerDownloader implements ICompilerDownloader {
   }
 
   public static defaultCompilerListCachePeriod = 3_600_00;
-  private readonly _mutex = new Mutex();
+  private readonly _mutex = new MultiProcessMutex("compiler-download");
 
   /**
    * Use CompilerDownloader.getConcurrencySafeDownloader instead

package/src/internal/solidity/compiler/index.ts

@@ -1,5 +1,8 @@
 import { execFile } from "child_process";
 import * as fs from "fs";
+import os from "node:os";
+import path from "node:path";
+import * as semver from "semver";
 import { CompilerInput, CompilerOutput } from "../../../types";
 import { HardhatError } from "../../core/errors";
 import { ERRORS } from "../../core/errors-list";
@@ -68,14 +71,31 @@ export class Compiler implements ICompiler {
 }
 
 export class NativeCompiler implements ICompiler {
-  constructor(private _pathToSolc: string) {}
+  constructor(private _pathToSolc: string, private _solcVersion?: string) {}
 
   public async compile(input: CompilerInput) {
+    const args = ["--standard-json"];
+
+    // Logic to make sure that solc default import callback is not being used.
+    // If solcVersion is not defined or <= 0.6.8, do not add extra args.
+    if (this._solcVersion !== undefined) {
+      if (semver.gte(this._solcVersion, "0.8.22")) {
+        // version >= 0.8.22
+        args.push("--no-import-callback");
+      } else if (semver.gte(this._solcVersion, "0.6.9")) {
+        // version >= 0.6.9
+        const tmpFolder = path.join(os.tmpdir(), "hardhat-solc");
+        fs.mkdirSync(tmpFolder, { recursive: true });
+        args.push(`--base-path`);
+        args.push(tmpFolder);
+      }
+    }
+
     const output: string = await new Promise((resolve, reject) => {
       try {
         const process = execFile(
           this._pathToSolc,
-          [`--standard-json`],
+          args,
           {
             maxBuffer: 1024 * 1024 * 500,
           },

package/src/internal/util/fs-utils.ts

@@ -65,7 +65,7 @@ export function getRealPathSync(absolutePath: string): string {
  *
  * @param absolutePathToDir A directory. If it doesn't exist `[]` is returned.
  * @param matches A function to filter files (not directories)
- * @returns An An array of absolute paths. Each file has its true case, except
+ * @returns An array of absolute paths. Each file has its true case, except
  *  for the initial absolutePathToDir part, which preserves the given casing.
  *  No order is guaranteed.
  */