hardhat 2.19.5 → 2.20.0

package/internal/hardhat-network/provider/node.js

@@ -26,14 +26,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HardhatNode = void 0;
+exports.assertTransientStorageCompatibility = exports.HardhatNode = void 0;
 const ethereumjs_block_1 = require("@nomicfoundation/ethereumjs-block");
 const ethereumjs_common_1 = require("@nomicfoundation/ethereumjs-common");
+const exceptions_1 = require("@nomicfoundation/ethereumjs-evm/dist/cjs/exceptions");
 const ethereumjs_tx_1 = require("@nomicfoundation/ethereumjs-tx");
 const ethereumjs_util_1 = require("@nomicfoundation/ethereumjs-util");
 const ethereumjs_vm_1 = require("@nomicfoundation/ethereumjs-vm");
 const ethereumjs_evm_1 = require("@nomicfoundation/ethereumjs-evm");
-const exceptions_1 = require("@nomicfoundation/ethereumjs-evm/dist/exceptions");
 const ethereumjs_statemanager_1 = require("@nomicfoundation/ethereumjs-statemanager");
 const eth_sig_util_1 = require("@metamask/eth-sig-util");
 const chalk_1 = __importDefault(require("chalk"));
@@ -79,6 +79,8 @@ const makeStateTrie_1 = require("./utils/makeStateTrie");
 const putGenesisBlock_1 = require("./utils/putGenesisBlock");
 const txMapToArray_1 = require("./utils/txMapToArray");
 const random_1 = require("./utils/random");
