hardhat 2.10.1 → 2.11.0-dev.0

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

@@ -4,18 +4,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HardhatNode = void 0;
-const block_1 = require("@ethereumjs/block");
-const common_1 = __importDefault(require("@ethereumjs/common"));
-const tx_1 = require("@ethereumjs/tx");
-const vm_1 = __importDefault(require("@ethereumjs/vm"));
-const bloom_1 = __importDefault(require("@ethereumjs/vm/dist/bloom"));
-const exceptions_1 = require("@ethereumjs/vm/dist/exceptions");
-const state_1 = require("@ethereumjs/vm/dist/state");
+const block_1 = require("@ignored/block");
+const common_1 = require("@ignored/common");
+const tx_1 = require("@ignored/tx");
+const util_1 = require("@ignored/util");
+const vm_1 = require("@ignored/vm");
+const evm_1 = require("@ignored/evm");
+const exceptions_1 = require("@ignored/evm/dist/exceptions");
+const statemanager_1 = require("@ignored/statemanager");
 const eth_sig_util_1 = require("@metamask/eth-sig-util");
 const chalk_1 = __importDefault(require("chalk"));
 const debug_1 = __importDefault(require("debug"));
-const ethereumjs_util_1 = require("ethereumjs-util");
 const events_1 = __importDefault(require("events"));
+const bigint_1 = require("../../util/bigint");
 const constants_1 = require("../../constants");
 const default_config_1 = require("../../core/config/default-config");
 const errors_1 = require("../../core/errors");
@@ -51,13 +52,13 @@ const getCurrentTimestamp_1 = require("./utils/getCurrentTimestamp");
 const makeCommon_1 = require("./utils/makeCommon");
 const makeForkClient_1 = require("./utils/makeForkClient");
 const makeStateTrie_1 = require("./utils/makeStateTrie");
-const makeForkCommon_1 = require("./utils/makeForkCommon");
 const putGenesisBlock_1 = require("./utils/putGenesisBlock");
 const txMapToArray_1 = require("./utils/txMapToArray");
