hardhat 2.19.5 → 2.20.0

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

@@ -1,36 +1,38 @@
 import { Block, HeaderData } from "@nomicfoundation/ethereumjs-block";
-import { Common, CustomCommonOpts } from "@nomicfoundation/ethereumjs-common";
+import {
+  Common,
+  EVMStateManagerInterface,
+} from "@nomicfoundation/ethereumjs-common";
+import { ERROR } from "@nomicfoundation/ethereumjs-evm/dist/cjs/exceptions";
 import {
   AccessListEIP2930Transaction,
   FeeMarketEIP1559Transaction,
-  Transaction,
+  LegacyTransaction,
   TypedTransaction,
+  BlobEIP4844Transaction,
 } from "@nomicfoundation/ethereumjs-tx";
 import {
   Address,
   ECDSASignature,
-  bigIntToBuffer,
-  bufferToHex,
+  bigIntToBytes,
+  bytesToHex as bufferToHex,
   ecsign,
+  equalsBytes,
   hashPersonalMessage,
   privateToAddress,
   setLengthLeft,
-  toBuffer,
-  bufferToBigInt,
+  toBytes,
+  bytesToBigInt,
+  Account,
 } from "@nomicfoundation/ethereumjs-util";
 import {
   Bloom,
-  EEI,
   RunBlockResult,
   RunTxResult,
   VM,
 } from "@nomicfoundation/ethereumjs-vm";
 import { EVM, EVMResult } from "@nomicfoundation/ethereumjs-evm";
-import { ERROR } from "@nomicfoundation/ethereumjs-evm/dist/exceptions";
-import {
-  DefaultStateManager,
-  StateManager,
-} from "@nomicfoundation/ethereumjs-statemanager";
+import { DefaultStateManager } from "@nomicfoundation/ethereumjs-statemanager";
 import { SignTypedDataVersion, signTypedData } from "@metamask/eth-sig-util";
 import chalk from "chalk";
 import { randomBytes } from "crypto";
@@ -132,6 +134,10 @@ import { RandomBufferGenerator } from "./utils/random";
 
 type ExecResult = EVMResult["execResult"];
 
+const BEACON_ROOT_ADDRESS = "0x000F3df6D732807Ef1319fB7B8bB8522d0Beac02";
+const BEACON_ROOT_BYTECODE =
+  "0x3373fffffffffffffffffffffffffffffffffffffffe14604d57602036146024575f5ffd5b5f35801560495762001fff810690815414603c575f5ffd5b62001fff01545f5260205ff35b5f5ffd5b62001fff42064281555f359062001fff015500";
+
 const log = debug("hardhat:core:hardhat-network:node");
 
 /* eslint-disable @nomicfoundation/hardhat-internal-rules/only-hardhat-error */
