@metamask-previews/transaction-controller 9.1.0-preview.04c2e62 → 9.2.0-preview.a8d97a1

package/dist/TransactionController.js

@@ -26,6 +26,7 @@ const events_1 = require("events");
 const nonce_tracker_1 = __importDefault(require("nonce-tracker"));
 const uuid_1 = require("uuid");
 const EtherscanRemoteTransactionSource_1 = require("./EtherscanRemoteTransactionSource");
+const external_transactions_1 = require("./external-transactions");
 const IncomingTransactionHelper_1 = require("./IncomingTransactionHelper");
 const types_1 = require("./types");
 const utils_1 = require("./utils");
@@ -176,22 +177,24 @@ class TransactionController extends base_controller_1.BaseController {
      *
      * @param transaction - The transaction object to add.
      * @param opts - Additional options to control how the transaction is added.
+     * @param opts.actionId - Unique ID to prevent duplicate requests.
      * @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.
      * @param opts.securityAlertResponse - Response from security validator.
      * @returns Object containing a promise resolving to the transaction hash if approved.
      */
-    addTransaction(transaction, { deviceConfirmedOn, origin, requireApproval, securityAlertResponse, } = {}) {
+    addTransaction(transaction, { actionId, deviceConfirmedOn, origin, requireApproval, securityAlertResponse, } = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { chainId, networkId } = this.getChainAndNetworkId();
+            const chainId = this.getChainId();
             const { transactions } = this.state;
             transaction = (0, utils_1.normalizeTransaction)(transaction);
             (0, utils_1.validateTransaction)(transaction);
             const dappSuggestedGasFees = this.generateDappSuggestedGasFees(transaction, origin);
-            const transactionMeta = {
+            const existingTransactionMeta = this.getTransactionWithActionId(actionId);
+            // If a request to add a transaction with the same actionId is submitted again, a new transaction will not be created for it.
+            const transactionMeta = existingTransactionMeta || {
                 id: (0, uuid_1.v1)(),
-                networkID: networkId !== null && networkId !== void 0 ? networkId : undefined,
                 chainId,
                 origin,
                 status: types_1.TransactionStatus.unapproved,
@@ -201,6 +204,8 @@ class TransactionController extends base_controller_1.BaseController {
                 verifiedOnBlockchain: false,
                 dappSuggestedGasFees,
                 securityAlertResponse,
+                // Add actionId to txMeta to check if same actionId is seen again
+                actionId,
             };
             try {
                 const { gas, estimateGasError } = yield this.estimateGas(transaction);
@@ -211,11 +216,17 @@ class TransactionController extends base_controller_1.BaseController {
                 this.failTransaction(transactionMeta, error);
                 return Promise.reject(error);
             }
-            transactions.push(transactionMeta);
-            this.update({ transactions: this.trimTransactionsForState(transactions) });
-            this.hub.emit(`unapprovedTransaction`, transactionMeta);
+            // Checks if a transaction already exists with a given actionId
+            if (!existingTransactionMeta) {
+                transactions.push(transactionMeta);
+                this.update({
+                    transactions: this.trimTransactionsForState(transactions),
+                });
+                this.hub.emit(`unapprovedTransaction`, transactionMeta);
+            }
             return {
                 result: this.processApproval(transactionMeta, {
+                    isExisting: Boolean(existingTransactionMeta),
                     requireApproval,
                 }),
                 transactionMeta,
@@ -237,9 +248,9 @@ class TransactionController extends base_controller_1.BaseController {
      * Creates approvals for all unapproved transactions persisted.
      */
     initApprovals() {
-        const { networkId, chainId } = this.getChainAndNetworkId();
+        const chainId = this.getChainId();
         const unapprovedTxs = this.state.transactions.filter((transaction) => transaction.status === types_1.TransactionStatus.unapproved &&
-            (0, utils_1.transactionMatchesNetwork)(transaction, chainId, networkId));
+            (0, utils_1.transactionMatchesChainId)(transaction, chainId));
         for (const txMeta of unapprovedTxs) {
             this.processApproval(txMeta, {
                 shouldShowRequest: false,
@@ -255,8 +266,10 @@ class TransactionController extends base_controller_1.BaseController {
      *
      * @param transactionID - The ID of the transaction to cancel.
      * @param gasValues - The gas values to use for the cancellation transaction.
+     * @param options - The options for the cancellation transaction.
+     * @param options.estimatedBaseFee - The estimated base fee of the transaction.
      */
-    stopTransaction(transactionID, gasValues) {
+    stopTransaction(transactionID, gasValues, { estimatedBaseFee } = {}) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             if (gasValues) {
@@ -310,8 +323,9 @@ class TransactionController extends base_controller_1.BaseController {
                 };
             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]);
+            const rawTx = (0, ethereumjs_util_1.bufferToHex)(signedTx.serialize());
+            yield (0, controller_utils_1.query)(this.ethQuery, 'sendRawTransaction', [rawTx]);
+            transactionMeta.estimatedBaseFee = estimatedBaseFee;
             transactionMeta.status = types_1.TransactionStatus.cancelled;
             this.hub.emit(`${transactionMeta.id}:finished`, transactionMeta);
         });
@@ -320,11 +334,18 @@ class TransactionController extends base_controller_1.BaseController {
      * 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.
+     * @param gasValues - The gas values to use for the speed up transaction.
+     * @param options - The options for the speed up transaction.
+     * @param options.actionId - Unique ID to prevent duplicate requests
+     * @param options.estimatedBaseFee - The estimated base fee of the transaction.
      */
-    speedUpTransaction(transactionID, gasValues) {
+    speedUpTransaction(transactionID, gasValues, { actionId, estimatedBaseFee, } = {}) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
+            // If transaction is found for same action id, do not create a new speed up transaction.
+            if (this.getTransactionWithActionId(actionId)) {
+                return;
+            }
             if (gasValues) {
                 (0, utils_1.validateGasValues)(gasValues);
             }
@@ -362,11 +383,12 @@ class TransactionController extends base_controller_1.BaseController {
                 ? 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 rawTx = (0, ethereumjs_util_1.bufferToHex)(signedTx.serialize());
             const transactionHash = yield (0, controller_utils_1.query)(this.ethQuery, 'sendRawTransaction', [
-                rawTransaction,
+                rawTx,
             ]);
-            const baseTransactionMeta = Object.assign(Object.assign({}, transactionMeta), { id: (0, uuid_1.v1)(), time: Date.now(), transactionHash });
+            const baseTransactionMeta = Object.assign(Object.assign({}, transactionMeta), { estimatedBaseFee, id: (0, uuid_1.v1)(), time: Date.now(), transactionHash,
+                actionId });
             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);
@@ -452,14 +474,11 @@ class TransactionController extends base_controller_1.BaseController {
     queryTransactionStatuses() {
         return __awaiter(this, void 0, void 0, function* () {
             const { transactions } = this.state;
-            const { chainId: currentChainId, networkId: currentNetworkID } = this.getChainAndNetworkId();
+            const currentChainId = this.getChainId();
             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) {
+                if (!meta.verifiedOnBlockchain &&
+                    (0, utils_1.transactionMatchesChainId)(meta, currentChainId)) {
                     const [reconciledTx, updateRequired] = yield this.blockchainTransactionStateReconciler(meta);
                     if (updateRequired) {
                         transactions[index] = reconciledTx;
@@ -502,13 +521,10 @@ class TransactionController extends base_controller_1.BaseController {
             this.update({ transactions: [] });
             return;
         }
-        const { chainId: currentChainId, networkId: currentNetworkID } = this.getChainAndNetworkId();
-        const newTransactions = this.state.transactions.filter(({ networkID, chainId, transaction }) => {
+        const currentChainId = this.getChainId();
+        const newTransactions = this.state.transactions.filter(({ 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);
+            const isMatchingNetwork = ignoreNetwork || chainId === currentChainId;
             if (!isMatchingNetwork) {
                 return true;
             }
@@ -525,35 +541,70 @@ class TransactionController extends base_controller_1.BaseController {
     stopIncomingTransactionProcessing() {
         this.incomingTransactionHelper.stop();
     }
-    processApproval(transactionMeta, { requireApproval, shouldShowRequest = true, }) {
+    /**
+     * Adds external provided transaction to state as confirmed transaction.
+     *
+     * @param transactionMeta - TransactionMeta to add transactions.
+     * @param transactionReceipt - TransactionReceipt of the external transaction.
+     * @param baseFeePerGas - Base fee per gas of the external transaction.
+     */
+    confirmExternalTransaction(transactionMeta, transactionReceipt, baseFeePerGas) {
         return __awaiter(this, void 0, void 0, function* () {
-            const transactionId = transactionMeta.id;
-            let resultCallbacks;
+            // Run validation and add external transaction to state.
+            this.addExternalTransaction(transactionMeta);
             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);
+                const transactionId = transactionMeta.id;
+                // Make sure status is confirmed and define gasUsed as in receipt.
+                transactionMeta.status = types_1.TransactionStatus.confirmed;
+                transactionMeta.txReceipt = transactionReceipt;
+                if (baseFeePerGas) {
+                    transactionMeta.baseFeePerGas = baseFeePerGas;
                 }
+                // Update same nonce local transactions as dropped and define replacedBy properties.
+                this.markNonceDuplicatesDropped(transactionId);
+                // Update external provided transaction with updated gas values and confirmed status.
+                this.updateTransaction(transactionMeta);
             }
             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');
+                console.error(error);
+            }
+        });
+    }
+    processApproval(transactionMeta, { isExisting = false, requireApproval, shouldShowRequest = true, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const transactionId = transactionMeta.id;
+            let resultCallbacks;
+            const { meta, isCompleted } = this.isTransactionCompleted(transactionId);
+            const finishedPromise = isCompleted
+                ? Promise.resolve(meta)
+                : this.waitForTransactionFinished(transactionId);
+            if (meta && !isExisting && !isCompleted) {
+                try {
+                    if (requireApproval !== false) {
+                        const acceptResult = yield this.requestApproval(transactionMeta, {
+                            shouldShowRequest,
+                        });
+                        resultCallbacks = acceptResult.resultCallbacks;
                     }
-                    else {
-                        this.failTransaction(meta, error);
+                    const { isCompleted: isTxCompleted } = this.isTransactionCompleted(transactionId);
+                    if (!isTxCompleted) {
+                        yield this.approveTransaction(transactionId);
+                    }
+                }
+                catch (error) {
+                    const { isCompleted: isTxCompleted } = this.isTransactionCompleted(transactionId);
+                    if (!isTxCompleted) {
+                        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);
+            const finalMeta = yield finishedPromise;
             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);
@@ -584,7 +635,7 @@ class TransactionController extends base_controller_1.BaseController {
         return __awaiter(this, void 0, void 0, function* () {
             const { transactions } = this.state;
             const releaseLock = yield this.mutex.acquire();
-            const { chainId } = this.getChainAndNetworkId();
+            const chainId = this.getChainId();
             const index = transactions.findIndex(({ id }) => transactionID === id);
             const transactionMeta = transactions[index];
             const { transaction: { nonce, from }, } = transactionMeta;
@@ -625,14 +676,15 @@ class TransactionController extends base_controller_1.BaseController {
                 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;
+                const rawTx = (0, ethereumjs_util_1.bufferToHex)(signedTx.serialize());
+                transactionMeta.rawTx = rawTx;
                 this.updateTransaction(transactionMeta);
                 const transactionHash = yield (0, controller_utils_1.query)(this.ethQuery, 'sendRawTransaction', [
-                    rawTransaction,
+                    rawTx,
                 ]);
                 transactionMeta.transactionHash = transactionHash;
                 transactionMeta.status = types_1.TransactionStatus.submitted;
+                transactionMeta.submittedTime = new Date().getTime();
                 this.updateTransaction(transactionMeta);
                 this.hub.emit(`${transactionMeta.id}:finished`, transactionMeta);
             }
@@ -681,9 +733,9 @@ class TransactionController extends base_controller_1.BaseController {
     trimTransactionsForState(transactions) {
         const nonceNetworkSet = new Set();
         const txsToKeep = transactions.reverse().filter((tx) => {
-            const { chainId, networkID, status, transaction, time } = tx;
+            const { chainId, status, transaction, time } = tx;
             if (transaction) {
-                const key = `${transaction.nonce}-${chainId ? (0, controller_utils_1.convertHexToDecimal)(chainId) : networkID}-${new Date(time).toDateString()}`;
+                const key = `${transaction.nonce}-${chainId}-${new Date(time).toDateString()}`;
                 if (nonceNetworkSet.has(key)) {
                     return true;
                 }
@@ -819,25 +871,24 @@ class TransactionController extends base_controller_1.BaseController {
             }, shouldShowRequest));
         });
     }
-    getTransaction(transactionID) {
+    getTransaction(transactionId) {
         const { transactions } = this.state;
-        return transactions.find(({ id }) => id === transactionID);
+        return transactions.find(({ id }) => id === transactionId);
     }
     getApprovalId(txMeta) {
         return String(txMeta.id);
     }
-    isTransactionCompleted(transactionid) {
-        const transaction = this.getTransaction(transactionid);
+    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 };
+    getChainId() {
+        const { providerConfig } = this.getNetworkState();
+        return providerConfig.chainId;
     }
     prepareUnsignedEthTx(txParams) {
         return tx_1.TransactionFactory.fromTxData(txParams, {
@@ -855,7 +906,7 @@ class TransactionController extends base_controller_1.BaseController {
      * @returns common configuration object
      */
     getCommonConfiguration() {
-        const { networkId, providerConfig: { type: chain, chainId, nickname: name }, } = this.getNetworkState();
+        const { 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']) {
@@ -864,7 +915,6 @@ class TransactionController extends base_controller_1.BaseController {
         const customChainParams = {
             name,
             chainId: parseInt(chainId, 16),
-            networkId: networkId === null ? NaN : parseInt(networkId, undefined),
             defaultHardfork: exports.HARDFORK,
         };
         return common_1.Common.custom(customChainParams);
@@ -911,6 +961,86 @@ class TransactionController extends base_controller_1.BaseController {
         }
         return dappSuggestedGasFees;
     }
+    /**
+     * Validates and adds external provided transaction to state.
+     *
+     * @param transactionMeta - Nominated external transaction to be added to state.
+     */
+    addExternalTransaction(transactionMeta) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const chainId = this.getChainId();
+            const { transactions } = this.state;
+            const fromAddress = (_a = transactionMeta === null || transactionMeta === void 0 ? void 0 : transactionMeta.transaction) === null || _a === void 0 ? void 0 : _a.from;
+            const sameFromAndNetworkTransactions = transactions.filter((transaction) => transaction.transaction.from === fromAddress &&
+                (0, utils_1.transactionMatchesChainId)(transaction, chainId));
+            const confirmedTxs = sameFromAndNetworkTransactions.filter((transaction) => transaction.status === types_1.TransactionStatus.confirmed);
+            const pendingTxs = sameFromAndNetworkTransactions.filter((transaction) => transaction.status === types_1.TransactionStatus.submitted);
+            (0, external_transactions_1.validateConfirmedExternalTransaction)(transactionMeta, confirmedTxs, pendingTxs);
+            const updatedTransactions = [...transactions, transactionMeta];
+            this.update({
+                transactions: this.trimTransactionsForState(updatedTransactions),
+            });
+        });
+    }
+    /**
+     * Sets other txMeta statuses to dropped if the txMeta that has been confirmed has other transactions
+     * in the transactions have the same nonce.
+     *
+     * @param transactionId - Used to identify original transaction.
+     */
+    markNonceDuplicatesDropped(transactionId) {
+        var _a, _b;
+        const chainId = this.getChainId();
+        const transactionMeta = this.getTransaction(transactionId);
+        const nonce = (_a = transactionMeta === null || transactionMeta === void 0 ? void 0 : transactionMeta.transaction) === null || _a === void 0 ? void 0 : _a.nonce;
+        const from = (_b = transactionMeta === null || transactionMeta === void 0 ? void 0 : transactionMeta.transaction) === null || _b === void 0 ? void 0 : _b.from;
+        const sameNonceTxs = this.state.transactions.filter((transaction) => transaction.transaction.from === from &&
+            transaction.transaction.nonce === nonce &&
+            (0, utils_1.transactionMatchesChainId)(transaction, chainId));
+        if (!sameNonceTxs.length) {
+            return;
+        }
+        // Mark all same nonce transactions as dropped and give it a replacedBy hash
+        for (const transaction of sameNonceTxs) {
+            if (transaction.id === transactionId) {
+                continue;
+            }
+            transaction.replacedBy = transactionMeta === null || transactionMeta === void 0 ? void 0 : transactionMeta.hash;
+            transaction.replacedById = transactionMeta === null || transactionMeta === void 0 ? void 0 : transactionMeta.id;
+            // Drop any transaction that wasn't previously failed (off chain failure)
+            if (transaction.status !== types_1.TransactionStatus.failed) {
+                this.setTransactionStatusDropped(transaction);
+            }
+        }
+    }
+    /**
+     * Method to set transaction status to dropped.
+     *
+     * @param transactionMeta - TransactionMeta of transaction to be marked as dropped.
+     */
+    setTransactionStatusDropped(transactionMeta) {
+        transactionMeta.status = types_1.TransactionStatus.dropped;
+        this.updateTransaction(transactionMeta);
+    }
+    /**
+     * Get transaction with provided actionId.
+     *
+     * @param actionId - Unique ID to prevent duplicate requests
+     * @returns the filtered transaction
+     */
+    getTransactionWithActionId(actionId) {
+        return this.state.transactions.find((transaction) => actionId && transaction.actionId === actionId);
+    }
+    waitForTransactionFinished(transactionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve) => {
+                this.hub.once(`${transactionId}:finished`, (txMeta) => {
+                    resolve(txMeta);
+                });
+            });
+        });
+    }
 }
 exports.TransactionController = TransactionController;
 exports.default = TransactionController;