+const random_1 = require("./utils/random");
 const log = (0, debug_1.default)("hardhat:core:hardhat-network:node");
 /* eslint-disable @nomiclabs/hardhat-internal-rules/only-hardhat-error */
 class HardhatNode extends events_1.default {
-    constructor(_vm, _stateManager, _blockchain, _txPool, _automine, _minGasPrice, _blockTimeOffsetSeconds = new ethereumjs_util_1.BN(0), _mempoolOrder, _coinbase, genesisAccounts, _configNetworkId, _configChainId, _hardforkActivations, tracingConfig, _forkNetworkId, _forkBlockNumber, nextBlockBaseFee, _forkClient) {
+    constructor(_vm, _stateManager, _blockchain, _txPool, _automine, _minGasPrice, _blockTimeOffsetSeconds = 0n, _mempoolOrder, _coinbase, genesisAccounts, _configNetworkId, _configChainId, hardfork, _hardforkActivations, _mixHashGenerator, tracingConfig, _forkNetworkId, _forkBlockNumber, nextBlockBaseFee, _forkClient) {
         super();
         this._vm = _vm;
         this._stateManager = _stateManager;
@@ -70,20 +71,23 @@ class HardhatNode extends events_1.default {
         this._coinbase = _coinbase;
         this._configNetworkId = _configNetworkId;
         this._configChainId = _configChainId;
+        this.hardfork = hardfork;
         this._hardforkActivations = _hardforkActivations;
+        this._mixHashGenerator = _mixHashGenerator;
         this._forkNetworkId = _forkNetworkId;
         this._forkBlockNumber = _forkBlockNumber;
         this._forkClient = _forkClient;
         this._localAccounts = new Map(); // address => private key
         this._impersonatedAccounts = new Set(); // address
-        this._nextBlockTimestamp = new ethereumjs_util_1.BN(0);
-        this._lastFilterId = new ethereumjs_util_1.BN(0);
+        this._nextBlockTimestamp = 0n;
+        this._lastFilterId = 0n;
         this._filters = new Map();
         this._nextSnapshotId = 1; // We start in 1 to mimic Ganache
         this._snapshots = [];
         this._consoleLogger = new consoleLogger_1.ConsoleLogger();
         this._failedStackTraces = 0;
-        this._irregularStatesByBlockNumber = new Map(); // blockNumber as BN.toString() => state root
+        // blockNumber => state root
+        this._irregularStatesByBlockNumber = new Map();
         this._initLocalAccounts(genesisAccounts);
         if (nextBlockBaseFee !== undefined) {
             this.setUserProvidedNextBlockBaseFeePerGas(nextBlockBaseFee);
@@ -114,7 +118,6 @@ class HardhatNode extends events_1.default {
     }
     static async create(config) {
         const { automine, genesisAccounts, blockGasLimit, allowUnlimitedContractSize, tracingConfig, minGasPrice, mempoolOrder, networkId, chainId, } = config;
-        let common;
         let stateManager;
         let blockchain;
         let initialBlockTimeOffset;
@@ -123,22 +126,23 @@ class HardhatNode extends events_1.default {
         let forkBlockNum;
         let hardforkActivations = new Map();
         const initialBaseFeePerGasConfig = config.initialBaseFeePerGas !== undefined
-            ? new ethereumjs_util_1.BN(config.initialBaseFeePerGas)
+            ? BigInt(config.initialBaseFeePerGas)
             : undefined;
         const hardfork = (0, hardforks_1.getHardforkName)(config.hardfork);
+        const mixHashGenerator = random_1.RandomBufferGenerator.create("randomMixHashSeed");
         let forkClient;
+        const common = (0, makeCommon_1.makeCommon)(config);
         if ((0, node_types_1.isForkedNodeConfig)(config)) {
             const { forkClient: _forkClient, forkBlockNumber, forkBlockTimestamp, } = await (0, makeForkClient_1.makeForkClient)(config.forkConfig, config.forkCachePath);
             forkClient = _forkClient;
-            common = await (0, makeForkCommon_1.makeForkCommon)(config);
             forkNetworkId = forkClient.getNetworkId();
-            forkBlockNum = forkBlockNumber.toNumber();
-            this._validateHardforks(config.forkConfig.blockNumber, common, forkNetworkId);
+            forkBlockNum = forkBlockNumber;
+            this._validateHardforks(bigint_1.BigIntUtils.mapNumberToBigInt(config.forkConfig.blockNumber), common, forkNetworkId);
             const forkStateManager = new ForkStateManager_1.ForkStateManager(forkClient, forkBlockNumber);
             await forkStateManager.initializeGenesisAccounts(genesisAccounts);
             stateManager = forkStateManager;
             blockchain = new ForkBlockchain_1.ForkBlockchain(forkClient, forkBlockNumber, common);
-            initialBlockTimeOffset = new ethereumjs_util_1.BN((0, date_1.getDifferenceInSeconds)(new Date(forkBlockTimestamp), new Date()));
+            initialBlockTimeOffset = BigInt((0, date_1.getDifferenceInSeconds)(new Date(forkBlockTimestamp), new Date()));
             // If the hardfork is London or later we need a base fee per gas for the
             // first local block. If initialBaseFeePerGas config was provided we use
             // that. Otherwise, what we do depends on the block we forked from. If
@@ -151,7 +155,7 @@ class HardhatNode extends events_1.default {
                 else {
                     const latestBlock = await blockchain.getLatestBlock();
                     if (latestBlock.header.baseFeePerGas === undefined) {
-                        nextBlockBaseFeePerGas = new ethereumjs_util_1.BN(default_config_1.HARDHAT_NETWORK_DEFAULT_INITIAL_BASE_FEE_PER_GAS);
+                        nextBlockBaseFeePerGas = BigInt(default_config_1.HARDHAT_NETWORK_DEFAULT_INITIAL_BASE_FEE_PER_GAS);
                     }
                 }
             }
@@ -161,30 +165,35 @@ class HardhatNode extends events_1.default {
         }
         else {
             const stateTrie = await (0, makeStateTrie_1.makeStateTrie)(genesisAccounts);
-            common = (0, makeCommon_1.makeCommon)(config, stateTrie);
-            stateManager = new state_1.DefaultStateManager({
-                common,
+            stateManager = new statemanager_1.DefaultStateManager({
                 trie: stateTrie,
             });
             const hardhatBlockchain = new HardhatBlockchain_1.HardhatBlockchain(common);
             const genesisBlockBaseFeePerGas = (0, hardforks_1.hardforkGte)(hardfork, hardforks_1.HardforkName.LONDON)
-                ? initialBaseFeePerGasConfig !== null && initialBaseFeePerGasConfig !== void 0 ? initialBaseFeePerGasConfig : new ethereumjs_util_1.BN(default_config_1.HARDHAT_NETWORK_DEFAULT_INITIAL_BASE_FEE_PER_GAS)
+                ? initialBaseFeePerGasConfig ??
+                    BigInt(default_config_1.HARDHAT_NETWORK_DEFAULT_INITIAL_BASE_FEE_PER_GAS)
                 : undefined;
-            await (0, putGenesisBlock_1.putGenesisBlock)(hardhatBlockchain, common, genesisBlockBaseFeePerGas);
+            await (0, putGenesisBlock_1.putGenesisBlock)(hardhatBlockchain, common, config, stateTrie, hardfork, mixHashGenerator.next(), genesisBlockBaseFeePerGas);
             if (config.initialDate !== undefined) {
-                initialBlockTimeOffset = new ethereumjs_util_1.BN((0, date_1.getDifferenceInSeconds)(config.initialDate, new Date()));
+                initialBlockTimeOffset = BigInt((0, date_1.getDifferenceInSeconds)(config.initialDate, new Date()));
             }
             blockchain = hardhatBlockchain;
         }
-        const txPool = new TxPool_1.TxPool(stateManager, new ethereumjs_util_1.BN(blockGasLimit), common);
-        const vm = new vm_1.default({
+        const txPool = new TxPool_1.TxPool(stateManager, BigInt(blockGasLimit), common);
+        const eei = new vm_1.EEI(stateManager, common, blockchain);
+        const evm = await evm_1.EVM.create({
+            eei,
+            allowUnlimitedContractSize,
             common,
+        });
+        const vm = await vm_1.VM.create({
+            evm,
             activatePrecompiles: true,
+            common,
             stateManager,
-            blockchain: blockchain,
-            allowUnlimitedContractSize,
+            blockchain,
         });
-        const node = new HardhatNode(vm, stateManager, blockchain, txPool, automine, minGasPrice, initialBlockTimeOffset, mempoolOrder, config.coinbase, genesisAccounts, networkId, chainId, hardforkActivations, tracingConfig, forkNetworkId, forkBlockNum, nextBlockBaseFeePerGas, forkClient);
+        const node = new HardhatNode(vm, stateManager, blockchain, txPool, automine, minGasPrice, initialBlockTimeOffset, mempoolOrder, config.coinbase, genesisAccounts, networkId, chainId, hardfork, hardforkActivations, mixHashGenerator, tracingConfig, forkNetworkId, forkBlockNum, nextBlockBaseFeePerGas, forkClient);
         return [common, node];
     }
     static _validateHardforks(forkBlockNumber, common, remoteChainId) {
@@ -196,9 +205,9 @@ The hardfork must be at least spuriousDragon, but ${common.hardfork()} was given
         if (forkBlockNumber !== undefined) {
             let upstreamCommon;
             try {
-                upstreamCommon = new common_1.default({ chain: remoteChainId });
+                upstreamCommon = new common_1.Common({ chain: remoteChainId });
             }
-            catch (_a) {
+            catch {
                 // If ethereumjs doesn't have a common it will throw and we won't have
                 // info about the activation block of each hardfork, so we don't run
                 // this validation.
@@ -213,7 +222,7 @@ 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, util_1.bufferToHex)(txParams.from);
         const pk = this._localAccounts.get(senderAddress);
         if (pk !== undefined) {
             let tx;
@@ -249,10 +258,12 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         return this._mineTransaction(tx);
     }
     async mineBlock(timestamp) {
-        const [blockTimestamp, offsetShouldChange, newOffset] = this._calculateTimestampAndOffset(timestamp);
+        const timestampAndOffset = this._calculateTimestampAndOffset(timestamp);
+        let [blockTimestamp] = timestampAndOffset;
+        const [, offsetShouldChange, newOffset] = timestampAndOffset;
         const needsTimestampIncrease = await this._timestampClashesWithPreviousBlockOne(blockTimestamp);
         if (needsTimestampIncrease) {
-            blockTimestamp.iaddn(1);
+            blockTimestamp += 1n;
         }
         let result;
         try {
@@ -260,7 +271,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         }
         catch (err) {
             if (err instanceof Error) {
-                if (err === null || err === void 0 ? void 0 : err.message.includes("sender doesn't have enough funds")) {
+                if (err?.message.includes("sender doesn't have enough funds")) {
                     throw new errors_2.InvalidInputError(err.message, err);
                 }
                 // Some network errors are HardhatErrors, and can end up here when forking
@@ -274,7 +285,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         }
         await this._saveBlockAsSuccessfullyRun(result.block, result.blockResult);
         if (needsTimestampIncrease) {
-            this.increaseTime(new ethereumjs_util_1.BN(1));
+            this.increaseTime(1n);
         }
         if (offsetShouldChange) {
             this.setTimeIncrement(newOffset);
@@ -290,8 +301,8 @@ Hardhat Network's forking functionality only works with blocks from at least spu
      * Returns an array with the results of the blocks that were really mined (the
      * ones that were reserved are not included).
      */
-    async mineBlocks(count = new ethereumjs_util_1.BN(1), interval = new ethereumjs_util_1.BN(1)) {
-        if (count.eqn(0)) {
+    async mineBlocks(count = 1n, interval = 1n) {
+        if (count === 0n) {
             // nothing to do
             return [];
         }
@@ -301,67 +312,77 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         // helper function to mine a block with a timstamp that respects the
         // interval
         const mineBlock = async () => {
-            const nextTimestamp = (await this.getLatestBlock()).header.timestamp.add(interval);
+            const nextTimestamp = (await this.getLatestBlock()).header.timestamp + interval;
             mineBlockResults.push(await this.mineBlock(nextTimestamp));
         };
         // then we mine any pending transactions
-        while (count.gtn(mineBlockResults.length) &&
+        while (count > mineBlockResults.length &&
             this._txPool.hasPendingTransactions()) {
             await mineBlock();
         }
         // If there is at least one remaining block, we mine one. This way, we
         // guarantee that there's an empty block immediately before and after the
         // reservation. This makes the logging easier to get right.
-        if (count.gtn(mineBlockResults.length)) {
+        if (count > mineBlockResults.length) {
             await mineBlock();
         }
-        const remainingBlockCount = count.subn(mineBlockResults.length);
+        const remainingBlockCount = count - BigInt(mineBlockResults.length);
         // There should be at least 2 blocks left for the reservation to work,
         // because we always mine a block after it. But here we use a bigger
         // number to err on the safer side.
-        if (remainingBlockCount.lten(5)) {
+        if (remainingBlockCount <= 5) {
             // if there are few blocks left to mine, we just mine them
-            while (count.gtn(mineBlockResults.length)) {
+            while (count > mineBlockResults.length) {
                 await mineBlock();
             }
             return mineBlockResults;
         }
         // otherwise, we reserve a range and mine the last one
         const latestBlock = await this.getLatestBlock();
-        this._blockchain.reserveBlocks(remainingBlockCount.subn(1), interval, await this._stateManager.getStateRoot(), await this.getBlockTotalDifficulty(latestBlock), (await this.getLatestBlock()).header.baseFeePerGas);
+        this._blockchain.reserveBlocks(remainingBlockCount - 1n, interval, await this._stateManager.getStateRoot(), await this.getBlockTotalDifficulty(latestBlock), (await this.getLatestBlock()).header.baseFeePerGas);
         await mineBlock();
         return mineBlockResults;
     }
     async runCall(call, blockNumberOrPending) {
-        var _a, _b, _c, _d;
         let txParams;
-        const nonce = await this._getNonce(new ethereumjs_util_1.Address(call.from), blockNumberOrPending);
+        const nonce = await this._getNonce(new util_1.Address(call.from), blockNumberOrPending);
         if (call.gasPrice !== undefined ||
             !this.isEip1559Active(blockNumberOrPending)) {
-            txParams = Object.assign({ gasPrice: new ethereumjs_util_1.BN(0), nonce }, call);
+            txParams = {
+                gasPrice: 0n,
+                nonce,
+                ...call,
+            };
         }
         else {
-            const maxFeePerGas = (_b = (_a = call.maxFeePerGas) !== null && _a !== void 0 ? _a : call.maxPriorityFeePerGas) !== null && _b !== void 0 ? _b : new ethereumjs_util_1.BN(0);
-            const maxPriorityFeePerGas = (_c = call.maxPriorityFeePerGas) !== null && _c !== void 0 ? _c : new ethereumjs_util_1.BN(0);
-            txParams = Object.assign(Object.assign({}, call), { nonce,
+            const maxFeePerGas = call.maxFeePerGas ?? call.maxPriorityFeePerGas ?? 0n;
+            const maxPriorityFeePerGas = call.maxPriorityFeePerGas ?? 0n;
+            txParams = {
+                ...call,
+                nonce,
                 maxFeePerGas,
-                maxPriorityFeePerGas, accessList: (_d = call.accessList) !== null && _d !== void 0 ? _d : [] });
+                maxPriorityFeePerGas,
+                accessList: call.accessList ?? [],
+            };
         }
         const tx = await this._getFakeTransaction(txParams);
         const result = await this._runInBlockContext(blockNumberOrPending, async () => this._runTxAndRevertMutations(tx, blockNumberOrPending, true));
         const traces = await this._gatherTraces(result.execResult);
-        return Object.assign(Object.assign({}, traces), { result: new return_data_1.ReturnData(result.execResult.returnValue) });
+        return {
+            ...traces,
+            result: new return_data_1.ReturnData(result.execResult.returnValue),
+        };
     }
     async getAccountBalance(address, blockNumberOrPending) {
         if (blockNumberOrPending === undefined) {
             blockNumberOrPending = this.getLatestBlockNumber();
         }
         const account = await this._runInBlockContext(blockNumberOrPending, () => this._stateManager.getAccount(address));
-        return new ethereumjs_util_1.BN(account.balance);
+        return account.balance;
     }
     async getNextConfirmedNonce(address, blockNumberOrPending) {
         const account = await this._runInBlockContext(blockNumberOrPending, () => this._stateManager.getAccount(address));
-        return new ethereumjs_util_1.BN(account.nonce);
+        return account.nonce;
     }
     async getAccountNextPendingNonce(address) {
         return this._txPool.getNextPendingNonce(address);
@@ -372,7 +393,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
             (0, message_trace_1.isCreateTrace)(trace)) {
             return Buffer.from("");
         }
-        return this.getCode(new ethereumjs_util_1.Address(trace.address), blockNumberOrPending);
+        return this.getCode(new util_1.Address(trace.address), blockNumberOrPending);
     }
     async getLatestBlock() {
         return this._blockchain.getLatestBlock();
@@ -394,10 +415,9 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         return this._txPool.getBlockGasLimit();
     }
     async estimateGas(callParams, blockNumberOrPending) {
-        var _a, _b;
         // We get the CallParams and transform it into a TransactionParams to be
         // able to run it.
-        const nonce = await this._getNonce(new ethereumjs_util_1.Address(callParams.from), blockNumberOrPending);
+        const nonce = await this._getNonce(new util_1.Address(callParams.from), blockNumberOrPending);
         // TODO: This is more complex in Geth, we should make sure we aren't missing
         //  anything here.
         const feePriceFields = await this._getEstimateGasFeePriceFields(callParams, blockNumberOrPending);
@@ -405,16 +425,31 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         if ("gasPrice" in feePriceFields) {
             if (callParams.accessList === undefined) {
                 // Legacy tx
-                txParams = Object.assign(Object.assign({}, callParams), { nonce, gasPrice: feePriceFields.gasPrice });
+                txParams = {
+                    ...callParams,
+                    nonce,
+                    gasPrice: feePriceFields.gasPrice,
+                };
             }
             else {
                 // Access list tx
-                txParams = Object.assign(Object.assign({}, callParams), { nonce, gasPrice: feePriceFields.gasPrice, accessList: (_a = callParams.accessList) !== null && _a !== void 0 ? _a : [] });
+                txParams = {
+                    ...callParams,
+                    nonce,
+                    gasPrice: feePriceFields.gasPrice,
+                    accessList: callParams.accessList ?? [],
+                };
             }
         }
         else {
             // EIP-1559 tx
-            txParams = Object.assign(Object.assign({}, callParams), { nonce, maxFeePerGas: feePriceFields.maxFeePerGas, maxPriorityFeePerGas: feePriceFields.maxPriorityFeePerGas, accessList: (_b = callParams.accessList) !== null && _b !== void 0 ? _b : [] });
+            txParams = {
+                ...callParams,
+                nonce,
+                maxFeePerGas: feePriceFields.maxFeePerGas,
+                maxPriorityFeePerGas: feePriceFields.maxPriorityFeePerGas,
+                accessList: callParams.accessList ?? [],
+            };
         }
         const tx = await this._getFakeTransaction(txParams);
         // TODO: This may not work if there are multiple txs in the mempool and
@@ -439,7 +474,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
                 consoleLogMessages,
             };
         }
-        const initialEstimation = result.gasUsed;
+        const initialEstimation = result.totalGasSpent;
         return {
             estimation: await this._correctInitialEstimation(blockNumberOrPending, txParams, initialEstimation),
             trace: vmTrace,
@@ -450,19 +485,19 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         const nextBlockBaseFeePerGas = await this.getNextBlockBaseFeePerGas();
         if (nextBlockBaseFeePerGas === undefined) {
             // We return a hardcoded value for networks without EIP-1559
-            return new ethereumjs_util_1.BN(8e9);
+            return 8n * 10n ** 9n;
         }
-        const suggestedPriorityFeePerGas = new ethereumjs_util_1.BN(1e9);
-        return nextBlockBaseFeePerGas.add(suggestedPriorityFeePerGas);
+        const suggestedPriorityFeePerGas = 10n ** 9n;
+        return nextBlockBaseFeePerGas + suggestedPriorityFeePerGas;
     }
     async getMaxPriorityFeePerGas() {
-        return new ethereumjs_util_1.BN(default_config_1.HARDHAT_NETWORK_DEFAULT_MAX_PRIORITY_FEE_PER_GAS);
+        return BigInt(default_config_1.HARDHAT_NETWORK_DEFAULT_MAX_PRIORITY_FEE_PER_GAS);
     }
     getCoinbaseAddress() {
-        return ethereumjs_util_1.Address.fromString(this._coinbase);
+        return util_1.Address.fromString(this._coinbase);
     }
     async getStorageAt(address, positionIndex, blockNumberOrPending) {
-        const key = positionIndex.toArrayLike(Buffer, "be", 32);
+        const key = (0, util_1.setLengthLeft)((0, util_1.bigIntToBuffer)(positionIndex), 32);
         const data = await this._runInBlockContext(blockNumberOrPending, () => this._stateManager.getContractStorage(address, key));
         const EXPECTED_DATA_SIZE = 32;
         if (data.length < EXPECTED_DATA_SIZE) {
@@ -475,15 +510,15 @@ Hardhat Network's forking functionality only works with blocks from at least spu
             return this._runInPendingBlockContext(() => this._blockchain.getLatestBlock());
         }
         const block = await this._blockchain.getBlock(blockNumberOrPending);
-        return block !== null && block !== void 0 ? block : undefined;
+        return block ?? undefined;
     }
     async getBlockByHash(blockHash) {
         const block = await this._blockchain.getBlock(blockHash);
-        return block !== null && block !== void 0 ? block : undefined;
+        return block ?? undefined;
     }
     async getBlockByTransactionHash(hash) {
         const block = await this._blockchain.getBlockByTransactionHash(hash);
-        return block !== null && block !== void 0 ? block : undefined;
+        return block ?? undefined;
     }
     async getBlockTotalDifficulty(block) {
         return this._blockchain.getTotalDifficulty(block.hash());
@@ -492,19 +527,19 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         return this._runInBlockContext(blockNumberOrPending, () => this._stateManager.getContractCode(address));
     }
     getNextBlockTimestamp() {
-        return this._nextBlockTimestamp.clone();
+        return this._nextBlockTimestamp;
     }
     setNextBlockTimestamp(timestamp) {
-        this._nextBlockTimestamp = new ethereumjs_util_1.BN(timestamp);
+        this._nextBlockTimestamp = timestamp;
     }
     getTimeIncrement() {
-        return this._blockTimeOffsetSeconds.clone();
+        return this._blockTimeOffsetSeconds;
     }
     setTimeIncrement(timeIncrement) {
         this._blockTimeOffsetSeconds = timeIncrement;
     }
     increaseTime(increment) {
-        this._blockTimeOffsetSeconds = this._blockTimeOffsetSeconds.add(increment);
+        this._blockTimeOffsetSeconds += increment;
     }
     setUserProvidedNextBlockBaseFeePerGas(baseFeePerGas) {
         this._userProvidedNextBlockBaseFeePerGas = baseFeePerGas;
@@ -527,13 +562,12 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         return latestBlock.header.calcNextBaseFee();
     }
     async getPendingTransaction(hash) {
-        var _a;
-        return (_a = this._txPool.getTransactionByHash(hash)) === null || _a === void 0 ? void 0 : _a.data;
+        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, util_1.toBuffer)(hash);
         const receipt = await this._blockchain.getTransactionReceipt(hashBuffer);
-        return receipt !== null && receipt !== void 0 ? receipt : undefined;
+        return receipt ?? undefined;
     }
     async getPendingTransactions() {
         const txPoolPending = (0, txMapToArray_1.txMapToArray)(this._txPool.getPendingTransactions());
@@ -541,9 +575,9 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         return txPoolPending.concat(txPoolQueued);
     }
     async signPersonalMessage(address, data) {
-        const messageHash = (0, ethereumjs_util_1.hashPersonalMessage)(data);
+        const messageHash = (0, util_1.hashPersonalMessage)(data);
         const privateKey = this._getLocalAccountPrivateKey(address);
-        return (0, ethereumjs_util_1.ecsign)(messageHash, privateKey);
+        return (0, util_1.ecsign)(messageHash, privateKey);
     }
     async signTypedDataV4(address, typedData) {
         const privateKey = this._getLocalAccountPrivateKey(address);
@@ -569,6 +603,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
             irregularStatesByBlockNumber: this._irregularStatesByBlockNumber,
             userProvidedNextBlockBaseFeePerGas: this.getUserProvidedNextBlockBaseFeePerGas(),
             coinbase: this.getCoinbaseAddress().toString(),
+            mixHashGenerator: this._mixHashGenerator.clone(),
         };
         this._irregularStatesByBlockNumber = new Map(this._irregularStatesByBlockNumber);
         this._snapshots.push(snapshot);
@@ -586,7 +621,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         const now = new Date();
         const offsetToSnapshotInMillis = snapshot.date.valueOf() - now.valueOf();
         const offsetToSnapshotInSecs = Math.ceil(offsetToSnapshotInMillis / 1000);
-        const newOffset = snapshot.blockTimeOffsetSeconds.addn(offsetToSnapshotInSecs);
+        const newOffset = snapshot.blockTimeOffsetSeconds + BigInt(offsetToSnapshotInSecs);
         // We delete all following blocks, changes the state root, and all the
         // relevant Node fields.
         //
@@ -594,8 +629,8 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         // used once
         this._blockchain.deleteLaterBlocks(snapshot.latestBlock);
         this._irregularStatesByBlockNumber = snapshot.irregularStatesByBlockNumber;
-        const irregularStateOrUndefined = this._irregularStatesByBlockNumber.get((await this.getLatestBlock()).header.number.toString());
-        await this._stateManager.setStateRoot(irregularStateOrUndefined !== null && irregularStateOrUndefined !== void 0 ? irregularStateOrUndefined : snapshot.stateRoot);
+        const irregularStateOrUndefined = this._irregularStatesByBlockNumber.get((await this.getLatestBlock()).header.number);
+        await this._stateManager.setStateRoot(irregularStateOrUndefined ?? snapshot.stateRoot);
         this.setTimeIncrement(newOffset);
         this.setNextBlockTimestamp(snapshot.nextBlockTimestamp);
         this._txPool.revert(snapshot.txPoolSnapshotId);
@@ -606,6 +641,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
             this._resetUserProvidedNextBlockBaseFeePerGas();
         }
         this._coinbase = snapshot.coinbase;
+        this._mixHashGenerator = snapshot.mixHashGenerator;
         // We delete this and the following snapshots, as they can only be used
         // once in Ganache
         this._snapshots.splice(snapshotIndex);
@@ -637,7 +673,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, util_1.bufferToHex)(block.header.hash())],
             logs: [],
             subscription: isSubscription,
         });
@@ -719,11 +755,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, util_1.bufferToHex)(address));
         return true;
     }
     removeImpersonatedAccount(address) {
-        return this._impersonatedAccounts.delete((0, ethereumjs_util_1.bufferToHex)(address));
+        return this._impersonatedAccounts.delete((0, util_1.bufferToHex)(address));
     }
     setAutomine(automine) {
         this._automine = automine;
@@ -745,7 +781,7 @@ 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, util_1.bufferToHex)(hash)} cannot be dropped because it's already mined`);
         }
         return false;
     }
@@ -764,7 +800,7 @@ 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.lt(account.nonce)) {
+        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;
@@ -772,23 +808,23 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         await this._persistIrregularWorldState();
     }
     async setStorageAt(address, positionIndex, value) {
-        await this._stateManager.putContractStorage(address, positionIndex.toArrayLike(Buffer, "be", 32), value);
+        await this._stateManager.putContractStorage(address, (0, util_1.setLengthLeft)((0, util_1.bigIntToBuffer)(positionIndex), 32), value);
         await this._persistIrregularWorldState();
     }
     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, util_1.bufferToHex)(hash)}`);
         }
-        return this._runInBlockContext(new ethereumjs_util_1.BN(block.header.number).subn(1), async () => {
-            const blockNumber = block.header.number.toNumber();
+        return this._runInBlockContext(block.header.number - 1n, async () => {
+            const blockNumber = block.header.number;
             const blockchain = this._blockchain;
             let vm = this._vm;
             if (blockchain instanceof ForkBlockchain_1.ForkBlockchain &&
-                blockNumber <= blockchain.getForkBlockNumber().toNumber()) {
+                blockNumber <= blockchain.getForkBlockNumber()) {
                 (0, errors_1.assertHardhatInvariant)(this._forkNetworkId !== undefined, "this._forkNetworkId should exist if the blockchain is an instance of ForkBlockchain");
                 const common = this._getCommonForTracing(this._forkNetworkId, blockNumber);
-                vm = new vm_1.default({
+                vm = await vm_1.VM.create({
                     common,
                     activatePrecompiles: true,
                     stateManager: this._vm.stateManager,
@@ -817,7 +853,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
                     });
                 }
                 else if (tx.type === 2) {
-                    txWithCommon = new FakeSenderEIP1559Transaction_1.FakeSenderEIP1559Transaction(sender, Object.assign(Object.assign({}, tx), { gasPrice: undefined }), {
+                    txWithCommon = new FakeSenderEIP1559Transaction_1.FakeSenderEIP1559Transaction(sender, { ...tx, gasPrice: undefined }, {
                         common: vm._common,
                     });
                 }
@@ -837,23 +873,22 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         });
     }
     async getFeeHistory(blockCount, newestBlock, rewardPercentiles) {
-        var _a;
         const latestBlock = this.getLatestBlockNumber();
-        const pendingBlockNumber = latestBlock.addn(1);
+        const pendingBlockNumber = latestBlock + 1n;
         const resolvedNewestBlock = newestBlock === "pending" ? pendingBlockNumber : newestBlock;
-        const oldestBlock = ethereumjs_util_1.BN.max(resolvedNewestBlock.sub(blockCount).addn(1), new ethereumjs_util_1.BN(0));
+        const oldestBlock = bigint_1.BigIntUtils.max(resolvedNewestBlock - blockCount + 1n, 0n);
         // This is part of a temporary fix to https://github.com/NomicFoundation/hardhat/issues/2380
         const rangeIncludesRemoteBlocks = this._forkBlockNumber !== undefined &&
-            oldestBlock.lten(this._forkBlockNumber);
+            oldestBlock <= this._forkBlockNumber;
         const baseFeePerGas = [];
         const gasUsedRatio = [];
         const reward = [];
-        const lastBlock = resolvedNewestBlock.addn(1);
+        const lastBlock = resolvedNewestBlock + 1n;
         // This is part of a temporary fix to https://github.com/NomicFoundation/hardhat/issues/2380
         if (rangeIncludesRemoteBlocks) {
             try {
-                const lastRemoteBlock = ethereumjs_util_1.BN.min(new ethereumjs_util_1.BN(this._forkBlockNumber), lastBlock);
-                const remoteBlockCount = lastRemoteBlock.sub(oldestBlock).addn(1);
+                const lastRemoteBlock = bigint_1.BigIntUtils.min(BigInt(this._forkBlockNumber), lastBlock);
+                const remoteBlockCount = lastRemoteBlock - oldestBlock + 1n;
                 const remoteValues = await this._forkClient.getFeeHistory(remoteBlockCount, lastRemoteBlock, rewardPercentiles);
                 baseFeePerGas.push(...remoteValues.baseFeePerGas);
                 gasUsedRatio.push(...remoteValues.gasUsedRatio);
@@ -869,39 +904,39 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         // We get the pending block here, and only if necessary, as it's something
         // costly to do.
         let pendingBlock;
-        if (lastBlock.gte(pendingBlockNumber)) {
+        if (lastBlock >= pendingBlockNumber) {
             pendingBlock = await this.getBlockByNumber("pending");
         }
         // This is part of a temporary fix to https://github.com/NomicFoundation/hardhat/issues/2380
         const firstLocalBlock = !rangeIncludesRemoteBlocks
             ? oldestBlock
-            : ethereumjs_util_1.BN.min(new ethereumjs_util_1.BN(this._forkBlockNumber), lastBlock).addn(1);
+            : bigint_1.BigIntUtils.min(BigInt(this._forkBlockNumber), lastBlock) + 1n;
         for (let blockNumber = firstLocalBlock; // This is part of a temporary fix to https://github.com/NomicFoundation/hardhat/issues/2380
-         blockNumber.lte(lastBlock); blockNumber = blockNumber.addn(1)) {
-            if (blockNumber.lt(pendingBlockNumber)) {
+         blockNumber <= lastBlock; blockNumber++) {
+            if (blockNumber < pendingBlockNumber) {
                 // We know the block exists
                 const block = (await this.getBlockByNumber(blockNumber));
-                baseFeePerGas.push((_a = block.header.baseFeePerGas) !== null && _a !== void 0 ? _a : new ethereumjs_util_1.BN(0));
-                if (blockNumber.lt(lastBlock)) {
+                baseFeePerGas.push(block.header.baseFeePerGas ?? 0n);
+                if (blockNumber < lastBlock) {
                     gasUsedRatio.push(this._getGasUsedRatio(block));
                     if (rewardPercentiles.length > 0) {
                         reward.push(await this._getRewards(block, rewardPercentiles));
                     }
                 }
             }
-            else if (blockNumber.eq(pendingBlockNumber)) {
+            else if (blockNumber === pendingBlockNumber) {
                 // This can only be run with EIP-1559, so this exists
                 baseFeePerGas.push((await this.getNextBlockBaseFeePerGas()));
-                if (blockNumber.lt(lastBlock)) {
+                if (blockNumber < lastBlock) {
                     gasUsedRatio.push(this._getGasUsedRatio(pendingBlock));
                     if (rewardPercentiles.length > 0) {
                         // We don't compute this for the pending block, as there's no
                         // effective miner fee yet.
-                        reward.push(rewardPercentiles.map((_) => new ethereumjs_util_1.BN(0)));
+                        reward.push(rewardPercentiles.map((_) => 0n));
                     }
                 }
             }
-            else if (blockNumber.eq(pendingBlockNumber.addn(1))) {
+            else if (blockNumber === pendingBlockNumber + 1n) {
                 baseFeePerGas.push(pendingBlock.header.calcNextBaseFee());
             }
             else {
@@ -920,49 +955,45 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     }
     _getGasUsedRatio(block) {
         const FLOATS_PRECISION = 100000;
-        return (block.header.gasUsed
-            .muln(FLOATS_PRECISION)
-            .div(block.header.gasLimit)
-            .toNumber() / FLOATS_PRECISION);
+        return (Number((block.header.gasUsed * BigInt(FLOATS_PRECISION)) /
+            block.header.gasLimit) / FLOATS_PRECISION);
     }
     async _getRewards(block, rewardPercentiles) {
         const FLOATS_PRECISION = 100000;
         if (block.transactions.length === 0) {
-            return rewardPercentiles.map((_) => new ethereumjs_util_1.BN(0));
+            return rewardPercentiles.map((_) => 0n);
         }
         const receipts = await Promise.all(block.transactions
             .map((tx) => tx.hash())
             .map((hash) => this.getTransactionReceipt(hash)));
         const effectiveGasRewardAndGas = receipts
             .map((r, i) => {
-            var _a;
             const tx = block.transactions[i];
-            const baseFeePerGas = (_a = block.header.baseFeePerGas) !== null && _a !== void 0 ? _a : new ethereumjs_util_1.BN(0);
+            const baseFeePerGas = block.header.baseFeePerGas ?? 0n;
             // reward = min(maxPriorityFeePerGas, maxFeePerGas - baseFeePerGas)
             let effectiveGasReward;
             if ("maxPriorityFeePerGas" in tx) {
-                effectiveGasReward = tx.maxFeePerGas.sub(baseFeePerGas);
-                if (tx.maxPriorityFeePerGas.lt(effectiveGasReward)) {
+                effectiveGasReward = tx.maxFeePerGas - baseFeePerGas;
+                if (tx.maxPriorityFeePerGas < effectiveGasReward) {
                     effectiveGasReward = tx.maxPriorityFeePerGas;
                 }
             }
             else {
-                effectiveGasReward = tx.gasPrice.sub(baseFeePerGas);
+                effectiveGasReward = tx.gasPrice - baseFeePerGas;
             }
             return {
                 effectiveGasReward,
-                gasUsed: (0, base_types_1.rpcQuantityToBN)(r === null || r === void 0 ? void 0 : r.gasUsed),
+                gasUsed: (0, base_types_1.rpcQuantityToBigInt)(r?.gasUsed),
             };
         })
-            .sort((a, b) => a.effectiveGasReward.cmp(b.effectiveGasReward));
+            .sort((a, b) => bigint_1.BigIntUtils.cmp(a.effectiveGasReward, b.effectiveGasReward));
         return rewardPercentiles.map((p) => {
-            let gasUsed = new ethereumjs_util_1.BN(0);
-            const targetGas = block.header.gasLimit
-                .muln(Math.ceil(p * FLOATS_PRECISION))
-                .divn(100 * FLOATS_PRECISION);
+            let gasUsed = 0n;
+            const targetGas = (block.header.gasLimit * BigInt(Math.ceil(p * FLOATS_PRECISION))) /
+                BigInt(100 * FLOATS_PRECISION);
             for (const values of effectiveGasRewardAndGas) {
-                gasUsed = gasUsed.add(values.gasUsed);
-                if (targetGas.lte(gasUsed)) {
+                gasUsed += values.gasUsed;
+                if (targetGas <= gasUsed) {
                     return values.effectiveGasReward;
                 }
             }
@@ -973,7 +1004,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, util_1.bufferToHex)(tx.hash());
     }
     async _mineTransaction(tx) {
         await this._addPendingTransaction(tx);
@@ -1037,29 +1068,29 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         }
         // validate nonce
         const nextPendingNonce = await this._txPool.getNextPendingNonce(sender);
-        const txNonce = new ethereumjs_util_1.BN(tx.nonce);
+        const txNonce = tx.nonce;
         const expectedNonceMsg = `Expected nonce to be ${nextPendingNonce.toString()} but got ${txNonce.toString()}.`;
-        if (txNonce.gt(nextPendingNonce)) {
+        if (txNonce > nextPendingNonce) {
             throw new errors_2.InvalidInputError(`Nonce too high. ${expectedNonceMsg} Note that transactions can't be queued when automining.`);
         }
-        if (txNonce.lt(nextPendingNonce)) {
+        if (txNonce < nextPendingNonce) {
             throw new errors_2.InvalidInputError(`Nonce too low. ${expectedNonceMsg}`);
         }
         // validate gas price
-        const txPriorityFee = new ethereumjs_util_1.BN("gasPrice" in tx ? tx.gasPrice : tx.maxPriorityFeePerGas);
-        if (txPriorityFee.lt(this._minGasPrice)) {
+        const txPriorityFee = "gasPrice" in tx ? tx.gasPrice : tx.maxPriorityFeePerGas;
+        if (txPriorityFee < this._minGasPrice) {
             throw new errors_2.InvalidInputError(`Transaction gas price is ${txPriorityFee.toString()}, which is below the minimum of ${this._minGasPrice.toString()}`);
         }
         // Validate that maxFeePerGas >= next block's baseFee
         const nextBlockGasFee = await this.getNextBlockBaseFeePerGas();
         if (nextBlockGasFee !== undefined) {
             if ("maxFeePerGas" in tx) {
-                if (nextBlockGasFee.gt(tx.maxFeePerGas)) {
+                if (nextBlockGasFee > tx.maxFeePerGas) {
                     throw new errors_2.InvalidInputError(`Transaction maxFeePerGas (${tx.maxFeePerGas.toString()}) is too low for the next block, which has a baseFeePerGas of ${nextBlockGasFee.toString()}`);
                 }
             }
             else {
-                if (nextBlockGasFee.gt(tx.gasPrice)) {
+                if (nextBlockGasFee > tx.gasPrice) {
                     throw new errors_2.InvalidInputError(`Transaction gasPrice (${tx.gasPrice.toString()}) is too low for the next block, which has a baseFeePerGas of ${nextBlockGasFee.toString()}`);
                 }
             }
@@ -1076,9 +1107,14 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         const headerData = {
             gasLimit: this.getBlockGasLimit(),
             coinbase: this.getCoinbaseAddress(),
-            nonce: "0x0000000000000042",
+            nonce: this.isPostMergeHardfork()
+                ? "0x0000000000000000"
+                : "0x0000000000000042",
             timestamp: blockTimestamp,
         };
+        if (this.isPostMergeHardfork()) {
+            headerData.mixHash = this._getNextMixHash();
+        }
         headerData.baseFeePerGas = await this.getNextBlockBaseFeePerGas();
         const blockBuilder = await this._vm.buildBlock({
             parentBlock,
@@ -1094,10 +1130,10 @@ Hardhat Network's forking functionality only works with blocks from at least spu
             let tx = transactionQueue.getNextTransaction();
             const results = [];
             const receipts = [];
-            while (blockGasLimit.sub(blockBuilder.gasUsed).gte(minTxFee) &&
+            while (blockGasLimit - blockBuilder.gasUsed >= minTxFee &&
                 tx !== undefined) {
                 if (!this._isTxMinable(tx, headerData.baseFeePerGas) ||
-                    tx.gasLimit.gt(blockGasLimit.sub(blockBuilder.gasUsed))) {
+                    tx.gasLimit > blockGasLimit - blockBuilder.gasUsed) {
                     transactionQueue.removeLastSenderTransactions();
                 }
                 else {
@@ -1116,7 +1152,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
                     results,
                     receipts,
                     stateRoot: block.header.stateRoot,
-                    logsBloom: block.header.bloom,
+                    logsBloom: block.header.logsBloom,
                     receiptRoot: block.header.receiptTrie,
                     gasUsed: block.header.gasUsed,
                 },
@@ -1130,10 +1166,10 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     }
     _getMinimalTransactionFee() {
         // Typically 21_000 gas
-        return new ethereumjs_util_1.BN(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);
+        const sender = new util_1.Address(txParams.from);
         if ("maxFeePerGas" in txParams && txParams.maxFeePerGas !== undefined) {
             return new FakeSenderEIP1559Transaction_1.FakeSenderEIP1559Transaction(sender, txParams, {
                 common: this._vm._common,
@@ -1168,9 +1204,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, util_1.toBuffer)(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, util_1.bufferToHex)((0, util_1.privateToAddress)(pk)), pk);
         }
     }
     async _getConsoleLogMessages(vmTrace, vmTracerError) {
@@ -1221,7 +1257,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
             returnDataExplanation = `with reason "${returnData.decodeError()}"`;
         }
         else if (returnData.isPanicReturnData()) {
-            const panicCode = returnData.decodePanic().toString("hex");
+            const panicCode = returnData.decodePanic().toString(16);
             returnDataExplanation = `with panic code "0x${panicCode}"`;
         }
         else {
@@ -1247,14 +1283,14 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     _calculateTimestampAndOffset(timestamp) {
         let blockTimestamp;
         let offsetShouldChange;
-        let newOffset = new ethereumjs_util_1.BN(0);
-        const currentTimestamp = new ethereumjs_util_1.BN((0, getCurrentTimestamp_1.getCurrentTimestamp)());
+        let newOffset = 0n;
+        const currentTimestamp = BigInt((0, getCurrentTimestamp_1.getCurrentTimestamp)());
         // if timestamp is not provided, we check nextBlockTimestamp, if it is
         // set, we use it as the timestamp instead. If it is not set, we use
         // time offset + real time as the timestamp.
-        if (timestamp === undefined || timestamp.eqn(0)) {
-            if (this.getNextBlockTimestamp().eqn(0)) {
-                blockTimestamp = currentTimestamp.add(this.getTimeIncrement());
+        if (timestamp === undefined || timestamp === 0n) {
+            if (this.getNextBlockTimestamp() === 0n) {
+                blockTimestamp = currentTimestamp + this.getTimeIncrement();
                 offsetShouldChange = false;
             }
             else {
@@ -1267,17 +1303,17 @@ Hardhat Network's forking functionality only works with blocks from at least spu
             blockTimestamp = timestamp;
         }
         if (offsetShouldChange) {
-            newOffset = blockTimestamp.sub(currentTimestamp);
+            newOffset = blockTimestamp - currentTimestamp;
         }
         return [blockTimestamp, offsetShouldChange, newOffset];
     }
     _resetNextBlockTimestamp() {
-        this.setNextBlockTimestamp(new ethereumjs_util_1.BN(0));
+        this.setNextBlockTimestamp(0n);
     }
     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, util_1.bufferToHex)(tx.hash());
                 if (filter.subscription) {
                     this._emitEthEvent(filter.id, hash);
                     return;
@@ -1316,10 +1352,10 @@ Hardhat Network's forking functionality only works with blocks from at least spu
                         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, util_1.bufferToHex)(hash));
                     break;
                 case filter_1.Type.LOGS_SUBSCRIPTION:
-                    if ((0, filter_1.bloomFilter)(new bloom_1.default(block.header.bloom), filter.criteria.addresses, filter.criteria.normalizedTopics)) {
+                    if ((0, filter_1.bloomFilter)(new vm_1.Bloom(block.header.logsBloom), filter.criteria.addresses, filter.criteria.normalizedTopics)) {
                         const logs = (0, filter_1.filterLogs)(rpcLogs, filter.criteria);
                         if (logs.length === 0) {
                             return;
@@ -1338,14 +1374,14 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     }
     async _timestampClashesWithPreviousBlockOne(blockTimestamp) {
         const latestBlock = await this.getLatestBlock();
-        const latestBlockTimestamp = new ethereumjs_util_1.BN(latestBlock.header.timestamp);
-        return latestBlockTimestamp.eq(blockTimestamp);
+        const latestBlockTimestamp = latestBlock.header.timestamp;
+        return latestBlockTimestamp === blockTimestamp;
     }
     async _runInBlockContext(blockNumberOrPending, action) {
         if (blockNumberOrPending === "pending") {
             return this._runInPendingBlockContext(action);
         }
-        if (blockNumberOrPending.eq(this.getLatestBlockNumber())) {
+        if (blockNumberOrPending === this.getLatestBlockNumber()) {
             return action();
         }
         const block = await this.getBlockByNumber(blockNumberOrPending);
@@ -1373,11 +1409,11 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         }
     }
     async _setBlockContext(block) {
-        const irregularStateOrUndefined = this._irregularStatesByBlockNumber.get(block.header.number.toString());
+        const irregularStateOrUndefined = this._irregularStatesByBlockNumber.get(block.header.number);
         if (this._stateManager instanceof ForkStateManager_1.ForkStateManager) {
             return this._stateManager.setBlockContext(block.header.stateRoot, block.header.number, irregularStateOrUndefined);
         }
-        return this._stateManager.setStateRoot(irregularStateOrUndefined !== null && irregularStateOrUndefined !== void 0 ? irregularStateOrUndefined : block.header.stateRoot);
+        return this._stateManager.setStateRoot(irregularStateOrUndefined ?? block.header.stateRoot);
     }
     async _restoreBlockContext(stateRoot) {
         if (this._stateManager instanceof ForkStateManager_1.ForkStateManager) {
@@ -1386,10 +1422,16 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         return this._stateManager.setStateRoot(stateRoot);
     }
     async _correctInitialEstimation(blockNumberOrPending, txParams, initialEstimation) {
-        let tx = await this._getFakeTransaction(Object.assign(Object.assign({}, txParams), { gasLimit: initialEstimation }));
-        if (tx.getBaseFee().gte(initialEstimation)) {
-            initialEstimation = tx.getBaseFee().addn(1);
-            tx = await this._getFakeTransaction(Object.assign(Object.assign({}, txParams), { gasLimit: initialEstimation }));
+        let tx = await this._getFakeTransaction({
+            ...txParams,
+            gasLimit: initialEstimation,
+        });
+        if (tx.getBaseFee() >= initialEstimation) {
+            initialEstimation = tx.getBaseFee() + 1n;
+            tx = await this._getFakeTransaction({
+                ...txParams,
+                gasLimit: initialEstimation,
+            });
         }
         const result = await this._runInBlockContext(blockNumberOrPending, () => this._runTxAndRevertMutations(tx, blockNumberOrPending));
         if (result.execResult.exceptionError === undefined) {
@@ -1398,40 +1440,43 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         return this._binarySearchEstimation(blockNumberOrPending, txParams, initialEstimation, this.getBlockGasLimit());
     }
     async _binarySearchEstimation(blockNumberOrPending, txParams, highestFailingEstimation, lowestSuccessfulEstimation, roundNumber = 0) {
-        if (lowestSuccessfulEstimation.lte(highestFailingEstimation)) {
+        if (lowestSuccessfulEstimation <= highestFailingEstimation) {
             // This shouldn't happen, but we don't want to go into an infinite loop
             // if it ever happens
             return lowestSuccessfulEstimation;
         }
         const MAX_GAS_ESTIMATION_IMPROVEMENT_ROUNDS = 20;
-        const diff = lowestSuccessfulEstimation.sub(highestFailingEstimation);
-        const minDiff = highestFailingEstimation.gten(4000000)
+        const diff = lowestSuccessfulEstimation - highestFailingEstimation;
+        const minDiff = highestFailingEstimation >= 4000000n
             ? 50000
-            : highestFailingEstimation.gten(1000000)
+            : highestFailingEstimation >= 1000000n
                 ? 10000
-                : highestFailingEstimation.gten(100000)
+                : highestFailingEstimation >= 100000n
                     ? 1000
-                    : highestFailingEstimation.gten(50000)
+                    : highestFailingEstimation >= 50000n
                         ? 500
-                        : highestFailingEstimation.gten(30000)
+                        : highestFailingEstimation >= 30000n
                             ? 300
                             : 200;
-        if (diff.lten(minDiff)) {
+        if (diff <= minDiff) {
             return lowestSuccessfulEstimation;
         }
         if (roundNumber > MAX_GAS_ESTIMATION_IMPROVEMENT_ROUNDS) {
             return lowestSuccessfulEstimation;
         }
-        const binSearchNewEstimation = highestFailingEstimation.add(diff.divn(2));
+        const binSearchNewEstimation = highestFailingEstimation + diff / 2n;
         const optimizedEstimation = roundNumber === 0
-            ? highestFailingEstimation.muln(3)
+            ? 3n * highestFailingEstimation
             : binSearchNewEstimation;
-        const newEstimation = optimizedEstimation.gt(binSearchNewEstimation)
+        const newEstimation = optimizedEstimation > binSearchNewEstimation
             ? binSearchNewEstimation
             : optimizedEstimation;
         // Let other things execute
         await new Promise((resolve) => setImmediate(resolve));
-        const tx = await this._getFakeTransaction(Object.assign(Object.assign({}, txParams), { gasLimit: newEstimation }));
+        const tx = await this._getFakeTransaction({
+            ...txParams,
+            gasLimit: newEstimation,
+        });
         const result = await this._runInBlockContext(blockNumberOrPending, () => this._runTxAndRevertMutations(tx, blockNumberOrPending));
         if (result.execResult.exceptionError === undefined) {
             return this._binarySearchEstimation(blockNumberOrPending, txParams, highestFailingEstimation, newEstimation, roundNumber + 1);
@@ -1443,7 +1488,6 @@ Hardhat Network's forking functionality only works with blocks from at least spu
      * makes.
      */
     async _runTxAndRevertMutations(tx, blockNumberOrPending, forceBaseFeeZero = false) {
-        var _a;
         const initialStateRoot = await this._stateManager.getStateRoot();
         let blockContext;
         let originalCommon;
@@ -1461,7 +1505,7 @@ 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
             }
-            // NOTE: This is a workaround of both an @ethereumjs/vm limitation, and
+            // NOTE: This is a workaround of both an @ignored/vm limitation, and
             //   a bug in Hardhat Network.
             //
             // See: https://github.com/nomiclabs/hardhat/issues/1666
@@ -1480,14 +1524,16 @@ Hardhat Network's forking functionality only works with blocks from at least spu
                     freeze: false,
                     common: this._vm._common,
                 });
-                blockContext.header.baseFeePerGas = new ethereumjs_util_1.BN(0);
+                blockContext.header.baseFeePerGas = 0n;
             }
             originalCommon = this._vm._common;
-            this._vm._common = new common_1.default({
-                chain: Object.assign(Object.assign({}, this._vm._common["_chainParams"]), { chainId: this._forkBlockNumber === undefined ||
-                        blockContext.header.number.gte(new ethereumjs_util_1.BN(this._forkBlockNumber))
-                        ? this._configChainId
-                        : this._forkNetworkId, networkId: (_a = this._forkNetworkId) !== null && _a !== void 0 ? _a : this._configNetworkId }),
+            this._vm._common = common_1.Common.custom({
+                chainId: this._forkBlockNumber === undefined ||
+                    blockContext.header.number >= this._forkBlockNumber
+                    ? this._configChainId
+                    : this._forkNetworkId,
+                networkId: this._forkNetworkId ?? this._configNetworkId,
+            }, {
                 hardfork: this._selectHardfork(blockContext.header.number),
             });
             return await this._vm.runTx({
@@ -1507,17 +1553,17 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     }
     async _computeFilterParams(filterParams, isFilter) {
         const latestBlockNumber = this.getLatestBlockNumber();
-        const newFilterParams = Object.assign({}, filterParams);
+        const newFilterParams = { ...filterParams };
         if (newFilterParams.fromBlock === filter_1.LATEST_BLOCK) {
             newFilterParams.fromBlock = latestBlockNumber;
         }
         if (!isFilter && newFilterParams.toBlock === filter_1.LATEST_BLOCK) {
             newFilterParams.toBlock = latestBlockNumber;
         }
-        if (newFilterParams.toBlock.gt(latestBlockNumber)) {
+        if (newFilterParams.toBlock > latestBlockNumber) {
             newFilterParams.toBlock = latestBlockNumber;
         }
-        if (newFilterParams.fromBlock.gt(latestBlockNumber)) {
+        if (newFilterParams.fromBlock > latestBlockNumber) {
             newFilterParams.fromBlock = latestBlockNumber;
         }
         return newFilterParams;
@@ -1528,7 +1574,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         return dt;
     }
     _getNextFilterId() {
-        this._lastFilterId = this._lastFilterId.addn(1);
+        this._lastFilterId++;
         return this._lastFilterId;
     }
     _filterIdToFiltersKey(filterId) {
@@ -1556,13 +1602,13 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     _isTxMinable(tx, nextBlockBaseFeePerGas) {
         const txMaxFee = "gasPrice" in tx ? tx.gasPrice : tx.maxFeePerGas;
         const canPayBaseFee = nextBlockBaseFeePerGas !== undefined
-            ? txMaxFee.gte(nextBlockBaseFeePerGas)
+            ? txMaxFee >= nextBlockBaseFeePerGas
             : true;
-        const atLeastMinGasPrice = txMaxFee.gte(this._minGasPrice);
+        const atLeastMinGasPrice = txMaxFee >= this._minGasPrice;
         return canPayBaseFee && atLeastMinGasPrice;
     }
     async _persistIrregularWorldState() {
-        this._irregularStatesByBlockNumber.set(this.getLatestBlockNumber().toString(), await this._stateManager.getStateRoot());
+        this._irregularStatesByBlockNumber.set(this.getLatestBlockNumber(), await this._stateManager.getStateRoot());
     }
     isEip1559Active(blockNumberOrPending) {
         if (blockNumberOrPending !== undefined &&
@@ -1571,35 +1617,41 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         }
         return this._vm._common.gteHardfork("london");
     }
+    isPostMergeHardfork() {
+        return (0, hardforks_1.hardforkGte)(this.hardfork, hardforks_1.HardforkName.MERGE);
+    }
+    _getNextMixHash() {
+        return this._mixHashGenerator.next();
+    }
     async _getEstimateGasFeePriceFields(callParams, blockNumberOrPending) {
-        var _a, _b;
         if (!this.isEip1559Active(blockNumberOrPending) ||
             callParams.gasPrice !== undefined) {
-            return { gasPrice: (_a = callParams.gasPrice) !== null && _a !== void 0 ? _a : (await this.getGasPrice()) };
+            return { gasPrice: callParams.gasPrice ?? (await this.getGasPrice()) };
         }
         let maxFeePerGas = callParams.maxFeePerGas;
         let maxPriorityFeePerGas = callParams.maxPriorityFeePerGas;
         if (maxPriorityFeePerGas === undefined) {
             maxPriorityFeePerGas = await this.getMaxPriorityFeePerGas();
-            if (maxFeePerGas !== undefined && maxFeePerGas.lt(maxPriorityFeePerGas)) {
+            if (maxFeePerGas !== undefined && maxFeePerGas < maxPriorityFeePerGas) {
                 maxPriorityFeePerGas = maxFeePerGas;
             }
         }
         if (maxFeePerGas === undefined) {
             if (blockNumberOrPending === "pending") {
                 const baseFeePerGas = await this.getNextBlockBaseFeePerGas();
-                maxFeePerGas = baseFeePerGas.muln(2).add(maxPriorityFeePerGas);
+                maxFeePerGas = 2n * baseFeePerGas + maxPriorityFeePerGas;
             }
             else {
                 const block = await this.getBlockByNumber(blockNumberOrPending);
-                maxFeePerGas = maxPriorityFeePerGas.add((_b = block.header.baseFeePerGas) !== null && _b !== void 0 ? _b : new ethereumjs_util_1.BN(0));
+                maxFeePerGas =
+                    maxPriorityFeePerGas + (block.header.baseFeePerGas ?? 0n);
             }
         }
         return { maxFeePerGas, maxPriorityFeePerGas };
     }
     _selectHardfork(blockNumber) {
         if (this._forkBlockNumber === undefined ||
-            blockNumber.gte(new ethereumjs_util_1.BN(this._forkBlockNumber))) {
+            blockNumber >= this._forkBlockNumber) {
             return this._vm._common.hardfork();
         }
         if (this._hardforkActivations.size === 0) {
@@ -1609,10 +1661,10 @@ Hardhat Network's forking functionality only works with blocks from at least spu
          * isn't higher than blockNumber, and then return that found block number's
          * associated hardfork name. */
         const hardforkHistory = Array.from(this._hardforkActivations.entries());
-        const [hardfork, activationBlock] = hardforkHistory.reduce(([highestHardfork, highestBlock], [thisHardfork, thisBlock]) => thisBlock > highestBlock && new ethereumjs_util_1.BN(thisBlock).lte(blockNumber)
+        const [hardfork, activationBlock] = hardforkHistory.reduce(([highestHardfork, highestBlock], [thisHardfork, thisBlock]) => thisBlock > highestBlock && thisBlock <= blockNumber
             ? [thisHardfork, thisBlock]
             : [highestHardfork, highestBlock]);
-        if (hardfork === undefined || blockNumber.ltn(activationBlock)) {
+        if (hardfork === undefined || blockNumber < activationBlock) {
             throw new errors_2.InternalError(`Could not find a hardfork to run for block ${blockNumber.toString()}, after having looked for one in the HardhatNode's hardfork activation history, which was: ${JSON.stringify(hardforkHistory)}. For more information, see https://hardhat.org/hardhat-network/reference/#config`);
         }
         if (!constants_1.HARDHAT_NETWORK_SUPPORTED_HARDFORKS.includes(hardfork)) {
@@ -1622,13 +1674,15 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     }
     _getCommonForTracing(networkId, blockNumber) {
         try {
-            const common = new common_1.default({
-                chain: Object.assign(Object.assign({}, common_1.default["_getChainParams"]("mainnet")), { chainId: networkId, networkId }),
-                hardfork: this._selectHardfork(new ethereumjs_util_1.BN(blockNumber)),
+            const common = common_1.Common.custom({
+                chainId: networkId,
+                networkId,
+            }, {
+                hardfork: this._selectHardfork(BigInt(blockNumber)),
             });
             return common;
         }
-        catch (_a) {
+        catch {
             throw new errors_2.InternalError(`Network id ${networkId} does not correspond to a network that Hardhat can trace`);
         }
     }