hardhat 2.19.4 → 2.20.0

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/constants.ts

@@ -22,6 +22,7 @@ export const HARDHAT_NETWORK_SUPPORTED_HARDFORKS = [
   "grayGlacier",
   "merge",
   "shanghai",
+  "cancun",
 ];
 
 export const HARDHAT_MEMPOOL_SUPPORTED_ORDERS = ["fifo", "priority"] as const;

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
   );
@@ -234,6 +238,19 @@ function resolveHardhatNetworkConfig(
     delete config.initialBaseFeePerGas;
   }
 
+  if (
+    hardhatNetworkConfig.enableTransientStorage === true &&
+    hardhatNetworkConfig.hardfork === undefined
+  ) {
+    config.hardfork = "cancun";
+  }
+  if (
+    hardhatNetworkConfig.enableTransientStorage === false &&
+    hardhatNetworkConfig.hardfork === undefined
+  ) {
+    config.hardfork = "shanghai";
+  }
+
   return config;
 }
 
@@ -246,6 +263,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 +445,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)) {
@@ -491,6 +498,25 @@ export function getValidationErrors(config: any): string[] {
           }
         });
       }
+
+      if (hardhatNetwork.hardfork !== undefined) {
+        if (
+          !hardforkGte(hardhatNetwork.hardfork, HardforkName.CANCUN) &&
+          hardhatNetwork.enableTransientStorage === true
+        ) {
+          errors.push(
+            `'enableTransientStorage' cannot be enabled if the hardfork is explicitly set to a pre-cancun value. If you want to use transient storage, use 'cancun' as the hardfork.`
+          );
+        }
+        if (
+          hardforkGte(hardhatNetwork.hardfork, HardforkName.CANCUN) &&
+          hardhatNetwork.enableTransientStorage === false
+        ) {
+          errors.push(
+            `'enableTransientStorage' cannot be disabled if the hardfork is explicitly set to cancun or later. If you want to disable transient storage, use a hardfork before 'cancun'.`
+          );
+        }
+      }
     }
 
     for (const [networkName, netConfig] of Object.entries<any>(

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

@@ -129,6 +129,17 @@ export const defaultHardhatNetworkParams: Omit<
         ]),
       },
     ],
+    [
+      11155111, // sepolia
+      {
+        hardforkHistory: new Map([
+          [HardforkName.GRAY_GLACIER, 0],
+          [HardforkName.MERGE, 1_450_409],
+          [HardforkName.SHANGHAI, 2_990_908],
+          [HardforkName.CANCUN, 5_187_023],
+        ]),
+      },
+    ],
   ]),
 };
 

package/src/internal/core/jsonrpc/types/base-types.ts

@@ -1,7 +1,7 @@
 import {
-  bufferToHex,
+  bytesToHex as bufferToHex,
   isValidAddress,
-  toBuffer,
+  toBytes,
 } from "@nomicfoundation/ethereumjs-util";
 import * as t from "io-ts";
 
@@ -22,14 +22,16 @@ export const rpcQuantity = new t.Type<bigint>(
 export const rpcData = new t.Type<Buffer>(
   "DATA",
   Buffer.isBuffer,
-  (u, c) => (isRpcDataString(u) ? t.success(toBuffer(u)) : t.failure(u, c)),
+  (u, c) =>
+    isRpcDataString(u) ? t.success(Buffer.from(toBytes(u))) : t.failure(u, c),
   t.identity
 );
 
 export const rpcHash = new t.Type<Buffer>(
   "HASH",
   (v): v is Buffer => Buffer.isBuffer(v) && v.length === HASH_LENGTH_BYTES,
-  (u, c) => (isRpcHashString(u) ? t.success(toBuffer(u)) : t.failure(u, c)),
+  (u, c) =>
+    isRpcHashString(u) ? t.success(Buffer.from(toBytes(u))) : t.failure(u, c),
   t.identity
 );
 
@@ -96,7 +98,10 @@ function validateStorageSlot(u: unknown, c: t.Context): t.Validation<bigint> {
 export const rpcAddress = new t.Type<Buffer>(
   "ADDRESS",
   (v): v is Buffer => Buffer.isBuffer(v) && v.length === ADDRESS_LENGTH_BYTES,
-  (u, c) => (isRpcAddressString(u) ? t.success(toBuffer(u)) : t.failure(u, c)),
+  (u, c) =>
+    isRpcAddressString(u)
+      ? t.success(Buffer.from(toBytes(u)))
+      : t.failure(u, c),
   t.identity
 );
 
@@ -173,7 +178,7 @@ export function rpcDataToBigInt(data: string): bigint {
 }
 
 export function bufferToRpcData(
-  buffer: Buffer,
+  buffer: Uint8Array,
   padToBytes: number = 0
 ): string {
   let s = bufferToHex(buffer);
@@ -191,7 +196,7 @@ export function rpcDataToBuffer(data: string): Buffer {
     });
   }
 
-  return toBuffer(data);
+  return Buffer.from(toBytes(data));
 }
 
 // Type guards