@@ -156,7 +162,7 @@ export class HardhatNode extends EventEmitter {
     const allowUnlimitedContractSize =
       config.allowUnlimitedContractSize ?? false;
 
-    let stateManager: StateManager;
+    let stateManager: EVMStateManagerInterface;
     let blockchain: HardhatBlockchainInterface;
     let initialBlockTimeOffset: bigint | undefined;
     let nextBlockBaseFeePerGas: bigint | undefined;
@@ -172,6 +178,10 @@ export class HardhatNode extends EventEmitter {
 
     const hardfork = getHardforkName(config.hardfork);
     const mixHashGenerator = RandomBufferGenerator.create("randomMixHashSeed");
+    const parentBeaconBlockRootGenerator = RandomBufferGenerator.create(
+      "randomParentBeaconBlockRootSeed"
+    );
+
     let forkClient: JsonRpcClient | undefined;
 
     const common = makeCommon(config);
@@ -200,6 +210,14 @@ export class HardhatNode extends EventEmitter {
         forkBlockNumber
       );
       await forkStateManager.initializeGenesisAccounts(genesisAccounts);
+
+      if (hardforkGte(hardfork, HardforkName.CANCUN)) {
+        await forkStateManager.putContractCode(
+          Address.fromString(BEACON_ROOT_ADDRESS),
+          Buffer.from(toBytes(BEACON_ROOT_BYTECODE))
+        );
+      }
+
       stateManager = forkStateManager;
 
       blockchain = new ForkBlockchain(forkClient, forkBlockNumber, common);
@@ -236,6 +254,13 @@ export class HardhatNode extends EventEmitter {
         trie: stateTrie,
       });
 
+      if (hardforkGte(hardfork, HardforkName.CANCUN)) {
+        await stateManager.putContractCode(
+          Address.fromString(BEACON_ROOT_ADDRESS),
+          Buffer.from(toBytes(BEACON_ROOT_BYTECODE))
+        );
+      }
+
       const hardhatBlockchain = new HardhatBlockchain(common);
 
       const genesisBlockBaseFeePerGas = hardforkGte(
@@ -250,9 +275,10 @@ export class HardhatNode extends EventEmitter {
         hardhatBlockchain,
         common,
         config,
-        stateTrie,
+        await stateManager.getStateRoot(),
         hardfork,
         mixHashGenerator.next(),
+        parentBeaconBlockRootGenerator.next(),
         genesisBlockBaseFeePerGas
       );
 
@@ -267,11 +293,12 @@ export class HardhatNode extends EventEmitter {
 
     const txPool = new TxPool(stateManager, BigInt(blockGasLimit), common);
 
-    const eei = new EEI(stateManager, common, blockchain);
-    const evm = await EVM.create({
-      eei,
+    const evm = new EVM({
       allowUnlimitedContractSize,
+      allowUnlimitedInitCodeSize: allowUnlimitedContractSize,
+      blockchain,
       common,
+      stateManager,
     });
 
     const vm = await VM.create({
@@ -282,7 +309,7 @@ export class HardhatNode extends EventEmitter {
       blockchain,
     });
 
-    const instanceId = bufferToBigInt(randomBytes(32));
+    const instanceId = bytesToBigInt(randomBytes(32));
 
     const node = new HardhatNode(
       vm,
@@ -301,6 +328,7 @@ export class HardhatNode extends EventEmitter {
       hardfork,
       hardforkActivations,
       mixHashGenerator,
+      parentBeaconBlockRootGenerator,
       allowUnlimitedContractSize,
       allowBlocksWithSameTimestamp,
       tracingConfig,
@@ -339,7 +367,7 @@ The hardfork must be at least spuriousDragon, but ${common.hardfork()} was given
         return;
       }
 
-      upstreamCommon.setHardforkByBlockNumber(forkBlockNumber);
+      upstreamCommon.setHardforkBy({ blockNumber: forkBlockNumber });
 
       if (!upstreamCommon.gteHardfork("spuriousDragon")) {
         throw new InternalError(
@@ -351,7 +379,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     }
   }
 
-  private readonly _localAccounts: Map<string, Buffer> = new Map(); // address => private key
+  private readonly _localAccounts: Map<string, Uint8Array> = new Map(); // address => private key
   private readonly _impersonatedAccounts: Set<string> = new Set(); // address
 
   private _nextBlockTimestamp: bigint = 0n;
@@ -370,12 +398,12 @@ Hardhat Network's forking functionality only works with blocks from at least spu
   private _failedStackTraces = 0;
 
   // blockNumber => state root
-  private _irregularStatesByBlockNumber: Map<bigint, Buffer> = new Map();
+  private _irregularStatesByBlockNumber: Map<bigint, Uint8Array> = new Map();
 
   private constructor(
     private readonly _vm: VM,
     private readonly _instanceId: bigint,
-    private readonly _stateManager: StateManager,
+    private readonly _stateManager: EVMStateManagerInterface,
     private readonly _blockchain: HardhatBlockchainInterface,
     private readonly _txPool: TxPool,
     private _automine: boolean,
@@ -389,6 +417,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     public readonly hardfork: HardforkName,
     private readonly _hardforkActivations: HardforkHistoryConfig,
     private _mixHashGenerator: RandomBufferGenerator,
+    private _parentBeaconBlockRootGenerator: RandomBufferGenerator,
     public readonly allowUnlimitedContractSize: boolean,
     private _allowBlocksWithSameTimestamp: boolean,
     tracingConfig?: TracingConfig,
@@ -461,20 +490,25 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     if (pk !== undefined) {
       let tx: TypedTransaction;
 
-      if ("maxFeePerGas" in txParams) {
+      if ("blobs" in txParams) {
+        tx = BlobEIP4844Transaction.fromTxData(txParams, {
+          common: this._vm.common,
+          allowUnlimitedInitCodeSize: true,
+        });
+      } else if ("maxFeePerGas" in txParams) {
         tx = FeeMarketEIP1559Transaction.fromTxData(txParams, {
-          common: this._vm._common,
-          disableMaxInitCodeSizeCheck: true,
+          common: this._vm.common,
+          allowUnlimitedInitCodeSize: true,
         });
       } else if ("accessList" in txParams) {
         tx = AccessListEIP2930Transaction.fromTxData(txParams, {
-          common: this._vm._common,
-          disableMaxInitCodeSizeCheck: true,
+          common: this._vm.common,
+          allowUnlimitedInitCodeSize: true,
         });
       } else {
-        tx = Transaction.fromTxData(txParams, {
-          common: this._vm._common,
-          disableMaxInitCodeSizeCheck: true,
+        tx = LegacyTransaction.fromTxData(txParams, {
+          common: this._vm.common,
+          allowUnlimitedInitCodeSize: true,
         });
       }
 
@@ -696,7 +730,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
       this._stateManager.getAccount(address)
     );
 
-    return account.balance;
+    return account?.balance ?? 0n;
   }
 
   public async getNextConfirmedNonce(
@@ -707,7 +741,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
       this._stateManager.getAccount(address)
     );
 
-    return account.nonce;
+    return account?.nonce ?? 0n;
   }
 
   public async getAccountNextPendingNonce(address: Address): Promise<bigint> {
@@ -881,10 +915,17 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     positionIndex: bigint,
     blockNumberOrPending: bigint | "pending"
   ): Promise<Buffer> {
-    const key = setLengthLeft(bigIntToBuffer(positionIndex), 32);
+    const key = setLengthLeft(bigIntToBytes(positionIndex), 32);
 
-    const data = await this._runInBlockContext(blockNumberOrPending, () =>
-      this._stateManager.getContractStorage(address, key)
+    const data = await this._runInBlockContext(
+      blockNumberOrPending,
+      async () => {
+        const account = await this._stateManager.getAccount(address);
+        if (account === undefined) {
+          return Uint8Array.from([]);
+        }
+        return this._stateManager.getContractStorage(address, key);
+      }
     );
 
     const EXPECTED_DATA_SIZE = 32;
@@ -895,7 +936,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
       );
     }
 
-    return data;
+    return Buffer.from(data);
   }
 
   public async getBlockByNumber(pending: "pending"): Promise<Block>;
@@ -945,7 +986,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     blockNumberOrPending: bigint | "pending"
   ): Promise<Buffer> {
     return this._runInBlockContext(blockNumberOrPending, () =>
-      this._stateManager.getContractCode(address)
+      this._stateManager.getContractCode(address).then(Buffer.from)
     );
   }
 
@@ -1002,9 +1043,9 @@ Hardhat Network's forking functionality only works with blocks from at least spu
   }
 
   public async getTransactionReceipt(
-    hash: Buffer | string
+    hash: Uint8Array | string
   ): Promise<RpcReceiptOutput | undefined> {
-    const hashBuffer = hash instanceof Buffer ? hash : toBuffer(hash);
+    const hashBuffer = hash instanceof Buffer ? hash : toBytes(hash);
     const receipt = await this._blockchain.getTransactionReceipt(hashBuffer);
     return receipt ?? undefined;
   }
@@ -1032,7 +1073,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     const privateKey = this._getLocalAccountPrivateKey(address);
 
     return signTypedData({
-      privateKey,
+      privateKey: Buffer.from(privateKey),
       version: SignTypedDataVersion.V4,
       data: typedData,
     });
@@ -1058,6 +1099,8 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         this.getUserProvidedNextBlockBaseFeePerGas(),
       coinbase: this.getCoinbaseAddress().toString(),
       mixHashGenerator: this._mixHashGenerator.clone(),
+      parentBeaconBlockRootGenerator:
+        this._parentBeaconBlockRootGenerator.clone(),
     };
 
     this._irregularStatesByBlockNumber = new Map(
@@ -1114,6 +1157,8 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     this._coinbase = snapshot.coinbase;
 
     this._mixHashGenerator = snapshot.mixHashGenerator;
+    this._parentBeaconBlockRootGenerator =
+      snapshot.parentBeaconBlockRootGenerator;
 
     // We delete this and the following snapshots, as they can only be used
     // once in Ganache
@@ -1331,8 +1376,16 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     newBalance: bigint
   ): Promise<void> {
     const account = await this._stateManager.getAccount(address);
-    account.balance = newBalance;
-    await this._stateManager.putAccount(address, account);
+
+    await this._stateManager.putAccount(
+      address,
+      Account.fromAccountData({
+        nonce: account?.nonce,
+        balance: newBalance,
+        storageRoot: account?.storageRoot,
+        codeHash: account?.codeHash,
+      })
+    );
     await this._persistIrregularWorldState();
   }
 
@@ -1354,13 +1407,21 @@ Hardhat Network's forking functionality only works with blocks from at least spu
       );
     }
     const account = await this._stateManager.getAccount(address);
-    if (newNonce < account.nonce) {
+    const accountNonce = account?.nonce ?? 0n;
+    if (newNonce < accountNonce) {
       throw new InvalidInputError(
-        `New nonce (${newNonce.toString()}) must not be smaller than the existing nonce (${account.nonce.toString()})`
+        `New nonce (${newNonce.toString()}) must not be smaller than the existing nonce (${accountNonce.toString()})`
       );
     }
-    account.nonce = newNonce;
-    await this._stateManager.putAccount(address, account);
+    await this._stateManager.putAccount(
+      address,
+      Account.fromAccountData({
+        nonce: newNonce,
+        balance: account?.balance,
+        storageRoot: account?.storageRoot,
+        codeHash: account?.codeHash,
+      })
+    );
     await this._persistIrregularWorldState();
   }
 
@@ -1371,7 +1432,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
   ) {
     await this._stateManager.putContractStorage(
       address,
-      setLengthLeft(bigIntToBuffer(positionIndex), 32),
+      setLengthLeft(bigIntToBytes(positionIndex), 32),
       value
     );
     await this._persistIrregularWorldState();
@@ -1427,7 +1488,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
       // to avoid having to distinguish between empty and non-existing accounts.
       // We *could* do it during the non-forked mode, but for simplicity we just
       // don't support it at all.
-      const isPreSpuriousDragon = !vm._common.gteHardfork("spuriousDragon");
+      const isPreSpuriousDragon = !vm.common.gteHardfork("spuriousDragon");
       if (isPreSpuriousDragon) {
         throw new InvalidInputError(
           "Tracing is not supported for transactions using hardforks older than Spurious Dragon. "
@@ -1439,19 +1500,19 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         const sender = tx.getSenderAddress();
         if (tx.type === 0) {
           txWithCommon = new FakeSenderTransaction(sender, tx, {
-            common: vm._common,
+            common: vm.common,
           });
         } else if (tx.type === 1) {
           txWithCommon = new FakeSenderAccessListEIP2930Transaction(
             sender,
             tx,
-            { common: vm._common }
+            { common: vm.common }
           );
         } else if (tx.type === 2) {
           txWithCommon = new FakeSenderEIP1559Transaction(
             sender,
             { ...tx, gasPrice: undefined },
-            { common: vm._common }
+            { common: vm.common }
           );
         } else {
           throw new InternalError(
@@ -1460,7 +1521,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         }
 
         const txHash = txWithCommon.hash();
-        if (txHash.equals(hash)) {
+        if (equalsBytes(txHash, hash)) {
           const vmDebugTracer = new VMDebugTracer(vm);
           return vmDebugTracer.trace(async () => {
             await vm.runTx({
@@ -1826,6 +1887,10 @@ Hardhat Network's forking functionality only works with blocks from at least spu
       headerData.mixHash = this._getNextMixHash();
     }
 
+    if (this.isPostCancunHardfork()) {
+      headerData.parentBeaconBlockRoot = this._getNextParentBeaconBlockRoot();
+    }
+
     headerData.baseFeePerGas = await this.getNextBlockBaseFeePerGas();
 
     const blockBuilder = await this._vm.buildBlock({
@@ -1895,7 +1960,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
 
   private _getMinimalTransactionFee(): bigint {
     // Typically 21_000 gas
-    return this._vm._common.param("gasPrices", "tx");
+    return this._vm.common.param("gasPrices", "tx");
   }
 
   private async _getFakeTransaction(
@@ -1909,18 +1974,18 @@ Hardhat Network's forking functionality only works with blocks from at least spu
 
     if ("maxFeePerGas" in txParams && txParams.maxFeePerGas !== undefined) {
       return new FakeSenderEIP1559Transaction(sender, txParams, {
-        common: this._vm._common,
+        common: this._vm.common,
       });
     }
 
     if ("accessList" in txParams && txParams.accessList !== undefined) {
       return new FakeSenderAccessListEIP2930Transaction(sender, txParams, {
-        common: this._vm._common,
+        common: this._vm.common,
       });
     }
 
     return new FakeSenderTransaction(sender, txParams, {
-      common: this._vm._common,
+      common: this._vm.common,
     });
   }
 
@@ -1948,7 +2013,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
   }
 
   private _initLocalAccounts(genesisAccounts: GenesisAccount[]) {
-    const privateKeys = genesisAccounts.map((acc) => toBuffer(acc.privateKey));
+    const privateKeys = genesisAccounts.map((acc) => toBytes(acc.privateKey));
     for (const pk of privateKeys) {
       this._localAccounts.set(bufferToHex(privateToAddress(pk)), pk);
     }
@@ -2110,7 +2175,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     });
   }
 
-  private _getLocalAccountPrivateKey(sender: Address): Buffer {
+  private _getLocalAccountPrivateKey(sender: Address): Uint8Array {
     const senderAddress = sender.toString();
     if (!this._localAccounts.has(senderAddress)) {
       throw new InvalidInputError(`unknown account ${senderAddress}`);
@@ -2130,7 +2195,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     const receipts = getRpcReceiptOutputsFromLocalBlockExecution(
       block,
       runBlockResult,
-      shouldShowTransactionTypeForHardfork(this._vm._common)
+      shouldShowTransactionTypeForHardfork(this._vm.common)
     );
 
     this._blockchain.addTransactionReceipts(receipts);
@@ -2155,7 +2220,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
               getRpcBlock(
                 block,
                 td,
-                shouldShowTransactionTypeForHardfork(this._vm._common),
+                shouldShowTransactionTypeForHardfork(this._vm.common),
                 false
               )
             );
@@ -2257,7 +2322,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     );
   }
 
-  private async _restoreBlockContext(stateRoot: Buffer) {
+  private async _restoreBlockContext(stateRoot: Uint8Array) {
     if (this._stateManager instanceof ForkStateManager) {
       return this._stateManager.restoreForkBlockContext(stateRoot);
     }
@@ -2385,7 +2450,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     for (const [addrToOverride, stateOverrideOptions] of Object.entries(
       stateOverrideSet
     )) {
-      const address = new Address(toBuffer(addrToOverride));
+      const address = new Address(toBytes(addrToOverride));
 
       const { balance, nonce, code, state, stateDiff } = stateOverrideOptions;
 
@@ -2451,8 +2516,8 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     for (const [storageKey, value] of Object.entries(newState)) {
       await this._stateManager.putContractStorage(
         address,
-        toBuffer(storageKey),
-        setLengthLeft(bigIntToBuffer(value), 32)
+        toBytes(storageKey),
+        setLengthLeft(bigIntToBytes(value), 32)
       );
     }
   }
@@ -2493,9 +2558,14 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         // know anything about the txs in the current block
       }
 
-      originalCommon = (this._vm as any)._common;
+      originalCommon = (this._vm as any).common;
+
+      assertTransientStorageCompatibility(
+        this._enableTransientStorage,
+        this._vm.common.hardfork() as HardforkName
+      );
 
-      (this._vm as any)._common = Common.custom(
+      (this._vm as any).common = Common.custom(
         {
           chainId:
             this._forkBlockNumber === undefined ||
@@ -2506,7 +2576,6 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         },
         {
           hardfork: this._selectHardfork(blockContext.header.number),
-          ...this._getTransientStorageSettings(),
         }
       );
 
@@ -2527,7 +2596,32 @@ Hardhat Network's forking functionality only works with blocks from at least spu
           },
           {
             freeze: false,
-            common: this._vm._common,
+            common: this._vm.common,
+
+            skipConsensusFormatValidation: true,
+          }
+        );
+      }
+
+      // If this VM is running without cancun, but the block has cancun fields,
+      // we remove them from the block
+      if (
+        !this.isCancunBlock(blockNumberOrPending) &&
+        blockContext.header.blobGasUsed !== undefined
+      ) {
+        blockContext = Block.fromBlockData(
+          {
+            ...blockContext,
+            header: {
+              ...blockContext.header,
+              blobGasUsed: undefined,
+              excessBlobGas: undefined,
+              parentBeaconBlockRoot: undefined,
+            },
+          },
+          {
+            freeze: false,
+            common: this._vm.common,
 
             skipConsensusFormatValidation: true,
           }
@@ -2553,7 +2647,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
       ) {
         blockContext = Block.fromBlockData(blockContext, {
           freeze: false,
-          common: this._vm._common,
+          common: this._vm.common,
 
           skipConsensusFormatValidation: true,
         });
@@ -2571,7 +2665,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
       });
     } finally {
       if (originalCommon !== undefined) {
-        (this._vm as any)._common = originalCommon;
+        (this._vm as any).common = originalCommon;
       }
       await this._stateManager.setStateRoot(initialStateRoot);
     }
@@ -2636,7 +2730,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     return this._runInBlockContext(blockNumberOrPending, async () => {
       const account = await this._stateManager.getAccount(address);
 
-      return account.nonce;
+      return account?.nonce ?? 0n;
     });
   }
 
@@ -2673,12 +2767,12 @@ Hardhat Network's forking functionality only works with blocks from at least spu
       blockNumberOrPending !== undefined &&
       blockNumberOrPending !== "pending"
     ) {
-      return this._vm._common.hardforkGteHardfork(
+      return this._vm.common.hardforkGteHardfork(
         this._selectHardfork(blockNumberOrPending),
         "london"
       );
     }
-    return this._vm._common.gteHardfork("london");
+    return this._vm.common.gteHardfork("london");
   }
 
   public isEip4895Active(blockNumberOrPending?: bigint | "pending"): boolean {
@@ -2686,18 +2780,35 @@ Hardhat Network's forking functionality only works with blocks from at least spu
       blockNumberOrPending !== undefined &&
       blockNumberOrPending !== "pending"
     ) {
-      return this._vm._common.hardforkGteHardfork(
+      return this._vm.common.hardforkGteHardfork(
         this._selectHardfork(blockNumberOrPending),
         "shanghai"
       );
     }
-    return this._vm._common.gteHardfork("shanghai");
+    return this._vm.common.gteHardfork("shanghai");
+  }
+
+  public isCancunBlock(blockNumberOrPending?: bigint | "pending"): boolean {
+    if (
+      blockNumberOrPending !== undefined &&
+      blockNumberOrPending !== "pending"
+    ) {
+      return this._vm.common.hardforkGteHardfork(
+        this._selectHardfork(blockNumberOrPending),
+        "cancun"
+      );
+    }
+    return this._vm.common.gteHardfork("cancun");
   }
 
   public isPostMergeHardfork(): boolean {
     return hardforkGte(this.hardfork, HardforkName.MERGE);
   }
 
+  public isPostCancunHardfork(): boolean {
+    return hardforkGte(this.hardfork, HardforkName.CANCUN);
+  }
+
   public setPrevRandao(prevRandao: Buffer): void {
     this._mixHashGenerator.setNext(prevRandao);
   }
@@ -2716,7 +2827,9 @@ Hardhat Network's forking functionality only works with blocks from at least spu
 
     const latestBlock = await this.getLatestBlock();
 
-    const latestBlockHashHex = latestBlock.header.hash().toString("hex");
+    const latestBlockHashHex = Buffer.from(latestBlock.header.hash()).toString(
+      "hex"
+    );
     const latestBlockHash = `0x${latestBlockHashHex}`;
 
     const metadata: HardhatMetadata = {
@@ -2747,10 +2860,14 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     return metadata;
   }
 
-  private _getNextMixHash(): Buffer {
+  private _getNextMixHash(): Uint8Array {
     return this._mixHashGenerator.next();
   }
 
+  private _getNextParentBeaconBlockRoot(): Uint8Array {
+    return this._parentBeaconBlockRootGenerator.next();
+  }
+
   private async _getEstimateGasFeePriceFields(
     callParams: CallParams,
     blockNumberOrPending: bigint | "pending"
@@ -2796,7 +2913,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
       this._forkBlockNumber === undefined ||
       blockNumber >= this._forkBlockNumber
     ) {
-      return this._vm._common.hardfork() as HardforkName;
+      return this._vm.common.hardfork() as HardforkName;
     }
 
     if (this._hardforkActivations.size === 0) {
@@ -2835,10 +2952,15 @@ Hardhat Network's forking functionality only works with blocks from at least spu
       );
     }
 
-    return hardfork;
+    return hardfork === "merge" ? "mergeForkIdTransition" : hardfork;
   }
 
   private _getCommonForTracing(networkId: number, blockNumber: bigint): Common {
+    assertTransientStorageCompatibility(
+      this._enableTransientStorage,
+      this._vm.common.hardfork() as HardforkName
+    );
+
     try {
       const common = Common.custom(
         {
@@ -2847,7 +2969,6 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         },
         {
           hardfork: this._selectHardfork(BigInt(blockNumber)),
-          ...this._getTransientStorageSettings(),
         }
       );
 
@@ -2858,12 +2979,15 @@ Hardhat Network's forking functionality only works with blocks from at least spu
       );
     }
   }
+}
 
-  private _getTransientStorageSettings(): Partial<CustomCommonOpts> {
-    if (this._enableTransientStorage) {
-      return { eips: [1153] };
-    }
-
-    return {};
+export function assertTransientStorageCompatibility(
+  enableTransientStorage: boolean,
+  hardfork: HardforkName
+) {
+  if (enableTransientStorage && !hardforkGte(hardfork, HardforkName.CANCUN)) {
+    throw new InternalError(
+      `Transient storage is not compatible with hardfork "${hardfork}". To use transient storage, set the hardfork to "cancun" or later.`
+    );
   }
 }