hardhat 2.19.5 → 2.20.0

package/src/internal/hardhat-network/provider/TxPool.ts

@@ -1,13 +1,16 @@
-import { Common } from "@nomicfoundation/ethereumjs-common";
+import {
+  Common,
+  StateManagerInterface,
+} from "@nomicfoundation/ethereumjs-common";
 import {
   TransactionFactory,
   TypedTransaction,
 } from "@nomicfoundation/ethereumjs-tx";
-import { StateManager } from "@nomicfoundation/ethereumjs-statemanager";
 import {
   Address,
-  bufferToHex,
-  toBuffer,
+  bytesToHex as bufferToHex,
+  equalsBytes,
+  toBytes,
 } from "@nomicfoundation/ethereumjs-util";
 import { List as ImmutableList, Record as ImmutableRecord } from "immutable";
 
@@ -56,7 +59,7 @@ export function deserializeTransaction(
   let data;
   if (fakeFrom !== undefined) {
     const sender = Address.fromString(fakeFrom);
-    const serialization = toBuffer(rlpSerialization);
+    const serialization = toBytes(rlpSerialization);
 
     if (tx.get("txType") === 1) {
       data =
@@ -79,9 +82,9 @@ export function deserializeTransaction(
       );
     }
   } else {
-    data = TransactionFactory.fromSerializedData(toBuffer(rlpSerialization), {
+    data = TransactionFactory.fromSerializedData(toBytes(rlpSerialization), {
       common,
-      disableMaxInitCodeSizeCheck: true,
+      allowUnlimitedInitCodeSize: true,
     });
   }
 
@@ -102,7 +105,7 @@ export class TxPool {
   ) => OrderedTransaction;
 
   constructor(
-    private readonly _stateManager: StateManager,
+    private readonly _stateManager: StateManagerInterface,
     blockGasLimit: bigint,
     common: Common
   ) {
@@ -282,8 +285,8 @@ export class TxPool {
       const senderAccount = await this._stateManager.getAccount(
         Address.fromString(address)
       );
-      const senderNonce = senderAccount.nonce;
-      const senderBalance = senderAccount.balance;
+      const senderNonce = senderAccount?.nonce ?? 0n;
+      const senderBalance = senderAccount?.balance ?? 0n;
 
       let moveToQueued = false;
       for (const tx of txs) {
@@ -320,8 +323,8 @@ export class TxPool {
       const senderAccount = await this._stateManager.getAccount(
         Address.fromString(address)
       );
-      const senderNonce = senderAccount.nonce;
-      const senderBalance = senderAccount.balance;
+      const senderNonce = senderAccount?.nonce ?? 0n;
+      const senderBalance = senderAccount?.balance ?? 0n;
 
       for (const tx of txs) {
         const deserializedTx = this._deserializeTransaction(tx);
@@ -446,7 +449,7 @@ export class TxPool {
     }
 
     const senderAccount = await this._stateManager.getAccount(senderAddress);
-    const senderBalance = senderAccount.balance;
+    const senderBalance = senderAccount?.balance ?? 0n;
 
     const maxFee = "gasPrice" in tx ? tx.gasPrice : tx.maxFeePerGas;
     const txMaxUpfrontCost = tx.gasLimit * maxFee + tx.value;
@@ -495,7 +498,7 @@ export class TxPool {
     txList: SenderTransactions | undefined
   ) {
     const existingTx = txList?.find((etx) =>
-      this._deserializeTransaction(etx).data.hash().equals(tx.hash())
+      equalsBytes(this._deserializeTransaction(etx).data.hash(), tx.hash())
     );
     return existingTx !== undefined;
   }
@@ -562,7 +565,7 @@ export class TxPool {
     this._state = this._state.set("blockGasLimit", BigIntUtils.toHex(newLimit));
   }
 
-  private _deleteTransactionByHash(hash: Buffer) {
+  private _deleteTransactionByHash(hash: Uint8Array) {
     this._state = this._state.set(
       "hashToTransaction",
       this._getTransactionsByHash().delete(bufferToHex(hash))
@@ -592,7 +595,7 @@ export class TxPool {
     accountAddress: Address
   ): Promise<bigint> {
     const account = await this._stateManager.getAccount(accountAddress);
-    return account.nonce;
+    return account?.nonce ?? 0n;
   }
 
   /**

package/src/internal/hardhat-network/provider/ethereumjs-workarounds.ts

@@ -1,17 +1,16 @@
 import { TransactionFactory } from "@nomicfoundation/ethereumjs-tx";
-import { BaseTransaction } from "@nomicfoundation/ethereumjs-tx/dist/baseTransaction";
+import { BaseTransaction } from "@nomicfoundation/ethereumjs-tx/dist/cjs/baseTransaction";
 import {
-  AccessListEIP2930TxData,
-  TxData,
   TxOptions,
-} from "@nomicfoundation/ethereumjs-tx/dist/types";
+  TypedTxData,
+} from "@nomicfoundation/ethereumjs-tx/dist/cjs/types";
 
 // This is a hack to prevent Block.fromBlockData from recreating our
 // transactions and changing their types. Note fromBlockData is used
 // by the BlockBuilder to update block it's building.
 const previousFromTxData = TransactionFactory.fromTxData;
 (TransactionFactory as any).fromTxData = function (
-  txData: TxData | AccessListEIP2930TxData,
+  txData: TypedTxData,
   txOptions?: TxOptions
 ) {
   if (txData instanceof BaseTransaction) {

package/src/internal/hardhat-network/provider/filter.ts

@@ -1,4 +1,7 @@
-import { bufferToHex, toBuffer } from "@nomicfoundation/ethereumjs-util";
+import {
+  bytesToHex as bufferToHex,
+  toBytes,
+} from "@nomicfoundation/ethereumjs-util";
 import { Bloom } from "@nomicfoundation/ethereumjs-vm";
 
 import { RpcLogOutput } from "./output";
@@ -14,8 +17,8 @@ export enum Type {
 export interface FilterCriteria {
   fromBlock: bigint;
   toBlock: bigint;
-  addresses: Buffer[];
-  normalizedTopics: Array<Array<Buffer | null> | null>;
+  addresses: Uint8Array[];
+  normalizedTopics: Array<Array<Uint8Array | null> | null>;
 }
 
 export interface Filter {
@@ -30,8 +33,8 @@ export interface Filter {
 
 export function bloomFilter(
   bloom: Bloom,
-  addresses: Buffer[],
-  normalizedTopics: Array<Array<Buffer | null> | null>
+  addresses: Uint8Array[],
+  normalizedTopics: Array<Array<Uint8Array | null> | null>
 ): boolean {
   if (addresses.length > 0) {
     let included = false;
@@ -84,7 +87,7 @@ export function filterLogs(
 
     if (
       criteria.addresses.length !== 0 &&
-      !includes(criteria.addresses, toBuffer(log.address))
+      !includes(criteria.addresses, toBytes(log.address))
     ) {
       continue;
     }
@@ -99,7 +102,7 @@ export function filterLogs(
   return filteredLogs;
 }
 
-export function includes(addresses: Buffer[], a: Buffer): boolean {
+export function includes(addresses: Uint8Array[], a: Uint8Array): boolean {
   for (const address of addresses) {
     if (Buffer.compare(address, a) === 0) {
       return true;
@@ -110,7 +113,7 @@ export function includes(addresses: Buffer[], a: Buffer): boolean {
 }
 
 export function topicMatched(
-  normalizedTopics: Array<Array<Buffer | null> | null>,
+  normalizedTopics: Array<Array<Uint8Array | null> | null>,
   logTopics: string[]
 ): boolean {
   for (let i = 0; i < normalizedTopics.length; i++) {

package/src/internal/hardhat-network/provider/fork/ForkBlockchain.ts

@@ -1,9 +1,19 @@
 import { Block } from "@nomicfoundation/ethereumjs-block";
+import {
+  BlockchainInterface,
+  BlockchainEvents,
+} from "@nomicfoundation/ethereumjs-blockchain";
 import { Common } from "@nomicfoundation/ethereumjs-common";
-import { TypedTransaction } from "@nomicfoundation/ethereumjs-tx";
-import { Address } from "@nomicfoundation/ethereumjs-util";
+import {
+  FeeMarketEIP1559TxData,
+  TypedTransaction,
+} from "@nomicfoundation/ethereumjs-tx";
+import {
+  Address,
+  AsyncEventEmitter,
+  equalsBytes,
+} from "@nomicfoundation/ethereumjs-util";
 
-import { FeeMarketEIP1559TxData } from "@nomicfoundation/ethereumjs-tx/dist/types";
 import { RpcBlockWithTransactions } from "../../../core/jsonrpc/types/output/block";
 import { RpcTransactionReceipt } from "../../../core/jsonrpc/types/output/receipt";
 import { RpcTransaction } from "../../../core/jsonrpc/types/output/transaction";
@@ -35,6 +45,7 @@ export class ForkBlockchain
   implements HardhatBlockchainInterface
 {
   private _latestBlockNumber = this._forkBlockNumber;
+  public events?: AsyncEventEmitter<BlockchainEvents> | undefined;
 
   constructor(
     private _jsonRpcClient: JsonRpcClient,
@@ -44,6 +55,22 @@ export class ForkBlockchain
     super(common);
   }
 
+  public getIteratorHead(_name?: string | undefined): Promise<Block> {
+    throw new Error("Method not implemented.");
+  }
+
+  public setIteratorHead(_tag: string, _headHash: Uint8Array): Promise<void> {
+    throw new Error("Method not implemented.");
+  }
+
+  public getCanonicalHeadBlock(): Promise<Block> {
+    throw new Error("Method not implemented.");
+  }
+
+  public shallowCopy(): BlockchainInterface {
+    return this;
+  }
+
   public getLatestBlockNumber(): bigint {
     return this._latestBlockNumber;
   }
@@ -87,7 +114,7 @@ export class ForkBlockchain
     // Thus, we avoid this check for the first block after the fork.
     if (blockNumber > this._forkBlockNumber + 1n) {
       const parent = await this.getLatestBlock();
-      if (!block.header.parentHash.equals(parent.hash())) {
+      if (!equalsBytes(block.header.parentHash, parent.hash())) {
         throw new Error("Invalid parent hash");
       }
     }
@@ -118,7 +145,10 @@ export class ForkBlockchain
   public deleteLaterBlocks(block: Block): void {
     const blockNumber = block.header.number;
     const savedBlock = this._data.getBlockByNumber(blockNumber);
-    if (savedBlock === undefined || !savedBlock.hash().equals(block.hash())) {
+    if (
+      savedBlock === undefined ||
+      !equalsBytes(savedBlock.hash(), block.hash())
+    ) {
       throw new Error("Invalid block");
     }
 
@@ -268,9 +298,12 @@ export class ForkBlockchain
     if (rpcBlock.baseFeePerGas === undefined) {
       common.setHardfork("berlin");
     } else if (rpcBlock.withdrawals === undefined) {
-      common.setHardfork("merge");
-    } else {
+      // ethereumjs uses this name for the merge hardfork
+      common.setHardfork("mergeForkIdTransition");
+    } else if (rpcBlock.parentBeaconBlockRoot === undefined) {
       common.setHardfork("shanghai");
+    } else {
+      common.setHardfork("cancun");
     }
 
     // we don't include the transactions to add our own custom tx objects,

package/src/internal/hardhat-network/provider/fork/ForkStateManager.ts

@@ -1,13 +1,18 @@
-import { StateManager } from "@nomicfoundation/ethereumjs-statemanager";
+import {
+  EVMStateManagerInterface,
+  Proof,
+  StorageRange,
+} from "@nomicfoundation/ethereumjs-common";
 import {
   Account,
   bigIntToHex,
-  bufferToBigInt,
+  bytesToBigInt,
   Address,
-  bufferToHex,
+  bytesToHex as bufferToHex,
+  equalsBytes,
   KECCAK256_NULL,
-  toBuffer,
-  unpadBuffer,
+  toBytes,
+  unpadBytes,
 } from "@nomicfoundation/ethereumjs-util";
 import { Map as ImmutableMap, Record as ImmutableRecord } from "immutable";
 
@@ -25,8 +30,13 @@ import {
   makeEmptyAccountState,
 } from "./AccountState";
 
-const encodeStorageKey = (address: Buffer, position: Buffer): string => {
-  return `${address.toString("hex")}${unpadBuffer(position).toString("hex")}`;
+const encodeStorageKey = (
+  address: Uint8Array,
+  position: Uint8Array
+): string => {
+  return `${Buffer.from(address).toString("hex")}${Buffer.from(
+    unpadBytes(position)
+  ).toString("hex")}`;
 };
 
 /* eslint-disable @nomicfoundation/hardhat-internal-rules/only-hardhat-error */
@@ -42,16 +52,28 @@ const notCheckpointedError = (method: string) =>
 const notSupportedError = (method: string) =>
   new Error(`${method} is not supported when forking from remote network`);
 
-export class ForkStateManager implements StateManager {
+export class ForkStateManager implements EVMStateManagerInterface {
   private _state: State = ImmutableMap<string, ImmutableRecord<AccountState>>();
   private _initialStateRoot: string = randomHash();
   private _stateRoot: string = this._initialStateRoot;
   private _stateRootToState: Map<string, State> = new Map();
-  private _originalStorageCache: Map<string, Buffer> = new Map();
+  private _originalStorageCache: Map<string, Uint8Array> = new Map();
   private _stateCheckpoints: string[] = [];
   private _contextBlockNumber = this._forkBlockNumber;
   private _contextChanged = false;
 
+  public originalStorageCache: {
+    get(address: Address, key: Uint8Array): Promise<Uint8Array>;
+    clear(): void;
+  } = {
+    get: async (address: Address, key: Uint8Array): Promise<Uint8Array> => {
+      return this.getOriginalContractStorage(address, key);
+    },
+    clear: (): void => {
+      this.clearOriginalStorageCache();
+    },
+  };
+
   constructor(
     private readonly _jsonRpcClient: JsonRpcClient,
     private readonly _forkBlockNumber: bigint
@@ -60,6 +82,24 @@ export class ForkStateManager implements StateManager {
 
     this._stateRootToState.set(this._initialStateRoot, this._state);
   }
+  public dumpStorageRange(
+    _address: Address,
+    _startKey: bigint,
+    _limit: number
+  ): Promise<StorageRange> {
+    throw new Error("Method not implemented.");
+  }
+  public getProof(
+    _address: Address,
+    _storageSlots?: Uint8Array[] | undefined
+  ): Promise<Proof> {
+    throw new Error("Method not implemented.");
+  }
+  public shallowCopy(
+    _downlevelCaches?: boolean | undefined
+  ): EVMStateManagerInterface {
+    return this;
+  }
 
   public async initializeGenesisAccounts(genesisAccounts: GenesisAccount[]) {
     const accounts: Array<{ address: Address; account: Account }> = [];
@@ -70,7 +110,7 @@ export class ForkStateManager implements StateManager {
       accounts.push(account);
 
       const noncePromise = this._jsonRpcClient.getTransactionCount(
-        account.address.toBuffer(),
+        account.address.toBytes(),
         this._forkBlockNumber
       );
       noncesPromises.push(noncePromise);
@@ -112,14 +152,14 @@ export class ForkStateManager implements StateManager {
     const localBalance = localAccount?.get("balance");
     const localCode = localAccount?.get("code");
 
-    let nonce: Buffer | bigint | undefined =
-      localNonce !== undefined ? toBuffer(localNonce) : undefined;
+    let nonce: Uint8Array | bigint | undefined =
+      localNonce !== undefined ? toBytes(localNonce) : undefined;
 
-    let balance: Buffer | bigint | undefined =
-      localBalance !== undefined ? toBuffer(localBalance) : undefined;
+    let balance: Uint8Array | bigint | undefined =
+      localBalance !== undefined ? toBytes(localBalance) : undefined;
 
-    let code: Buffer | undefined =
-      localCode !== undefined ? toBuffer(localCode) : undefined;
+    let code: Uint8Array | undefined =
+      localCode !== undefined ? toBytes(localCode) : undefined;
 
     if (balance === undefined || nonce === undefined || code === undefined) {
       const accountData = await this._jsonRpcClient.getAccountData(
@@ -162,10 +202,10 @@ export class ForkStateManager implements StateManager {
     this._state = this._state.set(hexAddress, account);
   }
 
-  public async getContractCode(address: Address): Promise<Buffer> {
+  public async getContractCode(address: Address): Promise<Uint8Array> {
     const localCode = this._state.get(address.toString())?.get("code");
     if (localCode !== undefined) {
-      return toBuffer(localCode);
+      return toBytes(localCode);
     }
 
     const accountData = await this._jsonRpcClient.getAccountData(
@@ -178,8 +218,8 @@ export class ForkStateManager implements StateManager {
 
   public async getContractStorage(
     address: Address,
-    key: Buffer
-  ): Promise<Buffer> {
+    key: Uint8Array
+  ): Promise<Uint8Array> {
     if (key.length !== 32) {
       throw new Error("Storage key must be 32 bytes long");
     }
@@ -189,21 +229,21 @@ export class ForkStateManager implements StateManager {
     const localValue = account?.get("storage").get(bufferToHex(key));
 
     if (localValue !== undefined) {
-      return toBuffer(localValue);
+      return toBytes(localValue);
     }
 
     const slotCleared = localValue === null;
     if (contractStorageCleared || slotCleared) {
-      return toBuffer([]);
+      return toBytes([]);
     }
 
     const remoteValue = await this._jsonRpcClient.getStorageAt(
       address,
-      bufferToBigInt(key),
+      bytesToBigInt(key),
       this._contextBlockNumber
     );
 
-    return unpadBuffer(remoteValue);
+    return unpadBytes(remoteValue);
   }
 
   public async putContractStorage(
@@ -219,7 +259,7 @@ export class ForkStateManager implements StateManager {
       throw new Error("Storage value cannot be longer than 32 bytes");
     }
 
-    const unpaddedValue = unpadBuffer(value);
+    const unpaddedValue = unpadBytes(value);
 
     const hexAddress = address.toString();
     let account = this._state.get(hexAddress) ?? makeAccountState();
@@ -266,18 +306,18 @@ export class ForkStateManager implements StateManager {
     if (checkpointedRoot === undefined) {
       throw notCheckpointedError("revert");
     }
-    await this.setStateRoot(toBuffer(checkpointedRoot));
+    await this.setStateRoot(toBytes(checkpointedRoot));
   }
 
-  public async getStateRoot(): Promise<Buffer> {
+  public async getStateRoot(): Promise<Uint8Array> {
     if (this._stateRootToState.get(this._stateRoot) !== this._state) {
       this._stateRoot = randomHash();
       this._stateRootToState.set(this._stateRoot, this._state);
     }
-    return toBuffer(this._stateRoot);
+    return toBytes(this._stateRoot);
   }
 
-  public async setStateRoot(stateRoot: Buffer): Promise<void> {
+  public async setStateRoot(stateRoot: Uint8Array): Promise<void> {
     this._setStateRoot(stateRoot);
   }
 
@@ -304,7 +344,7 @@ export class ForkStateManager implements StateManager {
     return (
       account.nonce === 0n &&
       account.balance === 0n &&
-      account.codeHash.equals(KECCAK256_NULL)
+      equalsBytes(account.codeHash, KECCAK256_NULL)
     );
   }
 
@@ -315,9 +355,9 @@ export class ForkStateManager implements StateManager {
   }
 
   public setBlockContext(
-    stateRoot: Buffer,
+    stateRoot: Uint8Array,
     blockNumber: bigint,
-    irregularState?: Buffer
+    irregularState?: Uint8Array
   ) {
     if (this._stateCheckpoints.length !== 0) {
       throw checkpointedError("setBlockContext");
@@ -329,7 +369,7 @@ export class ForkStateManager implements StateManager {
     }
 
     if (blockNumber === this._forkBlockNumber) {
-      this._setStateRoot(toBuffer(this._initialStateRoot));
+      this._setStateRoot(toBytes(this._initialStateRoot));
       return;
     }
     if (blockNumber > this._forkBlockNumber) {
@@ -345,7 +385,7 @@ export class ForkStateManager implements StateManager {
     // because the VM does it before executing a message anyway.
   }
 
-  public restoreForkBlockContext(stateRoot: Buffer) {
+  public restoreForkBlockContext(stateRoot: Uint8Array) {
     if (this._stateCheckpoints.length !== 0) {
       throw checkpointedError("restoreForkBlockContext");
     }
@@ -376,9 +416,9 @@ export class ForkStateManager implements StateManager {
 
   public async getOriginalContractStorage(
     address: Address,
-    key: Buffer
-  ): Promise<Buffer> {
-    const storageKey = encodeStorageKey(address.toBuffer(), key);
+    key: Uint8Array
+  ): Promise<Uint8Array> {
+    const storageKey = encodeStorageKey(Buffer.from(address.toBytes()), key);
     const cachedValue = this._originalStorageCache.get(storageKey);
     if (cachedValue !== undefined) {
       return cachedValue;
@@ -401,13 +441,13 @@ export class ForkStateManager implements StateManager {
 
     // Code is set to empty string here to prevent unnecessary
     // JsonRpcClient.getCode calls in getAccount method
-    if (account.codeHash.equals(KECCAK256_NULL)) {
+    if (equalsBytes(account.codeHash, KECCAK256_NULL)) {
       localAccount = localAccount.set("code", "0x");
     }
     this._state = this._state.set(hexAddress, localAccount);
   }
 
-  private _setStateRoot(stateRoot: Buffer) {
+  private _setStateRoot(stateRoot: Uint8Array) {
     const newRoot = bufferToHex(stateRoot);
     const state = this._stateRootToState.get(newRoot);
     if (state === undefined) {

package/src/internal/hardhat-network/provider/fork/rpcToBlockData.ts

@@ -24,6 +24,9 @@ export function rpcToBlockData(rpcBlock: RpcBlockWithTransactions): BlockData {
       nonce: rpcBlock.nonce,
       baseFeePerGas: rpcBlock.baseFeePerGas,
       withdrawalsRoot: rpcBlock.withdrawalsRoot,
+      parentBeaconBlockRoot: rpcBlock.parentBeaconBlockRoot,
+      blobGasUsed: rpcBlock.blobGasUsed,
+      excessBlobGas: rpcBlock.excessBlobGas,
     },
     transactions: rpcBlock.transactions.map(rpcToTxData),
     withdrawals: rpcBlock.withdrawals,

package/src/internal/hardhat-network/provider/fork/rpcToTxData.ts

@@ -2,7 +2,7 @@ import type { BigIntLike } from "@nomicfoundation/ethereumjs-util";
 
 import {
   AccessListEIP2930TxData,
-  TxData,
+  LegacyTxData,
 } from "@nomicfoundation/ethereumjs-tx";
 
 import { RpcTransaction } from "../../../core/jsonrpc/types/output/transaction";
@@ -17,7 +17,7 @@ interface FeeMarketEIP1559TxData extends AccessListEIP2930TxData {
 
 export function rpcToTxData(
   rpcTransaction: RpcTransaction
-): TxData | AccessListEIP2930TxData | FeeMarketEIP1559TxData {
+): LegacyTxData | AccessListEIP2930TxData | FeeMarketEIP1559TxData {
   const isEip1559 = rpcTransaction.type === 2n;
 
   return {

package/src/internal/hardhat-network/provider/modules/base.ts

@@ -1,7 +1,7 @@
 import { Block } from "@nomicfoundation/ethereumjs-block";
 import {
-  bufferToHex,
-  toBuffer,
+  bytesToHex as bufferToHex,
+  toBytes,
   zeroAddress,
 } from "@nomicfoundation/ethereumjs-util";
 import {
@@ -94,7 +94,7 @@ export class Base {
         rpcCall.from !== undefined
           ? rpcCall.from
           : await this._getDefaultCallFrom(),
-      data: rpcCall.data !== undefined ? rpcCall.data : toBuffer([]),
+      data: rpcCall.data !== undefined ? rpcCall.data : Buffer.from([]),
       gasLimit:
         rpcCall.gas !== undefined ? rpcCall.gas : this._node.getBlockGasLimit(),
       value: rpcCall.value !== undefined ? rpcCall.value : 0n,
@@ -148,9 +148,9 @@ export class Base {
     const localAccounts = await this._node.getLocalAccountAddresses();
 
     if (localAccounts.length === 0) {
-      return toBuffer(zeroAddress());
+      return Buffer.from(toBytes(zeroAddress()));
     }
 
-    return toBuffer(localAccounts[0]);
+    return Buffer.from(toBytes(localAccounts[0]));
   }
 }