hardhat 2.6.8 → 2.8.0

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

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HardhatNode = exports.COINBASE_ADDRESS = void 0;
+exports.HardhatNode = void 0;
 const block_1 = require("@ethereumjs/block");
 const common_1 = __importDefault(require("@ethereumjs/common"));
 const tx_1 = require("@ethereumjs/tx");
@@ -14,6 +14,7 @@ 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");
@@ -51,12 +52,11 @@ const makeForkClient_1 = require("./utils/makeForkClient");
 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");
-exports.COINBASE_ADDRESS = ethereumjs_util_1.Address.fromString("0xc014ba5ec014ba5ec014ba5ec014ba5ec014ba5e");
 /* 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), 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;
@@ -65,7 +65,13 @@ class HardhatNode extends events_1.default {
         this._automine = _automine;
         this._minGasPrice = _minGasPrice;
         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);
@@ -90,7 +96,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);
                 }
@@ -99,37 +105,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, } = 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;
                 }
@@ -140,18 +151,22 @@ 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);
+            common = (0, makeCommon_1.makeCommon)(config, initialStateRoot);
             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;
@@ -164,7 +179,7 @@ class HardhatNode extends events_1.default {
             blockchain: blockchain,
             allowUnlimitedContractSize,
         });
-        const node = new HardhatNode(vm, stateManager, blockchain, txPool, automine, minGasPrice, initialBlockTimeOffset, 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) {
@@ -178,7 +193,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.
@@ -193,7 +208,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;
@@ -239,14 +254,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) {
@@ -263,7 +282,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 {
@@ -294,8 +314,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);
@@ -385,7 +405,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         return new ethereumjs_util_1.BN(default_config_1.HARDHAT_NETWORK_DEFAULT_MAX_PRIORITY_FEE_PER_GAS);
     }
     getCoinbaseAddress() {
-        return exports.COINBASE_ADDRESS;
+        return ethereumjs_util_1.Address.fromString(this._coinbase);
     }
     async getStorageAt(address, positionIndex, blockNumberOrPending) {
         const key = positionIndex.toArrayLike(Buffer, "be", 32);
@@ -457,19 +477,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);
@@ -492,6 +512,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
             nextBlockTimestamp: this.getNextBlockTimestamp(),
             irregularStatesByBlockNumber: this._irregularStatesByBlockNumber,
             userProvidedNextBlockBaseFeePerGas: this.getUserProvidedNextBlockBaseFeePerGas(),
+            coinbase: this.getCoinbaseAddress().toString(),
         };
         this._irregularStatesByBlockNumber = new Map(this._irregularStatesByBlockNumber);
         this._snapshots.push(snapshot);
@@ -528,6 +549,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         else {
             this._resetUserProvidedNextBlockBaseFeePerGas();
         }
+        this._coinbase = snapshot.coinbase;
         // We delete this and the following snapshots, as they can only be used
         // once in Ganache
         this._snapshots.splice(snapshotIndex);
@@ -559,7 +581,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,
         });
@@ -628,7 +650,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."));
@@ -641,11 +663,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;
@@ -667,7 +689,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;
     }
@@ -700,7 +722,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();
@@ -708,8 +730,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,
@@ -802,7 +824,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 {
@@ -812,6 +834,9 @@ Hardhat Network's forking functionality only works with blocks from at least spu
             reward: rewardPercentiles.length > 0 ? reward : undefined,
         };
     }
+    async setCoinbase(coinbase) {
+        this._coinbase = coinbase.toString();
+    }
     _getGasUsedRatio(block) {
         const FLOATS_PRECISION = 100000;
         return (block.header.gasUsed
@@ -845,7 +870,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));
@@ -867,7 +892,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);
@@ -923,7 +948,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);
@@ -980,7 +1009,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
             const blockGasLimit = this.getBlockGasLimit();
             const minTxFee = this._getMinimalTransactionFee();
             const pendingTxs = this._txPool.getPendingTransactions();
-            const transactionQueue = new TransactionQueue_1.TransactionQueue(pendingTxs, headerData.baseFeePerGas);
+            const transactionQueue = new TransactionQueue_1.TransactionQueue(pendingTxs, this._mempoolOrder, headerData.baseFeePerGas);
             let tx = transactionQueue.getNextTransaction();
             const results = [];
             const receipts = [];
@@ -1058,9 +1087,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) {
@@ -1098,7 +1127,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");
         }
@@ -1120,12 +1149,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}`);
     }
@@ -1138,7 +1167,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.
@@ -1167,7 +1196,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;
@@ -1188,7 +1217,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 = [];
@@ -1203,14 +1232,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;
                         }
@@ -1333,8 +1362,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
@@ -1344,7 +1375,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
@@ -1362,7 +1393,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,
@@ -1370,6 +1401,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,
@@ -1379,6 +1415,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);
         }
     }
@@ -1441,12 +1480,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;
@@ -1469,16 +1513,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