package/src/internal/core/jsonrpc/types/input/callRequest.ts

@@ -5,6 +5,7 @@ import { rpcAccessList } from "../access-list";
 import {
   rpcAddress,
   rpcData,
+  rpcHash,
   rpcQuantity,
   rpcStorageSlot,
   rpcStorageSlotHexString,
@@ -23,6 +24,8 @@ export const rpcCallRequest = t.type(
     accessList: optionalOrNullable(rpcAccessList),
     maxFeePerGas: optionalOrNullable(rpcQuantity),
     maxPriorityFeePerGas: optionalOrNullable(rpcQuantity),
+    blobs: optionalOrNullable(t.array(rpcData)),
+    blobVersionedHashes: optionalOrNullable(t.array(rpcHash)),
   },
   "RpcCallRequest"
 );

package/src/internal/core/jsonrpc/types/input/transactionRequest.ts

@@ -2,7 +2,7 @@ import * as t from "io-ts";
 
 import { optionalOrNullable } from "../../../../util/io-ts";
 import { rpcAccessList } from "../access-list";
-import { rpcAddress, rpcData, rpcQuantity } from "../base-types";
+import { rpcAddress, rpcData, rpcHash, rpcQuantity } from "../base-types";
 
 // Type used by eth_sendTransaction
 export const rpcTransactionRequest = t.type(
@@ -18,6 +18,8 @@ export const rpcTransactionRequest = t.type(
     chainId: optionalOrNullable(rpcQuantity),
     maxFeePerGas: optionalOrNullable(rpcQuantity),
     maxPriorityFeePerGas: optionalOrNullable(rpcQuantity),
+    blobs: optionalOrNullable(t.array(rpcData)),
+    blobVersionedHashes: optionalOrNullable(t.array(rpcHash)),
   },
   "RpcTransactionRequest"
 );
@@ -38,6 +40,8 @@ export interface RpcTransactionRequestInput {
   }>;
   maxFeePerGas?: string;
   maxPriorityFeePerGas?: string;
+  blobs?: string[];
+  blobVersionedHashes?: string[];
 }
 
 export type RpcTransactionRequest = t.TypeOf<typeof rpcTransactionRequest>;

package/src/internal/core/jsonrpc/types/output/block.ts

@@ -38,6 +38,9 @@ const baseBlockResponse = {
   baseFeePerGas: optional(rpcQuantity),
   withdrawals: optional(t.array(rpcWithdrawalItem)),
   withdrawalsRoot: optional(rpcHash),
+  parentBeaconBlockRoot: optional(rpcHash),
+  blobGasUsed: optional(rpcQuantity),
+  excessBlobGas: optional(rpcQuantity),
 };
 
 export type RpcBlock = t.TypeOf<typeof rpcBlock>;

package/src/internal/core/providers/accounts.ts

@@ -43,8 +43,13 @@ export class LocalAccountsProvider extends ProviderWrapperWithChainId {
   }
 
   public async request(args: RequestArguments): Promise<unknown> {
-    const { ecsign, hashPersonalMessage, toRpcSig, toBuffer, bufferToHex } =
-      await import("@nomicfoundation/ethereumjs-util");
+    const {
+      ecsign,
+      hashPersonalMessage,
+      toRpcSig,
+      toBytes,
+      bytesToHex: bufferToHex,
+    } = await import("@nomicfoundation/ethereumjs-util");
 
     if (
       args.method === "eth_accounts" ||
@@ -65,7 +70,7 @@ export class LocalAccountsProvider extends ProviderWrapperWithChainId {
           }
 
           const privateKey = this._getPrivateKeyForAddress(address);
-          const messageHash = hashPersonalMessage(toBuffer(data));
+          const messageHash = hashPersonalMessage(toBytes(data));
           const signature = ecsign(messageHash, privateKey);
           return toRpcSig(signature.v, signature.r, signature.s);
         }
@@ -84,7 +89,7 @@ export class LocalAccountsProvider extends ProviderWrapperWithChainId {
           }
 
           const privateKey = this._getPrivateKeyForAddress(address);
-          const messageHash = hashPersonalMessage(toBuffer(data));
+          const messageHash = hashPersonalMessage(toBytes(data));
           const signature = ecsign(messageHash, privateKey);
           return toRpcSig(signature.v, signature.r, signature.s);
         }
