hardhat 2.19.5 → 2.20.0

package/src/internal/hardhat-network/provider/transactions/ReadOnlyValidTransaction.ts

@@ -1,5 +1,9 @@
 import { Common } from "@nomicfoundation/ethereumjs-common";
-import { Transaction, TxData, TxOptions } from "@nomicfoundation/ethereumjs-tx";
+import {
+  LegacyTransaction,
+  LegacyTxData,
+  TxOptions,
+} from "@nomicfoundation/ethereumjs-tx";
 import { Address } from "@nomicfoundation/ethereumjs-util";
 
 import { InternalError } from "../../../core/providers/errors";
@@ -20,15 +24,15 @@ import { InternalError } from "../../../core/providers/errors";
  * This class doesn't use its Common instance, so there's no need to provide
  * one.
  */
-export class ReadOnlyValidTransaction extends Transaction {
-  public static fromTxData(_txData: TxData, _opts?: TxOptions): never {
+export class ReadOnlyValidTransaction extends LegacyTransaction {
+  public static fromTxData(_txData: LegacyTxData, _opts?: TxOptions): never {
     throw new InternalError(
       "`fromTxData` is not implemented in ReadOnlyValidTransaction"
     );
   }
 
   public static fromSerializedTx(
-    _serialized: Buffer,
+    _serialized: Uint8Array,
     _opts?: TxOptions
   ): never {
     throw new InternalError(
@@ -37,7 +41,7 @@ export class ReadOnlyValidTransaction extends Transaction {
   }
 
   public static fromRlpSerializedTx(
-    _serialized: Buffer,
+    _serialized: Uint8Array,
     _opts?: TxOptions
   ): never {
     throw new InternalError(
@@ -45,7 +49,10 @@ export class ReadOnlyValidTransaction extends Transaction {
     );
   }
 
-  public static fromValuesArray(_values: Buffer[], _opts?: TxOptions): never {
+  public static fromValuesArray(
+    _values: Uint8Array[],
+    _opts?: TxOptions
+  ): never {
     throw new InternalError(
       "`fromRlpSerializedTx` is not implemented in ReadOnlyValidTransaction"
     );
@@ -55,8 +62,8 @@ export class ReadOnlyValidTransaction extends Transaction {
 
   private readonly _sender: Address;
 
-  constructor(sender: Address, data: TxData = {}) {
-    super(data, { freeze: false, disableMaxInitCodeSizeCheck: true });
+  constructor(sender: Address, data: LegacyTxData = {}) {
+    super(data, { freeze: false, allowUnlimitedInitCodeSize: true });
 
     this.common = this._getCommon();
     this._sender = sender;

package/src/internal/hardhat-network/provider/transactions/ReadOnlyValidUnknownTypeTransaction.ts

@@ -1,5 +1,9 @@
 import { Common } from "@nomicfoundation/ethereumjs-common";
-import { Transaction, TxData, TxOptions } from "@nomicfoundation/ethereumjs-tx";
+import {
+  LegacyTransaction,
+  LegacyTxData,
+  TxOptions,
+} from "@nomicfoundation/ethereumjs-tx";
 import { Address } from "@nomicfoundation/ethereumjs-util";
 
 import { InternalError } from "../../../core/providers/errors";
@@ -10,15 +14,15 @@ import { InternalError } from "../../../core/providers/errors";
  * This class is like `ReadOnlyValidTransaction` but for
  * a transaction with an unknown tx type.
  */
-export class ReadOnlyValidUnknownTypeTransaction extends Transaction {
-  public static fromTxData(_txData: TxData, _opts?: TxOptions): never {
+export class ReadOnlyValidUnknownTypeTransaction extends LegacyTransaction {
+  public static fromTxData(_txData: LegacyTxData, _opts?: TxOptions): never {
     throw new InternalError(
       "`fromTxData` is not implemented in ReadOnlyValidUnknownTypeTransaction"
     );
   }
 
   public static fromSerializedTx(
-    _serialized: Buffer,
+    _serialized: Uint8Array,
     _opts?: TxOptions
   ): never {
     throw new InternalError(
@@ -27,7 +31,7 @@ export class ReadOnlyValidUnknownTypeTransaction extends Transaction {
   }
 
   public static fromRlpSerializedTx(
-    _serialized: Buffer,
+    _serialized: Uint8Array,
     _opts?: TxOptions
   ): never {
     throw new InternalError(
@@ -35,7 +39,10 @@ export class ReadOnlyValidUnknownTypeTransaction extends Transaction {
     );
   }
 
-  public static fromValuesArray(_values: Buffer[], _opts?: TxOptions): never {
+  public static fromValuesArray(
+    _values: Uint8Array[],
+    _opts?: TxOptions
+  ): never {
     throw new InternalError(
       "`fromRlpSerializedTx` is not implemented in ReadOnlyValidUnknownTypeTransaction"
     );
@@ -46,8 +53,8 @@ export class ReadOnlyValidUnknownTypeTransaction extends Transaction {
   private readonly _sender: Address;
   private readonly _actualType: number;
 
-  constructor(sender: Address, type: number, data: TxData = {}) {
-    super(data, { freeze: false, disableMaxInitCodeSizeCheck: true });
+  constructor(sender: Address, type: number, data: LegacyTxData = {}) {
+    super(data, { freeze: false, allowUnlimitedInitCodeSize: true });
 
     this.common = this._getCommon();
     this._sender = sender;

package/src/internal/hardhat-network/provider/types/HardhatBlockchainInterface.ts

@@ -9,17 +9,17 @@ export interface HardhatBlockchainInterface extends BlockchainInterface {
   reserveBlocks(
     count: bigint,
     interval: bigint,
-    previousBlockStateRoot: Buffer,
+    previousBlockStateRoot: Uint8Array,
     previousBlockTotalDifficulty: bigint,
     previousBlockBaseFeePerGas: bigint | undefined
   ): void;
   deleteLaterBlocks(block: Block): void;
-  getBlockByTransactionHash(transactionHash: Buffer): Promise<Block | null>;
+  getBlockByTransactionHash(transactionHash: Uint8Array): Promise<Block | null>;
   getLatestBlock(): Promise<Block>;
   getLatestBlockNumber(): bigint;
   getLogs(filterParams: FilterParams): Promise<RpcLogOutput[]>;
-  getTotalDifficulty(blockHash: Buffer): Promise<bigint>;
+  getTotalDifficulty(blockHash: Uint8Array): Promise<bigint>;
   getTransactionReceipt(
-    transactionHash: Buffer
+    transactionHash: Uint8Array
   ): Promise<RpcReceiptOutput | null>;
 }

package/src/internal/hardhat-network/provider/utils/makeAccount.ts

@@ -2,7 +2,7 @@ import {
   Account,
   Address,
   privateToAddress,
-  toBuffer,
+  toBytes,
 } from "@nomicfoundation/ethereumjs-util";
 
 import { GenesisAccount } from "../node-types";
@@ -19,7 +19,7 @@ export function makeAccount(ga: GenesisAccount) {
   }
 
   const account = Account.fromAccountData({ balance });
-  const pk = toBuffer(ga.privateKey);
+  const pk = toBytes(ga.privateKey);
   const address = new Address(privateToAddress(pk));
   return { account, address };
 }

package/src/internal/hardhat-network/provider/utils/makeCommon.ts

@@ -1,6 +1,8 @@
 import { Common } from "@nomicfoundation/ethereumjs-common";
 
 import { LocalNodeConfig } from "../node-types";
+import { HardforkName } from "../../../util/hardforks";
+import { assertTransientStorageCompatibility } from "../node";
 
 export function makeCommon({
   chainId,
@@ -8,7 +10,10 @@ export function makeCommon({
   hardfork,
   enableTransientStorage,
 }: LocalNodeConfig) {
-  const otherSettings = enableTransientStorage ? { eips: [1153] } : {};
+  assertTransientStorageCompatibility(
+    enableTransientStorage,
+    hardfork as HardforkName
+  );
 
   const common = Common.custom(
     {
@@ -16,8 +21,9 @@ export function makeCommon({
       networkId,
     },
     {
-      hardfork,
-      ...otherSettings,
+      // ethereumjs uses this name for the merge hardfork
+      hardfork:
+        hardfork === HardforkName.MERGE ? "mergeForkIdTransition" : hardfork,
     }
   );
 

package/src/internal/hardhat-network/provider/utils/makeFakeSignature.ts

@@ -1,7 +1,7 @@
 import {
-  AccessListEIP2930Transaction,
-  FeeMarketEIP1559Transaction,
-  TxData,
+  AccessListEIP2930TxData,
+  FeeMarketEIP1559TxData,
+  LegacyTxData,
 } from "@nomicfoundation/ethereumjs-tx";
 import { Address } from "@nomicfoundation/ethereumjs-util";
 
@@ -9,7 +9,7 @@ import { createNonCryptographicHashBasedIdentifier } from "../../../util/hash";
 
 // Produces a signature with r and s values taken from a hash of the inputs.
 export function makeFakeSignature(
-  tx: TxData | AccessListEIP2930Transaction | FeeMarketEIP1559Transaction,
+  tx: LegacyTxData | AccessListEIP2930TxData | FeeMarketEIP1559TxData,
   sender: Address
 ): {
   r: number;
@@ -27,9 +27,23 @@ export function makeFakeSignature(
     "maxPriorityFeePerGas" in tx ? tx.maxPriorityFeePerGas : "",
     "maxFeePerGas" in tx ? tx.maxFeePerGas : "",
     "accessList" in tx
-      ? tx.accessList?.map(([buf, bufs]) =>
-          [buf, ...bufs].map((b) => b.toString("hex")).join(";")
-        )
+      ? tx.accessList?.map((accessListItem) => {
+          let address: string;
+          let storageKeys: string[];
+          if (Array.isArray(accessListItem)) {
+            address = Buffer.from(accessListItem[0]).toString("hex");
+            storageKeys = accessListItem[1].map((b) =>
+              Buffer.from(b).toString("hex")
+            );
+          } else {
+            address = accessListItem.address;
+            storageKeys = accessListItem.storageKeys;
+          }
+
+          return [address, ...storageKeys]
+            .map((b) => Buffer.from(b).toString("hex"))
+            .join(";");
+        })
       : "",
   ]
     .map((a) => a?.toString() ?? "")

package/src/internal/hardhat-network/provider/utils/makeStateTrie.ts

@@ -1,7 +1,7 @@
 import { Trie } from "@nomicfoundation/ethereumjs-trie";
 import {
   Account,
-  intToBuffer,
+  intToBytes,
   setLengthLeft,
 } from "@nomicfoundation/ethereumjs-util";
 
@@ -14,13 +14,13 @@ export async function makeStateTrie(genesisAccounts: GenesisAccount[]) {
 
   for (const acc of genesisAccounts) {
     const { address, account } = makeAccount(acc);
-    await stateTrie.put(address.toBuffer(), account.serialize());
+    await stateTrie.put(address.toBytes(), account.serialize());
   }
 
   // Mimic precompiles activation
   for (let i = 1; i <= 8; i++) {
     await stateTrie.put(
-      setLengthLeft(intToBuffer(i), 20),
+      setLengthLeft(intToBytes(i), 20),
       new Account().serialize()
     );
   }

package/src/internal/hardhat-network/provider/utils/putGenesisBlock.ts

@@ -1,7 +1,6 @@
 import { Block, HeaderData } from "@nomicfoundation/ethereumjs-block";
 import { Common } from "@nomicfoundation/ethereumjs-common";
-import { Trie } from "@nomicfoundation/ethereumjs-trie";
-import { bufferToHex } from "@nomicfoundation/ethereumjs-util";
+import { bytesToHex as bufferToHex } from "@nomicfoundation/ethereumjs-util";
 
 import { dateToTimestampSeconds } from "../../../util/date";
 import { hardforkGte, HardforkName } from "../../../util/hardforks";
@@ -13,9 +12,10 @@ export async function putGenesisBlock(
   blockchain: HardhatBlockchain,
   common: Common,
   { initialDate, blockGasLimit: initialBlockGasLimit }: LocalNodeConfig,
-  stateTrie: Trie,
+  stateRoot: Uint8Array,
   hardfork: HardforkName,
-  initialMixHash: Buffer,
+  initialMixHash: Uint8Array,
+  initialParentBeaconBlockRoot: Uint8Array,
   initialBaseFee?: bigint
 ) {
   const initialBlockTimestamp =
@@ -24,6 +24,7 @@ export async function putGenesisBlock(
       : getCurrentTimestamp();
 
   const isPostMerge = hardforkGte(hardfork, HardforkName.MERGE);
+  const isPostCancun = hardforkGte(hardfork, HardforkName.CANCUN);
 
   const header: HeaderData = {
     timestamp: `0x${initialBlockTimestamp.toString(16)}`,
@@ -31,13 +32,17 @@ export async function putGenesisBlock(
     difficulty: isPostMerge ? 0 : 1,
     nonce: isPostMerge ? "0x0000000000000000" : "0x0000000000000042",
     extraData: "0x1234",
-    stateRoot: bufferToHex(stateTrie.root()),
+    stateRoot: bufferToHex(stateRoot),
   };
 
   if (isPostMerge) {
     header.mixHash = initialMixHash;
   }
 
+  if (isPostCancun) {
+    header.parentBeaconBlockRoot = initialParentBeaconBlockRoot;
+  }
+
   if (initialBaseFee !== undefined) {
     header.baseFeePerGas = initialBaseFee;
   }

package/src/internal/hardhat-network/provider/utils/random.ts

@@ -2,7 +2,7 @@ import type EthereumjsUtilT from "@nomicfoundation/ethereumjs-util";
 import type * as UtilKeccakT from "../../../util/keccak";
 
 export class RandomBufferGenerator {
-  private constructor(private _nextValue: Buffer) {}
+  private constructor(private _nextValue: Uint8Array) {}
 
   public static create(seed: string): RandomBufferGenerator {
     const { keccak256 } = require("../../../util/keccak") as typeof UtilKeccakT;
@@ -12,7 +12,7 @@ export class RandomBufferGenerator {
     return new RandomBufferGenerator(nextValue);
   }
 
-  public next(): Buffer {
+  public next(): Uint8Array {
     const { keccak256 } = require("../../../util/keccak") as typeof UtilKeccakT;
 
     const valueToReturn = this._nextValue;
@@ -32,13 +32,13 @@ export class RandomBufferGenerator {
 }
 
 export const randomHash = () => {
-  const { bufferToHex } =
+  const { bytesToHex: bufferToHex } =
     require("@nomicfoundation/ethereumjs-util") as typeof EthereumjsUtilT;
   return bufferToHex(randomHashBuffer());
 };
 
 const generator = RandomBufferGenerator.create("seed");
-export const randomHashBuffer = (): Buffer => {
+export const randomHashBuffer = (): Uint8Array => {
   return generator.next();
 };
 
@@ -49,7 +49,7 @@ export const randomAddress = () => {
 };
 
 export const randomAddressString = () => {
-  const { bufferToHex } =
+  const { bytesToHex: bufferToHex } =
     require("@nomicfoundation/ethereumjs-util") as typeof EthereumjsUtilT;
   return bufferToHex(randomAddressBuffer());
 };

package/src/internal/hardhat-network/stack-traces/consoleLogger.ts

@@ -1,7 +1,7 @@
 import {
-  bufferToBigInt,
-  bufferToHex,
-  bufferToInt,
+  bytesToBigInt,
+  bytesToHex as bufferToHex,
+  bytesToInt,
   fromSigned,
 } from "@nomicfoundation/ethereumjs-util";
 import util from "util";
@@ -126,7 +126,7 @@ export class ConsoleLogger {
   }
 
   private _maybeConsoleLog(call: CallMessageTrace): ConsoleLogs | undefined {
-    const sig = bufferToInt(call.calldata.slice(0, 4));
+    const sig = bytesToInt(call.calldata.slice(0, 4));
     const parameters = call.calldata.slice(4);
 
     const types = this._consoleLogs[sig];
@@ -162,12 +162,12 @@ export class ConsoleLogger {
     }
   }
 
-  private _decode(data: Buffer, types: string[]): ConsoleLogs {
+  private _decode(data: Uint8Array, types: string[]): ConsoleLogs {
     return types.map((type, i) => {
       const position: number = i * 32;
       switch (types[i]) {
         case Uint256Ty:
-          return bufferToBigInt(
+          return bytesToBigInt(
             data.slice(position, position + REGISTER_SIZE)
           ).toString(10);
 
@@ -183,13 +183,13 @@ export class ConsoleLogger {
           return "false";
 
         case StringTy:
-          const sStart = bufferToInt(
+          const sStart = bytesToInt(
             data.slice(position, position + REGISTER_SIZE)
           );
-          const sLen = bufferToInt(data.slice(sStart, sStart + REGISTER_SIZE));
-          return data
-            .slice(sStart + REGISTER_SIZE, sStart + REGISTER_SIZE + sLen)
-            .toString();
+          const sLen = bytesToInt(data.slice(sStart, sStart + REGISTER_SIZE));
+          return Buffer.from(
+            data.slice(sStart + REGISTER_SIZE, sStart + REGISTER_SIZE + sLen)
+          ).toString();
 
         case AddressTy:
           return bufferToHex(
@@ -197,10 +197,10 @@ export class ConsoleLogger {
           );
 
         case BytesTy:
-          const bStart = bufferToInt(
+          const bStart = bytesToInt(
             data.slice(position, position + REGISTER_SIZE)
           );
-          const bLen = bufferToInt(data.slice(bStart, bStart + REGISTER_SIZE));
+          const bLen = bytesToInt(data.slice(bStart, bStart + REGISTER_SIZE));
           return bufferToHex(
             data.slice(bStart + REGISTER_SIZE, bStart + REGISTER_SIZE + bLen)
           );

package/src/internal/hardhat-network/stack-traces/constants.ts

@@ -1,2 +1,2 @@
-export const SUPPORTED_SOLIDITY_VERSION_RANGE = "<=0.8.23";
+export const SUPPORTED_SOLIDITY_VERSION_RANGE = "<=0.8.24";
 export const FIRST_SOLC_VERSION_SUPPORTED = "0.5.1";

package/src/internal/hardhat-network/stack-traces/contracts-identifier.ts

@@ -1,4 +1,4 @@
-import { bufferToHex } from "@nomicfoundation/ethereumjs-util";
+import { bytesToHex as bufferToHex } from "@nomicfoundation/ethereumjs-util";
 
 import {
   normalizeLibraryRuntimeBytecodeIfNecessary,
@@ -64,7 +64,7 @@ class BytecodeTrie {
    * entire code is covered by the trie, and there's no match, we return undefined.
    */
   public search(
-    code: Buffer,
+    code: Uint8Array,
     currentCodeByte: number = 0
   ): Bytecode | BytecodeTrie | undefined {
     if (currentCodeByte > code.length) {
@@ -130,7 +130,7 @@ export class ContractsIdentifier {
 
   private _searchBytecode(
     trace: EvmMessageTrace,
-    code: Buffer,
+    code: Uint8Array,
     normalizeLibraries = true,
     trie = this._trie,
     firstByteToSearch = 0
@@ -220,7 +220,7 @@ export class ContractsIdentifier {
   /**
    * Returns true if the lastByte is placed right when the metadata starts or after it.
    */
-  private _isMatchingMetadata(code: Buffer, lastByte: number): boolean {
+  private _isMatchingMetadata(code: Uint8Array, lastByte: number): boolean {
     for (let byte = 0; byte < lastByte; ) {
       const opcode = code[byte];
 

package/src/internal/hardhat-network/stack-traces/debug.ts

@@ -1,4 +1,4 @@
-import { bufferToHex } from "@nomicfoundation/ethereumjs-util";
+import { bytesToHex as bufferToHex } from "@nomicfoundation/ethereumjs-util";
 import chalk from "chalk";
 
 import {

package/src/internal/hardhat-network/stack-traces/error-inferrer.ts

@@ -1,6 +1,7 @@
 /* eslint "@typescript-eslint/no-non-null-assertion": "error" */
-import { ERROR } from "@nomicfoundation/ethereumjs-evm/dist/exceptions";
 import { defaultAbiCoder as abi } from "@ethersproject/abi";
+import { ERROR } from "@nomicfoundation/ethereumjs-evm/dist/cjs/exceptions";
+import { equalsBytes } from "@nomicfoundation/ethereumjs-util";
 import semver from "semver";
 
 import { assertHardhatInvariant } from "../../core/errors";
@@ -539,7 +540,7 @@ export class ErrorInferrer {
       return;
     }
 
-    const rawReturnData = returnData.value.toString("hex");
+    const rawReturnData = Buffer.from(returnData.value).toString("hex");
     let errorMessage = `reverted with an unrecognized custom error (return data: 0x${rawReturnData})`;
 
     for (const customError of trace.bytecode.contract.customErrors) {
@@ -1623,7 +1624,7 @@ export class ErrorInferrer {
   ): boolean {
     const call = trace.steps[callSubtraceStepIndex] as MessageTrace;
 
-    if (!trace.returnData.equals(call.returnData)) {
+    if (!equalsBytes(trace.returnData, call.returnData)) {
       return false;
     }
 
@@ -1679,7 +1680,7 @@ export class ErrorInferrer {
       return false;
     }
 
-    if (!trace.returnData.equals(subtrace.returnData)) {
+    if (!equalsBytes(trace.returnData, subtrace.returnData)) {
       return false;
     }
 
@@ -1730,7 +1731,7 @@ export class ErrorInferrer {
     return this._failsRightAfterCall(trace, callStepIndex);
   }
 
-  private _isPanicReturnData(returnData: Buffer): boolean {
+  private _isPanicReturnData(returnData: Uint8Array): boolean {
     return new ReturnData(returnData).isPanicReturnData();
   }
 }

package/src/internal/hardhat-network/stack-traces/library-utils.ts

@@ -50,9 +50,9 @@ export function linkHexStringBytecode(
 }
 
 export function zeroOutAddresses(
-  code: Buffer,
+  code: Uint8Array,
   addressesPositions: number[]
-): Buffer {
+): Uint8Array {
   const addressesSlices = addressesPositions.map((start) => ({
     start,
     length: 20,
@@ -62,9 +62,9 @@ export function zeroOutAddresses(
 }
 
 export function zeroOutSlices(
-  code: Buffer,
+  code: Uint8Array,
   slices: Array<{ start: number; length: number }>
-): Buffer {
+): Uint8Array {
   for (const { start, length } of slices) {
     code = Buffer.concat([
       code.slice(0, start),
@@ -77,8 +77,8 @@ export function zeroOutSlices(
 }
 
 export function normalizeLibraryRuntimeBytecodeIfNecessary(
-  code: Buffer
-): Buffer {
+  code: Uint8Array
+): Uint8Array {
   // Libraries' protection normalization:
   // Solidity 0.4.20 introduced a protection to prevent libraries from being called directly.
   // This is done by modifying the code on deployment, and hard-coding the contract address.

package/src/internal/hardhat-network/stack-traces/message-trace.ts

@@ -15,7 +15,7 @@ export type DecodedEvmMessageTrace =
 
 export interface BaseMessageTrace {
   value: bigint;
-  returnData: Buffer;
+  returnData: Uint8Array;
   error?: EvmError;
   gasUsed: bigint;
   depth: number;
@@ -23,13 +23,13 @@ export interface BaseMessageTrace {
 
 export interface PrecompileMessageTrace extends BaseMessageTrace {
   precompile: number;
-  calldata: Buffer;
+  calldata: Uint8Array;
 }
 
 export interface BaseEvmMessageTrace extends BaseMessageTrace {
-  code: Buffer;
+  code: Uint8Array;
   value: bigint;
-  returnData: Buffer;
+  returnData: Uint8Array;
   error?: EvmError;
   steps: MessageTraceStep[];
   bytecode?: Bytecode;
@@ -39,13 +39,13 @@ export interface BaseEvmMessageTrace extends BaseMessageTrace {
 }
 
 export interface CreateMessageTrace extends BaseEvmMessageTrace {
-  deployedContract: Buffer | undefined;
+  deployedContract: Uint8Array | undefined;
 }
 
 export interface CallMessageTrace extends BaseEvmMessageTrace {
-  calldata: Buffer;
-  address: Buffer;
-  codeAddress: Buffer;
+  calldata: Uint8Array;
+  address: Uint8Array;
+  codeAddress: Uint8Array;
 }
 
 export interface DecodedCreateMessageTrace extends CreateMessageTrace {

package/src/internal/hardhat-network/stack-traces/model.ts

@@ -1,4 +1,4 @@
-import { bufferToHex } from "@nomicfoundation/ethereumjs-util";
+import { bytesToHex as bufferToHex } from "@nomicfoundation/ethereumjs-util";
 
 import { AbiHelpers } from "../../util/abi-helpers";
 
@@ -212,7 +212,7 @@ export class Contract {
   }
 
   public getFunctionFromSelector(
-    selector: Buffer
+    selector: Uint8Array
   ): ContractFunction | undefined {
     return this._selectorHexToFunction.get(bufferToHex(selector));
   }
@@ -261,7 +261,7 @@ export class ContractFunction {
     public readonly contract?: Contract,
     public readonly visibility?: ContractFunctionVisibility,
     public readonly isPayable?: boolean,
-    public selector?: Buffer,
+    public selector?: Uint8Array,
     public readonly paramTypes?: any[]
   ) {
     if (contract !== undefined && !contract.location.contains(location)) {
@@ -269,7 +269,7 @@ export class ContractFunction {
     }
   }
 
-  public isValidCalldata(calldata: Buffer): boolean {
+  public isValidCalldata(calldata: Uint8Array): boolean {
     if (this.paramTypes === undefined) {
       // if we don't know the param types, we just assume that the call is valid
       return true;
@@ -294,7 +294,7 @@ export class CustomError {
   }
 
   private constructor(
-    public readonly selector: Buffer,
+    public readonly selector: Uint8Array,
     public readonly name: string,
     public readonly paramTypes: any[]
   ) {}

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

@@ -1,4 +1,4 @@
-import { bufferToHex } from "@nomicfoundation/ethereumjs-util";
+import { bytesToHex as bufferToHex } from "@nomicfoundation/ethereumjs-util";
 
 import { panicErrorCodeToMessage } from "./panic-errors";
 import {
@@ -271,7 +271,9 @@ function getMessageFromLastStackTraceEntry(
       }
 
       if (!stackTraceEntry.message.isEmpty()) {
-        const returnData = stackTraceEntry.message.value.toString("hex");
+        const returnData = Buffer.from(stackTraceEntry.message.value).toString(
+          "hex"
+        );
 
         return `VM Exception while processing transaction: reverted with an unrecognized custom error (return data: 0x${returnData})`;
       }

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

@@ -61,7 +61,7 @@ export interface UnrecognizedCreateCallstackEntryStackTraceEntry {
 
 export interface UnrecognizedContractCallstackEntryStackTraceEntry {
   type: StackTraceEntryType.UNRECOGNIZED_CONTRACT_CALLSTACK_ENTRY;
-  address: Buffer;
+  address: Uint8Array;
   sourceReference?: undefined;
 }
 
@@ -158,7 +158,7 @@ export interface UnrecognizedCreateErrorStackTraceEntry {
 
 export interface UnrecognizedContractErrorStackTraceEntry {
   type: StackTraceEntryType.UNRECOGNIZED_CONTRACT_ERROR;
-  address: Buffer;
+  address: Uint8Array;
   message: ReturnData;
   sourceReference?: undefined;
   isInvalidOpcodeError: boolean;