@metamask-previews/bridge-status-controller 75.4.0-preview-3866c0ff1 → 75.4.0-preview-e3275932a

package/dist/bridge-status-controller.cjs

@@ -0,0 +1,1144 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _BridgeStatusController_pollingTokensByTxMetaId, _BridgeStatusController_intentManager, _BridgeStatusController_quoteStatusManager, _BridgeStatusController_clientId, _BridgeStatusController_fetchFn, _BridgeStatusController_config, _BridgeStatusController_addTransactionBatchFn, _BridgeStatusController_trace, _BridgeStatusController_traceSwapOperationCompleted, _BridgeStatusController_onTransactionFailed, _BridgeStatusController_onTransactionConfirmed, _BridgeStatusController_reportSubmittedForNonEvmTx, _BridgeStatusController_reportSubmittedOnce, _BridgeStatusController_seedQuoteStatusEntriesFromHistory, _BridgeStatusController_restartPollingForIncompleteHistoryItems, _BridgeStatusController_addTxToHistory, _BridgeStatusController_rekeyHistoryItem, _BridgeStatusController_startPollingForTxId, _BridgeStatusController_handleFetchFailure, _BridgeStatusController_handleOldHistoryItem, _BridgeStatusController_fetchBridgeTxStatus, _BridgeStatusController_setAndGetSrcTxHash, _BridgeStatusController_updateHistoryItem, _BridgeStatusController_deleteHistoryItem, _BridgeStatusController_wipeBridgeStatusByChainId, _BridgeStatusController_executeSubmitStrategy, _BridgeStatusController_trackPollingStatusUpdatedEvent, _BridgeStatusController_trackUnifiedSwapBridgeEvent;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BridgeStatusController = void 0;
+const bridge_controller_1 = require("@metamask/bridge-controller");
+const bridge_controller_2 = require("@metamask/bridge-controller");
+const polling_controller_1 = require("@metamask/polling-controller");
+const transaction_controller_1 = require("@metamask/transaction-controller");
+const utils_1 = require("@metamask/utils");
+const bridge_status_controller_intent_1 = require("./bridge-status-controller.intent.cjs");
+const constants_js_1 = require("./constants.cjs");
+const constants_js_2 = require("./quote-status-manager/constants.cjs");
+const errors_js_1 = require("./quote-status-manager/errors.cjs");
+const quotes_status_manager_js_1 = require("./quote-status-manager/quotes-status-manager.cjs");
+const index_js_1 = __importDefault(require("./strategy/index.cjs"));
+const types_js_1 = require("./strategy/types.cjs");
+const types_js_2 = require("./types.cjs");
+const accounts_js_1 = require("./utils/accounts.cjs");
+const authentication_js_1 = require("./utils/authentication.cjs");
+const bridge_status_js_1 = require("./utils/bridge-status.cjs");
+const bridge_js_1 = require("./utils/bridge.cjs");
+const history_js_1 = require("./utils/history.cjs");
+const metrics_js_1 = require("./utils/metrics.cjs");
+const network_js_1 = require("./utils/network.cjs");
+const trace_js_1 = require("./utils/trace.cjs");
+const transaction_js_1 = require("./utils/transaction.cjs");
+const metadata = {
+    // We want to persist the bridge status state so that we can show the proper data for the Activity list
+    // basically match the behavior of TransactionController
+    txHistory: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    // Deferred status updates used by QuoteStatusUpdateManager
+    quoteUpdateStatusStore: {
+        includeInStateLogs: false,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: false,
+    },
+};
+const MESSENGER_EXPOSED_METHODS = [
+    'startPollingForBridgeTxStatus',
+    'wipeBridgeStatus',
+    'resetState',
+    'submitTx',
+    'submitIntent',
+    'submitBatchSell',
+    'restartPollingForFailedAttempts',
+    'getBridgeHistoryItemByTxMetaId',
+];
+class BridgeStatusController extends (0, polling_controller_1.StaticIntervalPollingController)() {
+    constructor({ messenger, state, clientId, clientProduct, clientVersion, fetchFn, addTransactionBatchFn, config, traceFn, onQuoteStatusManagerError, isQuoteStatusManagerEnabled, }) {
+        super({
+            name: constants_js_1.BRIDGE_STATUS_CONTROLLER_NAME,
+            metadata,
+            messenger,
+            // Restore the persisted state
+            state: {
+                ...constants_js_1.DEFAULT_BRIDGE_STATUS_CONTROLLER_STATE,
+                ...state,
+            },
+        });
+        _BridgeStatusController_pollingTokensByTxMetaId.set(this, {});
+        _BridgeStatusController_intentManager.set(this, void 0);
+        _BridgeStatusController_quoteStatusManager.set(this, void 0);
+        _BridgeStatusController_clientId.set(this, void 0);
+        _BridgeStatusController_fetchFn.set(this, void 0);
+        _BridgeStatusController_config.set(this, void 0);
+        _BridgeStatusController_addTransactionBatchFn.set(this, void 0);
+        _BridgeStatusController_trace.set(this, void 0);
+        _BridgeStatusController_traceSwapOperationCompleted.set(this, async (historyKey, result, terminalStage) => {
+            if (!historyKey) {
+                return;
+            }
+            const historyItem = this.state.txHistory[historyKey];
+            const featureId = historyItem?.featureId ?? bridge_controller_1.FeatureId.UNIFIED_SWAP_BRIDGE;
+            if (!historyItem ||
+                historyItem.batchSellData ||
+                !constants_js_1.ALLOWED_FEATURE_IDS_FOR_STATUS_EVENTS.includes(featureId)) {
+                return;
+            }
+            await __classPrivateFieldGet(this, _BridgeStatusController_trace, "f").call(this, (0, trace_js_1.getSwapOperationCompletedTraceParams)(historyItem, historyKey, result, terminalStage), () => undefined);
+        });
+        _BridgeStatusController_onTransactionFailed.set(this, ({ txMeta, historyKey, isApprovalTxMeta, }) => {
+            const isHistoryItemAlreadyFailed = historyKey
+                ? this.state.txHistory[historyKey]?.status.status === bridge_controller_2.StatusTypes.FAILED
+                : false;
+            const isIntent = historyKey
+                ? Boolean(this.state.txHistory[historyKey]?.quote.intent)
+                : false;
+            __classPrivateFieldGet(this, _BridgeStatusController_updateHistoryItem, "f").call(this, {
+                historyKey,
+                status: bridge_controller_2.StatusTypes.FAILED,
+                txHash: isApprovalTxMeta ? undefined : txMeta.hash,
+                completionTime: Date.now(),
+            });
+            if (txMeta.status === transaction_controller_1.TransactionStatus.rejected) {
+                return;
+            }
+            if (isHistoryItemAlreadyFailed) {
+                return;
+            }
+            if (!isIntent) {
+                __classPrivateFieldGet(this, _BridgeStatusController_traceSwapOperationCompleted, "f").call(this, historyKey, 'error', 'source').catch(() => undefined);
+            }
+            // Report finalized failure for swap/bridge transactions.
+            // Note: TransactionStatus.rejected means the user cancelled signing, so the tx was never broadcast.
+            // `hasNestedSwapTransactions` also covers batch/7702 swaps whose type may
+            // still read as `batch` rather than `swap`.
+            if ((txMeta.type && (0, transaction_js_1.isCrossChainTx)(txMeta.type)) ||
+                (0, transaction_js_1.hasNestedSwapTransactions)(txMeta)) {
+                __classPrivateFieldGet(this, _BridgeStatusController_quoteStatusManager, "f").reportFinalised(txMeta.id, false, txMeta.chainId, txMeta.hash);
+            }
+            __classPrivateFieldGet(this, _BridgeStatusController_trackUnifiedSwapBridgeEvent, "f").call(this, bridge_controller_2.UnifiedSwapBridgeEventName.Failed, historyKey, (0, metrics_js_1.getEVMTxPropertiesFromTransactionMeta)(txMeta));
+        });
+        // Only EVM txs
+        _BridgeStatusController_onTransactionConfirmed.set(this, ({ txMeta, historyKey, isApprovalTxMeta, }) => {
+            // Return early if the confirmed txMeta is for an approval since we
+            // still need to wait for the trade to be confirmed
+            if (isApprovalTxMeta) {
+                return;
+            }
+            __classPrivateFieldGet(this, _BridgeStatusController_updateHistoryItem, "f").call(this, {
+                historyKey,
+                txHash: txMeta.hash,
+            });
+            const isIntent = historyKey
+                ? Boolean(this.state.txHistory[historyKey]?.quote.intent)
+                : false;
+            const isSwap = txMeta.type === transaction_controller_1.TransactionType.swap || (0, transaction_js_1.hasNestedSwapTransactions)(txMeta);
+            if (isSwap) {
+                __classPrivateFieldGet(this, _BridgeStatusController_updateHistoryItem, "f").call(this, {
+                    historyKey,
+                    status: bridge_controller_2.StatusTypes.COMPLETE,
+                    completionTime: Date.now(),
+                });
+                // For EVM intent-based swaps the synthetic tx transitions
+                // submitted→confirmed in a single update that carries the CoW
+                // settlement hash, so the submitted status handler never has a hash
+                // and reportSubmitted is never called. Call it here (before
+                // reportFinalised) so the deferred-queue entry is created.
+                const historyItem = historyKey
+                    ? this.state.txHistory[historyKey]
+                    : undefined;
+                if (historyKey &&
+                    historyItem &&
+                    txMeta.hash &&
+                    !(0, bridge_controller_2.isNonEvmChainId)(historyItem.quote.srcChainId)) {
+                    __classPrivateFieldGet(this, _BridgeStatusController_reportSubmittedOnce, "f").call(this, historyKey, txMeta.hash, txMeta.id);
+                }
+                __classPrivateFieldGet(this, _BridgeStatusController_quoteStatusManager, "f").reportFinalised(txMeta.id, true, txMeta.chainId, txMeta.hash);
+                if (!isIntent) {
+                    __classPrivateFieldGet(this, _BridgeStatusController_traceSwapOperationCompleted, "f").call(this, historyKey, 'success', 'source').catch(() => undefined);
+                }
+                __classPrivateFieldGet(this, _BridgeStatusController_trackUnifiedSwapBridgeEvent, "f").call(this, bridge_controller_2.UnifiedSwapBridgeEventName.Completed, historyKey);
+            }
+            else if (historyKey) {
+                __classPrivateFieldGet(this, _BridgeStatusController_startPollingForTxId, "f").call(this, historyKey);
+            }
+        });
+        /**
+         * Reports the SUBMITTED quote status for non-EVM transactions.
+         *
+         * EVM transactions report SUBMITTED via the
+         * `TransactionController:transactionStatusUpdated` subscription, which also
+         * picks up hash replacements (speed-up/cancel) and the late hash assignment
+         * of smart/batch transactions. Non-EVM transactions (Solana, Bitcoin, Tron)
+         * are submitted through Snaps and never emit TransactionController lifecycle
+         * events, so they are reported here once the history item exists and the
+         * source tx hash is known.
+         *
+         * @param historyKey - The key of the history item in `txHistory`
+         * @param txMeta - The submitted trade transaction's id and hash
+         * @param txMeta.id - The transaction meta id, used for finalization matching
+         * @param txMeta.hash - The source chain transaction hash
+         */
+        _BridgeStatusController_reportSubmittedForNonEvmTx.set(this, (historyKey, txMeta) => {
+            if (!txMeta?.id || !txMeta.hash) {
+                return;
+            }
+            const historyItem = this.state.txHistory[historyKey];
+            if (!historyItem || !(0, bridge_controller_2.isNonEvmChainId)(historyItem.quote.srcChainId)) {
+                return;
+            }
+            __classPrivateFieldGet(this, _BridgeStatusController_reportSubmittedOnce, "f").call(this, historyKey, txMeta.hash, txMeta.id);
+        });
+        /**
+         * Reports a SUBMITTED quote status update exactly once per source tx hash.
+         *
+         * SUBMITTED can be triggered from several code paths (submission, the first
+         * poll where the hash is known, and the final-status branch) and the poll
+         * path runs on every interval.
+         *
+         * For 7702/nested batch sells a single source transaction carries multiple
+         * quotes: the parent history item lists all of them in `quoteIds` (each a key
+         * into `txHistory`). In that case every quote is reported under the shared
+         * source tx hash and `txMetaId`.
+         *
+         * @param historyKey - The key of the history item in `txHistory`
+         * @param srcTxHash - The source chain transaction hash
+         * @param txMetaId - The transaction meta id, used for finalization matching
+         */
+        _BridgeStatusController_reportSubmittedOnce.set(this, (historyKey, srcTxHash, txMetaId) => {
+            const historyItem = this.state.txHistory[historyKey];
+            if (!historyItem) {
+                return;
+            }
+            // For a 7702/nested batch the parent item lists every quote in `quoteIds`
+            // (keys into `txHistory`); resolve each to its real quote id. Otherwise fall
+            // back to the item's own single quote id.
+            let quoteIds;
+            if (historyItem.quoteIds?.length) {
+                quoteIds = historyItem.quoteIds
+                    .map((quoteKey) => this.state.txHistory[quoteKey]?.quoteId)
+                    .filter((quoteId) => Boolean(quoteId));
+            }
+            else if (historyItem.quoteId) {
+                quoteIds = [historyItem.quoteId];
+            }
+            else {
+                quoteIds = [];
+            }
+            if (quoteIds.length === 0) {
+                return;
+            }
+            // `reportedSubmittedTxHash` is set once `reportSubmitted` is called.
+            // This avoids processing multiple `eportSubmitted` for the
+            // same swap/bridge.
+            if (historyItem.reportedSubmittedTxHash === srcTxHash) {
+                return;
+            }
+            for (const quoteId of quoteIds) {
+                __classPrivateFieldGet(this, _BridgeStatusController_quoteStatusManager, "f").reportSubmitted(quoteId, srcTxHash, txMetaId, historyItem.quote.srcChainId);
+            }
+            this.update((state) => {
+                const item = state.txHistory[historyKey];
+                if (item) {
+                    item.reportedSubmittedTxHash = srcTxHash;
+                }
+            });
+        });
+        this.resetState = () => {
+            __classPrivateFieldGet(this, _BridgeStatusController_quoteStatusManager, "f").destroy();
+            this.update((state) => {
+                state.txHistory = constants_js_1.DEFAULT_BRIDGE_STATUS_CONTROLLER_STATE.txHistory;
+                state.quoteUpdateStatusStore =
+                    constants_js_1.DEFAULT_BRIDGE_STATUS_CONTROLLER_STATE.quoteUpdateStatusStore;
+            });
+        };
+        this.wipeBridgeStatus = ({ address, ignoreNetwork, }) => {
+            // Wipe all networks for this address
+            if (ignoreNetwork) {
+                this.update((state) => {
+                    state.txHistory = constants_js_1.DEFAULT_BRIDGE_STATUS_CONTROLLER_STATE.txHistory;
+                });
+            }
+            else {
+                const selectedChainId = (0, network_js_1.getSelectedChainId)(this.messenger);
+                __classPrivateFieldGet(this, _BridgeStatusController_wipeBridgeStatusByChainId, "f").call(this, address, selectedChainId);
+            }
+        };
+        /**
+         * Resets the attempts counter for a bridge transaction history item
+         * and restarts polling if it was previously stopped due to max attempts
+         *
+         * @param identifier - Object containing either txMetaId or txHash to identify the history item
+         * @param identifier.txMetaId - The transaction meta ID
+         * @param identifier.txHash - The transaction hash
+         */
+        this.restartPollingForFailedAttempts = (identifier) => {
+            const { txMetaId, txHash } = identifier;
+            if (!txMetaId && !txHash) {
+                throw new Error('Either txMetaId or txHash must be provided');
+            }
+            // Find the history item by txMetaId or txHash
+            let targetTxMetaId;
+            if (txMetaId) {
+                // Direct lookup by txMetaId
+                if (this.state.txHistory[txMetaId]) {
+                    targetTxMetaId = txMetaId;
+                }
+            }
+            else if (txHash) {
+                // Search by txHash in status.srcChain.txHash
+                targetTxMetaId = Object.keys(this.state.txHistory).find((id) => this.state.txHistory[id].status.srcChain.txHash === txHash);
+            }
+            if (!targetTxMetaId) {
+                throw new Error(`No bridge transaction history found for ${txMetaId ? `txMetaId: ${txMetaId}` : `txHash: ${txHash}`}`);
+            }
+            const historyItem = this.state.txHistory[targetTxMetaId];
+            // Capture attempts count before resetting for metrics
+            const previousAttempts = historyItem.attempts?.counter ?? 0;
+            // Reset the attempts counter
+            this.update((state) => {
+                if (targetTxMetaId) {
+                    state.txHistory[targetTxMetaId].attempts = undefined;
+                }
+            });
+            // Restart polling if it was stopped and this tx still needs status updates
+            if ((0, history_js_1.shouldPollHistoryItem)(historyItem)) {
+                // Check if polling was stopped (no active polling token)
+                const existingPollingToken = __classPrivateFieldGet(this, _BridgeStatusController_pollingTokensByTxMetaId, "f")[targetTxMetaId];
+                if (!existingPollingToken) {
+                    // Restart polling
+                    __classPrivateFieldGet(this, _BridgeStatusController_startPollingForTxId, "f").call(this, targetTxMetaId);
+                    // Track polling manually restarted event
+                    __classPrivateFieldGet(this, _BridgeStatusController_trackUnifiedSwapBridgeEvent, "f").call(this, bridge_controller_2.UnifiedSwapBridgeEventName.PollingStatusUpdated, targetTxMetaId, {
+                        polling_status: bridge_controller_2.PollingStatus.ManuallyRestarted,
+                        retry_attempts: previousAttempts,
+                    });
+                }
+            }
+        };
+        /**
+         * Gets a bridge history item from the history by its transaction meta ID
+         *
+         * @param txMetaId - The transaction meta ID to look up
+         * @returns The bridge history item if found, undefined otherwise
+         */
+        this.getBridgeHistoryItemByTxMetaId = (txMetaId) => {
+            return this.state.txHistory[txMetaId];
+        };
+        /**
+         * Seeds missing quote-status entries from persisted history on startup.
+         *
+         * The deferred quote-status entry (keyed by `${quoteId}:${srcTxHash}`) is only
+         * created when `reportSubmitted` runs. If the client closes after a swap/bridge
+         * is submitted but before that happens, the entry is never created and
+         * `QuoteStatusManager.init()` has nothing to reconcile. The persisted history
+         * item carries the `quoteId`, source tx hash, and `txMetaId` needed to rebuild
+         * the entry, so we replay `reportSubmitted` here (idempotent via
+         * `#reportSubmittedOnce`) before `init()` runs.
+         */
+        _BridgeStatusController_seedQuoteStatusEntriesFromHistory.set(this, () => {
+            if (!__classPrivateFieldGet(this, _BridgeStatusController_quoteStatusManager, "f").enabled) {
+                // Skip seeding to prevent `#reportSubmittedOnce` from persisting
+                // `reportedSubmittedTxHash` so recent bridge history cannot be marked as
+                //  already reported with no store entry or backend update.
+                return;
+            }
+            for (const [historyKey, historyItem] of Object.entries(this.state.txHistory)) {
+                const { quoteId, quoteIds, txMetaId } = historyItem;
+                // A 7702/nested batch parent reports its quotes via `quoteIds` rather than
+                // its own single `quoteId`, so accept either. `#reportSubmittedOnce`
+                // resolves the actual set of quotes to report.
+                if ((!quoteId && !quoteIds?.length) || !txMetaId) {
+                    continue;
+                }
+                // Skip items older than the backfill window: the backend would reject
+                // a status report for a quote that old, so there is no point creating
+                // an entry or making a request.
+                if (Date.now() - historyItem.startTime >
+                    constants_js_2.QUOTE_STATUS_BACKFILL_WINDOW_MS) {
+                    continue;
+                }
+                // Prefer the history hash; fall back to the tx hash (covers STX swaps
+                // confirmed while closed, where the history hash was never written).
+                const srcTxHash = historyItem.status.srcChain.txHash ??
+                    (0, transaction_js_1.getTransactionMetaById)(this.messenger, txMetaId)?.hash;
+                if (!srcTxHash) {
+                    continue;
+                }
+                // Call `reportSubmittedOnce` for each history item that satisfies
+                // the above criteria. The method will then take care the rest
+                // (ie. if it actually needs to be reported or not because it already has been).
+                __classPrivateFieldGet(this, _BridgeStatusController_reportSubmittedOnce, "f").call(this, historyKey, srcTxHash, txMetaId);
+            }
+        });
+        /**
+         * Restart polling for txs that are not in a final state
+         * This is called during initialization
+         */
+        _BridgeStatusController_restartPollingForIncompleteHistoryItems.set(this, () => {
+            // Check for historyItems that do not have a status of complete and restart polling
+            const { txHistory } = this.state;
+            const historyItems = Object.entries(txHistory);
+            const incompleteHistoryItems = historyItems
+                .filter(([_, historyItem]) => historyItem.status.status === bridge_controller_2.StatusTypes.PENDING ||
+                historyItem.status.status === bridge_controller_2.StatusTypes.UNKNOWN)
+                // Only poll items with txMetaId (post-submission items)
+                .filter(([_, historyItem]) => {
+                if (!historyItem.txMetaId) {
+                    return false;
+                }
+                // Check if we are already polling this tx, if so, skip restarting polling for that
+                const pollingToken = __classPrivateFieldGet(this, _BridgeStatusController_pollingTokensByTxMetaId, "f")[historyItem.txMetaId];
+                return !pollingToken;
+            })
+                // Only restart polling for items that still require status updates
+                .filter(([_, historyItem]) => {
+                return (0, history_js_1.shouldPollHistoryItem)(historyItem);
+            });
+            incompleteHistoryItems.forEach(([historyKey, historyItem]) => {
+                const shouldSkipFetch = (0, bridge_status_js_1.shouldSkipFetchDueToFetchFailures)(historyItem.attempts);
+                if (shouldSkipFetch) {
+                    return;
+                }
+                // We manually call startPolling() here rather than go through startPollingForBridgeTxStatus()
+                // because we don't want to overwrite the existing historyItem in state
+                __classPrivateFieldGet(this, _BridgeStatusController_startPollingForTxId, "f").call(this, historyKey);
+            });
+        });
+        _BridgeStatusController_addTxToHistory.set(this, (historyKey, ...args) => {
+            const txHistoryItem = (0, history_js_1.getInitialHistoryItem)(...args);
+            this.update((state) => {
+                state.txHistory[historyKey] = txHistoryItem;
+            });
+            return historyKey;
+        });
+        /**
+         * Rekeys a history item from actionId to txMeta.id after successful submission.
+         * Also updates txMetaId and srcTxHash which weren't available pre-submission.
+         *
+         * @param oldKey - The temporary key to use for the history item, usually the actionId
+         * @param newKey - The new key to use, typcally the txmeta.id
+         * @param txMeta - The transaction meta from the successful submission
+         * @param txMeta.id - The transaction meta id to use as the new key
+         * @param txMeta.hash - The transaction hash to set on the history item
+         */
+        _BridgeStatusController_rekeyHistoryItem.set(this, (oldKey, newKey, txMeta) => {
+            this.update((state) => {
+                (0, history_js_1.rekeyHistoryItemInState)(state, oldKey, newKey, txMeta);
+            });
+        });
+        _BridgeStatusController_startPollingForTxId.set(this, (txId) => {
+            // If we are already polling for this tx, stop polling for it before restarting
+            const existingPollingToken = __classPrivateFieldGet(this, _BridgeStatusController_pollingTokensByTxMetaId, "f")[txId];
+            if (existingPollingToken) {
+                this.stopPollingByPollingToken(existingPollingToken);
+            }
+            const txHistoryItem = this.state.txHistory[txId];
+            if (txHistoryItem && (0, history_js_1.shouldPollHistoryItem)(txHistoryItem)) {
+                __classPrivateFieldGet(this, _BridgeStatusController_pollingTokensByTxMetaId, "f")[txId] = this.startPolling({
+                    bridgeTxMetaId: txId,
+                });
+            }
+        });
+        /**
+         * @deprecated For EVM/Solana swap/bridge txs we add tx to history in submitTx()
+         * For Solana swap/bridge we start polling in submitTx()
+         * For EVM bridge we listen for 'TransactionController:transactionConfirmed' and start polling there
+         * No clients currently call this, safe to remove in future versions
+         *
+         * Adds tx to history and starts polling for the bridge tx status
+         *
+         * @param txHistoryMeta - The parameters for creating the history item
+         */
+        this.startPollingForBridgeTxStatus = (txHistoryMeta) => {
+            const { bridgeTxMeta } = txHistoryMeta;
+            if (!bridgeTxMeta?.id) {
+                throw new Error('Cannot start polling: bridgeTxMeta.id is required for polling');
+            }
+            const historyKey = __classPrivateFieldGet(this, _BridgeStatusController_addTxToHistory, "f").call(this, bridgeTxMeta.id, txHistoryMeta);
+            __classPrivateFieldGet(this, _BridgeStatusController_startPollingForTxId, "f").call(this, historyKey);
+        };
+        // This will be called after you call this.startPolling()
+        // The args passed in are the args you passed in to startPolling()
+        this._executePoll = async (pollingInput) => {
+            await __classPrivateFieldGet(this, _BridgeStatusController_fetchBridgeTxStatus, "f").call(this, pollingInput);
+        };
+        /**
+         * Handles the failure to fetch the bridge tx status
+         * We eventually stop polling for the tx if we fail too many times
+         * Failures (500 errors) can be due to:
+         * - The srcTxHash not being available immediately for STX
+         * - The srcTxHash being invalid for the chain. This case will never resolve so we stop polling for it to avoid hammering the Bridge API forever.
+         *
+         * @param bridgeTxMetaId - The txMetaId of the bridge tx
+         */
+        _BridgeStatusController_handleFetchFailure.set(this, (bridgeTxMetaId) => {
+            const { attempts } = this.state.txHistory[bridgeTxMetaId];
+            const newAttempts = attempts
+                ? {
+                    counter: attempts.counter + 1,
+                    lastAttemptTime: Date.now(),
+                }
+                : {
+                    counter: 1,
+                    lastAttemptTime: Date.now(),
+                };
+            // If we've failed too many times, stop polling for the tx
+            const pollingToken = __classPrivateFieldGet(this, _BridgeStatusController_pollingTokensByTxMetaId, "f")[bridgeTxMetaId];
+            if (newAttempts.counter >= constants_js_1.MAX_ATTEMPTS && pollingToken) {
+                this.stopPollingByPollingToken(pollingToken);
+                delete __classPrivateFieldGet(this, _BridgeStatusController_pollingTokensByTxMetaId, "f")[bridgeTxMetaId];
+                // Track max polling reached event
+                const historyItem = this.state.txHistory[bridgeTxMetaId];
+                if (historyItem) {
+                    // Track polling status updated event
+                    __classPrivateFieldGet(this, _BridgeStatusController_trackPollingStatusUpdatedEvent, "f").call(this, bridgeTxMetaId, bridge_controller_2.PollingStatus.MaxPollingReached);
+                }
+            }
+            // Update the attempts counter
+            __classPrivateFieldGet(this, _BridgeStatusController_updateHistoryItem, "f").call(this, {
+                historyKey: bridgeTxMetaId,
+                attempts: newAttempts,
+            });
+        });
+        /**
+         * Checks if the history item should be preserved so its status can be fetched.
+         *
+         * @param bridgeTxMetaId - The txMetaId of the bridge tx
+         */
+        _BridgeStatusController_handleOldHistoryItem.set(this, async (bridgeTxMetaId) => {
+            // Continue polling on next restart if the history item is valid
+            if (this.state.txHistory[bridgeTxMetaId] &&
+                (await (0, bridge_status_js_1.shouldWaitForFinalBridgeStatus)(this.messenger, this.state.txHistory[bridgeTxMetaId]))) {
+                return;
+            }
+            const pollingToken = __classPrivateFieldGet(this, _BridgeStatusController_pollingTokensByTxMetaId, "f")[bridgeTxMetaId];
+            // Track polling status updated event
+            __classPrivateFieldGet(this, _BridgeStatusController_trackPollingStatusUpdatedEvent, "f").call(this, bridgeTxMetaId, bridge_controller_2.PollingStatus.InvalidTransactionHash);
+            // If we've failed too many times, stop polling for the tx
+            if (pollingToken) {
+                this.stopPollingByPollingToken(pollingToken);
+                delete __classPrivateFieldGet(this, _BridgeStatusController_pollingTokensByTxMetaId, "f")[bridgeTxMetaId];
+            }
+            // Delete the history item so polling doesn't start over on the next restart.
+            // Report finalization as a failure here, this is the only place that
+            // permanently ends polling, so it's the correct and non-duplicative point
+            // to emit the final status.
+            const historyItem = this.state.txHistory[bridgeTxMetaId];
+            __classPrivateFieldGet(this, _BridgeStatusController_quoteStatusManager, "f").reportFinalised(bridgeTxMetaId, false, historyItem?.quote.srcChainId, historyItem?.status.srcChain.txHash);
+            __classPrivateFieldGet(this, _BridgeStatusController_deleteHistoryItem, "f").call(this, bridgeTxMetaId);
+        });
+        _BridgeStatusController_fetchBridgeTxStatus.set(this, async ({ bridgeTxMetaId, }) => {
+            // 1. Check for history item
+            const { txHistory } = this.state;
+            const historyItem = txHistory[bridgeTxMetaId];
+            if (!historyItem) {
+                return;
+            }
+            // 2. Check for previous failures
+            if ((0, bridge_status_js_1.shouldSkipFetchDueToFetchFailures)(historyItem.attempts)) {
+                return;
+            }
+            // 3. Fetch transaction status
+            try {
+                let status;
+                let validationFailures = [];
+                if (historyItem.quote.intent) {
+                    const intentTxStatus = await __classPrivateFieldGet(this, _BridgeStatusController_intentManager, "f").getIntentTransactionStatus(bridgeTxMetaId, historyItem.quote.srcChainId, historyItem.quote.intent.protocol, __classPrivateFieldGet(this, _BridgeStatusController_clientId, "f"), historyItem.status.srcChain.txHash);
+                    if (intentTxStatus?.bridgeStatus === null ||
+                        intentTxStatus?.bridgeStatus === undefined) {
+                        return;
+                    }
+                    status = intentTxStatus.bridgeStatus.status;
+                    // Report SUBMITTED as soon as the intent's source/settlement hash is
+                    // known at poll time, before the order reaches a terminal status.
+                    const intentSrcTxHash = status.srcChain.txHash;
+                    if (intentSrcTxHash) {
+                        __classPrivateFieldGet(this, _BridgeStatusController_reportSubmittedOnce, "f").call(this, bridgeTxMetaId, intentSrcTxHash, bridgeTxMetaId);
+                    }
+                }
+                else {
+                    // We try here because we receive 500 errors from Bridge API if we try to fetch immediately after submitting the source tx
+                    // Oddly mostly happens on Optimism, never on Arbitrum. By the 2nd fetch, the Bridge API responds properly.
+                    // Also srcTxHash may not be available immediately for STX, so we don't want to fetch in those cases
+                    const srcTxHash = __classPrivateFieldGet(this, _BridgeStatusController_setAndGetSrcTxHash, "f").call(this, bridgeTxMetaId);
+                    if (!srcTxHash) {
+                        return;
+                    }
+                    // Report SUBMITTED as soon as a srcTxHash is known at poll time, for
+                    // every chain not just non-EVM sources.
+                    __classPrivateFieldGet(this, _BridgeStatusController_reportSubmittedOnce, "f").call(this, bridgeTxMetaId, srcTxHash, bridgeTxMetaId);
+                    const statusRequest = (0, bridge_status_js_1.getStatusRequestWithSrcTxHash)(historyItem.quote, srcTxHash);
+                    const response = (historyItem.quoteId
+                        ? await (0, bridge_status_js_1.fetchBridgeQuoteStatus)(__classPrivateFieldGet(this, _BridgeStatusController_quoteStatusManager, "f"), historyItem.quoteId)
+                        : null) ??
+                        (await (0, bridge_status_js_1.fetchBridgeTxStatus)(statusRequest, __classPrivateFieldGet(this, _BridgeStatusController_clientId, "f"), await (0, authentication_js_1.getJwt)(this.messenger), __classPrivateFieldGet(this, _BridgeStatusController_fetchFn, "f"), __classPrivateFieldGet(this, _BridgeStatusController_config, "f").customBridgeApiBaseUrl));
+                    status = response.status;
+                    validationFailures = response.validationFailures;
+                }
+                if (validationFailures.length > 0) {
+                    __classPrivateFieldGet(this, _BridgeStatusController_trackUnifiedSwapBridgeEvent, "f").call(this, bridge_controller_2.UnifiedSwapBridgeEventName.StatusValidationFailed, bridgeTxMetaId, {
+                        failures: validationFailures,
+                        refresh_count: historyItem.attempts?.counter ?? 0,
+                    });
+                    throw new Error(`Bridge status validation failed: ${validationFailures.join(', ')}`);
+                }
+                // 4. Create bridge history item
+                const newBridgeHistoryItem = {
+                    ...historyItem,
+                    status,
+                    completionTime: status.status === bridge_controller_2.StatusTypes.COMPLETE ||
+                        status.status === bridge_controller_2.StatusTypes.FAILED
+                        ? Date.now()
+                        : undefined, // TODO make this more accurate by looking up dest txHash block time
+                    attempts: undefined,
+                };
+                // No need to purge these on network change or account change, TransactionController does not purge either.
+                // TODO In theory we can skip checking status if it's not the current account/network
+                // we need to keep track of the account that this is associated with as well so that we don't show it in Activity list for other accounts
+                // First stab at this will not stop polling when you are on a different account
+                this.update((state) => {
+                    state.txHistory[bridgeTxMetaId] = newBridgeHistoryItem;
+                });
+                if (historyItem.quote.intent) {
+                    __classPrivateFieldGet(this, _BridgeStatusController_intentManager, "f").syncTransactionFromIntentStatus(bridgeTxMetaId, historyItem);
+                }
+                // 5. After effects
+                const pollingToken = __classPrivateFieldGet(this, _BridgeStatusController_pollingTokensByTxMetaId, "f")[bridgeTxMetaId];
+                const isFinalStatus = status.status === bridge_controller_2.StatusTypes.COMPLETE ||
+                    status.status === bridge_controller_2.StatusTypes.FAILED;
+                if (isFinalStatus) {
+                    if (pollingToken) {
+                        this.stopPollingByPollingToken(pollingToken);
+                        delete __classPrivateFieldGet(this, _BridgeStatusController_pollingTokensByTxMetaId, "f")[bridgeTxMetaId];
+                    }
+                    // Ensure a deferred entry exists before reportFinalised is called.
+                    const settlementTxHash = newBridgeHistoryItem.status.srcChain.txHash;
+                    if (settlementTxHash) {
+                        __classPrivateFieldGet(this, _BridgeStatusController_reportSubmittedOnce, "f").call(this, bridgeTxMetaId, settlementTxHash, bridgeTxMetaId);
+                    }
+                    __classPrivateFieldGet(this, _BridgeStatusController_quoteStatusManager, "f").reportFinalised(bridgeTxMetaId, status.status === bridge_controller_2.StatusTypes.COMPLETE, historyItem.quote.srcChainId, settlementTxHash);
+                    await __classPrivateFieldGet(this, _BridgeStatusController_traceSwapOperationCompleted, "f").call(this, bridgeTxMetaId, status.status === bridge_controller_2.StatusTypes.COMPLETE ? 'success' : 'error', (0, bridge_controller_2.isCrossChain)(historyItem.quote.srcChainId, historyItem.quote.destChainId)
+                        ? 'destination'
+                        : 'source').catch(() => undefined);
+                    if (status.status === bridge_controller_2.StatusTypes.COMPLETE) {
+                        __classPrivateFieldGet(this, _BridgeStatusController_trackUnifiedSwapBridgeEvent, "f").call(this, bridge_controller_2.UnifiedSwapBridgeEventName.Completed, bridgeTxMetaId);
+                        this.messenger.publish('BridgeStatusController:destinationTransactionCompleted', historyItem.quote.destAsset.assetId);
+                    }
+                    if (status.status === bridge_controller_2.StatusTypes.FAILED) {
+                        __classPrivateFieldGet(this, _BridgeStatusController_trackUnifiedSwapBridgeEvent, "f").call(this, bridge_controller_2.UnifiedSwapBridgeEventName.Failed, bridgeTxMetaId);
+                    }
+                }
+            }
+            catch (error) {
+                console.warn('Failed to fetch bridge tx status', error);
+                __classPrivateFieldGet(this, _BridgeStatusController_handleFetchFailure, "f").call(this, bridgeTxMetaId);
+            }
+            finally {
+                await __classPrivateFieldGet(this, _BridgeStatusController_handleOldHistoryItem, "f").call(this, bridgeTxMetaId);
+            }
+        });
+        /**
+         * Returns the srcTxHash for a non-STX EVM tx, the hash from the bridge status api,
+         * or the local hash from the TransactionController if the tx is in a finalized state
+         *
+         * @param bridgeTxMetaId - The bridge tx meta id
+         * @returns The srcTxHash
+         */
+        _BridgeStatusController_setAndGetSrcTxHash.set(this, (bridgeTxMetaId) => {
+            const { txHistory } = this.state;
+            // Prefer the srcTxHash from bridgeStatusState so we don't have to look up in TransactionController
+            // But it is possible to have bridgeHistoryItem in state without the srcTxHash yet when it is an STX
+            const srcTxHash = txHistory[bridgeTxMetaId].status.srcChain.txHash;
+            if (srcTxHash ||
+                (0, bridge_controller_2.isNonEvmChainId)(txHistory[bridgeTxMetaId].quote.srcChainId)) {
+                return srcTxHash;
+            }
+            // Update history with TransactionController's hash if it has been updated
+            const txMeta = (0, transaction_js_1.getTransactionMetaById)(this.messenger, bridgeTxMetaId);
+            if (!txMeta) {
+                return undefined;
+            }
+            // Wait for finalized status before updating the history item
+            const localTxHash = [
+                transaction_controller_1.TransactionStatus.confirmed,
+                transaction_controller_1.TransactionStatus.dropped,
+                transaction_controller_1.TransactionStatus.rejected,
+                transaction_controller_1.TransactionStatus.failed,
+            ].includes(txMeta.status)
+                ? txMeta.hash
+                : undefined;
+            __classPrivateFieldGet(this, _BridgeStatusController_updateHistoryItem, "f").call(this, {
+                historyKey: bridgeTxMetaId,
+                txHash: localTxHash,
+            });
+            return localTxHash;
+        });
+        _BridgeStatusController_updateHistoryItem.set(this, ({ historyKey, status, txHash, attempts, completionTime, }) => {
+            if (!historyKey) {
+                return;
+            }
+            this.update((currentState) => {
+                if (status) {
+                    currentState.txHistory[historyKey].status.status = status;
+                }
+                if (txHash) {
+                    currentState.txHistory[historyKey].status.srcChain.txHash = txHash;
+                }
+                if (attempts) {
+                    currentState.txHistory[historyKey].attempts = attempts;
+                }
+                if (completionTime) {
+                    currentState.txHistory[historyKey].completionTime = completionTime;
+                }
+            });
+        });
+        _BridgeStatusController_deleteHistoryItem.set(this, (historyKey) => {
+            this.update((currentState) => {
+                delete currentState.txHistory[historyKey];
+            });
+        });
+        // Wipes the bridge status for the given address and chainId
+        // Will match only source chainId to the selectedChainId
+        _BridgeStatusController_wipeBridgeStatusByChainId.set(this, (address, selectedChainId) => {
+            const sourceTxMetaIdsToDelete = Object.keys(this.state.txHistory).filter((txMetaId) => {
+                const bridgeHistoryItem = this.state.txHistory[txMetaId];
+                const hexSourceChainId = (0, utils_1.numberToHex)(bridgeHistoryItem.quote.srcChainId);
+                return (bridgeHistoryItem.account === address &&
+                    hexSourceChainId === selectedChainId);
+            });
+            sourceTxMetaIdsToDelete.forEach((sourceTxMetaId) => {
+                const pollingToken = __classPrivateFieldGet(this, _BridgeStatusController_pollingTokensByTxMetaId, "f")[sourceTxMetaId];
+                if (pollingToken) {
+                    this.stopPollingByPollingToken(__classPrivateFieldGet(this, _BridgeStatusController_pollingTokensByTxMetaId, "f")[sourceTxMetaId]);
+                    delete __classPrivateFieldGet(this, _BridgeStatusController_pollingTokensByTxMetaId, "f")[sourceTxMetaId];
+                }
+            });
+            this.update((state) => {
+                state.txHistory = sourceTxMetaIdsToDelete.reduce((acc, sourceTxMetaId) => {
+                    delete acc[sourceTxMetaId];
+                    return acc;
+                }, state.txHistory);
+            });
+        });
+        /**
+         * ******************************************************
+         * TX SUBMISSION HANDLING
+         *******************************************************
+         */
+        _BridgeStatusController_executeSubmitStrategy.set(this, async (params, sharedHistoryItemProperties) => {
+            let tradeTxMeta;
+            const steps = (0, index_js_1.default)(params);
+            // Each submission strategy determines when to execute step, which means these actions can happen in any order
+            for await (const { type, payload } of steps) {
+                try {
+                    switch (type) {
+                        case types_js_1.SubmitStep.RekeyHistoryItem:
+                            __classPrivateFieldGet(this, _BridgeStatusController_rekeyHistoryItem, "f").call(this, payload.oldHistoryKey, payload.newHistoryKey, payload.tradeMeta);
+                            // Report SUBMITTED as soon as the trade hash is known at submission
+                            // time, instead of waiting for the delayed transactionStatusUpdated
+                            // (submitted) event.
+                            if (payload.tradeMeta.hash) {
+                                __classPrivateFieldGet(this, _BridgeStatusController_reportSubmittedOnce, "f").call(this, payload.newHistoryKey, payload.tradeMeta.hash, payload.tradeMeta.id);
+                            }
+                            break;
+                        case types_js_1.SubmitStep.UpdateBatchTransactions:
+                            (0, transaction_js_1.updateTransactionsInBatch)({
+                                messenger: this.messenger,
+                                allTradesWithMetadata: payload.quoteAndTxMetas,
+                            });
+                            break;
+                        case types_js_1.SubmitStep.SetTradeMeta:
+                            tradeTxMeta = payload.tradeMeta;
+                            break;
+                        case types_js_1.SubmitStep.AddHistoryItem:
+                            __classPrivateFieldGet(this, _BridgeStatusController_addTxToHistory, "f").call(this, payload.historyKey, {
+                                ...payload,
+                                ...sharedHistoryItemProperties,
+                                quoteResponse: payload.quoteResponse,
+                                accountAddress: params.selectedAccount.address,
+                                isStxEnabled: params.isStxEnabled,
+                                slippagePercentage: sharedHistoryItemProperties.slippagePercentage ??
+                                    payload.quoteResponse.quote.slippage ??
+                                    0,
+                            });
+                            __classPrivateFieldGet(this, _BridgeStatusController_reportSubmittedForNonEvmTx, "f").call(this, payload.historyKey, payload.bridgeTxMeta);
+                            break;
+                        case types_js_1.SubmitStep.StartPolling:
+                            __classPrivateFieldGet(this, _BridgeStatusController_startPollingForTxId, "f").call(this, payload.historyKey);
+                            break;
+                        case types_js_1.SubmitStep.PublishCompletedEvent: {
+                            const completedHistoryItem = this.state.txHistory[payload.historyKey];
+                            __classPrivateFieldGet(this, _BridgeStatusController_traceSwapOperationCompleted, "f").call(this, payload.historyKey, 'success', 'source').catch(() => undefined);
+                            __classPrivateFieldGet(this, _BridgeStatusController_quoteStatusManager, "f").reportFinalised(payload.historyKey, true, completedHistoryItem?.quote.srcChainId, completedHistoryItem?.status.srcChain.txHash);
+                            __classPrivateFieldGet(this, _BridgeStatusController_trackUnifiedSwapBridgeEvent, "f").call(this, bridge_controller_2.UnifiedSwapBridgeEventName.Completed, payload.historyKey);
+                            break;
+                        }
+                        /* c8 ignore start */
+                        default:
+                            throw new Error(`Unknown submit step type: ${String(type)}`);
+                        /* c8 ignore end */
+                    }
+                }
+                catch (error) {
+                    console.error('Failed to add to bridge history and start polling.', error);
+                }
+            }
+            return tradeTxMeta;
+        });
+        /**
+         * Submits a cross-chain swap transaction
+         *
+         * @param accountAddress - The address of the account to submit the transaction for
+         * @param maybeQuoteResponses - A single quote response or an array of quote responses
+         * @param isStxEnabled - Whether smart transactions are enabled on the client, for example the getSmartTransactionsEnabled selector value from the extension
+         * @param quotesReceivedContext - The context for the QuotesReceived event
+         * @param location - The entry point from which the user initiated the swap or bridge (e.g. Main View, Token View, Trending Explore)
+         * @param abTests - Legacy A/B test context for `ab_tests` (backward compatibility)
+         * @param activeAbTests - New A/B test context for `active_ab_tests` (migration target). Attributes events to specific experiments.
+         * @param tokenSecurityTypeDestination - The security classification of the destination token, supplied by the client (e.g. from token security/scanning data). Pass `null` when no security data is available.
+         * @param batchSellTrades - Contains transaction data for the quotes, provided by the obtainGaslessBatch API
+         * @param inputPrimaryDenomination - The denomination shown as the primary source amount input at submission time.
+         * @param migrationPhase - The active migration phase for the quote response
+         * @returns The transaction meta
+         * @throws An error if transaction submission fails before it gets published
+         */
+        this.submitTx = async (accountAddress, maybeQuoteResponses, isStxEnabled, quotesReceivedContext, location = bridge_controller_2.MetaMetricsSwapsEventSource.Unknown, abTests, activeAbTests, tokenSecurityTypeDestination, batchSellTrades, inputPrimaryDenomination, migrationPhase) => {
+            /**
+             * If there are multiple quote responses, we assume that they all originate from the same src chain
+             * and the same account. In this case its safe to use the first quote response's properties for
+             * metrics and other pre-submission logic
+             */
+            const quoteResponsesV1orV2 = Array.isArray(maybeQuoteResponses)
+                ? maybeQuoteResponses
+                : [maybeQuoteResponses];
+            // Convert quote responses to V1 format and preserve metadata for consistency
+            const quoteResponses = quoteResponsesV1orV2.map((quote) => {
+                if (!(0, bridge_controller_1.isQuoteResponseV2)(quote)) {
+                    return quote;
+                }
+                const quoteMetadataV1 = (0, bridge_controller_1.toQuoteMetadataV1)(quote, migrationPhase);
+                // This coercion omits legacy metadata from the resulting V1 quote
+                const quoteResponseV1 = (0, bridge_controller_1.toQuoteResponseV1)(quote);
+                // Merge legacy-shaped metadata to V1-shaped quote response
+                return { ...quoteResponseV1, ...quoteMetadataV1 };
+            });
+            const quoteResponse = quoteResponses[0];
+            const { quote } = quoteResponse;
+            const startTime = Date.now();
+            (0, bridge_js_1.stopPollingForQuotes)(this.messenger, quotesReceivedContext);
+            const selectedAccount = (0, accounts_js_1.getAccountByAddress)(this.messenger, accountAddress);
+            if (!selectedAccount) {
+                throw new Error('Failed to submit cross-chain swap transaction: undefined multichain account');
+            }
+            const accountHardwareType = (0, bridge_controller_2.getAccountHardwareType)(selectedAccount);
+            /**
+             * For hardware wallets on Mobile, this is fixes an issue where the Ledger does not get prompted for the 2nd approval.
+             * Extension does not have this issue
+             */
+            const requireApproval = __classPrivateFieldGet(this, _BridgeStatusController_clientId, "f") === types_js_2.BridgeClientId.MOBILE && accountHardwareType !== null;
+            const isBridgeTx = (0, bridge_controller_2.isCrossChain)(quote.srcChainId, quote.destChainId);
+            const batchId = quoteResponses.some(({ featureId: quoteFeatureId }) => quoteFeatureId === bridge_controller_1.FeatureId.BATCH_SELL)
+                ? (0, transaction_controller_1.generateBatchId)()
+                : undefined;
+            const preConfirmationProperties = (0, metrics_js_1.getPreConfirmationPropertiesFromQuote)(quoteResponse, isStxEnabled, accountHardwareType, location, abTests, activeAbTests, tokenSecurityTypeDestination, batchSellTrades, batchId, quotesReceivedContext);
+            try {
+                // Emit Submitted event after submit button is clicked
+                __classPrivateFieldGet(this, _BridgeStatusController_trackUnifiedSwapBridgeEvent, "f").call(this, bridge_controller_2.UnifiedSwapBridgeEventName.Submitted, undefined, {
+                    ...preConfirmationProperties,
+                    ...(inputPrimaryDenomination && {
+                        input_primary_denomination: inputPrimaryDenomination,
+                    }),
+                });
+                /**
+                 * Check if the account is an EIP-7702 delegated account.
+                 * Delegated accounts only allow 1 in-flight tx, so approve + swap
+                 * must be batched into a single transaction
+                 */
+                const isDelegatedAccount = (0, bridge_controller_2.isNonEvmChainId)(quote.srcChainId)
+                    ? false
+                    : await (0, transaction_js_1.checkIsDelegatedAccount)(this.messenger, selectedAccount.address, [(0, bridge_controller_2.formatChainIdToHex)(quote.srcChainId)]);
+                const strategyParams = {
+                    messenger: this.messenger,
+                    quoteResponses,
+                    batchSellTrades,
+                    isStxEnabled,
+                    isBridgeTx,
+                    isDelegatedAccount,
+                    selectedAccount,
+                    requireApproval,
+                    clientId: __classPrivateFieldGet(this, _BridgeStatusController_clientId, "f"),
+                    bridgeApiBaseUrl: __classPrivateFieldGet(this, _BridgeStatusController_config, "f").customBridgeApiBaseUrl,
+                    addTransactionBatchFn: __classPrivateFieldGet(this, _BridgeStatusController_addTransactionBatchFn, "f"),
+                    fetchFn: __classPrivateFieldGet(this, _BridgeStatusController_fetchFn, "f"),
+                    traceFn: __classPrivateFieldGet(this, _BridgeStatusController_trace, "f"),
+                    batchId,
+                };
+                return await __classPrivateFieldGet(this, _BridgeStatusController_trace, "f").call(this, (0, trace_js_1.getTraceParams)(quoteResponse, isStxEnabled), async () => await __classPrivateFieldGet(this, _BridgeStatusController_executeSubmitStrategy, "f").call(this, strategyParams, {
+                    startTime,
+                    location,
+                    abTests,
+                    activeAbTests,
+                    tokenSecurityTypeDestination,
+                    inputPrimaryDenomination,
+                    customSlippage: quotesReceivedContext?.custom_slippage,
+                    slippagePercentage: quotesReceivedContext?.slippage_limit,
+                }));
+            }
+            catch (error) {
+                __classPrivateFieldGet(this, _BridgeStatusController_trackUnifiedSwapBridgeEvent, "f").call(this, bridge_controller_2.UnifiedSwapBridgeEventName.Failed, undefined, {
+                    error_message: error?.message,
+                    ...preConfirmationProperties,
+                });
+                throw error;
+            }
+        };
+        /**
+         * Submits an intent order and creates a synthetic history entry for UX.
+         * The EIP-712 payload is always signed inside this controller via KeyringController.
+         *
+         * @param params - Object containing intent submission parameters
+         * @param params.quoteResponse - Quote carrying intent data
+         * @param params.accountAddress - The EOA submitting the order
+         * @param params.location - The entry point from which the user initiated the swap or bridge
+         * @param params.abTests - Legacy A/B test context for `ab_tests` (backward compatibility)
+         * @param params.activeAbTests - New A/B test context for `active_ab_tests` (migration target). Attributes events to specific experiments.
+         * @param params.tokenSecurityTypeDestination - The security classification of the destination token, supplied by the client (e.g. from token security/scanning data). Pass `null` when no security data is available.
+         * @param params.inputPrimaryDenomination - The denomination shown as the primary source amount input at submission time.
+         * @param params.isStxEnabled - Whether smart transactions are enabled on the client, for example the getSmartTransactionsEnabled selector value from the extension
+         * @param params.quotesReceivedContext - The context for the QuotesReceived event
+         * @param params.migrationPhase - The active migration phase for the quote response
+         * @returns A lightweight TransactionMeta-like object for history linking
+         * @throws An error if intent or transaction submission fails before they get published
+         */
+        this.submitIntent = async (params) => {
+            const { quoteResponse, accountAddress, location, abTests, migrationPhase, activeAbTests, tokenSecurityTypeDestination, inputPrimaryDenomination, isStxEnabled = false, quotesReceivedContext, } = params;
+            return await this.submitTx(accountAddress, quoteResponse, isStxEnabled, quotesReceivedContext, location, abTests, activeAbTests, tokenSecurityTypeDestination, undefined, inputPrimaryDenomination, migrationPhase);
+        };
+        this.submitBatchSell = async (params) => {
+            /**
+             * Retrieve the batch sell trades from the BridgeController's state to ensure we submit
+             * the original response data from the bridge-api
+             */
+            const batchSellTrades = (0, bridge_js_1.getBatchSellTrades)(this.messenger);
+            return await this.submitTx(params.accountAddress, params.quoteResponses.filter((quoteResponse) => quoteResponse !== null), params.isStxEnabled ?? false, params.quotesReceivedContext, params.location, params.abTests, params.activeAbTests, params.tokenSecurityTypeDestination, batchSellTrades, undefined, params.migrationPhase);
+        };
+        _BridgeStatusController_trackPollingStatusUpdatedEvent.set(this, (historyKey, pollingStatus) => {
+            // Track polling status updated event
+            const historyItem = this.state.txHistory[historyKey];
+            __classPrivateFieldGet(this, _BridgeStatusController_trackUnifiedSwapBridgeEvent, "f").call(this, bridge_controller_2.UnifiedSwapBridgeEventName.PollingStatusUpdated, historyKey, {
+                polling_status: pollingStatus,
+                retry_attempts: historyItem.attempts?.counter ?? 0,
+            });
+        });
+        /**
+         * Tracks post-submission events for a cross-chain swap based on the history item
+         *
+         * @param eventName - The name of the event to track
+         * @param txHistoryKey - The txMetaId, actionId or intentUid of the history item to track the event for
+         * @param eventProperties - The properties for the event
+         */
+        _BridgeStatusController_trackUnifiedSwapBridgeEvent.set(this, (eventName, txHistoryKey, eventProperties) => {
+            const historyItem = txHistoryKey
+                ? this.state.txHistory[txHistoryKey]
+                : undefined;
+            const featureId = eventProperties?.feature_id ??
+                historyItem?.featureId ??
+                bridge_controller_1.FeatureId.UNIFIED_SWAP_BRIDGE;
+            if (!(constants_js_1.ALLOWED_FEATURE_IDS_FOR_STATUS_EVENTS.includes(featureId) ||
+                eventName === bridge_controller_2.UnifiedSwapBridgeEventName.StatusValidationFailed)) {
+                return;
+            }
+            // Legacy/new metrics fields are intentionally kept independent during migration.
+            const historyAbTests = txHistoryKey
+                ? this.state.txHistory?.[txHistoryKey]?.abTests
+                : undefined;
+            const historyActiveAbTests = txHistoryKey
+                ? this.state.txHistory?.[txHistoryKey]?.activeAbTests
+                : undefined;
+            const resolvedAbTests = eventProperties?.ab_tests ?? historyAbTests;
+            const resolvedActiveAbTests = eventProperties?.active_ab_tests ?? historyActiveAbTests;
+            const location = historyItem?.location ??
+                eventProperties?.location ??
+                bridge_controller_2.MetaMetricsSwapsEventSource.Unknown;
+            const baseProperties = {
+                action_type: bridge_controller_2.MetricsActionType.SWAPBRIDGE_V1,
+                feature_id: featureId ?? bridge_controller_1.FeatureId.UNIFIED_SWAP_BRIDGE,
+                ...(historyItem?.batchId ? { batch_id: historyItem.batchId } : {}),
+                ...(eventProperties ?? {}),
+                location,
+                ...(resolvedAbTests &&
+                    Object.keys(resolvedAbTests).length > 0 && {
+                    ab_tests: resolvedAbTests,
+                }),
+                ...(resolvedActiveAbTests &&
+                    resolvedActiveAbTests.length > 0 && {
+                    active_ab_tests: resolvedActiveAbTests,
+                }),
+            };
+            // This will publish events for PERPS dropped tx failures as well
+            if (!historyItem) {
+                (0, bridge_js_1.trackMetricsEvent)({
+                    messenger: this.messenger,
+                    eventName,
+                    properties: baseProperties,
+                });
+                return;
+            }
+            const { approvalTxId, quote } = historyItem;
+            const requestParamProperties = (0, metrics_js_1.getRequestParamFromHistory)(historyItem);
+            if (eventName === bridge_controller_2.UnifiedSwapBridgeEventName.StatusValidationFailed) {
+                (0, bridge_js_1.trackMetricsEvent)({
+                    messenger: this.messenger,
+                    eventName,
+                    properties: {
+                        ...baseProperties,
+                        chain_id_source: requestParamProperties.chain_id_source,
+                        chain_id_destination: requestParamProperties.chain_id_destination,
+                        token_address_source: requestParamProperties.token_address_source,
+                        token_address_destination: requestParamProperties.token_address_destination,
+                        token_security_type_destination: requestParamProperties.token_security_type_destination,
+                        refresh_count: historyItem.attempts?.counter ?? 0,
+                    },
+                });
+                return;
+            }
+            const selectedAccount = (0, accounts_js_1.getAccountByAddress)(this.messenger, historyItem.account);
+            const transactions = (0, transaction_js_1.getTransactions)(this.messenger);
+            const txMeta = transactions.find((tx) => tx.id === txHistoryKey);
+            const approvalTxMeta = transactions.find((tx) => tx.id === approvalTxId);
+            const requiredEventProperties = {
+                ...baseProperties,
+                ...requestParamProperties,
+                ...(0, metrics_js_1.getRequestMetadataFromHistory)(historyItem, selectedAccount),
+                ...(0, metrics_js_1.getTradeDataFromHistory)(historyItem),
+                ...(0, metrics_js_1.getTxStatusesFromHistory)(historyItem),
+                ...(0, metrics_js_1.getFinalizedTxProperties)(historyItem, txMeta, approvalTxMeta),
+                ...(0, metrics_js_1.getPriceImpactFromQuote)(quote),
+                ...(eventName === bridge_controller_2.UnifiedSwapBridgeEventName.Completed && {
+                    ...(!(0, bridge_controller_2.isNonEvmChainId)(historyItem.quote.srcChainId) &&
+                        historyItem.txMetaId && {
+                        transaction_internal_id: historyItem.txMetaId,
+                    }),
+                    ...(historyItem.inputPrimaryDenomination && {
+                        input_primary_denomination: historyItem.inputPrimaryDenomination,
+                    }),
+                }),
+            };
+            (0, bridge_js_1.trackMetricsEvent)({
+                messenger: this.messenger,
+                eventName,
+                properties: requiredEventProperties,
+            });
+        });
+        __classPrivateFieldSet(this, _BridgeStatusController_clientId, clientId, "f");
+        __classPrivateFieldSet(this, _BridgeStatusController_fetchFn, fetchFn, "f");
+        __classPrivateFieldSet(this, _BridgeStatusController_addTransactionBatchFn, addTransactionBatchFn, "f");
+        __classPrivateFieldSet(this, _BridgeStatusController_config, {
+            customBridgeApiBaseUrl: config?.customBridgeApiBaseUrl ?? constants_js_1.BRIDGE_PROD_API_BASE_URL,
+        }, "f");
+        __classPrivateFieldSet(this, _BridgeStatusController_trace, traceFn ?? ((_request, fn) => fn?.()), "f");
+        __classPrivateFieldSet(this, _BridgeStatusController_intentManager, new bridge_status_controller_intent_1.IntentManager({
+            messenger: this.messenger,
+            customBridgeApiBaseUrl: __classPrivateFieldGet(this, _BridgeStatusController_config, "f").customBridgeApiBaseUrl,
+            fetchFn: __classPrivateFieldGet(this, _BridgeStatusController_fetchFn, "f"),
+        }), "f");
+        __classPrivateFieldSet(this, _BridgeStatusController_quoteStatusManager, new quotes_status_manager_js_1.QuoteStatusManager({
+            messenger: this.messenger,
+            clientId: __classPrivateFieldGet(this, _BridgeStatusController_clientId, "f"),
+            clientProduct,
+            clientVersion,
+            apiBaseUrl: __classPrivateFieldGet(this, _BridgeStatusController_config, "f").customBridgeApiBaseUrl,
+            initialData: this.state.quoteUpdateStatusStore,
+            onPersistUpdates: (updates) => {
+                this.update((draft) => {
+                    draft.quoteUpdateStatusStore = updates;
+                });
+            },
+            entryTtlMs: constants_js_2.QUOTE_STATUS_UPDATE_ENTRY_TTL,
+            updateIntervalMs: constants_js_2.QUOTE_STATUS_UPDATE_RETRY_INTERVAL_MS,
+            onError: onQuoteStatusManagerError,
+            isEnabled: isQuoteStatusManagerEnabled,
+        }), "f");
+        // Register action handlers
+        this.messenger.registerMethodActionHandlers(this, MESSENGER_EXPOSED_METHODS);
+        // Set interval
+        this.setIntervalLength(constants_js_1.REFRESH_INTERVAL_MS);
+        this.messenger.subscribe('TransactionController:transactionStatusUpdated', ({ txMeta, historyKey, historyItem, isApprovalTxMeta }) => {
+            if (!txMeta) {
+                return;
+            }
+            const { type, status } = txMeta;
+            // Allow event publishing if the txMeta is a swap/bridge OR if the
+            // corresponding history item exists
+            const isSwapOrBridgeTransaction = type && (0, transaction_js_1.isCrossChainTx)(type);
+            if (!isSwapOrBridgeTransaction && !historyKey && !historyItem) {
+                return;
+            }
+            switch (status) {
+                case transaction_controller_1.TransactionStatus.submitted:
+                    // EVM txs report SUBMITTED here (not via transactionSubmitted) so hash
+                    // replacements before confirmation still reach the Bridge API.
+                    if (txMeta.hash &&
+                        txMeta.type &&
+                        (0, transaction_js_1.isCrossChainTx)(txMeta.type) &&
+                        !isApprovalTxMeta &&
+                        historyKey) {
+                        __classPrivateFieldGet(this, _BridgeStatusController_reportSubmittedOnce, "f").call(this, historyKey, txMeta.hash, txMeta.id);
+                    }
+                    break;
+                case transaction_controller_1.TransactionStatus.confirmed:
+                    __classPrivateFieldGet(this, _BridgeStatusController_onTransactionConfirmed, "f").call(this, {
+                        txMeta,
+                        historyKey,
+                        isApprovalTxMeta,
+                    });
+                    break;
+                case transaction_controller_1.TransactionStatus.failed:
+                case transaction_controller_1.TransactionStatus.dropped:
+                case transaction_controller_1.TransactionStatus.rejected:
+                    __classPrivateFieldGet(this, _BridgeStatusController_onTransactionFailed, "f").call(this, { txMeta, historyKey, isApprovalTxMeta });
+                    break;
+                default:
+                    break;
+            }
+        }, ({ transactionMeta }) => {
+            const entry = (0, history_js_1.getMatchingHistoryEntryForTxMeta)(this.state.txHistory, transactionMeta);
+            const approvalEntry = (0, history_js_1.getMatchingHistoryEntryForApprovalTxMeta)(this.state.txHistory, transactionMeta);
+            const entryToUse = entry ?? approvalEntry;
+            return {
+                historyKey: entryToUse?.[0],
+                historyItem: entryToUse?.[1],
+                txMeta: transactionMeta,
+                isApprovalTxMeta: entryToUse?.[1]?.approvalTxId === transactionMeta.id,
+            };
+        });
+        // Seed any missing quote-status entries from persisted history before
+        // init(), so init()'s reconciliation loop can finalize quotes whose
+        // deferred entry was never created (e.g. the client closed before
+        // reportSubmitted ran).
+        __classPrivateFieldGet(this, _BridgeStatusController_seedQuoteStatusEntriesFromHistory, "f").call(this);
+        // Replay swap/bridge finalizations that resolved while the client was
+        // closed, before resuming polling (which recovers in-flight bridges).
+        __classPrivateFieldGet(this, _BridgeStatusController_quoteStatusManager, "f").init();
+        // If you close the extension, but keep the browser open, the polling continues
+        // If you close the browser, the polling stops
+        // Check for historyItems that do not have a status of complete and restart polling
+        __classPrivateFieldGet(this, _BridgeStatusController_restartPollingForIncompleteHistoryItems, "f").call(this);
+    }
+}
+exports.BridgeStatusController = BridgeStatusController;
+_BridgeStatusController_pollingTokensByTxMetaId = new WeakMap(), _BridgeStatusController_intentManager = new WeakMap(), _BridgeStatusController_quoteStatusManager = new WeakMap(), _BridgeStatusController_clientId = new WeakMap(), _BridgeStatusController_fetchFn = new WeakMap(), _BridgeStatusController_config = new WeakMap(), _BridgeStatusController_addTransactionBatchFn = new WeakMap(), _BridgeStatusController_trace = new WeakMap(), _BridgeStatusController_traceSwapOperationCompleted = new WeakMap(), _BridgeStatusController_onTransactionFailed = new WeakMap(), _BridgeStatusController_onTransactionConfirmed = new WeakMap(), _BridgeStatusController_reportSubmittedForNonEvmTx = new WeakMap(), _BridgeStatusController_reportSubmittedOnce = new WeakMap(), _BridgeStatusController_seedQuoteStatusEntriesFromHistory = new WeakMap(), _BridgeStatusController_restartPollingForIncompleteHistoryItems = new WeakMap(), _BridgeStatusController_addTxToHistory = new WeakMap(), _BridgeStatusController_rekeyHistoryItem = new WeakMap(), _BridgeStatusController_startPollingForTxId = new WeakMap(), _BridgeStatusController_handleFetchFailure = new WeakMap(), _BridgeStatusController_handleOldHistoryItem = new WeakMap(), _BridgeStatusController_fetchBridgeTxStatus = new WeakMap(), _BridgeStatusController_setAndGetSrcTxHash = new WeakMap(), _BridgeStatusController_updateHistoryItem = new WeakMap(), _BridgeStatusController_deleteHistoryItem = new WeakMap(), _BridgeStatusController_wipeBridgeStatusByChainId = new WeakMap(), _BridgeStatusController_executeSubmitStrategy = new WeakMap(), _BridgeStatusController_trackPollingStatusUpdatedEvent = new WeakMap(), _BridgeStatusController_trackUnifiedSwapBridgeEvent = new WeakMap();
+//# sourceMappingURL=bridge-status-controller.cjs.map