@@ -189,13 +194,13 @@ export class LocalAccountsProvider extends ProviderWrapperWithChainId {
 
   private _initializePrivateKeys(localAccountsHexPrivateKeys: string[]) {
     const {
-      bufferToHex,
-      toBuffer,
+      bytesToHex: bufferToHex,
+      toBytes,
       privateToAddress,
     } = require("@nomicfoundation/ethereumjs-util");
 
     const privateKeys: Buffer[] = localAccountsHexPrivateKeys.map((h) =>
-      toBuffer(h)
+      toBytes(h)
     );
 
     for (const pk of privateKeys) {
@@ -205,7 +210,9 @@ export class LocalAccountsProvider extends ProviderWrapperWithChainId {
   }
 
   private _getPrivateKeyForAddress(address: Buffer): Buffer {
-    const { bufferToHex } = require("@nomicfoundation/ethereumjs-util");
+    const {
+      bytesToHex: bufferToHex,
+    } = require("@nomicfoundation/ethereumjs-util");
     const pk = this._addressToPrivateKey.get(bufferToHex(address));
     if (pk === undefined) {
       throw new HardhatError(ERRORS.NETWORK.NOT_LOCAL_ACCOUNT, {
@@ -225,7 +232,9 @@ export class LocalAccountsProvider extends ProviderWrapperWithChainId {
   }
 
   private async _getNonce(address: Buffer): Promise<bigint> {
-    const { bufferToHex } = await import("@nomicfoundation/ethereumjs-util");
+    const { bytesToHex: bufferToHex } = await import(
+      "@nomicfoundation/ethereumjs-util"
+    );
 
     const response = (await this._wrappedProvider.request({
       method: "eth_getTransactionCount",
@@ -239,8 +248,8 @@ export class LocalAccountsProvider extends ProviderWrapperWithChainId {
     transactionRequest: RpcTransactionRequest,
     chainId: number,
     privateKey: Buffer
-  ): Promise<Buffer> {
-    const { AccessListEIP2930Transaction, Transaction } = await import(
+  ): Promise<Uint8Array> {
+    const { AccessListEIP2930Transaction, LegacyTransaction } = await import(
       "@nomicfoundation/ethereumjs-tx"
     );
 
@@ -282,7 +291,7 @@ export class LocalAccountsProvider extends ProviderWrapperWithChainId {
         { common }
       );
     } else {
-      transaction = Transaction.fromTxData(txData, { common });
+      transaction = LegacyTransaction.fromTxData(txData, { common });
     }
 
     const signedTransaction = transaction.sign(privateKey);
@@ -311,7 +320,9 @@ export class HDWalletProvider extends LocalAccountsProvider {
       passphrase
     );
 
-    const { bufferToHex } = require("@nomicfoundation/ethereumjs-util");
+    const {
+      bytesToHex: bufferToHex,
+    } = require("@nomicfoundation/ethereumjs-util");
     const privateKeysAsHex = privateKeys.map((pk) => bufferToHex(pk));
     super(provider, privateKeysAsHex);
   }

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/core/providers/util.ts

@@ -53,7 +53,7 @@ export function normalizeHardhatNetworkAccountsConfig(
     return accountsConfig;
   }
 
-  const { bufferToHex } = require("@nomicfoundation/ethereumjs-util");
+  const { bytesToHex } = require("@nomicfoundation/ethereumjs-util");
 
   return derivePrivateKeys(
     accountsConfig.mnemonic,
@@ -62,7 +62,7 @@ export function normalizeHardhatNetworkAccountsConfig(
     accountsConfig.count,
     accountsConfig.passphrase
   ).map((pk) => ({
-    privateKey: bufferToHex(pk),
+    privateKey: bytesToHex(pk),
     balance: accountsConfig.accountsBalance ?? DEFAULT_HARDHAT_NETWORK_BALANCE,
   }));
 }