hardhat 2.7.0 → 2.8.1

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

@@ -10,10 +10,12 @@ 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 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 constants_1 = require("../../constants");
 const default_config_1 = require("../../core/config/default-config");
 const errors_1 = require("../../core/errors");
 const errors_2 = require("../../core/providers/errors");
@@ -36,7 +38,6 @@ const filter_1 = require("./filter");
 const ForkBlockchain_1 = require("./fork/ForkBlockchain");
 const ForkStateManager_1 = require("./fork/ForkStateManager");
 const HardhatBlockchain_1 = require("./HardhatBlockchain");
-const HardhatStateManager_1 = require("./HardhatStateManager");
 const node_types_1 = require("./node-types");
 const output_1 = require("./output");
 const return_data_1 = require("./return-data");
@@ -48,14 +49,15 @@ const TransactionQueue_1 = require("./TransactionQueue");
 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 log = debug_1.default("hardhat:core:hardhat-network:node");
+const log = (0, debug_1.default)("hardhat:core:hardhat-network:node");
 const ethSigUtil = require("eth-sig-util");
 /* 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, tracingConfig, _forkNetworkId, nextBlockBaseFee) {
+    constructor(_vm, _stateManager, _blockchain, _txPool, _automine, _minGasPrice, _blockTimeOffsetSeconds = new ethereumjs_util_1.BN(0), _mempoolOrder, _coinbase, genesisAccounts, _configNetworkId, _configChainId, _hardforkActivations, tracingConfig, _forkNetworkId, _forkBlockNumber, nextBlockBaseFee) {
         super();
         this._vm = _vm;
         this._stateManager = _stateManager;
@@ -66,7 +68,11 @@ class HardhatNode extends events_1.default {
         this._blockTimeOffsetSeconds = _blockTimeOffsetSeconds;
         this._mempoolOrder = _mempoolOrder;
         this._coinbase = _coinbase;
+        this._configNetworkId = _configNetworkId;
+        this._configChainId = _configChainId;
+        this._hardforkActivations = _hardforkActivations;
         this._forkNetworkId = _forkNetworkId;
+        this._forkBlockNumber = _forkBlockNumber;
         this._localAccounts = new Map(); // address => private key
         this._impersonatedAccounts = new Set(); // address
         this._nextBlockTimestamp = new ethereumjs_util_1.BN(0);
@@ -91,7 +97,7 @@ class HardhatNode extends events_1.default {
         }
         try {
             for (const buildInfo of tracingConfig.buildInfos) {
-                const bytecodes = compiler_to_model_1.createModelsAndDecodeBytecodes(buildInfo.solcVersion, buildInfo.input, buildInfo.output);
+                const bytecodes = (0, compiler_to_model_1.createModelsAndDecodeBytecodes)(buildInfo.solcVersion, buildInfo.input, buildInfo.output);
                 for (const bytecode of bytecodes) {
                     this._vmTraceDecoder.addBytecode(bytecode);
                 }
@@ -100,37 +106,42 @@ class HardhatNode extends events_1.default {
         catch (error) {
             console.warn(chalk_1.default.yellow("The Hardhat Network tracing engine could not be initialized. Run Hardhat with --verbose to learn more."));
             log("Hardhat Network tracing disabled: ContractsIdentifier failed to be initialized. Please report this to help us improve Hardhat.\n", error);
-            reporter_1.Reporter.reportError(error);
+            if (error instanceof Error) {
+                reporter_1.Reporter.reportError(error);
+            }
         }
     }
     static async create(config) {
-        const { automine, genesisAccounts, blockGasLimit, allowUnlimitedContractSize, tracingConfig, minGasPrice, mempoolOrder, } = config;
+        const { automine, genesisAccounts, blockGasLimit, allowUnlimitedContractSize, tracingConfig, minGasPrice, mempoolOrder, networkId, chainId, } = config;
         let common;
         let stateManager;
         let blockchain;
         let initialBlockTimeOffset;
         let nextBlockBaseFeePerGas;
         let forkNetworkId;
+        let forkBlockNum;
+        let hardforkActivations = new Map();
         const initialBaseFeePerGasConfig = config.initialBaseFeePerGas !== undefined
             ? new ethereumjs_util_1.BN(config.initialBaseFeePerGas)
             : undefined;
-        const hardfork = hardforks_1.getHardforkName(config.hardfork);
-        if (node_types_1.isForkedNodeConfig(config)) {
-            const { forkClient, forkBlockNumber, forkBlockTimestamp } = await makeForkClient_1.makeForkClient(config.forkConfig, config.forkCachePath);
-            common = await makeForkCommon_1.makeForkCommon(config);
+        const hardfork = (0, hardforks_1.getHardforkName)(config.hardfork);
+        if ((0, node_types_1.isForkedNodeConfig)(config)) {
+            const { forkClient, forkBlockNumber, forkBlockTimestamp } = await (0, makeForkClient_1.makeForkClient)(config.forkConfig, config.forkCachePath);
+            common = await (0, makeForkCommon_1.makeForkCommon)(config);
             forkNetworkId = forkClient.getNetworkId();
+            forkBlockNum = forkBlockNumber.toNumber();
             this._validateHardforks(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(date_1.getDifferenceInSeconds(new Date(forkBlockTimestamp), new Date()));
+            initialBlockTimeOffset = new ethereumjs_util_1.BN((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
             // it's an EIP-1559 block we don't need to do anything here, as we'll
             // end up automatically computing the next base fee per gas based on it.
-            if (hardforks_1.hardforkGte(hardfork, hardforks_1.HardforkName.LONDON)) {
+            if ((0, hardforks_1.hardforkGte)(hardfork, hardforks_1.HardforkName.LONDON)) {
                 if (initialBaseFeePerGasConfig !== undefined) {
                     nextBlockBaseFeePerGas = initialBaseFeePerGasConfig;
                 }
@@ -141,21 +152,26 @@ class HardhatNode extends events_1.default {
                     }
                 }
             }
+            if (config.chains.has(forkNetworkId)) {
+                hardforkActivations = config.chains.get(forkNetworkId).hardforkHistory;
+            }
         }
         else {
-            const hardhatStateManager = new HardhatStateManager_1.HardhatStateManager();
-            await hardhatStateManager.initializeGenesisAccounts(genesisAccounts);
-            const initialStateRoot = await hardhatStateManager.getStateRoot();
-            common = makeCommon_1.makeCommon(config, initialStateRoot);
+            const stateTrie = await (0, makeStateTrie_1.makeStateTrie)(genesisAccounts);
+            common = (0, makeCommon_1.makeCommon)(config, stateTrie);
+            stateManager = new state_1.DefaultStateManager({
+                common,
+                trie: stateTrie,
+            });
             const hardhatBlockchain = new HardhatBlockchain_1.HardhatBlockchain();
-            const genesisBlockBaseFeePerGas = 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) : undefined;
-            await putGenesisBlock_1.putGenesisBlock(hardhatBlockchain, common, genesisBlockBaseFeePerGas);
+            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)
+                : undefined;
+            await (0, putGenesisBlock_1.putGenesisBlock)(hardhatBlockchain, common, genesisBlockBaseFeePerGas);
             if (config.initialDate !== undefined) {
-                initialBlockTimeOffset = new ethereumjs_util_1.BN(date_1.getDifferenceInSeconds(config.initialDate, new Date()));
+                initialBlockTimeOffset = new ethereumjs_util_1.BN((0, date_1.getDifferenceInSeconds)(config.initialDate, new Date()));
             }
             blockchain = hardhatBlockchain;
-            stateManager = hardhatStateManager;
         }
         const txPool = new TxPool_1.TxPool(stateManager, new ethereumjs_util_1.BN(blockGasLimit), common);
         const vm = new vm_1.default({
@@ -165,7 +181,7 @@ class HardhatNode extends events_1.default {
             blockchain: blockchain,
             allowUnlimitedContractSize,
         });
-        const node = new HardhatNode(vm, stateManager, blockchain, txPool, automine, minGasPrice, initialBlockTimeOffset, mempoolOrder, config.coinbase, genesisAccounts, tracingConfig, forkNetworkId, nextBlockBaseFeePerGas);
+        const node = new HardhatNode(vm, stateManager, blockchain, txPool, automine, minGasPrice, initialBlockTimeOffset, mempoolOrder, config.coinbase, genesisAccounts, networkId, chainId, hardforkActivations, tracingConfig, forkNetworkId, forkBlockNum, nextBlockBaseFeePerGas);
         return [common, node];
     }
     static _validateHardforks(forkBlockNumber, common, remoteChainId) {
@@ -179,7 +195,7 @@ The hardfork must be at least spuriousDragon, but ${common.hardfork()} was given
             try {
                 upstreamCommon = new common_1.default({ chain: remoteChainId });
             }
-            catch (error) {
+            catch (_a) {
                 // 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.
@@ -194,7 +210,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         }
     }
     async getSignedTransaction(txParams) {
-        const senderAddress = ethereumjs_util_1.bufferToHex(txParams.from);
+        const senderAddress = (0, ethereumjs_util_1.bufferToHex)(txParams.from);
         const pk = this._localAccounts.get(senderAddress);
         if (pk !== undefined) {
             let tx;
@@ -240,14 +256,18 @@ Hardhat Network's forking functionality only works with blocks from at least spu
             result = await this._mineBlockWithPendingTxs(blockTimestamp);
         }
         catch (err) {
-            if (err === null || err === void 0 ? void 0 : 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
-            if (errors_1.HardhatError.isHardhatError(err)) {
-                throw err;
+            if (err instanceof Error) {
+                if (err === null || err === void 0 ? void 0 : 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
+                if (errors_1.HardhatError.isHardhatError(err)) {
+                    throw err;
+                }
+                throw new errors_2.TransactionExecutionError(err);
             }
-            throw new errors_2.TransactionExecutionError(err);
+            // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
+            throw err;
         }
         await this._saveBlockAsSuccessfullyRun(result.block, result.blockResult);
         if (needsTimestampIncrease) {
@@ -264,7 +284,8 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         var _a, _b, _c, _d;
         let txParams;
         const nonce = await this._getNonce(new ethereumjs_util_1.Address(call.from), blockNumberOrPending);
-        if (call.gasPrice !== undefined || !this.isEip1559Active()) {
+        if (call.gasPrice !== undefined ||
+            !this.isEip1559Active(blockNumberOrPending)) {
             txParams = Object.assign({ gasPrice: new ethereumjs_util_1.BN(0), nonce }, call);
         }
         else {
@@ -295,8 +316,8 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     }
     async getCodeFromTrace(trace, blockNumberOrPending) {
         if (trace === undefined ||
-            message_trace_1.isPrecompileTrace(trace) ||
-            message_trace_1.isCreateTrace(trace)) {
+            (0, message_trace_1.isPrecompileTrace)(trace) ||
+            (0, message_trace_1.isCreateTrace)(trace)) {
             return Buffer.from("");
         }
         return this.getCode(new ethereumjs_util_1.Address(trace.address), blockNumberOrPending);
@@ -458,19 +479,19 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         return (_a = this._txPool.getTransactionByHash(hash)) === null || _a === void 0 ? void 0 : _a.data;
     }
     async getTransactionReceipt(hash) {
-        const hashBuffer = hash instanceof Buffer ? hash : ethereumjs_util_1.toBuffer(hash);
+        const hashBuffer = hash instanceof Buffer ? hash : (0, ethereumjs_util_1.toBuffer)(hash);
         const receipt = await this._blockchain.getTransactionReceipt(hashBuffer);
         return receipt !== null && receipt !== void 0 ? receipt : undefined;
     }
     async getPendingTransactions() {
-        const txPoolPending = txMapToArray_1.txMapToArray(this._txPool.getPendingTransactions());
-        const txPoolQueued = txMapToArray_1.txMapToArray(this._txPool.getQueuedTransactions());
+        const txPoolPending = (0, txMapToArray_1.txMapToArray)(this._txPool.getPendingTransactions());
+        const txPoolQueued = (0, txMapToArray_1.txMapToArray)(this._txPool.getQueuedTransactions());
         return txPoolPending.concat(txPoolQueued);
     }
     async signPersonalMessage(address, data) {
-        const messageHash = ethereumjs_util_1.hashPersonalMessage(data);
+        const messageHash = (0, ethereumjs_util_1.hashPersonalMessage)(data);
         const privateKey = this._getLocalAccountPrivateKey(address);
-        return ethereumjs_util_1.ecsign(messageHash, privateKey);
+        return (0, ethereumjs_util_1.ecsign)(messageHash, privateKey);
     }
     async signTypedDataV4(address, typedData) {
         const privateKey = this._getLocalAccountPrivateKey(address);
@@ -562,7 +583,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: [ethereumjs_util_1.bufferToHex(block.header.hash())],
+            hashes: [(0, ethereumjs_util_1.bufferToHex)(block.header.hash())],
             logs: [],
             subscription: isSubscription,
         });
@@ -631,7 +652,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     async addCompilationResult(solcVersion, compilerInput, compilerOutput) {
         let bytecodes;
         try {
-            bytecodes = compiler_to_model_1.createModelsAndDecodeBytecodes(solcVersion, compilerInput, compilerOutput);
+            bytecodes = (0, compiler_to_model_1.createModelsAndDecodeBytecodes)(solcVersion, compilerInput, compilerOutput);
         }
         catch (error) {
             console.warn(chalk_1.default.yellow("The Hardhat Network tracing engine could not be updated. Run Hardhat with --verbose to learn more."));
@@ -644,11 +665,11 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         return true;
     }
     addImpersonatedAccount(address) {
-        this._impersonatedAccounts.add(ethereumjs_util_1.bufferToHex(address));
+        this._impersonatedAccounts.add((0, ethereumjs_util_1.bufferToHex)(address));
         return true;
     }
     removeImpersonatedAccount(address) {
-        return this._impersonatedAccounts.delete(ethereumjs_util_1.bufferToHex(address));
+        return this._impersonatedAccounts.delete((0, ethereumjs_util_1.bufferToHex)(address));
     }
     setAutomine(automine) {
         this._automine = automine;
@@ -670,7 +691,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 ${ethereumjs_util_1.bufferToHex(hash)} cannot be dropped because it's already mined`);
+            throw new errors_2.InvalidArgumentsError(`Transaction ${(0, ethereumjs_util_1.bufferToHex)(hash)} cannot be dropped because it's already mined`);
         }
         return false;
     }
@@ -703,7 +724,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 ${ethereumjs_util_1.bufferToHex(hash)}`);
+            throw new errors_2.InvalidInputError(`Unable to find a block containing transaction ${(0, ethereumjs_util_1.bufferToHex)(hash)}`);
         }
         return this._runInBlockContext(new ethereumjs_util_1.BN(block.header.number).subn(1), async () => {
             const blockNumber = block.header.number.toNumber();
@@ -711,8 +732,8 @@ Hardhat Network's forking functionality only works with blocks from at least spu
             let vm = this._vm;
             if (blockchain instanceof ForkBlockchain_1.ForkBlockchain &&
                 blockNumber <= blockchain.getForkBlockNumber().toNumber()) {
-                errors_1.assertHardhatInvariant(this._forkNetworkId !== undefined, "this._forkNetworkId should exist if the blockchain is an instance of ForkBlockchain");
-                const common = getCommonForTracing(this._forkNetworkId, blockNumber);
+                (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({
                     common,
                     activatePrecompiles: true,
@@ -805,7 +826,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
                 baseFeePerGas.push(pendingBlock.header.calcNextBaseFee());
             }
             else {
-                errors_1.assertHardhatInvariant(false, "This should never happen");
+                (0, errors_1.assertHardhatInvariant)(false, "This should never happen");
             }
         }
         return {
@@ -851,7 +872,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
             }
             return {
                 effectiveGasReward,
-                gasUsed: base_types_1.rpcQuantityToBN(r === null || r === void 0 ? void 0 : r.gasUsed),
+                gasUsed: (0, base_types_1.rpcQuantityToBN)(r === null || r === void 0 ? void 0 : r.gasUsed),
             };
         })
             .sort((a, b) => a.effectiveGasReward.cmp(b.effectiveGasReward));
@@ -873,7 +894,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 ethereumjs_util_1.bufferToHex(tx.hash());
+        return (0, ethereumjs_util_1.bufferToHex)(tx.hash());
     }
     async _mineTransaction(tx) {
         await this._addPendingTransaction(tx);
@@ -929,7 +950,11 @@ Hardhat Network's forking functionality only works with blocks from at least spu
             sender = tx.getSenderAddress(); // verifies signature as a side effect
         }
         catch (e) {
-            throw new errors_2.InvalidInputError(e.message);
+            if (e instanceof Error) {
+                throw new errors_2.InvalidInputError(e.message);
+            }
+            // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
+            throw e;
         }
         // validate nonce
         const nextPendingNonce = await this._txPool.getNextPendingNonce(sender);
@@ -1064,9 +1089,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) => ethereumjs_util_1.toBuffer(acc.privateKey));
+        const privateKeys = genesisAccounts.map((acc) => (0, ethereumjs_util_1.toBuffer)(acc.privateKey));
         for (const pk of privateKeys) {
-            this._localAccounts.set(ethereumjs_util_1.bufferToHex(ethereumjs_util_1.privateToAddress(pk)), pk);
+            this._localAccounts.set((0, ethereumjs_util_1.bufferToHex)((0, ethereumjs_util_1.privateToAddress)(pk)), pk);
         }
     }
     async _getConsoleLogMessages(vmTrace, vmTracerError) {
@@ -1104,7 +1129,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         if (error.error === exceptions_1.ERROR.OUT_OF_GAS) {
             if (stackTrace !== undefined &&
                 this._isContractTooLargeStackTrace(stackTrace)) {
-                return solidity_errors_1.encodeSolidityStackTrace("Transaction ran out of gas", stackTrace);
+                return (0, solidity_errors_1.encodeSolidityStackTrace)("Transaction ran out of gas", stackTrace);
             }
             return new errors_2.TransactionExecutionError("Transaction ran out of gas");
         }
@@ -1126,12 +1151,12 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         if (error.error === exceptions_1.ERROR.REVERT) {
             const fallbackMessage = `VM Exception while processing transaction: revert ${returnDataExplanation}`;
             if (stackTrace !== undefined) {
-                return solidity_errors_1.encodeSolidityStackTrace(fallbackMessage, stackTrace);
+                return (0, solidity_errors_1.encodeSolidityStackTrace)(fallbackMessage, stackTrace);
             }
             return new errors_2.TransactionExecutionError(fallbackMessage);
         }
         if (stackTrace !== undefined) {
-            return solidity_errors_1.encodeSolidityStackTrace(`Transaction failed: revert ${returnDataExplanation}`, stackTrace);
+            return (0, solidity_errors_1.encodeSolidityStackTrace)(`Transaction failed: revert ${returnDataExplanation}`, stackTrace);
         }
         return new errors_2.TransactionExecutionError(`Transaction reverted ${returnDataExplanation}`);
     }
@@ -1144,7 +1169,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         let blockTimestamp;
         let offsetShouldChange;
         let newOffset = new ethereumjs_util_1.BN(0);
-        const currentTimestamp = new ethereumjs_util_1.BN(getCurrentTimestamp_1.getCurrentTimestamp());
+        const currentTimestamp = new ethereumjs_util_1.BN((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.
@@ -1173,7 +1198,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 = ethereumjs_util_1.bufferToHex(tx.hash());
+                const hash = (0, ethereumjs_util_1.bufferToHex)(tx.hash());
                 if (filter.subscription) {
                     this._emitEthEvent(filter.id, hash);
                     return;
@@ -1194,7 +1219,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 = output_1.getRpcReceiptOutputsFromLocalBlockExecution(block, runBlockResult, 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 = [];
@@ -1209,14 +1234,14 @@ 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, output_1.getRpcBlock(block, td, 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(ethereumjs_util_1.bufferToHex(hash));
+                    filter.hashes.push((0, ethereumjs_util_1.bufferToHex)(hash));
                     break;
                 case filter_1.Type.LOGS_SUBSCRIPTION:
-                    if (filter_1.bloomFilter(new bloom_1.default(block.header.bloom), filter.criteria.addresses, filter.criteria.normalizedTopics)) {
-                        const logs = filter_1.filterLogs(rpcLogs, filter.criteria);
+                    if ((0, filter_1.bloomFilter)(new bloom_1.default(block.header.bloom), filter.criteria.addresses, filter.criteria.normalizedTopics)) {
+                        const logs = (0, filter_1.filterLogs)(rpcLogs, filter.criteria);
                         if (logs.length === 0) {
                             return;
                         }
@@ -1339,8 +1364,10 @@ Hardhat Network's forking functionality only works with blocks from at least spu
      * makes.
      */
     async _runTxAndRevertMutations(tx, blockNumberOrPending, forceBaseFeeZero = false) {
+        var _a, _b;
         const initialStateRoot = await this._stateManager.getStateRoot();
         let blockContext;
+        let originalCommon;
         try {
             if (blockNumberOrPending === "pending") {
                 // the new block has already been mined by _runInBlockContext hence we take latest here
@@ -1350,7 +1377,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
                 // We know that this block number exists, because otherwise
                 // there would be an error in the RPC layer.
                 const block = await this.getBlockByNumber(blockNumberOrPending);
-                errors_1.assertHardhatInvariant(block !== undefined, "Tried to run a tx in the context of a non-existent block");
+                (0, errors_1.assertHardhatInvariant)(block !== undefined, "Tried to run a tx in the context of a non-existent block");
                 blockContext = block;
                 // we don't need to add the tx to the block because runTx doesn't
                 // know anything about the txs in the current block
@@ -1368,7 +1395,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
             // we don't want to debit any balance nor fail any tx when running an
             // eth_call. This will make the BASEFEE option also return 0, which
             // shouldn't. See: https://github.com/nomiclabs/hardhat/issues/1688
-            if (this.isEip1559Active() &&
+            if (this.isEip1559Active(blockNumberOrPending) &&
                 (blockContext.header.baseFeePerGas === undefined || forceBaseFeeZero)) {
                 blockContext = block_1.Block.fromBlockData(blockContext, {
                     freeze: false,
@@ -1376,6 +1403,11 @@ Hardhat Network's forking functionality only works with blocks from at least spu
                 });
                 blockContext.header.baseFeePerGas = new ethereumjs_util_1.BN(0);
             }
+            originalCommon = this._vm._common;
+            this._vm._common = new common_1.default({
+                chain: Object.assign(Object.assign({}, this._vm._common["_chainParams"]), { chainId: (_a = this._forkNetworkId) !== null && _a !== void 0 ? _a : this._configChainId, networkId: (_b = this._forkNetworkId) !== null && _b !== void 0 ? _b : this._configNetworkId }),
+                hardfork: this._selectHardfork(blockContext.header.number),
+            });
             return await this._vm.runTx({
                 block: blockContext,
                 tx,
@@ -1385,6 +1417,9 @@ Hardhat Network's forking functionality only works with blocks from at least spu
             });
         }
         finally {
+            if (originalCommon !== undefined) {
+                this._vm._common = originalCommon;
+            }
             await this._stateManager.setStateRoot(initialStateRoot);
         }
     }
@@ -1447,12 +1482,17 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     async _persistIrregularWorldState() {
         this._irregularStatesByBlockNumber.set((await this.getLatestBlock()).header.number.toString(), await this._stateManager.getStateRoot());
     }
-    isEip1559Active() {
+    isEip1559Active(blockNumberOrPending) {
+        if (blockNumberOrPending !== undefined &&
+            blockNumberOrPending !== "pending") {
+            return this._vm._common.hardforkGteHardfork(this._selectHardfork(blockNumberOrPending), "london");
+        }
         return this._vm._common.gteHardfork("london");
     }
     async _getEstimateGasFeePriceFields(callParams, blockNumberOrPending) {
         var _a, _b;
-        if (!this.isEip1559Active() || callParams.gasPrice !== undefined) {
+        if (!this.isEip1559Active(blockNumberOrPending) ||
+            callParams.gasPrice !== undefined) {
             return { gasPrice: (_a = callParams.gasPrice) !== null && _a !== void 0 ? _a : (await this.getGasPrice()) };
         }
         let maxFeePerGas = callParams.maxFeePerGas;
@@ -1475,16 +1515,41 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         }
         return { maxFeePerGas, maxPriorityFeePerGas };
     }
-}
-exports.HardhatNode = HardhatNode;
-function getCommonForTracing(networkId, blockNumber) {
-    try {
-        const common = new common_1.default({ chain: networkId });
-        common.setHardfork(common.activeHardfork(blockNumber));
-        return common;
+    _selectHardfork(blockNumber) {
+        if (this._forkBlockNumber === undefined ||
+            blockNumber.gte(new ethereumjs_util_1.BN(this._forkBlockNumber))) {
+            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/hardhat-network/guides/mainnet-forking.html#using-a-custom-hardfork-history`);
+        }
+        /** search this._hardforkActivations for the highest block number that
+         * 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)
+            ? [thisHardfork, thisBlock]
+            : [highestHardfork, highestBlock]);
+        if (hardfork === undefined || blockNumber.ltn(activationBlock)) {
+            throw new errors_2.InternalError(`Could not find a hardfork to run for block ${blockNumber}, 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)) {
+            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;
     }
-    catch (e) {
-        throw new errors_2.InternalError(`Network id ${networkId} does not correspond to a network that Hardhat can trace`);
+    _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)),
+            });
+            return common;
+        }
+        catch (_a) {
+            throw new errors_2.InternalError(`Network id ${networkId} does not correspond to a network that Hardhat can trace`);
+        }
     }
 }
+exports.HardhatNode = HardhatNode;
 //# sourceMappingURL=node.js.map