hardhat 2.6.6 → 2.7.1

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");
@@ -51,12 +51,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, tracingConfig, _forkNetworkId, nextBlockBaseFee) {
         super();
         this._vm = _vm;
         this._stateManager = _stateManager;
@@ -65,6 +64,8 @@ class HardhatNode extends events_1.default {
         this._automine = _automine;
         this._minGasPrice = _minGasPrice;
         this._blockTimeOffsetSeconds = _blockTimeOffsetSeconds;
+        this._mempoolOrder = _mempoolOrder;
+        this._coinbase = _coinbase;
         this._forkNetworkId = _forkNetworkId;
         this._localAccounts = new Map(); // address => private key
         this._impersonatedAccounts = new Set(); // address
@@ -90,7 +91,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,11 +100,13 @@ 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, } = config;
         let common;
         let stateManager;
         let blockchain;
@@ -113,23 +116,23 @@ class HardhatNode extends events_1.default {
         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();
             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;
                 }
@@ -145,13 +148,14 @@ class HardhatNode extends events_1.default {
             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 +168,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, tracingConfig, forkNetworkId, nextBlockBaseFeePerGas);
         return [common, node];
     }
     static _validateHardforks(forkBlockNumber, common, remoteChainId) {
@@ -178,7 +182,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 +197,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 +243,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) {
@@ -294,8 +302,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 +393,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 +465,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 +500,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 +537,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 +569,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 +638,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,15 +651,18 @@ 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;
     }
+    getAutomine() {
+        return this._automine;
+    }
     async setBlockGasLimit(gasLimit) {
         this._txPool.setBlockGasLimit(gasLimit);
         await this._txPool.updatePendingAndQueued();
@@ -664,7 +677,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;
     }
@@ -697,7 +710,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();
@@ -705,7 +718,7 @@ 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");
+                (0, errors_1.assertHardhatInvariant)(this._forkNetworkId !== undefined, "this._forkNetworkId should exist if the blockchain is an instance of ForkBlockchain");
                 const common = getCommonForTracing(this._forkNetworkId, blockNumber);
                 vm = new vm_1.default({
                     common,
@@ -799,7 +812,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 {
@@ -809,6 +822,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
@@ -824,31 +840,47 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         const receipts = await Promise.all(block.transactions
             .map((tx) => tx.hash())
             .map((hash) => this.getTransactionReceipt(hash)));
-        const effectiveGasPriceAndGas = receipts
-            .map((r) => ({
-            effectiveGasPrice: base_types_1.rpcQuantityToBN(r === null || r === void 0 ? void 0 : r.effectiveGasPrice),
-            gasUsed: base_types_1.rpcQuantityToBN(r === null || r === void 0 ? void 0 : r.gasUsed),
-        }))
-            .sort((a, b) => a.effectiveGasPrice.cmp(b.effectiveGasPrice));
+        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);
+            // reward = min(maxPriorityFeePerGas, maxFeePerGas - baseFeePerGas)
+            let effectiveGasReward;
+            if ("maxPriorityFeePerGas" in tx) {
+                effectiveGasReward = tx.maxFeePerGas.sub(baseFeePerGas);
+                if (tx.maxPriorityFeePerGas.lt(effectiveGasReward)) {
+                    effectiveGasReward = tx.maxPriorityFeePerGas;
+                }
+            }
+            else {
+                effectiveGasReward = tx.gasPrice.sub(baseFeePerGas);
+            }
+            return {
+                effectiveGasReward,
+                gasUsed: (0, base_types_1.rpcQuantityToBN)(r === null || r === void 0 ? void 0 : r.gasUsed),
+            };
+        })
+            .sort((a, b) => a.effectiveGasReward.cmp(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);
-            for (const values of effectiveGasPriceAndGas) {
+            for (const values of effectiveGasRewardAndGas) {
                 gasUsed = gasUsed.add(values.gasUsed);
                 if (targetGas.lte(gasUsed)) {
-                    return values.effectiveGasPrice;
+                    return values.effectiveGasReward;
                 }
             }
-            return effectiveGasPriceAndGas[effectiveGasPriceAndGas.length - 1]
-                .effectiveGasPrice;
+            return effectiveGasRewardAndGas[effectiveGasRewardAndGas.length - 1]
+                .effectiveGasReward;
         });
     }
     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);
@@ -904,7 +936,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);
@@ -961,7 +997,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 = [];
@@ -1039,9 +1075,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) {
@@ -1079,7 +1115,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");
         }
@@ -1101,12 +1137,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}`);
     }
@@ -1119,7 +1155,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.
@@ -1148,7 +1184,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;
@@ -1169,7 +1205,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 = [];
@@ -1184,14 +1220,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;
                         }
@@ -1325,7 +1361,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
@@ -1458,7 +1494,7 @@ function getCommonForTracing(networkId, blockNumber) {
         common.setHardfork(common.activeHardfork(blockNumber));
         return common;
     }
-    catch (e) {
+    catch (_a) {
         throw new errors_2.InternalError(`Network id ${networkId} does not correspond to a network that Hardhat can trace`);
     }
 }