hardhat 2.19.4 → 2.19.5

package/internal/util/multi-process-mutex.js

@@ -0,0 +1,116 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiProcessMutex = void 0;
+/* eslint-disable @nomicfoundation/hardhat-internal-rules/only-hardhat-error */
+const debug_1 = __importDefault(require("debug"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_os_1 = __importDefault(require("node:os"));
+// Logic explanation: the fs.writeFile function, when used with the wx+ flag, performs an atomic operation to create a file.
+// If multiple processes try to create the same file simultaneously, only one will succeed.
+// This logic can be utilized to implement a mutex.
+// ATTENTION: in the current implementation, there's still a risk of two processes running simultaneously.
+// For example, if processA has locked the mutex and is running, processB will wait.
+// During this wait, processB continuously checks the elapsed time since the mutex lock file was created.
+// If an excessive amount of time has passed, processB will assume ownership of the mutex to avoid stale locks.
+// However, there's a possibility that processB might take ownership because the mutex creation file is outdated, even though processA is still running
+// For more info check the Nomic Notion page (internal link).
+const log = (0, debug_1.default)("hardhat:util:multi-process-mutex");
+const DEFAULT_MAX_MUTEX_LIFESPAN_IN_MS = 60000;
+const MUTEX_LOOP_WAITING_TIME_IN_MS = 100;
+class MultiProcessMutex {
+    constructor(mutexName, maxMutexLifespanInMs) {
+        log(`Creating mutex with name '${mutexName}'`);
+        this._mutexFilePath = node_path_1.default.join(node_os_1.default.tmpdir(), `${mutexName}.txt`);
+        this._mutexLifespanInMs =
+            maxMutexLifespanInMs ?? DEFAULT_MAX_MUTEX_LIFESPAN_IN_MS;
+    }
+    async use(f) {
+        log(`Starting mutex process with mutex file '${this._mutexFilePath}'`);
+        while (true) {
+            if (await this._tryToAcquireMutex()) {
+                // Mutex has been acquired
+                return this._executeFunctionAndReleaseMutex(f);
+            }
+            // Mutex not acquired
+            if (this._isMutexFileTooOld()) {
+                // If the mutex file is too old, it likely indicates a stale lock, so the file should be removed
+                log(`Current mutex file is too old, removing it at path '${this._mutexFilePath}'`);
+                this._deleteMutexFile();
+            }
+            else {
+                // wait
+                await this._waitMs();
+            }
+        }
+    }
+    async _tryToAcquireMutex() {
+        try {
+            // Create a file only if it does not exist
+            node_fs_1.default.writeFileSync(this._mutexFilePath, "", { flag: "wx+" });
+            return true;
+        }
+        catch (error) {
+            if (error.code === "EEXIST") {
+                // File already exists, so the mutex is already acquired
+                return false;
+            }
+            throw error;
+        }
+    }
+    async _executeFunctionAndReleaseMutex(f) {
+        log(`Mutex acquired at path '${this._mutexFilePath}'`);
+        try {
+            const res = await f();
+            // Release the mutex
+            log(`Mutex released at path '${this._mutexFilePath}'`);
+            this._deleteMutexFile();
+            log(`Mutex released at path '${this._mutexFilePath}'`);
+            return res;
+        }
+        catch (error) {
+            // Catch any error to avoid stale locks.
+            // Remove the mutex file and re-throw the error
+            this._deleteMutexFile();
+            throw error;
+        }
+    }
+    _isMutexFileTooOld() {
+        let fileStat;
+        try {
+            fileStat = node_fs_1.default.statSync(this._mutexFilePath);
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                // The file might have been deleted by another process while this function was trying to access it.
+                return false;
+            }
+            throw error;
+        }
+        const now = new Date();
+        const fileDate = new Date(fileStat.ctime);
+        const diff = now.getTime() - fileDate.getTime();
+        return diff > this._mutexLifespanInMs;
+    }
+    _deleteMutexFile() {
+        try {
+            log(`Deleting mutex file at path '${this._mutexFilePath}'`);
+            node_fs_1.default.unlinkSync(this._mutexFilePath);
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                // The file might have been deleted by another process while this function was trying to access it.
+                return;
+            }
+            throw error;
+        }
+    }
+    async _waitMs() {
+        return new Promise((resolve) => setTimeout(resolve, MUTEX_LOOP_WAITING_TIME_IN_MS));
+    }
+}
+exports.MultiProcessMutex = MultiProcessMutex;
+//# sourceMappingURL=multi-process-mutex.js.map

package/internal/util/multi-process-mutex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"multi-process-mutex.js","sourceRoot":"","sources":["../../src/internal/util/multi-process-mutex.ts"],"names":[],"mappings":"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"}

package/internal/util/report-telemetry-consent.js

