@metamask-previews/transaction-controller 8.0.1-preview.d32a7cc

package/dist/TransactionController.js

@@ -0,0 +1,887 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionController = exports.SPEED_UP_RATE = exports.CANCEL_RATE = exports.HARDFORK = void 0;
+const common_1 = require("@ethereumjs/common");
+const tx_1 = require("@ethereumjs/tx");
+const base_controller_1 = require("@metamask/base-controller");
+const controller_utils_1 = require("@metamask/controller-utils");
+const eth_query_1 = __importDefault(require("@metamask/eth-query"));
+const async_mutex_1 = require("async-mutex");
+const eth_method_registry_1 = __importDefault(require("eth-method-registry"));
+const eth_rpc_errors_1 = require("eth-rpc-errors");
+const ethereumjs_util_1 = require("ethereumjs-util");
+const events_1 = require("events");
+const nonce_tracker_1 = __importDefault(require("nonce-tracker"));
+const uuid_1 = require("uuid");
+const EtherscanRemoteTransactionSource_1 = require("./EtherscanRemoteTransactionSource");
+const IncomingTransactionHelper_1 = require("./IncomingTransactionHelper");
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+exports.HARDFORK = common_1.Hardfork.London;
+/**
+ * Multiplier used to determine a transaction's increased gas fee during cancellation
+ */
+exports.CANCEL_RATE = 1.5;
+/**
+ * Multiplier used to determine a transaction's increased gas fee during speed up
+ */
+exports.SPEED_UP_RATE = 1.1;
+/**
+ * The name of the {@link TransactionController}.
+ */
+const controllerName = 'TransactionController';
+/**
+ * Controller responsible for submitting and managing transactions.
+ */
+class TransactionController extends base_controller_1.BaseController {
+    /**
+     * Creates a TransactionController instance.
+     *
+     * @param options - The controller options.
+     * @param options.blockTracker - The block tracker used to poll for new blocks data.
+     * @param options.getNetworkState - Gets the state of the network controller.
+     * @param options.getSelectedAddress - Gets the address of the currently selected account.
+     * @param options.incomingTransactions - Configuration options for incoming transaction support.
+     * @param options.incomingTransactions.apiKey - An optional API key to use when fetching remote transaction data.
+     * @param options.incomingTransactions.includeTokenTransfers - Whether or not to include ERC20 token transfers.
+     * @param options.incomingTransactions.isEnabled - Whether or not incoming transaction retrieval is enabled.
+     * @param options.incomingTransactions.updateTransactions - Whether or not to update local transactions using remote transaction data.
+     * @param options.messenger - The controller messenger.
+     * @param options.onNetworkStateChange - Allows subscribing to network controller state changes.
+     * @param options.provider - The provider used to create the underlying EthQuery instance.
+     * @param config - Initial options used to configure this controller.
+     * @param state - Initial state to set on this controller.
+     */
+    constructor({ blockTracker, getNetworkState, getSelectedAddress, incomingTransactions = {}, messenger, onNetworkStateChange, provider, }, config, state) {
+        super(config, state);
+        this.mutex = new async_mutex_1.Mutex();
+        /**
+         * EventEmitter instance used to listen to specific transactional events
+         */
+        this.hub = new events_1.EventEmitter();
+        /**
+         * Name of this controller used during composition
+         */
+        this.name = 'TransactionController';
+        this.defaultConfig = {
+            interval: 15000,
+            txHistoryLimit: 40,
+        };
+        this.defaultState = {
+            methodData: {},
+            transactions: [],
+            lastFetchedBlockNumbers: {},
+        };
+        this.initialize();
+        this.provider = provider;
+        this.messagingSystem = messenger;
+        this.getNetworkState = getNetworkState;
+        this.ethQuery = new eth_query_1.default(provider);
+        this.registry = new eth_method_registry_1.default({ provider });
+        this.nonceTracker = new nonce_tracker_1.default({
+            provider,
+            blockTracker,
+            getPendingTransactions: (address) => (0, utils_1.getAndFormatTransactionsForNonceTracker)(address, types_1.TransactionStatus.submitted, this.state.transactions),
+            getConfirmedTransactions: (address) => (0, utils_1.getAndFormatTransactionsForNonceTracker)(address, types_1.TransactionStatus.confirmed, this.state.transactions),
+        });
+        this.incomingTransactionHelper = new IncomingTransactionHelper_1.IncomingTransactionHelper({
+            blockTracker,
+            getCurrentAccount: getSelectedAddress,
+            getNetworkState,
+            isEnabled: incomingTransactions.isEnabled,
+            remoteTransactionSource: new EtherscanRemoteTransactionSource_1.EtherscanRemoteTransactionSource({
+                apiKey: incomingTransactions.apiKey,
+                includeTokenTransfers: incomingTransactions.includeTokenTransfers,
+            }),
+            transactionLimit: this.config.txHistoryLimit,
+            updateTransactions: incomingTransactions.updateTransactions,
+        });
+        this.incomingTransactionHelper.hub.on('transactions', this.onIncomingTransactions.bind(this));
+        this.incomingTransactionHelper.hub.on('updatedLastFetchedBlockNumbers', this.onUpdatedLastFetchedBlockNumbers.bind(this));
+        onNetworkStateChange(() => {
+            this.ethQuery = new eth_query_1.default(this.provider);
+            this.registry = new eth_method_registry_1.default({ provider: this.provider });
+        });
+        this.poll();
+    }
+    failTransaction(transactionMeta, error) {
+        const newTransactionMeta = Object.assign(Object.assign({}, transactionMeta), { error, status: types_1.TransactionStatus.failed });
+        this.updateTransaction(newTransactionMeta);
+        this.hub.emit(`${transactionMeta.id}:finished`, newTransactionMeta);
+    }
+    registryLookup(fourBytePrefix) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const registryMethod = yield this.registry.lookup(fourBytePrefix);
+            const parsedRegistryMethod = this.registry.parse(registryMethod);
+            return { registryMethod, parsedRegistryMethod };
+        });
+    }
+    /**
+     * Starts a new polling interval.
+     *
+     * @param interval - The polling interval used to fetch new transaction statuses.
+     */
+    poll(interval) {
+        return __awaiter(this, void 0, void 0, function* () {
+            interval && this.configure({ interval }, false, false);
+            this.handle && clearTimeout(this.handle);
+            yield (0, controller_utils_1.safelyExecute)(() => this.queryTransactionStatuses());
+            this.handle = setTimeout(() => {
+                this.poll(this.config.interval);
+            }, this.config.interval);
+        });
+    }
+    /**
+     * Handle new method data request.
+     *
+     * @param fourBytePrefix - The method prefix.
+     * @returns The method data object corresponding to the given signature prefix.
+     */
+    handleMethodData(fourBytePrefix) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const releaseLock = yield this.mutex.acquire();
+            try {
+                const { methodData } = this.state;
+                const knownMethod = Object.keys(methodData).find((knownFourBytePrefix) => fourBytePrefix === knownFourBytePrefix);
+                if (knownMethod) {
+                    return methodData[fourBytePrefix];
+                }
+                const registry = yield this.registryLookup(fourBytePrefix);
+                this.update({
+                    methodData: Object.assign(Object.assign({}, methodData), { [fourBytePrefix]: registry }),
+                });
+                return registry;
+            }
+            finally {
+                releaseLock();
+            }
+        });
+    }
+    /**
+     * Add a new unapproved transaction to state. Parameters will be validated, a
+     * unique transaction id will be generated, and gas and gasPrice will be calculated
+     * if not provided. If A `<tx.id>:unapproved` hub event will be emitted once added.
+     *
+     * @param transaction - The transaction object to add.
+     * @param opts - Additional options to control how the transaction is added.
+     * @param opts.deviceConfirmedOn - An enum to indicate what device confirmed the transaction.
+     * @param opts.origin - The origin of the transaction request, such as a dApp hostname.
+     * @param opts.requireApproval - Whether the transaction requires approval by the user, defaults to true unless explicitly disabled.
+     * @returns Object containing a promise resolving to the transaction hash if approved.
+     */
+    addTransaction(transaction, { deviceConfirmedOn, origin, requireApproval, } = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { chainId, networkId } = this.getChainAndNetworkId();
+            const { transactions } = this.state;
+            transaction = (0, utils_1.normalizeTransaction)(transaction);
+            (0, utils_1.validateTransaction)(transaction);
+            const transactionMeta = {
+                id: (0, uuid_1.v1)(),
+                networkID: networkId !== null && networkId !== void 0 ? networkId : undefined,
+                chainId,
+                origin,
+                status: types_1.TransactionStatus.unapproved,
+                time: Date.now(),
+                transaction,
+                deviceConfirmedOn,
+                verifiedOnBlockchain: false,
+            };
+            try {
+                const { gas, estimateGasError } = yield this.estimateGas(transaction);
+                transaction.gas = gas;
+                transaction.estimateGasError = estimateGasError;
+            }
+            catch (error) {
+                this.failTransaction(transactionMeta, error);
+                return Promise.reject(error);
+            }
+            transactions.push(transactionMeta);
+            this.update({ transactions: this.trimTransactionsForState(transactions) });
+            this.hub.emit(`unapprovedTransaction`, transactionMeta);
+            return {
+                result: this.processApproval(transactionMeta, {
+                    requireApproval,
+                }),
+                transactionMeta,
+            };
+        });
+    }
+    startIncomingTransactionPolling() {
+        this.incomingTransactionHelper.start();
+    }
+    stopIncomingTransactionPolling() {
+        this.incomingTransactionHelper.stop();
+    }
+    updateIncomingTransactions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.incomingTransactionHelper.update();
+        });
+    }
+    /**
+     * Creates approvals for all unapproved transactions persisted.
+     */
+    initApprovals() {
+        const { networkId, chainId } = this.getChainAndNetworkId();
+        const unapprovedTxs = this.state.transactions.filter((transaction) => transaction.status === types_1.TransactionStatus.unapproved &&
+            (0, utils_1.transactionMatchesNetwork)(transaction, chainId, networkId));
+        for (const txMeta of unapprovedTxs) {
+            this.processApproval(txMeta, {
+                shouldShowRequest: false,
+            }).catch((error) => {
+                /* istanbul ignore next */
+                console.error('Error during persisted transaction approval', error);
+            });
+        }
+    }
+    /**
+     * Attempts to cancel a transaction based on its ID by setting its status to "rejected"
+     * and emitting a `<tx.id>:finished` hub event.
+     *
+     * @param transactionID - The ID of the transaction to cancel.
+     * @param gasValues - The gas values to use for the cancellation transaction.
+     */
+    stopTransaction(transactionID, gasValues) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (gasValues) {
+                (0, utils_1.validateGasValues)(gasValues);
+            }
+            const transactionMeta = this.state.transactions.find(({ id }) => id === transactionID);
+            if (!transactionMeta) {
+                return;
+            }
+            if (!this.sign) {
+                throw new Error('No sign method defined.');
+            }
+            // gasPrice (legacy non EIP1559)
+            const minGasPrice = (0, utils_1.getIncreasedPriceFromExisting)(transactionMeta.transaction.gasPrice, exports.CANCEL_RATE);
+            const gasPriceFromValues = (0, utils_1.isGasPriceValue)(gasValues) && gasValues.gasPrice;
+            const newGasPrice = (gasPriceFromValues &&
+                (0, utils_1.validateMinimumIncrease)(gasPriceFromValues, minGasPrice)) ||
+                minGasPrice;
+            // maxFeePerGas (EIP1559)
+            const existingMaxFeePerGas = (_a = transactionMeta.transaction) === null || _a === void 0 ? void 0 : _a.maxFeePerGas;
+            const minMaxFeePerGas = (0, utils_1.getIncreasedPriceFromExisting)(existingMaxFeePerGas, exports.CANCEL_RATE);
+            const maxFeePerGasValues = (0, utils_1.isFeeMarketEIP1559Values)(gasValues) && gasValues.maxFeePerGas;
+            const newMaxFeePerGas = (maxFeePerGasValues &&
+                (0, utils_1.validateMinimumIncrease)(maxFeePerGasValues, minMaxFeePerGas)) ||
+                (existingMaxFeePerGas && minMaxFeePerGas);
+            // maxPriorityFeePerGas (EIP1559)
+            const existingMaxPriorityFeePerGas = (_b = transactionMeta.transaction) === null || _b === void 0 ? void 0 : _b.maxPriorityFeePerGas;
+            const minMaxPriorityFeePerGas = (0, utils_1.getIncreasedPriceFromExisting)(existingMaxPriorityFeePerGas, exports.CANCEL_RATE);
+            const maxPriorityFeePerGasValues = (0, utils_1.isFeeMarketEIP1559Values)(gasValues) && gasValues.maxPriorityFeePerGas;
+            const newMaxPriorityFeePerGas = (maxPriorityFeePerGasValues &&
+                (0, utils_1.validateMinimumIncrease)(maxPriorityFeePerGasValues, minMaxPriorityFeePerGas)) ||
+                (existingMaxPriorityFeePerGas && minMaxPriorityFeePerGas);
+            const txParams = newMaxFeePerGas && newMaxPriorityFeePerGas
+                ? {
+                    from: transactionMeta.transaction.from,
+                    gasLimit: transactionMeta.transaction.gas,
+                    maxFeePerGas: newMaxFeePerGas,
+                    maxPriorityFeePerGas: newMaxPriorityFeePerGas,
+                    type: 2,
+                    nonce: transactionMeta.transaction.nonce,
+                    to: transactionMeta.transaction.from,
+                    value: '0x0',
+                }
+                : {
+                    from: transactionMeta.transaction.from,
+                    gasLimit: transactionMeta.transaction.gas,
+                    gasPrice: newGasPrice,
+                    nonce: transactionMeta.transaction.nonce,
+                    to: transactionMeta.transaction.from,
+                    value: '0x0',
+                };
+            const unsignedEthTx = this.prepareUnsignedEthTx(txParams);
+            const signedTx = yield this.sign(unsignedEthTx, transactionMeta.transaction.from);
+            const rawTransaction = (0, ethereumjs_util_1.bufferToHex)(signedTx.serialize());
+            yield (0, controller_utils_1.query)(this.ethQuery, 'sendRawTransaction', [rawTransaction]);
+            transactionMeta.status = types_1.TransactionStatus.cancelled;
+            this.hub.emit(`${transactionMeta.id}:finished`, transactionMeta);
+        });
+    }
+    /**
+     * Attempts to speed up a transaction increasing transaction gasPrice by ten percent.
+     *
+     * @param transactionID - The ID of the transaction to speed up.
+     * @param gasValues - The gas values to use for the speed up transation.
+     */
+    speedUpTransaction(transactionID, gasValues) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (gasValues) {
+                (0, utils_1.validateGasValues)(gasValues);
+            }
+            const transactionMeta = this.state.transactions.find(({ id }) => id === transactionID);
+            /* istanbul ignore next */
+            if (!transactionMeta) {
+                return;
+            }
+            /* istanbul ignore next */
+            if (!this.sign) {
+                throw new Error('No sign method defined.');
+            }
+            const { transactions } = this.state;
+            // gasPrice (legacy non EIP1559)
+            const minGasPrice = (0, utils_1.getIncreasedPriceFromExisting)(transactionMeta.transaction.gasPrice, exports.SPEED_UP_RATE);
+            const gasPriceFromValues = (0, utils_1.isGasPriceValue)(gasValues) && gasValues.gasPrice;
+            const newGasPrice = (gasPriceFromValues &&
+                (0, utils_1.validateMinimumIncrease)(gasPriceFromValues, minGasPrice)) ||
+                minGasPrice;
+            // maxFeePerGas (EIP1559)
+            const existingMaxFeePerGas = (_a = transactionMeta.transaction) === null || _a === void 0 ? void 0 : _a.maxFeePerGas;
+            const minMaxFeePerGas = (0, utils_1.getIncreasedPriceFromExisting)(existingMaxFeePerGas, exports.SPEED_UP_RATE);
+            const maxFeePerGasValues = (0, utils_1.isFeeMarketEIP1559Values)(gasValues) && gasValues.maxFeePerGas;
+            const newMaxFeePerGas = (maxFeePerGasValues &&
+                (0, utils_1.validateMinimumIncrease)(maxFeePerGasValues, minMaxFeePerGas)) ||
+                (existingMaxFeePerGas && minMaxFeePerGas);
+            // maxPriorityFeePerGas (EIP1559)
+            const existingMaxPriorityFeePerGas = (_b = transactionMeta.transaction) === null || _b === void 0 ? void 0 : _b.maxPriorityFeePerGas;
+            const minMaxPriorityFeePerGas = (0, utils_1.getIncreasedPriceFromExisting)(existingMaxPriorityFeePerGas, exports.SPEED_UP_RATE);
+            const maxPriorityFeePerGasValues = (0, utils_1.isFeeMarketEIP1559Values)(gasValues) && gasValues.maxPriorityFeePerGas;
+            const newMaxPriorityFeePerGas = (maxPriorityFeePerGasValues &&
+                (0, utils_1.validateMinimumIncrease)(maxPriorityFeePerGasValues, minMaxPriorityFeePerGas)) ||
+                (existingMaxPriorityFeePerGas && minMaxPriorityFeePerGas);
+            const txParams = newMaxFeePerGas && newMaxPriorityFeePerGas
+                ? Object.assign(Object.assign({}, transactionMeta.transaction), { gasLimit: transactionMeta.transaction.gas, maxFeePerGas: newMaxFeePerGas, maxPriorityFeePerGas: newMaxPriorityFeePerGas, type: 2 }) : Object.assign(Object.assign({}, transactionMeta.transaction), { gasLimit: transactionMeta.transaction.gas, gasPrice: newGasPrice });
+            const unsignedEthTx = this.prepareUnsignedEthTx(txParams);
+            const signedTx = yield this.sign(unsignedEthTx, transactionMeta.transaction.from);
+            const rawTransaction = (0, ethereumjs_util_1.bufferToHex)(signedTx.serialize());
+            const transactionHash = yield (0, controller_utils_1.query)(this.ethQuery, 'sendRawTransaction', [
+                rawTransaction,
+            ]);
+            const baseTransactionMeta = Object.assign(Object.assign({}, transactionMeta), { id: (0, uuid_1.v1)(), time: Date.now(), transactionHash });
+            const newTransactionMeta = newMaxFeePerGas && newMaxPriorityFeePerGas
+                ? Object.assign(Object.assign({}, baseTransactionMeta), { transaction: Object.assign(Object.assign({}, transactionMeta.transaction), { maxFeePerGas: newMaxFeePerGas, maxPriorityFeePerGas: newMaxPriorityFeePerGas }) }) : Object.assign(Object.assign({}, baseTransactionMeta), { transaction: Object.assign(Object.assign({}, transactionMeta.transaction), { gasPrice: newGasPrice }) });
+            transactions.push(newTransactionMeta);
+            this.update({ transactions: this.trimTransactionsForState(transactions) });
+            this.hub.emit(`${transactionMeta.id}:speedup`, newTransactionMeta);
+        });
+    }
+    /**
+     * Estimates required gas for a given transaction.
+     *
+     * @param transaction - The transaction to estimate gas for.
+     * @returns The gas and gas price.
+     */
+    estimateGas(transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const estimatedTransaction = Object.assign({}, transaction);
+            const { gas, gasPrice: providedGasPrice, to, value, data, } = estimatedTransaction;
+            const gasPrice = typeof providedGasPrice === 'undefined'
+                ? yield (0, controller_utils_1.query)(this.ethQuery, 'gasPrice')
+                : providedGasPrice;
+            const { providerConfig } = this.getNetworkState();
+            const isCustomNetwork = providerConfig.type === controller_utils_1.NetworkType.rpc;
+            // 1. If gas is already defined on the transaction, use it
+            if (typeof gas !== 'undefined') {
+                return { gas, gasPrice };
+            }
+            const { gasLimit } = yield (0, controller_utils_1.query)(this.ethQuery, 'getBlockByNumber', [
+                'latest',
+                false,
+            ]);
+            // 2. If to is not defined or this is not a contract address, and there is no data use 0x5208 / 21000.
+            // If the newtwork is a custom network then bypass this check and fetch 'estimateGas'.
+            /* istanbul ignore next */
+            const code = to ? yield (0, controller_utils_1.query)(this.ethQuery, 'getCode', [to]) : undefined;
+            /* istanbul ignore next */
+            if (!isCustomNetwork &&
+                (!to || (to && !data && (!code || code === '0x')))) {
+                return { gas: '0x5208', gasPrice };
+            }
+            // if data, should be hex string format
+            estimatedTransaction.data = !data
+                ? data
+                : /* istanbul ignore next */ (0, ethereumjs_util_1.addHexPrefix)(data);
+            // 3. If this is a contract address, safely estimate gas using RPC
+            estimatedTransaction.value =
+                typeof value === 'undefined' ? '0x0' : /* istanbul ignore next */ value;
+            const gasLimitBN = (0, controller_utils_1.hexToBN)(gasLimit);
+            estimatedTransaction.gas = (0, controller_utils_1.BNToHex)((0, controller_utils_1.fractionBN)(gasLimitBN, 19, 20));
+            let gasHex;
+            let estimateGasError;
+            try {
+                gasHex = yield (0, controller_utils_1.query)(this.ethQuery, 'estimateGas', [
+                    estimatedTransaction,
+                ]);
+            }
+            catch (error) {
+                estimateGasError = utils_1.ESTIMATE_GAS_ERROR;
+            }
+            // 4. Pad estimated gas without exceeding the most recent block gasLimit. If the network is a
+            // a custom network then return the eth_estimateGas value.
+            const gasBN = (0, controller_utils_1.hexToBN)(gasHex);
+            const maxGasBN = gasLimitBN.muln(0.9);
+            const paddedGasBN = gasBN.muln(1.5);
+            /* istanbul ignore next */
+            if (gasBN.gt(maxGasBN) || isCustomNetwork) {
+                return { gas: (0, ethereumjs_util_1.addHexPrefix)(gasHex), gasPrice, estimateGasError };
+            }
+            /* istanbul ignore next */
+            if (paddedGasBN.lt(maxGasBN)) {
+                return {
+                    gas: (0, ethereumjs_util_1.addHexPrefix)((0, controller_utils_1.BNToHex)(paddedGasBN)),
+                    gasPrice,
+                    estimateGasError,
+                };
+            }
+            return { gas: (0, ethereumjs_util_1.addHexPrefix)((0, controller_utils_1.BNToHex)(maxGasBN)), gasPrice, estimateGasError };
+        });
+    }
+    /**
+     * Check the status of submitted transactions on the network to determine whether they have
+     * been included in a block. Any that have been included in a block are marked as confirmed.
+     */
+    queryTransactionStatuses() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { transactions } = this.state;
+            const { chainId: currentChainId, networkId: currentNetworkID } = this.getChainAndNetworkId();
+            let gotUpdates = false;
+            yield (0, controller_utils_1.safelyExecute)(() => Promise.all(transactions.map((meta, index) => __awaiter(this, void 0, void 0, function* () {
+                // Using fallback to networkID only when there is no chainId present.
+                // Should be removed when networkID is completely removed.
+                const txBelongsToCurrentChain = meta.chainId === currentChainId ||
+                    (!meta.chainId && meta.networkID === currentNetworkID);
+                if (!meta.verifiedOnBlockchain && txBelongsToCurrentChain) {
+                    const [reconciledTx, updateRequired] = yield this.blockchainTransactionStateReconciler(meta);
+                    if (updateRequired) {
+                        transactions[index] = reconciledTx;
+                        gotUpdates = updateRequired;
+                    }
+                }
+            }))));
+            /* istanbul ignore else */
+            if (gotUpdates) {
+                this.update({
+                    transactions: this.trimTransactionsForState(transactions),
+                });
+            }
+        });
+    }
+    /**
+     * Updates an existing transaction in state.
+     *
+     * @param transactionMeta - The new transaction to store in state.
+     */
+    updateTransaction(transactionMeta) {
+        const { transactions } = this.state;
+        transactionMeta.transaction = (0, utils_1.normalizeTransaction)(transactionMeta.transaction);
+        (0, utils_1.validateTransaction)(transactionMeta.transaction);
+        const index = transactions.findIndex(({ id }) => transactionMeta.id === id);
+        transactions[index] = transactionMeta;
+        this.update({ transactions: this.trimTransactionsForState(transactions) });
+    }
+    /**
+     * Removes all transactions from state, optionally based on the current network.
+     *
+     * @param ignoreNetwork - Determines whether to wipe all transactions, or just those on the
+     * current network. If `true`, all transactions are wiped.
+     * @param address - If specified, only transactions originating from this address will be
+     * wiped on current network.
+     */
+    wipeTransactions(ignoreNetwork, address) {
+        /* istanbul ignore next */
+        if (ignoreNetwork && !address) {
+            this.update({ transactions: [] });
+            return;
+        }
+        const { chainId: currentChainId, networkId: currentNetworkID } = this.getChainAndNetworkId();
+        const newTransactions = this.state.transactions.filter(({ networkID, chainId, transaction }) => {
+            var _a;
+            // Using fallback to networkID only when there is no chainId present. Should be removed when networkID is completely removed.
+            const isMatchingNetwork = ignoreNetwork ||
+                chainId === currentChainId ||
+                (!chainId && networkID === currentNetworkID);
+            if (!isMatchingNetwork) {
+                return true;
+            }
+            const isMatchingAddress = !address || ((_a = transaction.from) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === address.toLowerCase();
+            return !isMatchingAddress;
+        });
+        this.update({
+            transactions: this.trimTransactionsForState(newTransactions),
+        });
+    }
+    startIncomingTransactionProcessing() {
+        this.incomingTransactionHelper.start();
+    }
+    stopIncomingTransactionProcessing() {
+        this.incomingTransactionHelper.stop();
+    }
+    processApproval(transactionMeta, { requireApproval, shouldShowRequest = true, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const transactionId = transactionMeta.id;
+            let resultCallbacks;
+            try {
+                if (requireApproval !== false) {
+                    const acceptResult = yield this.requestApproval(transactionMeta, {
+                        shouldShowRequest,
+                    });
+                    resultCallbacks = acceptResult.resultCallbacks;
+                }
+                const { meta, isCompleted } = this.isTransactionCompleted(transactionId);
+                if (meta && !isCompleted) {
+                    yield this.approveTransaction(transactionId);
+                }
+            }
+            catch (error) {
+                const { meta, isCompleted } = this.isTransactionCompleted(transactionId);
+                if (meta && !isCompleted) {
+                    if (error.code === eth_rpc_errors_1.errorCodes.provider.userRejectedRequest) {
+                        this.cancelTransaction(transactionId);
+                        throw eth_rpc_errors_1.ethErrors.provider.userRejectedRequest('User rejected the transaction');
+                    }
+                    else {
+                        this.failTransaction(meta, error);
+                    }
+                }
+            }
+            const finalMeta = this.getTransaction(transactionId);
+            switch (finalMeta === null || finalMeta === void 0 ? void 0 : finalMeta.status) {
+                case types_1.TransactionStatus.failed:
+                    resultCallbacks === null || resultCallbacks === void 0 ? void 0 : resultCallbacks.error(finalMeta.error);
+                    throw eth_rpc_errors_1.ethErrors.rpc.internal(finalMeta.error.message);
+                case types_1.TransactionStatus.cancelled:
+                    const cancelError = eth_rpc_errors_1.ethErrors.rpc.internal('User cancelled the transaction');
+                    resultCallbacks === null || resultCallbacks === void 0 ? void 0 : resultCallbacks.error(cancelError);
+                    throw cancelError;
+                case types_1.TransactionStatus.submitted:
+                    resultCallbacks === null || resultCallbacks === void 0 ? void 0 : resultCallbacks.success();
+                    return finalMeta.transactionHash;
+                default:
+                    const internalError = eth_rpc_errors_1.ethErrors.rpc.internal(`MetaMask Tx Signature: Unknown problem: ${JSON.stringify(finalMeta || transactionId)}`);
+                    resultCallbacks === null || resultCallbacks === void 0 ? void 0 : resultCallbacks.error(internalError);
+                    throw internalError;
+            }
+        });
+    }
+    /**
+     * Approves a transaction and updates it's status in state. If this is not a
+     * retry transaction, a nonce will be generated. The transaction is signed
+     * using the sign configuration property, then published to the blockchain.
+     * A `<tx.id>:finished` hub event is fired after success or failure.
+     *
+     * @param transactionID - The ID of the transaction to approve.
+     */
+    approveTransaction(transactionID) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { transactions } = this.state;
+            const releaseLock = yield this.mutex.acquire();
+            const { chainId } = this.getChainAndNetworkId();
+            const index = transactions.findIndex(({ id }) => transactionID === id);
+            const transactionMeta = transactions[index];
+            const { transaction: { nonce, from }, } = transactionMeta;
+            let nonceLock;
+            try {
+                if (!this.sign) {
+                    releaseLock();
+                    this.failTransaction(transactionMeta, new Error('No sign method defined.'));
+                    return;
+                }
+                else if (!chainId) {
+                    releaseLock();
+                    this.failTransaction(transactionMeta, new Error('No chainId defined.'));
+                    return;
+                }
+                const { approved: status } = types_1.TransactionStatus;
+                let nonceToUse = nonce;
+                // if a nonce already exists on the transactionMeta it means this is a speedup or cancel transaction
+                // so we want to reuse that nonce and hope that it beats the previous attempt to chain. Otherwise use a new locked nonce
+                if (!nonceToUse) {
+                    nonceLock = yield this.nonceTracker.getNonceLock(from);
+                    nonceToUse = (0, ethereumjs_util_1.addHexPrefix)(nonceLock.nextNonce.toString(16));
+                }
+                transactionMeta.status = status;
+                transactionMeta.transaction.nonce = nonceToUse;
+                transactionMeta.transaction.chainId = chainId;
+                const baseTxParams = Object.assign(Object.assign({}, transactionMeta.transaction), { gasLimit: transactionMeta.transaction.gas });
+                const isEIP1559 = (0, utils_1.isEIP1559Transaction)(transactionMeta.transaction);
+                const txParams = isEIP1559
+                    ? Object.assign(Object.assign({}, baseTxParams), { maxFeePerGas: transactionMeta.transaction.maxFeePerGas, maxPriorityFeePerGas: transactionMeta.transaction.maxPriorityFeePerGas, estimatedBaseFee: transactionMeta.transaction.estimatedBaseFee, 
+                        // specify type 2 if maxFeePerGas and maxPriorityFeePerGas are set
+                        type: 2 }) : baseTxParams;
+                // delete gasPrice if maxFeePerGas and maxPriorityFeePerGas are set
+                if (isEIP1559) {
+                    delete txParams.gasPrice;
+                }
+                const unsignedEthTx = this.prepareUnsignedEthTx(txParams);
+                const signedTx = yield this.sign(unsignedEthTx, from);
+                transactionMeta.status = types_1.TransactionStatus.signed;
+                this.updateTransaction(transactionMeta);
+                const rawTransaction = (0, ethereumjs_util_1.bufferToHex)(signedTx.serialize());
+                transactionMeta.rawTransaction = rawTransaction;
+                this.updateTransaction(transactionMeta);
+                const transactionHash = yield (0, controller_utils_1.query)(this.ethQuery, 'sendRawTransaction', [
+                    rawTransaction,
+                ]);
+                transactionMeta.transactionHash = transactionHash;
+                transactionMeta.status = types_1.TransactionStatus.submitted;
+                this.updateTransaction(transactionMeta);
+                this.hub.emit(`${transactionMeta.id}:finished`, transactionMeta);
+            }
+            catch (error) {
+                this.failTransaction(transactionMeta, error);
+            }
+            finally {
+                // must set transaction to submitted/failed before releasing lock
+                if (nonceLock) {
+                    nonceLock.releaseLock();
+                }
+                releaseLock();
+            }
+        });
+    }
+    /**
+     * Cancels a transaction based on its ID by setting its status to "rejected"
+     * and emitting a `<tx.id>:finished` hub event.
+     *
+     * @param transactionID - The ID of the transaction to cancel.
+     */
+    cancelTransaction(transactionID) {
+        const transactionMeta = this.state.transactions.find(({ id }) => id === transactionID);
+        if (!transactionMeta) {
+            return;
+        }
+        transactionMeta.status = types_1.TransactionStatus.rejected;
+        this.hub.emit(`${transactionMeta.id}:finished`, transactionMeta);
+        const transactions = this.state.transactions.filter(({ id }) => id !== transactionID);
+        this.update({ transactions: this.trimTransactionsForState(transactions) });
+    }
+    /**
+     * Trim the amount of transactions that are set on the state. Checks
+     * if the length of the tx history is longer then desired persistence
+     * limit and then if it is removes the oldest confirmed or rejected tx.
+     * Pending or unapproved transactions will not be removed by this
+     * operation. For safety of presenting a fully functional transaction UI
+     * representation, this function will not break apart transactions with the
+     * same nonce, created on the same day, per network. Not accounting for transactions of the same
+     * nonce, same day and network combo can result in confusing or broken experiences
+     * in the UI. The transactions are then updated using the BaseController update.
+     *
+     * @param transactions - The transactions to be applied to the state.
+     * @returns The trimmed list of transactions.
+     */
+    trimTransactionsForState(transactions) {
+        const nonceNetworkSet = new Set();
+        const txsToKeep = transactions.reverse().filter((tx) => {
+            const { chainId, networkID, status, transaction, time } = tx;
+            if (transaction) {
+                const key = `${transaction.nonce}-${chainId ? (0, controller_utils_1.convertHexToDecimal)(chainId) : networkID}-${new Date(time).toDateString()}`;
+                if (nonceNetworkSet.has(key)) {
+                    return true;
+                }
+                else if (nonceNetworkSet.size < this.config.txHistoryLimit ||
+                    !this.isFinalState(status)) {
+                    nonceNetworkSet.add(key);
+                    return true;
+                }
+            }
+            return false;
+        });
+        txsToKeep.reverse();
+        return txsToKeep;
+    }
+    /**
+     * Determines if the transaction is in a final state.
+     *
+     * @param status - The transaction status.
+     * @returns Whether the transaction is in a final state.
+     */
+    isFinalState(status) {
+        return (status === types_1.TransactionStatus.rejected ||
+            status === types_1.TransactionStatus.confirmed ||
+            status === types_1.TransactionStatus.failed ||
+            status === types_1.TransactionStatus.cancelled);
+    }
+    /**
+     * Whether the transaction has at least completed all local processing.
+     *
+     * @param status - The transaction status.
+     * @returns Whether the transaction is in a final state.
+     */
+    isLocalFinalState(status) {
+        return [
+            types_1.TransactionStatus.cancelled,
+            types_1.TransactionStatus.confirmed,
+            types_1.TransactionStatus.failed,
+            types_1.TransactionStatus.rejected,
+            types_1.TransactionStatus.submitted,
+        ].includes(status);
+    }
+    /**
+     * Method to verify the state of a transaction using the Blockchain as a source of truth.
+     *
+     * @param meta - The local transaction to verify on the blockchain.
+     * @returns A tuple containing the updated transaction, and whether or not an update was required.
+     */
+    blockchainTransactionStateReconciler(meta) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { status, transactionHash } = meta;
+            switch (status) {
+                case types_1.TransactionStatus.confirmed:
+                    const txReceipt = yield (0, controller_utils_1.query)(this.ethQuery, 'getTransactionReceipt', [
+                        transactionHash,
+                    ]);
+                    if (!txReceipt) {
+                        return [meta, false];
+                    }
+                    const txBlock = yield (0, controller_utils_1.query)(this.ethQuery, 'getBlockByHash', [
+                        txReceipt.blockHash,
+                    ]);
+                    meta.verifiedOnBlockchain = true;
+                    meta.transaction.gasUsed = txReceipt.gasUsed;
+                    meta.txReceipt = txReceipt;
+                    meta.baseFeePerGas = txBlock === null || txBlock === void 0 ? void 0 : txBlock.baseFeePerGas;
+                    // According to the Web3 docs:
+                    // TRUE if the transaction was successful, FALSE if the EVM reverted the transaction.
+                    if (Number(txReceipt.status) === 0) {
+                        const error = new Error('Transaction failed. The transaction was reversed');
+                        this.failTransaction(meta, error);
+                        return [meta, false];
+                    }
+                    return [meta, true];
+                case types_1.TransactionStatus.submitted:
+                    const txObj = yield (0, controller_utils_1.query)(this.ethQuery, 'getTransactionByHash', [
+                        transactionHash,
+                    ]);
+                    if (!txObj) {
+                        const receiptShowsFailedStatus = yield this.checkTxReceiptStatusIsFailed(transactionHash);
+                        // Case the txObj is evaluated as false, a second check will
+                        // determine if the tx failed or it is pending or confirmed
+                        if (receiptShowsFailedStatus) {
+                            const error = new Error('Transaction failed. The transaction was dropped or replaced by a new one');
+                            this.failTransaction(meta, error);
+                        }
+                    }
+                    /* istanbul ignore next */
+                    if (txObj === null || txObj === void 0 ? void 0 : txObj.blockNumber) {
+                        meta.status = types_1.TransactionStatus.confirmed;
+                        this.hub.emit(`${meta.id}:confirmed`, meta);
+                        return [meta, true];
+                    }
+                    return [meta, false];
+                default:
+                    return [meta, false];
+            }
+        });
+    }
+    /**
+     * Method to check if a tx has failed according to their receipt
+     * According to the Web3 docs:
+     * TRUE if the transaction was successful, FALSE if the EVM reverted the transaction.
+     * The receipt is not available for pending transactions and returns null.
+     *
+     * @param txHash - The transaction hash.
+     * @returns Whether the transaction has failed.
+     */
+    checkTxReceiptStatusIsFailed(txHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const txReceipt = yield (0, controller_utils_1.query)(this.ethQuery, 'getTransactionReceipt', [
+                txHash,
+            ]);
+            if (!txReceipt) {
+                // Transaction is pending
+                return false;
+            }
+            return Number(txReceipt.status) === 0;
+        });
+    }
+    requestApproval(txMeta, { shouldShowRequest }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const id = this.getApprovalId(txMeta);
+            const { origin } = txMeta;
+            const type = controller_utils_1.ApprovalType.Transaction;
+            const requestData = { txId: txMeta.id };
+            return (yield this.messagingSystem.call('ApprovalController:addRequest', {
+                id,
+                origin: origin || controller_utils_1.ORIGIN_METAMASK,
+                type,
+                requestData,
+                expectsResult: true,
+            }, shouldShowRequest));
+        });
+    }
+    getTransaction(transactionID) {
+        const { transactions } = this.state;
+        return transactions.find(({ id }) => id === transactionID);
+    }
+    getApprovalId(txMeta) {
+        return String(txMeta.id);
+    }
+    isTransactionCompleted(transactionid) {
+        const transaction = this.getTransaction(transactionid);
+        if (!transaction) {
+            return { meta: undefined, isCompleted: false };
+        }
+        const isCompleted = this.isLocalFinalState(transaction.status);
+        return { meta: transaction, isCompleted };
+    }
+    getChainAndNetworkId() {
+        const { networkId, providerConfig } = this.getNetworkState();
+        const chainId = providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.chainId;
+        return { networkId, chainId };
+    }
+    prepareUnsignedEthTx(txParams) {
+        return tx_1.TransactionFactory.fromTxData(txParams, {
+            common: this.getCommonConfiguration(),
+            freeze: false,
+        });
+    }
+    /**
+     * `@ethereumjs/tx` uses `@ethereumjs/common` as a configuration tool for
+     * specifying which chain, network, hardfork and EIPs to support for
+     * a transaction. By referencing this configuration, and analyzing the fields
+     * specified in txParams, @ethereumjs/tx is able to determine which EIP-2718
+     * transaction type to use.
+     *
+     * @returns common configuration object
+     */
+    getCommonConfiguration() {
+        const { networkId, providerConfig: { type: chain, chainId, nickname: name }, } = this.getNetworkState();
+        if (chain !== controller_utils_1.RPC &&
+            chain !== controller_utils_1.NetworkType['linea-goerli'] &&
+            chain !== controller_utils_1.NetworkType['linea-mainnet']) {
+            return new common_1.Common({ chain, hardfork: exports.HARDFORK });
+        }
+        const customChainParams = {
+            name,
+            chainId: parseInt(chainId, 16),
+            networkId: networkId === null ? NaN : parseInt(networkId, undefined),
+            defaultHardfork: exports.HARDFORK,
+        };
+        return common_1.Common.custom(customChainParams);
+    }
+    onIncomingTransactions({ added, updated, }) {
+        const { transactions: currentTransactions } = this.state;
+        const updatedTransactions = [
+            ...added,
+            ...currentTransactions.map((originalTransaction) => {
+                const updatedTransaction = updated.find(({ transactionHash }) => transactionHash === originalTransaction.transactionHash);
+                return updatedTransaction !== null && updatedTransaction !== void 0 ? updatedTransaction : originalTransaction;
+            }),
+        ];
+        this.update({
+            transactions: this.trimTransactionsForState(updatedTransactions),
+        });
+    }
+    onUpdatedLastFetchedBlockNumbers({ lastFetchedBlockNumbers, blockNumber, }) {
+        this.update({ lastFetchedBlockNumbers });
+        this.hub.emit('incomingTransactionBlock', blockNumber);
+    }
+}
+exports.TransactionController = TransactionController;
+exports.default = TransactionController;
+//# sourceMappingURL=TransactionController.js.map