+const BEACON_ROOT_ADDRESS = "0x000F3df6D732807Ef1319fB7B8bB8522d0Beac02";
+const BEACON_ROOT_BYTECODE = "0x3373fffffffffffffffffffffffffffffffffffffffe14604d57602036146024575f5ffd5b5f35801560495762001fff810690815414603c575f5ffd5b62001fff01545f5260205ff35b5f5ffd5b62001fff42064281555f359062001fff015500";
 const log = (0, debug_1.default)("hardhat:core:hardhat-network:node");
 /* eslint-disable @nomicfoundation/hardhat-internal-rules/only-hardhat-error */
 class HardhatNode extends events_1.default {
@@ -98,6 +100,7 @@ class HardhatNode extends events_1.default {
             : undefined;
         const hardfork = (0, hardforks_1.getHardforkName)(config.hardfork);
         const mixHashGenerator = random_1.RandomBufferGenerator.create("randomMixHashSeed");
+        const parentBeaconBlockRootGenerator = random_1.RandomBufferGenerator.create("randomParentBeaconBlockRootSeed");
         let forkClient;
         const common = (0, makeCommon_1.makeCommon)(config);
         if ((0, node_types_1.isForkedNodeConfig)(config)) {
@@ -109,6 +112,9 @@ class HardhatNode extends events_1.default {
             this._validateHardforks(config.forkConfig.blockNumber, common, forkNetworkId);
             const forkStateManager = new ForkStateManager_1.ForkStateManager(forkClient, forkBlockNumber);
             await forkStateManager.initializeGenesisAccounts(genesisAccounts);
+            if ((0, hardforks_1.hardforkGte)(hardfork, hardforks_1.HardforkName.CANCUN)) {
+                await forkStateManager.putContractCode(ethereumjs_util_1.Address.fromString(BEACON_ROOT_ADDRESS), Buffer.from((0, ethereumjs_util_1.toBytes)(BEACON_ROOT_BYTECODE)));
+            }
             stateManager = forkStateManager;
             blockchain = new ForkBlockchain_1.ForkBlockchain(forkClient, forkBlockNumber, common);
             initialBlockTimeOffset = BigInt((0, date_1.getDifferenceInSeconds)(new Date(forkBlockTimestamp), new Date()));
@@ -137,23 +143,27 @@ class HardhatNode extends events_1.default {
             stateManager = new ethereumjs_statemanager_1.DefaultStateManager({
                 trie: stateTrie,
             });
+            if ((0, hardforks_1.hardforkGte)(hardfork, hardforks_1.HardforkName.CANCUN)) {
+                await stateManager.putContractCode(ethereumjs_util_1.Address.fromString(BEACON_ROOT_ADDRESS), Buffer.from((0, ethereumjs_util_1.toBytes)(BEACON_ROOT_BYTECODE)));
+            }
             const hardhatBlockchain = new HardhatBlockchain_1.HardhatBlockchain(common);
             const genesisBlockBaseFeePerGas = (0, hardforks_1.hardforkGte)(hardfork, hardforks_1.HardforkName.LONDON)
                 ? initialBaseFeePerGasConfig ??
                     BigInt(default_config_1.HARDHAT_NETWORK_DEFAULT_INITIAL_BASE_FEE_PER_GAS)
                 : undefined;
-            await (0, putGenesisBlock_1.putGenesisBlock)(hardhatBlockchain, common, config, stateTrie, hardfork, mixHashGenerator.next(), genesisBlockBaseFeePerGas);
+            await (0, putGenesisBlock_1.putGenesisBlock)(hardhatBlockchain, common, config, await stateManager.getStateRoot(), hardfork, mixHashGenerator.next(), parentBeaconBlockRootGenerator.next(), genesisBlockBaseFeePerGas);
             if (config.initialDate !== undefined) {
                 initialBlockTimeOffset = BigInt((0, date_1.getDifferenceInSeconds)(config.initialDate, new Date()));
             }
             blockchain = hardhatBlockchain;
         }
         const txPool = new TxPool_1.TxPool(stateManager, BigInt(blockGasLimit), common);
-        const eei = new ethereumjs_vm_1.EEI(stateManager, common, blockchain);
-        const evm = await ethereumjs_evm_1.EVM.create({
-            eei,
+        const evm = new ethereumjs_evm_1.EVM({
             allowUnlimitedContractSize,
+            allowUnlimitedInitCodeSize: allowUnlimitedContractSize,
+            blockchain,
             common,
+            stateManager,
         });
         const vm = await ethereumjs_vm_1.VM.create({
             evm,
@@ -162,8 +172,8 @@ class HardhatNode extends events_1.default {
             stateManager,
             blockchain,
         });
-        const instanceId = (0, ethereumjs_util_1.bufferToBigInt)((0, crypto_1.randomBytes)(32));
-        const node = new HardhatNode(vm, instanceId, stateManager, blockchain, txPool, automine, minGasPrice, initialBlockTimeOffset, mempoolOrder, config.coinbase, genesisAccounts, networkId, chainId, hardfork, hardforkActivations, mixHashGenerator, allowUnlimitedContractSize, allowBlocksWithSameTimestamp, tracingConfig, forkNetworkId, forkBlockNum, forkBlockHash, nextBlockBaseFeePerGas, forkClient, enableTransientStorage);
+        const instanceId = (0, ethereumjs_util_1.bytesToBigInt)((0, crypto_1.randomBytes)(32));
+        const node = new HardhatNode(vm, instanceId, stateManager, blockchain, txPool, automine, minGasPrice, initialBlockTimeOffset, mempoolOrder, config.coinbase, genesisAccounts, networkId, chainId, hardfork, hardforkActivations, mixHashGenerator, parentBeaconBlockRootGenerator, allowUnlimitedContractSize, allowBlocksWithSameTimestamp, tracingConfig, forkNetworkId, forkBlockNum, forkBlockHash, nextBlockBaseFeePerGas, forkClient, enableTransientStorage);
         return [common, node];
     }
     static _validateHardforks(forkBlockNumber, common, remoteChainId) {
@@ -183,7 +193,7 @@ The hardfork must be at least spuriousDragon, but ${common.hardfork()} was given
                 // this validation.
                 return;
             }
-            upstreamCommon.setHardforkByBlockNumber(forkBlockNumber);
+            upstreamCommon.setHardforkBy({ blockNumber: forkBlockNumber });
             if (!upstreamCommon.gteHardfork("spuriousDragon")) {
                 throw new errors_2.InternalError(`Cannot fork ${upstreamCommon.chainName()} from block ${forkBlockNumber}.
 
@@ -191,7 +201,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
             }
         }
     }
-    constructor(_vm, _instanceId, _stateManager, _blockchain, _txPool, _automine, _minGasPrice, _blockTimeOffsetSeconds = 0n, _mempoolOrder, _coinbase, genesisAccounts, _configNetworkId, _configChainId, hardfork, _hardforkActivations, _mixHashGenerator, allowUnlimitedContractSize, _allowBlocksWithSameTimestamp, tracingConfig, _forkNetworkId, _forkBlockNumber, _forkBlockHash, nextBlockBaseFee, _forkClient, _enableTransientStorage = false) {
+    constructor(_vm, _instanceId, _stateManager, _blockchain, _txPool, _automine, _minGasPrice, _blockTimeOffsetSeconds = 0n, _mempoolOrder, _coinbase, genesisAccounts, _configNetworkId, _configChainId, hardfork, _hardforkActivations, _mixHashGenerator, _parentBeaconBlockRootGenerator, allowUnlimitedContractSize, _allowBlocksWithSameTimestamp, tracingConfig, _forkNetworkId, _forkBlockNumber, _forkBlockHash, nextBlockBaseFee, _forkClient, _enableTransientStorage = false) {
         super();
         this._vm = _vm;
         this._instanceId = _instanceId;
@@ -208,6 +218,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         this.hardfork = hardfork;
         this._hardforkActivations = _hardforkActivations;
         this._mixHashGenerator = _mixHashGenerator;
+        this._parentBeaconBlockRootGenerator = _parentBeaconBlockRootGenerator;
         this.allowUnlimitedContractSize = allowUnlimitedContractSize;
         this._allowBlocksWithSameTimestamp = _allowBlocksWithSameTimestamp;
         this._forkNetworkId = _forkNetworkId;
@@ -255,26 +266,32 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         }
     }
     async getSignedTransaction(txParams) {
-        const senderAddress = (0, ethereumjs_util_1.bufferToHex)(txParams.from);
+        const senderAddress = (0, ethereumjs_util_1.bytesToHex)(txParams.from);
         const pk = this._localAccounts.get(senderAddress);
         if (pk !== undefined) {
             let tx;
-            if ("maxFeePerGas" in txParams) {
+            if ("blobs" in txParams) {
+                tx = ethereumjs_tx_1.BlobEIP4844Transaction.fromTxData(txParams, {
+                    common: this._vm.common,
+                    allowUnlimitedInitCodeSize: true,
+                });
+            }
+            else if ("maxFeePerGas" in txParams) {
                 tx = ethereumjs_tx_1.FeeMarketEIP1559Transaction.fromTxData(txParams, {
-                    common: this._vm._common,
-                    disableMaxInitCodeSizeCheck: true,
+                    common: this._vm.common,
+                    allowUnlimitedInitCodeSize: true,
                 });
             }
             else if ("accessList" in txParams) {
                 tx = ethereumjs_tx_1.AccessListEIP2930Transaction.fromTxData(txParams, {
-                    common: this._vm._common,
-                    disableMaxInitCodeSizeCheck: true,
+                    common: this._vm.common,
+                    allowUnlimitedInitCodeSize: true,
                 });
             }
             else {
-                tx = ethereumjs_tx_1.Transaction.fromTxData(txParams, {
-                    common: this._vm._common,
-                    disableMaxInitCodeSizeCheck: true,
+                tx = ethereumjs_tx_1.LegacyTransaction.fromTxData(txParams, {
+                    common: this._vm.common,
+                    allowUnlimitedInitCodeSize: true,
                 });
             }
             return tx.sign(pk);
@@ -417,11 +434,11 @@ Hardhat Network's forking functionality only works with blocks from at least spu
             blockNumberOrPending = this.getLatestBlockNumber();
         }
         const account = await this._runInBlockContext(blockNumberOrPending, () => this._stateManager.getAccount(address));
-        return account.balance;
+        return account?.balance ?? 0n;
     }
     async getNextConfirmedNonce(address, blockNumberOrPending) {
         const account = await this._runInBlockContext(blockNumberOrPending, () => this._stateManager.getAccount(address));
-        return account.nonce;
+        return account?.nonce ?? 0n;
     }
     async getAccountNextPendingNonce(address) {
         return this._txPool.getNextPendingNonce(address);
@@ -536,13 +553,19 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         return ethereumjs_util_1.Address.fromString(this._coinbase);
     }
     async getStorageAt(address, positionIndex, blockNumberOrPending) {
-        const key = (0, ethereumjs_util_1.setLengthLeft)((0, ethereumjs_util_1.bigIntToBuffer)(positionIndex), 32);
-        const data = await this._runInBlockContext(blockNumberOrPending, () => this._stateManager.getContractStorage(address, key));
+        const key = (0, ethereumjs_util_1.setLengthLeft)((0, ethereumjs_util_1.bigIntToBytes)(positionIndex), 32);
+        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;
         if (data.length < EXPECTED_DATA_SIZE) {
             return Buffer.concat([Buffer.alloc(EXPECTED_DATA_SIZE - data.length, 0), data], EXPECTED_DATA_SIZE);
         }
-        return data;
+        return Buffer.from(data);
     }
     async getBlockByNumber(blockNumberOrPending) {
         if (blockNumberOrPending === "pending") {
@@ -573,7 +596,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         return this._blockchain.getTotalDifficulty(block.hash());
     }
     async getCode(address, blockNumberOrPending) {
-        return this._runInBlockContext(blockNumberOrPending, () => this._stateManager.getContractCode(address));
+        return this._runInBlockContext(blockNumberOrPending, () => this._stateManager.getContractCode(address).then(Buffer.from));
     }
     getNextBlockTimestamp() {
         return this._nextBlockTimestamp;
@@ -614,7 +637,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         return this._txPool.getTransactionByHash(hash)?.data;
     }
     async getTransactionReceipt(hash) {
-        const hashBuffer = hash instanceof Buffer ? hash : (0, ethereumjs_util_1.toBuffer)(hash);
+        const hashBuffer = hash instanceof Buffer ? hash : (0, ethereumjs_util_1.toBytes)(hash);
         const receipt = await this._blockchain.getTransactionReceipt(hashBuffer);
         return receipt ?? undefined;
     }
@@ -631,7 +654,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     async signTypedDataV4(address, typedData) {
         const privateKey = this._getLocalAccountPrivateKey(address);
         return (0, eth_sig_util_1.signTypedData)({
-            privateKey,
+            privateKey: Buffer.from(privateKey),
             version: eth_sig_util_1.SignTypedDataVersion.V4,
             data: typedData,
         });
@@ -653,6 +676,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
             userProvidedNextBlockBaseFeePerGas: this.getUserProvidedNextBlockBaseFeePerGas(),
             coinbase: this.getCoinbaseAddress().toString(),
             mixHashGenerator: this._mixHashGenerator.clone(),
+            parentBeaconBlockRootGenerator: this._parentBeaconBlockRootGenerator.clone(),
         };
         this._irregularStatesByBlockNumber = new Map(this._irregularStatesByBlockNumber);
         this._snapshots.push(snapshot);
@@ -691,6 +715,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
         this._snapshots.splice(snapshotIndex);
@@ -722,7 +748,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
             id: filterId,
             type: filter_1.Type.BLOCK_SUBSCRIPTION,
             deadline: this._newDeadline(),
-            hashes: [(0, ethereumjs_util_1.bufferToHex)(block.header.hash())],
+            hashes: [(0, ethereumjs_util_1.bytesToHex)(block.header.hash())],
             logs: [],
             subscription: isSubscription,
         });
@@ -804,11 +830,11 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         return true;
     }
     addImpersonatedAccount(address) {
-        this._impersonatedAccounts.add((0, ethereumjs_util_1.bufferToHex)(address));
+        this._impersonatedAccounts.add((0, ethereumjs_util_1.bytesToHex)(address));
         return true;
     }
     removeImpersonatedAccount(address) {
-        return this._impersonatedAccounts.delete((0, ethereumjs_util_1.bufferToHex)(address));
+        return this._impersonatedAccounts.delete((0, ethereumjs_util_1.bytesToHex)(address));
     }
     setAutomine(automine) {
         this._automine = automine;
@@ -830,14 +856,18 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         }
         const isTransactionMined = await this._isTransactionMined(hash);
         if (isTransactionMined) {
-            throw new errors_2.InvalidArgumentsError(`Transaction ${(0, ethereumjs_util_1.bufferToHex)(hash)} cannot be dropped because it's already mined`);
+            throw new errors_2.InvalidArgumentsError(`Transaction ${(0, ethereumjs_util_1.bytesToHex)(hash)} cannot be dropped because it's already mined`);
         }
         return false;
     }
     async setAccountBalance(address, newBalance) {
         const account = await this._stateManager.getAccount(address);
-        account.balance = newBalance;
-        await this._stateManager.putAccount(address, account);
+        await this._stateManager.putAccount(address, ethereumjs_util_1.Account.fromAccountData({
+            nonce: account?.nonce,
+            balance: newBalance,
+            storageRoot: account?.storageRoot,
+            codeHash: account?.codeHash,
+        }));
         await this._persistIrregularWorldState();
     }
     async setAccountCode(address, newCode) {
@@ -849,15 +879,20 @@ Hardhat Network's forking functionality only works with blocks from at least spu
             throw new errors_2.InternalError("Cannot set account nonce when the transaction pool is not empty");
         }
         const account = await this._stateManager.getAccount(address);
-        if (newNonce < account.nonce) {
-            throw new errors_2.InvalidInputError(`New nonce (${newNonce.toString()}) must not be smaller than the existing nonce (${account.nonce.toString()})`);
-        }
-        account.nonce = newNonce;
-        await this._stateManager.putAccount(address, account);
+        const accountNonce = account?.nonce ?? 0n;
+        if (newNonce < accountNonce) {
+            throw new errors_2.InvalidInputError(`New nonce (${newNonce.toString()}) must not be smaller than the existing nonce (${accountNonce.toString()})`);
+        }
+        await this._stateManager.putAccount(address, ethereumjs_util_1.Account.fromAccountData({
+            nonce: newNonce,
+            balance: account?.balance,
+            storageRoot: account?.storageRoot,
+            codeHash: account?.codeHash,
+        }));
         await this._persistIrregularWorldState();
     }
     async setStorageAt(address, positionIndex, value) {
-        await this._stateManager.putContractStorage(address, (0, ethereumjs_util_1.setLengthLeft)((0, ethereumjs_util_1.bigIntToBuffer)(positionIndex), 32), value);
+        await this._stateManager.putContractStorage(address, (0, ethereumjs_util_1.setLengthLeft)((0, ethereumjs_util_1.bigIntToBytes)(positionIndex), 32), value);
         await this._persistIrregularWorldState();
     }
     async traceCall(callParams, block, traceConfig) {
@@ -869,7 +904,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     async traceTransaction(hash, config) {
         const block = await this.getBlockByTransactionHash(hash);
         if (block === undefined) {
-            throw new errors_2.InvalidInputError(`Unable to find a block containing transaction ${(0, ethereumjs_util_1.bufferToHex)(hash)}`);
+            throw new errors_2.InvalidInputError(`Unable to find a block containing transaction ${(0, ethereumjs_util_1.bytesToHex)(hash)}`);
         }
         return this._runInBlockContext(block.header.number - 1n, async () => {
             const blockNumber = block.header.number;
@@ -890,7 +925,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 errors_2.InvalidInputError("Tracing is not supported for transactions using hardforks older than Spurious Dragon. ");
             }
@@ -899,20 +934,20 @@ Hardhat Network's forking functionality only works with blocks from at least spu
                 const sender = tx.getSenderAddress();
                 if (tx.type === 0) {
                     txWithCommon = new FakeSenderTransaction_1.FakeSenderTransaction(sender, tx, {
-                        common: vm._common,
+                        common: vm.common,
                     });
                 }
                 else if (tx.type === 1) {
-                    txWithCommon = new FakeSenderAccessListEIP2930Transaction_1.FakeSenderAccessListEIP2930Transaction(sender, tx, { common: vm._common });
+                    txWithCommon = new FakeSenderAccessListEIP2930Transaction_1.FakeSenderAccessListEIP2930Transaction(sender, tx, { common: vm.common });
                 }
                 else if (tx.type === 2) {
-                    txWithCommon = new FakeSenderEIP1559Transaction_1.FakeSenderEIP1559Transaction(sender, { ...tx, gasPrice: undefined }, { common: vm._common });
+                    txWithCommon = new FakeSenderEIP1559Transaction_1.FakeSenderEIP1559Transaction(sender, { ...tx, gasPrice: undefined }, { common: vm.common });
                 }
                 else {
                     throw new errors_2.InternalError("Only legacy, EIP2930, and EIP1559 txs are supported");
                 }
                 const txHash = txWithCommon.hash();
-                if (txHash.equals(hash)) {
+                if ((0, ethereumjs_util_1.equalsBytes)(txHash, hash)) {
                     const vmDebugTracer = new vm_debug_tracer_1.VMDebugTracer(vm);
                     return vmDebugTracer.trace(async () => {
                         await vm.runTx({
@@ -1063,7 +1098,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     async _addPendingTransaction(tx) {
         await this._txPool.addTransaction(tx);
         await this._notifyPendingTransaction(tx);
-        return (0, ethereumjs_util_1.bufferToHex)(tx.hash());
+        return (0, ethereumjs_util_1.bytesToHex)(tx.hash());
     }
     async _mineTransaction(tx) {
         await this._addPendingTransaction(tx);
@@ -1174,6 +1209,9 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         if (this.isPostMergeHardfork()) {
             headerData.mixHash = this._getNextMixHash();
         }
+        if (this.isPostCancunHardfork()) {
+            headerData.parentBeaconBlockRoot = this._getNextParentBeaconBlockRoot();
+        }
         headerData.baseFeePerGas = await this.getNextBlockBaseFeePerGas();
         const blockBuilder = await this._vm.buildBlock({
             parentBlock,
@@ -1225,22 +1263,22 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     }
     _getMinimalTransactionFee() {
         // Typically 21_000 gas
-        return this._vm._common.param("gasPrices", "tx");
+        return this._vm.common.param("gasPrices", "tx");
     }
     async _getFakeTransaction(txParams) {
         const sender = new ethereumjs_util_1.Address(txParams.from);
         if ("maxFeePerGas" in txParams && txParams.maxFeePerGas !== undefined) {
             return new FakeSenderEIP1559Transaction_1.FakeSenderEIP1559Transaction(sender, txParams, {
-                common: this._vm._common,
+                common: this._vm.common,
             });
         }
         if ("accessList" in txParams && txParams.accessList !== undefined) {
             return new FakeSenderAccessListEIP2930Transaction_1.FakeSenderAccessListEIP2930Transaction(sender, txParams, {
-                common: this._vm._common,
+                common: this._vm.common,
             });
         }
         return new FakeSenderTransaction_1.FakeSenderTransaction(sender, txParams, {
-            common: this._vm._common,
+            common: this._vm.common,
         });
     }
     _getSnapshotIndex(id) {
@@ -1263,9 +1301,9 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         this._snapshots.splice(snapshotIndex);
     }
     _initLocalAccounts(genesisAccounts) {
-        const privateKeys = genesisAccounts.map((acc) => (0, ethereumjs_util_1.toBuffer)(acc.privateKey));
+        const privateKeys = genesisAccounts.map((acc) => (0, ethereumjs_util_1.toBytes)(acc.privateKey));
         for (const pk of privateKeys) {
-            this._localAccounts.set((0, ethereumjs_util_1.bufferToHex)((0, ethereumjs_util_1.privateToAddress)(pk)), pk);
+            this._localAccounts.set((0, ethereumjs_util_1.bytesToHex)((0, ethereumjs_util_1.privateToAddress)(pk)), pk);
         }
     }
     async _getConsoleLogMessages(vmTrace, vmTracerError) {
@@ -1371,7 +1409,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     async _notifyPendingTransaction(tx) {
         this._filters.forEach((filter) => {
             if (filter.type === filter_1.Type.PENDING_TRANSACTION_SUBSCRIPTION) {
-                const hash = (0, ethereumjs_util_1.bufferToHex)(tx.hash());
+                const hash = (0, ethereumjs_util_1.bytesToHex)(tx.hash());
                 if (filter.subscription) {
                     this._emitEthEvent(filter.id, hash);
                     return;
@@ -1392,7 +1430,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
      * was added to the blockchain.
      */
     async _saveBlockAsSuccessfullyRun(block, runBlockResult) {
-        const receipts = (0, output_1.getRpcReceiptOutputsFromLocalBlockExecution)(block, runBlockResult, (0, output_1.shouldShowTransactionTypeForHardfork)(this._vm._common));
+        const receipts = (0, output_1.getRpcReceiptOutputsFromLocalBlockExecution)(block, runBlockResult, (0, output_1.shouldShowTransactionTypeForHardfork)(this._vm.common));
         this._blockchain.addTransactionReceipts(receipts);
         const td = await this.getBlockTotalDifficulty(block);
         const rpcLogs = [];
@@ -1407,10 +1445,10 @@ Hardhat Network's forking functionality only works with blocks from at least spu
                 case filter_1.Type.BLOCK_SUBSCRIPTION:
                     const hash = block.hash();
                     if (filter.subscription) {
-                        this._emitEthEvent(filter.id, (0, output_1.getRpcBlock)(block, td, (0, output_1.shouldShowTransactionTypeForHardfork)(this._vm._common), false));
+                        this._emitEthEvent(filter.id, (0, output_1.getRpcBlock)(block, td, (0, output_1.shouldShowTransactionTypeForHardfork)(this._vm.common), false));
                         return;
                     }
-                    filter.hashes.push((0, ethereumjs_util_1.bufferToHex)(hash));
+                    filter.hashes.push((0, ethereumjs_util_1.bytesToHex)(hash));
                     break;
                 case filter_1.Type.LOGS_SUBSCRIPTION:
                     if ((0, filter_1.bloomFilter)(new ethereumjs_vm_1.Bloom(block.header.logsBloom), filter.criteria.addresses, filter.criteria.normalizedTopics)) {
@@ -1544,7 +1582,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     async _applyStateOverrideSet(stateOverrideSet) {
         // Multiple state override set can be configured for different addresses, hence the loop
         for (const [addrToOverride, stateOverrideOptions] of Object.entries(stateOverrideSet)) {
-            const address = new ethereumjs_util_1.Address((0, ethereumjs_util_1.toBuffer)(addrToOverride));
+            const address = new ethereumjs_util_1.Address((0, ethereumjs_util_1.toBytes)(addrToOverride));
             const { balance, nonce, code, state, stateDiff } = stateOverrideOptions;
             await this._overrideBalanceAndNonce(address, balance, nonce);
             await this._overrideCode(address, code);
@@ -1587,7 +1625,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
             throw new errors_2.InvalidInputError("The properties 'state' and 'stateDiff' cannot be used simultaneously when configuring the state override set passed to the eth_call method.");
         }
         for (const [storageKey, value] of Object.entries(newState)) {
-            await this._stateManager.putContractStorage(address, (0, ethereumjs_util_1.toBuffer)(storageKey), (0, ethereumjs_util_1.setLengthLeft)((0, ethereumjs_util_1.bigIntToBuffer)(value), 32));
+            await this._stateManager.putContractStorage(address, (0, ethereumjs_util_1.toBytes)(storageKey), (0, ethereumjs_util_1.setLengthLeft)((0, ethereumjs_util_1.bigIntToBytes)(value), 32));
         }
     }
     /**
@@ -1613,8 +1651,9 @@ Hardhat Network's forking functionality only works with blocks from at least spu
                 // we don't need to add the tx to the block because runTx doesn't
                 // know anything about the txs in the current block
             }
-            originalCommon = this._vm._common;
-            this._vm._common = ethereumjs_common_1.Common.custom({
+            originalCommon = this._vm.common;
+            assertTransientStorageCompatibility(this._enableTransientStorage, this._vm.common.hardfork());
+            this._vm.common = ethereumjs_common_1.Common.custom({
                 chainId: this._forkBlockNumber === undefined ||
                     blockContext.header.number >= this._forkBlockNumber
                     ? this._configChainId
@@ -1622,7 +1661,6 @@ Hardhat Network's forking functionality only works with blocks from at least spu
                 networkId: this._forkNetworkId ?? this._configNetworkId,
             }, {
                 hardfork: this._selectHardfork(blockContext.header.number),
-                ...this._getTransientStorageSettings(),
             });
             // If this VM is running without EIP4895, but the block has withdrawals,
             // we remove them and the withdrawal root from the block
@@ -1637,7 +1675,25 @@ 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 = ethereumjs_block_1.Block.fromBlockData({
+                    ...blockContext,
+                    header: {
+                        ...blockContext.header,
+                        blobGasUsed: undefined,
+                        excessBlobGas: undefined,
+                        parentBeaconBlockRoot: undefined,
+                    },
+                }, {
+                    freeze: false,
+                    common: this._vm.common,
                     skipConsensusFormatValidation: true,
                 });
             }
@@ -1658,7 +1714,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
                 (blockContext.header.baseFeePerGas === undefined || forceBaseFeeZero)) {
                 blockContext = ethereumjs_block_1.Block.fromBlockData(blockContext, {
                     freeze: false,
-                    common: this._vm._common,
+                    common: this._vm.common,
                     skipConsensusFormatValidation: true,
                 });
                 blockContext.header.baseFeePerGas = 0n;
@@ -1674,7 +1730,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         }
         finally {
             if (originalCommon !== undefined) {
-                this._vm._common = originalCommon;
+                this._vm.common = originalCommon;
             }
             await this._stateManager.setStateRoot(initialStateRoot);
         }
@@ -1720,7 +1776,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;
         });
     }
     async _isTransactionMined(hash) {
@@ -1741,20 +1797,30 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     isEip1559Active(blockNumberOrPending) {
         if (blockNumberOrPending !== undefined &&
             blockNumberOrPending !== "pending") {
-            return this._vm._common.hardforkGteHardfork(this._selectHardfork(blockNumberOrPending), "london");
+            return this._vm.common.hardforkGteHardfork(this._selectHardfork(blockNumberOrPending), "london");
         }
-        return this._vm._common.gteHardfork("london");
+        return this._vm.common.gteHardfork("london");
     }
     isEip4895Active(blockNumberOrPending) {
         if (blockNumberOrPending !== undefined &&
             blockNumberOrPending !== "pending") {
-            return this._vm._common.hardforkGteHardfork(this._selectHardfork(blockNumberOrPending), "shanghai");
+            return this._vm.common.hardforkGteHardfork(this._selectHardfork(blockNumberOrPending), "shanghai");
         }
-        return this._vm._common.gteHardfork("shanghai");
+        return this._vm.common.gteHardfork("shanghai");
+    }
+    isCancunBlock(blockNumberOrPending) {
+        if (blockNumberOrPending !== undefined &&
+            blockNumberOrPending !== "pending") {
+            return this._vm.common.hardforkGteHardfork(this._selectHardfork(blockNumberOrPending), "cancun");
+        }
+        return this._vm.common.gteHardfork("cancun");
     }
     isPostMergeHardfork() {
         return (0, hardforks_1.hardforkGte)(this.hardfork, hardforks_1.HardforkName.MERGE);
     }
+    isPostCancunHardfork() {
+        return (0, hardforks_1.hardforkGte)(this.hardfork, hardforks_1.HardforkName.CANCUN);
+    }
     setPrevRandao(prevRandao) {
         this._mixHashGenerator.setNext(prevRandao);
     }
@@ -1768,7 +1834,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         const instanceIdHex = BigIntUtils.toEvmWord(this._instanceId);
         const instanceId = `0x${instanceIdHex}`;
         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 = {
             clientVersion,
@@ -1791,6 +1857,9 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     _getNextMixHash() {
         return this._mixHashGenerator.next();
     }
+    _getNextParentBeaconBlockRoot() {
+        return this._parentBeaconBlockRootGenerator.next();
+    }
     async _getEstimateGasFeePriceFields(callParams, blockNumberOrPending) {
         if (!this.isEip1559Active(blockNumberOrPending) ||
             callParams.gasPrice !== undefined) {
@@ -1820,7 +1889,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     _selectHardfork(blockNumber) {
         if (this._forkBlockNumber === undefined ||
             blockNumber >= this._forkBlockNumber) {
-            return this._vm._common.hardfork();
+            return this._vm.common.hardfork();
         }
         if (this._hardforkActivations.size === 0) {
             throw new errors_2.InternalError(`No known hardfork for execution on historical block ${blockNumber.toString()} (relative to fork block number ${this._forkBlockNumber}). The node was not configured with a hardfork activation history.  See http://hardhat.org/custom-hardfork-history`);
@@ -1838,16 +1907,16 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         if (!constants_1.HARDHAT_NETWORK_SUPPORTED_HARDFORKS.includes(hardfork)) {
             throw new errors_2.InternalError(`Tried to run a call or transaction in the context of a block whose hardfork is "${hardfork}", but Hardhat Network only supports the following hardforks: ${constants_1.HARDHAT_NETWORK_SUPPORTED_HARDFORKS.join(", ")}`);
         }
-        return hardfork;
+        return hardfork === "merge" ? "mergeForkIdTransition" : hardfork;
     }
     _getCommonForTracing(networkId, blockNumber) {
+        assertTransientStorageCompatibility(this._enableTransientStorage, this._vm.common.hardfork());
         try {
             const common = ethereumjs_common_1.Common.custom({
                 chainId: networkId,
                 networkId,
             }, {
                 hardfork: this._selectHardfork(BigInt(blockNumber)),
-                ...this._getTransientStorageSettings(),
             });
             return common;
         }
@@ -1855,12 +1924,12 @@ Hardhat Network's forking functionality only works with blocks from at least spu
             throw new errors_2.InternalError(`Network id ${networkId} does not correspond to a network that Hardhat can trace`);
         }
     }
-    _getTransientStorageSettings() {
-        if (this._enableTransientStorage) {
-            return { eips: [1153] };
-        }
-        return {};
-    }
 }
 exports.HardhatNode = HardhatNode;
+function assertTransientStorageCompatibility(enableTransientStorage, hardfork) {
+    if (enableTransientStorage && !(0, hardforks_1.hardforkGte)(hardfork, hardforks_1.HardforkName.CANCUN)) {
+        throw new errors_2.InternalError(`Transient storage is not compatible with hardfork "${hardfork}". To use transient storage, set the hardfork to "cancun" or later.`);
+    }
+}
+exports.assertTransientStorageCompatibility = assertTransientStorageCompatibility;
 //# sourceMappingURL=node.js.map