@@ -2,7 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const analytics_1 = require("../cli/analytics");
 async function main() {
-    const [telemetryConsent] = process.argv.slice(2);
+    // This default value shouldn't be necessary, but we add one to make it
+    // easier to recognize if the telemetry consent value is not passed.
+    const [telemetryConsent = "<undefined-telemetry-consent>"] = process.argv.slice(2);
     // we pass undefined as the telemetryConsent value because
     // this hit is done before the consent is saved
     const analytics = await analytics_1.Analytics.getInstance(undefined);

package/internal/util/report-telemetry-consent.js.map

@@ -1 +1 @@
-{"version":3,"file":"report-telemetry-consent.js","sourceRoot":"","sources":["../../src/internal/util/report-telemetry-consent.ts"],"names":[],"mappings":";;AAAA,gDAA6C;AAE7C,KAAK,UAAU,IAAI;IACjB,MAAM,CAAC,gBAAgB,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAEjD,0DAA0D;IAC1D,+CAA+C;IAC/C,MAAM,SAAS,GAAG,MAAM,qBAAS,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC;IAEzD,MAAM,CAAC,CAAC,EAAE,iBAAiB,CAAC,GAAG,MAAM,SAAS,CAAC,uBAAuB,CACpE,gBAAgC,CACjC,CAAC;IACF,MAAM,iBAAiB,CAAC;AAC1B,CAAC;AAED,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC"}
+{"version":3,"file":"report-telemetry-consent.js","sourceRoot":"","sources":["../../src/internal/util/report-telemetry-consent.ts"],"names":[],"mappings":";;AAAA,gDAA6C;AAE7C,KAAK,UAAU,IAAI;IACjB,uEAAuE;IACvE,oEAAoE;IACpE,MAAM,CAAC,gBAAgB,GAAG,+BAA+B,CAAC,GACxD,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAExB,0DAA0D;IAC1D,+CAA+C;IAC/C,MAAM,SAAS,GAAG,MAAM,qBAAS,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC;IAEzD,MAAM,CAAC,CAAC,EAAE,iBAAiB,CAAC,GAAG,MAAM,SAAS,CAAC,uBAAuB,CACpE,gBAAgC,CACjC,CAAC;IACF,MAAM,iBAAiB,CAAC;AAC1B,CAAC;AAED,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hardhat",
-  "version": "2.19.4",
+  "version": "2.19.5",
   "author": "Nomic Labs LLC",
   "license": "MIT",
   "homepage": "https://hardhat.org",
@@ -101,6 +101,7 @@
     "adm-zip": "^0.4.16",
     "aggregate-error": "^3.0.0",
     "ansi-escapes": "^4.3.0",
+    "boxen": "^5.1.2",
     "chalk": "^2.4.2",
     "chokidar": "^3.4.0",
     "ci-info": "^2.0.0",

package/src/builtin-tasks/compile.ts

@@ -674,9 +674,26 @@ subtask(TASK_COMPILE_SOLIDITY_RUN_SOLCJS)
 subtask(TASK_COMPILE_SOLIDITY_RUN_SOLC)
   .addParam("input", undefined, undefined, types.any)
   .addParam("solcPath", undefined, undefined, types.string)
+  .addOptionalParam("solcVersion", undefined, undefined, types.string)
   .setAction(
-    async ({ input, solcPath }: { input: CompilerInput; solcPath: string }) => {
-      const compiler = new NativeCompiler(solcPath);
+    async ({
+      input,
+      solcPath,
+      solcVersion,
+    }: {
+      input: CompilerInput;
+      solcPath: string;
+      solcVersion?: string;
+    }) => {
+      if (solcVersion !== undefined && semver.valid(solcVersion) === null) {
+        throw new HardhatError(ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE, {
+          value: solcVersion,
+          name: "solcVersion",
+          type: "string",
+        });
+      }
+
+      const compiler = new NativeCompiler(solcPath, solcVersion);
 
       return compiler.compile(input);
     }
@@ -740,6 +757,7 @@ subtask(TASK_COMPILE_SOLIDITY_COMPILE_SOLC)
         output = await run(TASK_COMPILE_SOLIDITY_RUN_SOLC, {
           input,
           solcPath: solcBuild.compilerPath,
+          solcVersion,
         });
       }
 

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,
@@ -36,7 +37,6 @@ import {
   writePromptedForHHVSCode,
 } from "../util/global-dir";
 import { getPackageJson } from "../util/packageInfo";
-
 import { saveFlamegraph } from "../core/flamegraph";
 import { Analytics, requestTelemetryConsent } from "./analytics";
 import { ArgumentsParser } from "./ArgumentsParser";
@@ -367,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

@@ -568,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));
 }
@@ -611,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/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