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

package/dist/bridge-controller.mjs

@@ -0,0 +1,1040 @@
+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 _BridgeController_instances, _BridgeController_abortController, _BridgeController_batchSellTradesAbortController, _BridgeController_quotesFirstFetched, _BridgeController_location, _BridgeController_clientId, _BridgeController_clientVersion, _BridgeController_getLayer1GasFee, _BridgeController_fetchFn, _BridgeController_trackMetaMetricsFn, _BridgeController_trace, _BridgeController_config, _BridgeController_getUseAssetsControllerForRates, _BridgeController_trackQuoteValidationFailures, _BridgeController_fetchAssetExchangeRates, _BridgeController_hasInsufficientBalance, _BridgeController_appendInsufficientBalAndResetApproval, _BridgeController_shouldResetApproval, _BridgeController_fetchBridgeQuotes, _BridgeController_handleQuoteStreaming, _BridgeController_setMinimumBalanceForRentExemptionInLamports, _BridgeController_getMultichainSelectedAccount, _BridgeController_getNetworkClientByChainId, _BridgeController_getJwt, _BridgeController_getRequestMetadata, _BridgeController_getQuoteFetchData, _BridgeController_getEventProperties, _BridgeController_trackInputChangedEvents, _BridgeController_getUSDTMainnetAllowance;
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+import { BigNumber } from "@ethersproject/bignumber";
+import { Contract } from "@ethersproject/contracts";
+import { Web3Provider } from "@ethersproject/providers";
+import { abiERC20 } from "@metamask/metamask-eth-abis";
+import { StaticIntervalPollingController } from "@metamask/polling-controller";
+import { v4 as uuid } from "uuid";
+import { toQuoteResponseV2 } from "./coercers/quote-response-v1-to-v2.mjs";
+import { BRIDGE_CONTROLLER_NAME, BRIDGE_PROD_API_BASE_URL, DEFAULT_BRIDGE_CONTROLLER_STATE, METABRIDGE_ETHEREUM_ADDRESS, REFRESH_INTERVAL_MS } from "./constants/bridge.mjs";
+import { CHAIN_IDS } from "./constants/chains.mjs";
+import { SWAPS_CONTRACT_ADDRESSES } from "./constants/swaps.mjs";
+import { TraceName } from "./constants/traces.mjs";
+import { RequestStatus } from "./types.mjs";
+import { getAssetIdsForToken, toExchangeRates } from "./utils/assets.mjs";
+import { hasSufficientBalance } from "./utils/balance.mjs";
+import { getDefaultBridgeControllerState, isCrossChain, isEthUsdt, isNonEvmChainId, isSolanaChainId } from "./utils/bridge.mjs";
+import { formatAddressToCaipReference, formatChainIdToCaip, formatChainIdToHex } from "./utils/caip-formatters.mjs";
+import { getBridgeFeatureFlags, hasMinimumRequiredVersion } from "./utils/feature-flags.mjs";
+import { fetchAssetPrices, fetchBridgeQuotes, fetchBridgeQuoteStream, fetchBatchSellTrades } from "./utils/fetch.mjs";
+import { AbortReason, BatchSellMetricsEventName, MetaMetricsSwapsEventSource, MetricsActionType, UnifiedSwapBridgeEventName } from "./utils/metrics/constants.mjs";
+import { formatProviderLabel, getAccountHardwareType, getRequestParams, getSwapType, getSwapTypeFromQuote, isCustomSlippage, toInputChangedPropertyKey, toInputChangedPropertyValue } from "./utils/metrics/properties.mjs";
+import { appendFeesToQuotes } from "./utils/quote-fees.mjs";
+import { getMinimumBalanceForRentExemptionInLamports } from "./utils/snaps.mjs";
+import { sortQuotes } from "./utils/sort-quotes.mjs";
+import { isValidQuoteRequest, isValidBatchSellQuoteRequest } from "./validators/quote-request.mjs";
+const metadata = {
+    quoteRequest: {
+        includeInStateLogs: true,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    quotes: {
+        includeInStateLogs: true,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    quotesInitialLoadTime: {
+        includeInStateLogs: true,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    quotesLastFetched: {
+        includeInStateLogs: true,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    quotesLoadingStatus: {
+        includeInStateLogs: true,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    quoteFetchError: {
+        includeInStateLogs: true,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    quotesRefreshCount: {
+        includeInStateLogs: true,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    assetExchangeRates: {
+        includeInStateLogs: true,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    minimumBalanceForRentExemptionInLamports: {
+        includeInStateLogs: true,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    tokenWarnings: {
+        includeInStateLogs: true,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    tokenSecurityTypeDestination: {
+        includeInStateLogs: true,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    inputPrimaryDenomination: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    quoteStreamComplete: {
+        includeInStateLogs: true,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    batchSellTrades: {
+        includeInStateLogs: true,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    batchSellTradesLoadingStatus: {
+        includeInStateLogs: true,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+};
+const QUOTE_ABORT_REASONS = new Set(Object.values(AbortReason));
+const isExpectedQuoteAbort = (error, signal) => {
+    if (signal?.aborted) {
+        return true;
+    }
+    if (QUOTE_ABORT_REASONS.has(String(error))) {
+        return true;
+    }
+    const errorText = error instanceof Error ? `${error.name} ${error.message}` : String(error);
+    return (errorText.includes('AbortError') ||
+        errorText.includes('FetchRequestCanceledException'));
+};
+const MESSENGER_EXPOSED_METHODS = [
+    'updateBridgeQuoteRequestParams',
+    'fetchQuotes',
+    'updateBatchSellTrades',
+    'stopPollingForQuotes',
+    'setLocation',
+    'getLocation',
+    'setInputPrimaryDenomination',
+    'resetState',
+    'setChainIntervalLength',
+    'trackUnifiedSwapBridgeEvent',
+];
+export class BridgeController extends StaticIntervalPollingController() {
+    constructor({ messenger, state, clientId, clientVersion, getLayer1GasFee, fetchFn, config, trackMetaMetricsFn, traceFn, getUseAssetsControllerForRates, }) {
+        super({
+            name: BRIDGE_CONTROLLER_NAME,
+            metadata,
+            messenger,
+            state: {
+                ...getDefaultBridgeControllerState(),
+                ...state,
+            },
+        });
+        _BridgeController_instances.add(this);
+        _BridgeController_abortController.set(this, void 0);
+        _BridgeController_batchSellTradesAbortController.set(this, void 0);
+        _BridgeController_quotesFirstFetched.set(this, void 0);
+        /**
+         * Stores the location/entry point from which the user initiated the swap or bridge flow.
+         * Set via setLocation() before navigating to the swap/bridge flow.
+         * Used as default for all subsequent internal events.
+         */
+        _BridgeController_location.set(this, MetaMetricsSwapsEventSource.Unknown);
+        _BridgeController_clientId.set(this, void 0);
+        _BridgeController_clientVersion.set(this, void 0);
+        _BridgeController_getLayer1GasFee.set(this, void 0);
+        _BridgeController_fetchFn.set(this, void 0);
+        _BridgeController_trackMetaMetricsFn.set(this, void 0);
+        _BridgeController_trace.set(this, void 0);
+        _BridgeController_config.set(this, void 0);
+        /**
+         * Returns whether to use AssetsController for exchange rates.
+         * Set via constructor option getUseAssetsControllerForRates; defaults to false.
+         *
+         * @returns True when exchange rates should be read from AssetsController:getExchangeRatesForBridge.
+         */
+        _BridgeController_getUseAssetsControllerForRates.set(this, void 0);
+        this._executePoll = async (pollingInput) => {
+            await __classPrivateFieldGet(this, _BridgeController_fetchBridgeQuotes, "f").call(this, pollingInput);
+        };
+        /**
+         * Updates the quote request at the specified index with the given parameters, then starts
+         * polling for quotes.
+         *
+         * @param paramsToUpdate - The parameters to update in the quote request at the specified index
+         * @param context - metrics context
+         * @param quoteRequestIndex - The index of the quote request to update
+         * @param quoteRequestCount - The number of quote requests in the UI
+         */
+        this.updateBridgeQuoteRequestParams = async (paramsToUpdate, context, quoteRequestIndex = 0, quoteRequestCount = 1) => {
+            // Guard against updating a quote request that doesn't exist
+            if (quoteRequestIndex >= quoteRequestCount) {
+                return;
+            }
+            __classPrivateFieldGet(this, _BridgeController_trackInputChangedEvents, "f").call(this, paramsToUpdate, context.feature_id, quoteRequestIndex);
+            this.resetState(AbortReason.QuoteRequestUpdated, quoteRequestIndex);
+            this.update((state) => {
+                // Update only the specified quote request and keep the rest of the quote requests unchanged
+                state.quoteRequest = state.quoteRequest
+                    .slice(0, quoteRequestIndex)
+                    .concat({
+                    ...DEFAULT_BRIDGE_CONTROLLER_STATE.quoteRequest[0],
+                    ...paramsToUpdate,
+                })
+                    .concat(state.quoteRequest.slice(quoteRequestIndex + 1, quoteRequestCount));
+                state.tokenSecurityTypeDestination =
+                    context.token_security_type_destination ?? null;
+            });
+            // BatchSell and Unified swaps both use the same polling logic so both validations should pass
+            if (isValidQuoteRequest(paramsToUpdate) &&
+                isValidBatchSellQuoteRequest(this.state.quoteRequest)) {
+                __classPrivateFieldSet(this, _BridgeController_quotesFirstFetched, Date.now(), "f");
+                // Update the insufficientBal and resetApproval params for the quote request
+                const quoteWithInsufficientBalAndResetApproval = await __classPrivateFieldGet(this, _BridgeController_appendInsufficientBalAndResetApproval, "f").call(this, paramsToUpdate);
+                this.update((state) => {
+                    state.quoteRequest[quoteRequestIndex] =
+                        quoteWithInsufficientBalAndResetApproval;
+                });
+                // Set refresh rate based on the source chain before starting polling
+                this.setChainIntervalLength();
+                this.startPolling({
+                    quoteRequests: this.state.quoteRequest,
+                    context,
+                });
+            }
+        };
+        /**
+         * Fetches quotes for specified request without updating the controller state
+         * This method does not start polling for quotes and does not emit UnifiedSwapBridge events
+         *
+         * @param quoteRequest - The parameters for quote requests to fetch
+         * @param featureId - The feature ID that maps to quoteParam overrides from LD
+         * @param abortSignal - The abort signal to cancel all the requests
+         * @returns A list of validated quotes
+         */
+        this.fetchQuotes = async (quoteRequest, featureId, abortSignal = null) => {
+            const bridgeFeatureFlags = getBridgeFeatureFlags(this.messenger);
+            const jwt = await __classPrivateFieldGet(this, _BridgeController_getJwt, "f").call(this);
+            // If featureId is specified, retrieve the quoteRequestOverrides for that featureId
+            const quoteRequestOverrides = featureId
+                ? bridgeFeatureFlags.quoteRequestOverrides?.[featureId]
+                : undefined;
+            const resetApproval = await __classPrivateFieldGet(this, _BridgeController_shouldResetApproval, "f").call(this, quoteRequest);
+            // If quoteRequestOverrides is specified, merge it with the quoteRequest
+            const { quotes: baseQuotes, validationFailures } = await fetchBridgeQuotes(quoteRequestOverrides
+                ? { ...quoteRequest, ...quoteRequestOverrides, resetApproval }
+                : { ...quoteRequest, resetApproval }, abortSignal, __classPrivateFieldGet(this, _BridgeController_clientId, "f"), jwt, __classPrivateFieldGet(this, _BridgeController_fetchFn, "f"), __classPrivateFieldGet(this, _BridgeController_config, "f").customBridgeApiBaseUrl ?? BRIDGE_PROD_API_BASE_URL, featureId, __classPrivateFieldGet(this, _BridgeController_clientVersion, "f"));
+            __classPrivateFieldGet(this, _BridgeController_trackQuoteValidationFailures, "f").call(this, validationFailures, featureId);
+            const srcChainIds = Array.from(new Set(baseQuotes.map((quote) => quote.quote.srcChainId))).filter(Boolean);
+            const quotesWithFees = srcChainIds.length > 1 || srcChainIds.length === 0
+                ? // Don't append fees if there are multiple srcChainIds
+                    baseQuotes
+                : await appendFeesToQuotes(formatChainIdToCaip(srcChainIds[0]), baseQuotes, this.messenger, __classPrivateFieldGet(this, _BridgeController_getLayer1GasFee, "f"), __classPrivateFieldGet(this, _BridgeController_instances, "m", _BridgeController_getMultichainSelectedAccount).call(this, quoteRequest.walletAddress));
+            return sortQuotes(quotesWithFees, featureId);
+        };
+        /**
+         * Fetches gasless transaction data and fees for BatchSell quotes.
+         * To use this in the clients, add a listener for the recommendedQuotes and call
+         * this handler whenever they change.
+         *
+         * @param quotes - The quotes to fetch the gasless transaction data and fees for
+         * @param stxEnabled - Flag to estimate gas cost more precisely for the batch sell feature.
+         */
+        this.updateBatchSellTrades = async (quotes, stxEnabled) => {
+            __classPrivateFieldGet(this, _BridgeController_batchSellTradesAbortController, "f")?.abort(AbortReason.GaslessTxBatchFetched);
+            __classPrivateFieldSet(this, _BridgeController_batchSellTradesAbortController, new AbortController(), "f");
+            this.update((state) => {
+                // Set loading status again if recommended quotes are re-ordered
+                state.batchSellTradesLoadingStatus = RequestStatus.LOADING;
+            });
+            try {
+                const batchSellTradesResponse = await fetchBatchSellTrades(quotes, stxEnabled, __classPrivateFieldGet(this, _BridgeController_batchSellTradesAbortController, "f").signal, __classPrivateFieldGet(this, _BridgeController_clientId, "f"), await __classPrivateFieldGet(this, _BridgeController_getJwt, "f").call(this), __classPrivateFieldGet(this, _BridgeController_fetchFn, "f"), __classPrivateFieldGet(this, _BridgeController_config, "f").customBridgeApiBaseUrl ?? BRIDGE_PROD_API_BASE_URL, __classPrivateFieldGet(this, _BridgeController_clientVersion, "f"));
+                this.update((state) => {
+                    state.batchSellTrades = batchSellTradesResponse;
+                    state.batchSellTradesLoadingStatus = RequestStatus.FETCHED;
+                });
+                // TODO if fee.asset.assetId is not in exchange rates, fetch the exchange rate and update the state
+            }
+            catch (error) {
+                // Ignore abort errors
+                if (error.toString().includes('AbortError') ||
+                    error.toString().includes('FetchRequestCanceledException') ||
+                    [
+                        AbortReason.ResetState,
+                        AbortReason.NewQuoteRequest,
+                        AbortReason.QuoteRequestUpdated,
+                        AbortReason.TransactionSubmitted,
+                        AbortReason.GaslessTxBatchFetched,
+                    ].includes(error)) {
+                    // Exit the function early to prevent other state updates
+                    return;
+                }
+                this.update((state) => {
+                    // Reset the batch sell trades if the fetch fails to avoid showing stale data
+                    state.batchSellTrades = DEFAULT_BRIDGE_CONTROLLER_STATE.batchSellTrades;
+                    // Update loading status
+                    state.batchSellTradesLoadingStatus = RequestStatus.ERROR;
+                });
+                console.log(`Failed to fetch batch sell trades`, error);
+            }
+        };
+        _BridgeController_trackQuoteValidationFailures.set(this, (validationFailures, featureId) => {
+            if (validationFailures.length === 0) {
+                return;
+            }
+            this.trackUnifiedSwapBridgeEvent(UnifiedSwapBridgeEventName.QuotesValidationFailed, {
+                feature_id: featureId,
+                failures: validationFailures,
+                location: __classPrivateFieldGet(this, _BridgeController_location, "f"),
+            });
+        });
+        /**
+         * Fetches the exchange rates for the assets in the quote request if they are not already in the state
+         * In addition to the selected tokens, this also fetches the native asset for the source and destination chains
+         *
+         * @param quoteRequests - The quote requests to fetch the exchange rates for
+         */
+        _BridgeController_fetchAssetExchangeRates.set(this, async (quoteRequests) => {
+            // Get unique assetIds for all quote requests
+            const assetIds = new Set(quoteRequests.flatMap((quoteRequest) => [
+                getAssetIdsForToken(quoteRequest.srcTokenAddress, quoteRequest.srcChainId),
+                getAssetIdsForToken(quoteRequest.destTokenAddress, quoteRequest.destChainId),
+            ].flat()));
+            const currency = __classPrivateFieldGet(this, _BridgeController_getUseAssetsControllerForRates, "f").call(this)
+                ? this.messenger.call('AssetsController:getExchangeRatesForBridge')
+                    .currentCurrency
+                : this.messenger.call('CurrencyRateController:getState').currentCurrency;
+            if (assetIds.size === 0) {
+                return;
+            }
+            const pricesByAssetId = await fetchAssetPrices({
+                assetIds,
+                currencies: new Set([currency, 'usd']),
+                clientId: __classPrivateFieldGet(this, _BridgeController_clientId, "f"),
+                clientVersion: __classPrivateFieldGet(this, _BridgeController_clientVersion, "f"),
+                fetchFn: __classPrivateFieldGet(this, _BridgeController_fetchFn, "f"),
+                signal: __classPrivateFieldGet(this, _BridgeController_abortController, "f")?.signal,
+            });
+            const exchangeRates = toExchangeRates(currency, pricesByAssetId);
+            this.update((state) => {
+                state.assetExchangeRates = {
+                    ...state.assetExchangeRates,
+                    ...exchangeRates,
+                };
+            });
+        });
+        _BridgeController_hasInsufficientBalance.set(this, async (quoteRequest) => {
+            try {
+                const srcChainIdInHex = formatChainIdToHex(quoteRequest.srcChainId);
+                const provider = __classPrivateFieldGet(this, _BridgeController_instances, "m", _BridgeController_getNetworkClientByChainId).call(this, srcChainIdInHex)?.provider;
+                const normalizedSrcTokenAddress = formatAddressToCaipReference(quoteRequest.srcTokenAddress);
+                return !(provider &&
+                    normalizedSrcTokenAddress &&
+                    quoteRequest.srcTokenAmount &&
+                    srcChainIdInHex &&
+                    (await hasSufficientBalance(provider, quoteRequest.walletAddress, normalizedSrcTokenAddress, quoteRequest.srcTokenAmount, srcChainIdInHex)));
+            }
+            catch (error) {
+                console.warn('Failed to set insufficientBal', error);
+                // Fall back to true so the backend returns quotes
+                return true;
+            }
+        });
+        _BridgeController_appendInsufficientBalAndResetApproval.set(this, async (quoteRequest) => {
+            const isSrcChainNonEVM = isNonEvmChainId(quoteRequest.srcChainId);
+            const providerConfig = isSrcChainNonEVM
+                ? undefined
+                : __classPrivateFieldGet(this, _BridgeController_instances, "m", _BridgeController_getNetworkClientByChainId).call(this, formatChainIdToHex(quoteRequest.srcChainId))?.configuration;
+            let insufficientBal;
+            let resetApproval = Boolean(quoteRequest.resetApproval);
+            if (isSrcChainNonEVM) {
+                // If the source chain is not an EVM network, use value from params
+                insufficientBal = quoteRequest.insufficientBal;
+            }
+            else if (providerConfig?.rpcUrl?.includes('tenderly')) {
+                // If the rpcUrl is a tenderly fork (e2e tests), set insufficientBal=true
+                // The bridge-api filters out quotes if the balance on mainnet is insufficient so this override allows quotes to always be returned
+                insufficientBal = true;
+            }
+            else {
+                // Set loading status if RPC calls are made before the quotes are fetched
+                this.update((state) => {
+                    state.quotesLoadingStatus = RequestStatus.LOADING;
+                });
+                resetApproval = await __classPrivateFieldGet(this, _BridgeController_shouldResetApproval, "f").call(this, quoteRequest);
+                // Otherwise query the src token balance from the RPC provider
+                insufficientBal =
+                    quoteRequest.insufficientBal ??
+                        (await __classPrivateFieldGet(this, _BridgeController_hasInsufficientBalance, "f").call(this, quoteRequest));
+            }
+            return {
+                ...quoteRequest,
+                insufficientBal,
+                resetApproval,
+            };
+        });
+        _BridgeController_shouldResetApproval.set(this, async (quoteRequest) => {
+            if (isNonEvmChainId(quoteRequest.srcChainId)) {
+                return false;
+            }
+            try {
+                const normalizedSrcTokenAddress = formatAddressToCaipReference(quoteRequest.srcTokenAddress);
+                if (isEthUsdt(quoteRequest.srcChainId, normalizedSrcTokenAddress)) {
+                    const allowance = BigNumber.from(await __classPrivateFieldGet(this, _BridgeController_getUSDTMainnetAllowance, "f").call(this, quoteRequest.walletAddress, normalizedSrcTokenAddress, quoteRequest.destChainId));
+                    return allowance.lt(quoteRequest.srcTokenAmount) && allowance.gt(0);
+                }
+                return false;
+            }
+            catch (error) {
+                console.warn('Failed to set resetApproval', error);
+                // Fall back to true so the backend returns quotes
+                return true;
+            }
+        });
+        this.stopPollingForQuotes = (reason, context) => {
+            this.stopAllPolling();
+            // If polling is stopped before quotes finish loading, track QuotesReceived
+            if (this.state.quotesLoadingStatus === RequestStatus.LOADING && context) {
+                this.trackUnifiedSwapBridgeEvent(UnifiedSwapBridgeEventName.QuotesReceived, context);
+            }
+            // Clears quotes list in state
+            __classPrivateFieldGet(this, _BridgeController_abortController, "f")?.abort(reason);
+            __classPrivateFieldGet(this, _BridgeController_batchSellTradesAbortController, "f")?.abort(reason);
+        };
+        /**
+         * Sets the location/entry point for the current swap or bridge flow.
+         * Call this when the user enters the flow so that all internally-fired
+         * events (InputChanged, QuotesRequested, etc.) carry the correct location.
+         *
+         * @param location - The entry point from which the user initiated the flow
+         */
+        this.setLocation = (location) => {
+            __classPrivateFieldSet(this, _BridgeController_location, location, "f");
+        };
+        /**
+         * Returns the location/entry point for the current swap or bridge flow.
+         *
+         * @returns The entry point from which the user initiated the flow
+         */
+        this.getLocation = () => {
+            return __classPrivateFieldGet(this, _BridgeController_location, "f");
+        };
+        this.setInputPrimaryDenomination = (inputPrimaryDenomination) => {
+            this.update((state) => {
+                state.inputPrimaryDenomination = inputPrimaryDenomination;
+            });
+        };
+        this.resetState = (reason = AbortReason.ResetState, quoteRequestIndex = null, context) => {
+            this.stopPollingForQuotes(reason, context);
+            this.update((state) => {
+                // Cannot do direct assignment to state, i.e. state = {... }, need to manually assign each field
+                if (quoteRequestIndex === null) {
+                    // Clear all requests if index is null
+                    state.quoteRequest = DEFAULT_BRIDGE_CONTROLLER_STATE.quoteRequest;
+                }
+                else {
+                    // Otherwise only clear the specified request
+                    state.quoteRequest = state.quoteRequest
+                        .slice(0, quoteRequestIndex)
+                        .concat(DEFAULT_BRIDGE_CONTROLLER_STATE.quoteRequest[0])
+                        .concat(state.quoteRequest.slice(quoteRequestIndex + 1));
+                }
+                state.quotesInitialLoadTime =
+                    DEFAULT_BRIDGE_CONTROLLER_STATE.quotesInitialLoadTime;
+                state.quotes = DEFAULT_BRIDGE_CONTROLLER_STATE.quotes;
+                state.quotesLastFetched =
+                    DEFAULT_BRIDGE_CONTROLLER_STATE.quotesLastFetched;
+                state.quotesLoadingStatus =
+                    DEFAULT_BRIDGE_CONTROLLER_STATE.quotesLoadingStatus;
+                state.quoteFetchError = DEFAULT_BRIDGE_CONTROLLER_STATE.quoteFetchError;
+                state.quotesRefreshCount =
+                    DEFAULT_BRIDGE_CONTROLLER_STATE.quotesRefreshCount;
+                state.assetExchangeRates =
+                    DEFAULT_BRIDGE_CONTROLLER_STATE.assetExchangeRates;
+                state.minimumBalanceForRentExemptionInLamports =
+                    DEFAULT_BRIDGE_CONTROLLER_STATE.minimumBalanceForRentExemptionInLamports;
+                state.tokenWarnings = DEFAULT_BRIDGE_CONTROLLER_STATE.tokenWarnings;
+                state.tokenSecurityTypeDestination =
+                    DEFAULT_BRIDGE_CONTROLLER_STATE.tokenSecurityTypeDestination;
+                state.quoteStreamComplete =
+                    DEFAULT_BRIDGE_CONTROLLER_STATE.quoteStreamComplete;
+                state.batchSellTrades = DEFAULT_BRIDGE_CONTROLLER_STATE.batchSellTrades;
+                state.batchSellTradesLoadingStatus =
+                    DEFAULT_BRIDGE_CONTROLLER_STATE.batchSellTradesLoadingStatus;
+            });
+        };
+        /**
+         * Sets the interval length based on the source chain
+         */
+        this.setChainIntervalLength = () => {
+            const { state } = this;
+            // Assume that BatchSell quote requests all have the same source chain
+            // Use the first one to determine refresh rate
+            const { srcChainId } = state.quoteRequest[0];
+            const bridgeFeatureFlags = getBridgeFeatureFlags(this.messenger);
+            const refreshRateOverride = srcChainId
+                ? bridgeFeatureFlags.chains[formatChainIdToCaip(srcChainId)]?.refreshRate
+                : undefined;
+            const defaultRefreshRate = bridgeFeatureFlags.refreshRate;
+            this.setIntervalLength(refreshRateOverride ?? defaultRefreshRate);
+        };
+        _BridgeController_fetchBridgeQuotes.set(this, async ({ quoteRequests, context, }) => {
+            __classPrivateFieldGet(this, _BridgeController_abortController, "f")?.abort(AbortReason.NewQuoteRequest);
+            __classPrivateFieldGet(this, _BridgeController_batchSellTradesAbortController, "f")?.abort(AbortReason.NewQuoteRequest);
+            __classPrivateFieldSet(this, _BridgeController_abortController, new AbortController(), "f");
+            const quoteTraceStartTime = Date.now();
+            const quoteTraceRequestId = uuid();
+            const quoteAbortSignal = __classPrivateFieldGet(this, _BridgeController_abortController, "f").signal;
+            __classPrivateFieldGet(this, _BridgeController_fetchAssetExchangeRates, "f").call(this, quoteRequests).catch((error) => console.warn('Failed to fetch asset exchange rates', error));
+            this.trackUnifiedSwapBridgeEvent(UnifiedSwapBridgeEventName.QuotesRequested, context);
+            const { sse, maxRefreshCount } = getBridgeFeatureFlags(this.messenger);
+            const shouldStream = sse?.enabled &&
+                hasMinimumRequiredVersion(__classPrivateFieldGet(this, _BridgeController_clientVersion, "f"), sse.minimumVersion);
+            const isBatchSellRequest = quoteRequests.length > 1;
+            this.update((state) => {
+                state.quoteFetchError = DEFAULT_BRIDGE_CONTROLLER_STATE.quoteFetchError;
+                state.tokenWarnings = DEFAULT_BRIDGE_CONTROLLER_STATE.tokenWarnings;
+                state.quoteStreamComplete =
+                    DEFAULT_BRIDGE_CONTROLLER_STATE.quoteStreamComplete;
+                state.quotesLastFetched = Date.now();
+                state.quotesLoadingStatus = RequestStatus.LOADING;
+                // Prevent clients from displaying stale batch sell fees
+                if (quoteRequests.length > 1) {
+                    state.batchSellTradesLoadingStatus = RequestStatus.LOADING;
+                    state.batchSellTrades = DEFAULT_BRIDGE_CONTROLLER_STATE.batchSellTrades;
+                }
+            });
+            const jwt = await __classPrivateFieldGet(this, _BridgeController_getJwt, "f").call(this);
+            const [firstQuoteRequest] = quoteRequests;
+            let traceResult = 'error';
+            let traceName = TraceName.BatchSellQuotesFetched;
+            if (!isBatchSellRequest) {
+                traceName = isCrossChain(firstQuoteRequest.srcChainId, firstQuoteRequest.destChainId)
+                    ? TraceName.BridgeQuotesFetched
+                    : TraceName.SwapQuotesFetched;
+            }
+            const tracedProviders = new Set();
+            const traceWithoutImpact = async (request) => {
+                try {
+                    await __classPrivateFieldGet(this, _BridgeController_trace, "f").call(this, request, () => undefined);
+                }
+                catch {
+                    // Telemetry failures must not affect quote fetching or state updates.
+                }
+            };
+            const traceProviderFirstResult = (providerData) => {
+                const provider = formatProviderLabel(providerData);
+                if (isBatchSellRequest || tracedProviders.has(provider)) {
+                    return;
+                }
+                tracedProviders.add(provider);
+                // Provider telemetry must not delay quote processing.
+                // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                traceWithoutImpact({
+                    name: TraceName.QuoteProviderFirstResult,
+                    startTime: quoteTraceStartTime,
+                    data: {
+                        provider,
+                        feature_id: context.feature_id,
+                        request_id: quoteTraceRequestId,
+                        swap_type: getSwapType(firstQuoteRequest.srcChainId, firstQuoteRequest.destChainId),
+                        srcChainId: formatChainIdToCaip(firstQuoteRequest.srcChainId),
+                        destChainId: formatChainIdToCaip(firstQuoteRequest.destChainId),
+                        result: 'success',
+                    },
+                });
+            };
+            try {
+                const selectedAccount = __classPrivateFieldGet(this, _BridgeController_instances, "m", _BridgeController_getMultichainSelectedAccount).call(this, firstQuoteRequest.walletAddress);
+                // This call is not awaited to prevent blocking quote fetching if the snap takes too long to respond
+                // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                __classPrivateFieldGet(this, _BridgeController_setMinimumBalanceForRentExemptionInLamports, "f").call(this, firstQuoteRequest.srcChainId, selectedAccount?.metadata?.snap?.id);
+                // Use SSE if enabled and return early
+                if (shouldStream || isBatchSellRequest) {
+                    const quoteCount = await __classPrivateFieldGet(this, _BridgeController_handleQuoteStreaming, "f").call(this, {
+                        quoteRequests,
+                        featureId: context.feature_id,
+                        jwt,
+                        selectedAccount,
+                        signal: quoteAbortSignal,
+                        traceProviderFirstResult,
+                    });
+                    if (quoteAbortSignal.aborted) {
+                        traceResult = 'cancelled';
+                        return;
+                    }
+                    traceResult = quoteCount > 0 ? 'success' : 'no_quotes';
+                }
+                else {
+                    // Otherwise use regular fetch
+                    const quotes = await this.fetchQuotes(firstQuoteRequest, context.feature_id, quoteAbortSignal);
+                    for (const quote of quotes) {
+                        traceProviderFirstResult(quote.quote);
+                    }
+                    this.update((state) => {
+                        // Set the initial load time if this is the first fetch
+                        if (state.quotesRefreshCount ===
+                            DEFAULT_BRIDGE_CONTROLLER_STATE.quotesRefreshCount &&
+                            __classPrivateFieldGet(this, _BridgeController_quotesFirstFetched, "f")) {
+                            state.quotesInitialLoadTime = Date.now() - __classPrivateFieldGet(this, _BridgeController_quotesFirstFetched, "f");
+                        }
+                        state.quotes = quotes.map(toQuoteResponseV2);
+                        state.quotesLoadingStatus = RequestStatus.FETCHED;
+                    });
+                    traceResult = quotes.length > 0 ? 'success' : 'no_quotes';
+                }
+            }
+            catch (error) {
+                // Reset the quotes list if the fetch fails to avoid showing stale quotes
+                this.update((state) => {
+                    state.quotes = DEFAULT_BRIDGE_CONTROLLER_STATE.quotes;
+                });
+                // Ignore abort errors
+                if (isExpectedQuoteAbort(error, quoteAbortSignal)) {
+                    traceResult = 'cancelled';
+                    // Exit the function early to prevent other state updates
+                    return;
+                }
+                // Update loading status and error message
+                this.update((state) => {
+                    // The error object reference is not guaranteed to exist on mobile so reading
+                    // the message directly could cause an error.
+                    let errorMessage;
+                    try {
+                        errorMessage =
+                            error?.message ?? error.toString();
+                    }
+                    catch {
+                        // Intentionally empty
+                    }
+                    finally {
+                        state.quoteFetchError = errorMessage ?? 'Unknown error';
+                    }
+                    state.quotesLoadingStatus = RequestStatus.ERROR;
+                });
+                // Track event and log error
+                this.trackUnifiedSwapBridgeEvent(UnifiedSwapBridgeEventName.QuotesError, context);
+                console.log(`Failed to ${shouldStream ? 'stream' : 'fetch'} bridge quotes`, error);
+            }
+            finally {
+                await traceWithoutImpact({
+                    name: traceName,
+                    startTime: quoteTraceStartTime,
+                    data: {
+                        srcChainId: formatChainIdToCaip(firstQuoteRequest.srcChainId),
+                        destChainId: formatChainIdToCaip(firstQuoteRequest.destChainId),
+                        ...(!isBatchSellRequest && {
+                            request_id: quoteTraceRequestId,
+                            feature_id: context.feature_id,
+                            result: traceResult,
+                        }),
+                    },
+                });
+            }
+            // Update refresh count after fetching, validation and fee calculation have completed
+            this.update((state) => {
+                state.quotesRefreshCount += 1;
+            });
+            const hasNoFundedQuoteRequests = quoteRequests.every(({ insufficientBal }) => Boolean(insufficientBal));
+            if (hasNoFundedQuoteRequests
+                ? // If all quote requests are insufficiently funded, stop polling
+                    // So if a BatchSell has at least 1 sufficiently funded quote request, polling continues
+                    true
+                : // Otherwise continue polling until the maximum number of refreshes has been reached
+                    this.state.quotesRefreshCount >= maxRefreshCount) {
+                this.stopAllPolling();
+            }
+        });
+        _BridgeController_handleQuoteStreaming.set(this, async ({ quoteRequests, featureId, jwt, selectedAccount, signal, traceProviderFirstResult, }) => {
+            /**
+             * Tracks the number of valid quotes received from the current stream, which is used
+             * to determine when to clear the quotes list and set the initial load time
+             */
+            let validQuotesCounter = 0;
+            /**
+             * Tracks all pending promises from appendFeesToQuotes calls to ensure they complete
+             * before setting quotesLoadingStatus to FETCHED
+             */
+            const pendingFeeAppendPromises = new Set();
+            await fetchBridgeQuoteStream(__classPrivateFieldGet(this, _BridgeController_fetchFn, "f"), quoteRequests, signal, featureId, __classPrivateFieldGet(this, _BridgeController_clientId, "f"), jwt, __classPrivateFieldGet(this, _BridgeController_config, "f").customBridgeApiBaseUrl ?? BRIDGE_PROD_API_BASE_URL, {
+                onQuoteValidationFailure: (validationFailures) => __classPrivateFieldGet(this, _BridgeController_trackQuoteValidationFailures, "f").call(this, validationFailures, featureId),
+                onValidQuoteReceived: async (quote) => {
+                    const feeAppendPromise = (async () => {
+                        const quotesWithFees = await appendFeesToQuotes(quote.chainId, [quote], this.messenger, __classPrivateFieldGet(this, _BridgeController_getLayer1GasFee, "f"), selectedAccount);
+                        if (quotesWithFees.length > 0) {
+                            validQuotesCounter += 1;
+                            traceProviderFirstResult(quote.quote);
+                        }
+                        this.update((state) => {
+                            // Clear previous quotes and quotes load time when first quote in the current
+                            // polling loop is received
+                            // This enables clients to continue showing the previous quotes while new
+                            // quotes are loading
+                            // Note: If there are no valid quotes until the 2nd fetch, quotesInitialLoadTime will be > refreshRate
+                            if (validQuotesCounter === 1) {
+                                state.quotes = DEFAULT_BRIDGE_CONTROLLER_STATE.quotes;
+                                if (!state.quotesInitialLoadTime && __classPrivateFieldGet(this, _BridgeController_quotesFirstFetched, "f")) {
+                                    // Set the initial load time after the first quote is received
+                                    state.quotesInitialLoadTime =
+                                        Date.now() - __classPrivateFieldGet(this, _BridgeController_quotesFirstFetched, "f");
+                                }
+                            }
+                            state.quotes = [...state.quotes, ...quotesWithFees];
+                        });
+                    })();
+                    pendingFeeAppendPromises.add(feeAppendPromise);
+                    feeAppendPromise
+                        .catch((error) => {
+                        // Catch errors to prevent them from breaking stream processing
+                        // If appendFeesToQuotes throws, the state update never happens, so no invalid entry is added
+                        console.error('Error appending fees to quote', error);
+                    })
+                        .finally(() => {
+                        pendingFeeAppendPromises.delete(feeAppendPromise);
+                    });
+                    // Await the promise to ensure errors are caught and handled before continuing
+                    // The promise is also tracked in pendingFeeAppendPromises for onClose to wait for
+                    await feeAppendPromise;
+                },
+                onTokenWarning: (warning) => {
+                    this.update((state) => {
+                        const isDuplicate = state.tokenWarnings.some((existing) => existing.feature_id === warning.feature_id);
+                        if (!isDuplicate) {
+                            state.tokenWarnings = [...state.tokenWarnings, warning];
+                        }
+                    });
+                },
+                onComplete: (data) => {
+                    this.update((state) => {
+                        state.quoteStreamComplete = data;
+                    });
+                },
+                onClose: async () => {
+                    // Wait for all pending appendFeesToQuotes operations to complete
+                    // before setting quotesLoadingStatus to FETCHED
+                    await Promise.allSettled(Array.from(pendingFeeAppendPromises));
+                    this.update((state) => {
+                        // If there are no valid quotes in the current stream, clear the quotes list
+                        // to remove quotes from the previous stream
+                        if (validQuotesCounter === 0) {
+                            state.quotes = DEFAULT_BRIDGE_CONTROLLER_STATE.quotes;
+                        }
+                        state.quotesLoadingStatus = RequestStatus.FETCHED;
+                    });
+                },
+            }, __classPrivateFieldGet(this, _BridgeController_clientVersion, "f"));
+            return validQuotesCounter;
+        });
+        _BridgeController_setMinimumBalanceForRentExemptionInLamports.set(this, async (srcChainId, snapId) => {
+            if (!isSolanaChainId(srcChainId) || !snapId) {
+                return;
+            }
+            const minimumBalanceForRentExemptionInLamports = await getMinimumBalanceForRentExemptionInLamports(snapId, this.messenger);
+            this.update((state) => {
+                state.minimumBalanceForRentExemptionInLamports =
+                    minimumBalanceForRentExemptionInLamports;
+            });
+        });
+        _BridgeController_getJwt.set(this, async () => {
+            try {
+                const token = await this.messenger.call('AuthenticationController:getBearerToken');
+                return token;
+            }
+            catch (error) {
+                console.error('Error getting JWT token for bridge-api request', error);
+                return undefined;
+            }
+        });
+        _BridgeController_getRequestMetadata.set(this, (quoteRequestIndex = 0) => {
+            const quoteRequest = this.state.quoteRequest[quoteRequestIndex];
+            const { walletAddress } = quoteRequest;
+            const accountHardwareType = getAccountHardwareType(walletAddress
+                ? __classPrivateFieldGet(this, _BridgeController_instances, "m", _BridgeController_getMultichainSelectedAccount).call(this, walletAddress)
+                : undefined);
+            return {
+                slippage_limit: quoteRequest.slippage ?? 0,
+                swap_type: getSwapTypeFromQuote(quoteRequest),
+                custom_slippage: isCustomSlippage(quoteRequest.slippage),
+                account_hardware_type: accountHardwareType,
+                is_hardware_wallet: accountHardwareType !== null,
+            };
+        });
+        _BridgeController_getQuoteFetchData.set(this, () => {
+            return {
+                quotes_count: this.state.quotes.length,
+                quotes_list: this.state.quotes.map(({ quote }) => formatProviderLabel(quote)),
+                initial_load_time_all_quotes: this.state.quotesInitialLoadTime ?? 0,
+                has_gas_included_quote: this.state.quotes.some(({ quote }) => quote.gasIncluded),
+            };
+        });
+        _BridgeController_getEventProperties.set(this, (eventName, propertiesFromClient, quoteRequestIndex = 0) => {
+            const clientProps = propertiesFromClient;
+            const baseProperties = {
+                ...propertiesFromClient,
+                location: clientProps?.location ?? __classPrivateFieldGet(this, _BridgeController_location, "f"),
+                action_type: MetricsActionType.SWAPBRIDGE_V1,
+            };
+            const inputPrimaryDenominationProperties = {
+                input_primary_denomination: this.state.inputPrimaryDenomination,
+            };
+            const batchSellClientChainProperties = propertiesFromClient;
+            const batchSellBaseProperties = {
+                chain_id_source: batchSellClientChainProperties.chain_id_source,
+                chain_id_destination: batchSellClientChainProperties.chain_id_destination,
+                location: clientProps?.location ?? __classPrivateFieldGet(this, _BridgeController_location, "f"),
+            };
+            const quoteRequest = this.state.quoteRequest[quoteRequestIndex];
+            switch (eventName) {
+                case UnifiedSwapBridgeEventName.ButtonClicked:
+                    return {
+                        ...getRequestParams(quoteRequest, this.state.tokenSecurityTypeDestination),
+                        ...baseProperties,
+                    };
+                case UnifiedSwapBridgeEventName.PageViewed:
+                    return {
+                        ...getRequestParams(quoteRequest, this.state.tokenSecurityTypeDestination),
+                        ...__classPrivateFieldGet(this, _BridgeController_getRequestMetadata, "f").call(this),
+                        ...inputPrimaryDenominationProperties,
+                        ...baseProperties,
+                    };
+                case BatchSellMetricsEventName.BatchSellTokenPageViewed:
+                    return batchSellBaseProperties;
+                case BatchSellMetricsEventName.BatchSellTokenPageContinueClicked: {
+                    const propsFromClient = propertiesFromClient;
+                    return {
+                        ...batchSellBaseProperties,
+                        source_token_count: propsFromClient.source_token_addresses.length,
+                        source_token_symbols: propsFromClient.source_token_symbols,
+                        source_token_addresses: propsFromClient.source_token_addresses,
+                    };
+                }
+                case BatchSellMetricsEventName.BatchSellQuotePageViewed:
+                case BatchSellMetricsEventName.BatchSellQuotePageReviewClicked: {
+                    const propsFromClient = propertiesFromClient;
+                    return {
+                        ...batchSellBaseProperties,
+                        source_token_count: propsFromClient.source_token_addresses.length,
+                        source_token_symbols: propsFromClient.source_token_symbols,
+                        source_token_addresses: propsFromClient.source_token_addresses,
+                        destination_token_symbol: propsFromClient.destination_token_symbol,
+                        destination_token_address: propsFromClient.destination_token_address,
+                        usd_amount_source_tokens: propsFromClient.usd_amount_source_tokens,
+                        usd_amount_source_total: propsFromClient.usd_amount_source_total,
+                        source_token_slippages: propsFromClient.source_token_slippages,
+                    };
+                }
+                case BatchSellMetricsEventName.BatchSellReviewModalSubmitted: {
+                    const reviewModalProperties = propertiesFromClient;
+                    return {
+                        ...batchSellBaseProperties,
+                        source_token_count: reviewModalProperties.source_token_addresses.length,
+                        source_token_symbols: reviewModalProperties.source_token_symbols,
+                        source_token_addresses: reviewModalProperties.source_token_addresses,
+                        destination_token_symbol: reviewModalProperties.destination_token_symbol,
+                        destination_token_address: reviewModalProperties.destination_token_address,
+                        usd_amount_source_tokens: reviewModalProperties.usd_amount_source_tokens,
+                        usd_amount_source_total: reviewModalProperties.usd_amount_source_total,
+                        source_token_slippages: reviewModalProperties.source_token_slippages,
+                        usd_quoted_gas: reviewModalProperties.usd_quoted_gas,
+                        usd_quoted_return: reviewModalProperties.usd_quoted_return,
+                    };
+                }
+                case UnifiedSwapBridgeEventName.FiatCryptoToggleClicked:
+                    return {
+                        ...getRequestParams(quoteRequest, this.state.tokenSecurityTypeDestination),
+                        swap_type: getSwapTypeFromQuote(quoteRequest),
+                        ...baseProperties,
+                    };
+                case UnifiedSwapBridgeEventName.QuotesValidationFailed:
+                    return {
+                        ...getRequestParams(quoteRequest, this.state.tokenSecurityTypeDestination),
+                        refresh_count: this.state.quotesRefreshCount,
+                        ...baseProperties,
+                    };
+                case UnifiedSwapBridgeEventName.QuotesReceived:
+                    return {
+                        ...getRequestParams(quoteRequest, this.state.tokenSecurityTypeDestination),
+                        ...__classPrivateFieldGet(this, _BridgeController_getRequestMetadata, "f").call(this),
+                        ...__classPrivateFieldGet(this, _BridgeController_getQuoteFetchData, "f").call(this),
+                        refresh_count: this.state.quotesRefreshCount,
+                        has_sufficient_funds: !quoteRequest.insufficientBal,
+                        ...inputPrimaryDenominationProperties,
+                        ...baseProperties,
+                    };
+                case UnifiedSwapBridgeEventName.QuotesRequested:
+                    return {
+                        ...getRequestParams(quoteRequest, this.state.tokenSecurityTypeDestination),
+                        ...__classPrivateFieldGet(this, _BridgeController_getRequestMetadata, "f").call(this),
+                        has_sufficient_funds: !quoteRequest.insufficientBal,
+                        ...inputPrimaryDenominationProperties,
+                        ...baseProperties,
+                    };
+                case UnifiedSwapBridgeEventName.QuotesError:
+                    return {
+                        ...getRequestParams(quoteRequest, this.state.tokenSecurityTypeDestination),
+                        ...__classPrivateFieldGet(this, _BridgeController_getRequestMetadata, "f").call(this),
+                        error_message: this.state.quoteFetchError,
+                        has_sufficient_funds: !quoteRequest.insufficientBal,
+                        ...baseProperties,
+                    };
+                case UnifiedSwapBridgeEventName.AllQuotesOpened:
+                case UnifiedSwapBridgeEventName.AllQuotesSorted:
+                case UnifiedSwapBridgeEventName.QuoteSelected:
+                    return {
+                        ...getRequestParams(quoteRequest, this.state.tokenSecurityTypeDestination),
+                        ...__classPrivateFieldGet(this, _BridgeController_getRequestMetadata, "f").call(this),
+                        ...__classPrivateFieldGet(this, _BridgeController_getQuoteFetchData, "f").call(this),
+                        ...baseProperties,
+                    };
+                case UnifiedSwapBridgeEventName.Failed: {
+                    // Populate the properties that the error occurred before the tx was submitted
+                    return {
+                        ...baseProperties,
+                        ...getRequestParams(quoteRequest, this.state.tokenSecurityTypeDestination),
+                        ...__classPrivateFieldGet(this, _BridgeController_getRequestMetadata, "f").call(this),
+                        ...__classPrivateFieldGet(this, _BridgeController_getQuoteFetchData, "f").call(this),
+                        ...propertiesFromClient,
+                    };
+                }
+                case UnifiedSwapBridgeEventName.AssetDetailTooltipClicked:
+                case UnifiedSwapBridgeEventName.AssetPickerOpened:
+                    return baseProperties;
+                // Inject `token_security_type_destination` from controller state so the
+                // field is always present on this event. `baseProperties` (which spreads
+                // `propertiesFromClient`) wins if the client supplies a value explicitly.
+                case UnifiedSwapBridgeEventName.InputSourceDestinationSwitched:
+                    return {
+                        token_security_type_destination: this.state.tokenSecurityTypeDestination,
+                        ...baseProperties,
+                    };
+                // These events may be published after the bridge-controller state is reset
+                // So the BridgeStatusController populates all the properties
+                case UnifiedSwapBridgeEventName.Submitted:
+                case UnifiedSwapBridgeEventName.Completed:
+                    return propertiesFromClient;
+                case UnifiedSwapBridgeEventName.InputChanged:
+                default:
+                    return baseProperties;
+            }
+        });
+        _BridgeController_trackInputChangedEvents.set(this, (paramsToUpdate, featureId, quoteRequestIndex = 0) => {
+            Object.entries(paramsToUpdate).forEach(([key, value]) => {
+                const inputKey = toInputChangedPropertyKey[key];
+                const inputValue = toInputChangedPropertyValue[key]?.(paramsToUpdate);
+                if (inputKey &&
+                    inputValue !== undefined &&
+                    this.state.quoteRequest[quoteRequestIndex] &&
+                    value !==
+                        this.state.quoteRequest[quoteRequestIndex][key]) {
+                    this.trackUnifiedSwapBridgeEvent(UnifiedSwapBridgeEventName.InputChanged, {
+                        input: inputKey,
+                        input_value: inputValue,
+                        location: __classPrivateFieldGet(this, _BridgeController_location, "f"),
+                        feature_id: featureId,
+                    });
+                }
+            });
+        });
+        /**
+         * This method tracks cross-chain swaps events
+         *
+         * @param eventName - The name of the event to track
+         * @param propertiesFromClient - Properties that can't be calculated from the event name and need to be provided by the client
+         * @param quoteRequestIndex - The index of the quote request to track the event for
+         * @example
+         * this.trackUnifiedSwapBridgeEvent(UnifiedSwapBridgeEventName.ActionOpened, {
+         *   location: MetaMetricsSwapsEventSource.MainView,
+         * });
+         */
+        this.trackUnifiedSwapBridgeEvent = (eventName, propertiesFromClient, quoteRequestIndex = 0) => {
+            try {
+                const combinedPropertiesForEvent = __classPrivateFieldGet(this, _BridgeController_getEventProperties, "f").call(this, eventName, propertiesFromClient, quoteRequestIndex);
+                __classPrivateFieldGet(this, _BridgeController_trackMetaMetricsFn, "f").call(this, eventName, combinedPropertiesForEvent);
+            }
+            catch (error) {
+                console.error(`Error tracking cross-chain swaps MetaMetrics event ${eventName}`, error);
+            }
+        };
+        /**
+         *
+         * @param walletAddress - The address of the account to get the allowance for
+         * @param contractAddress - The address of the ERC20 token contract on mainnet
+         * @param destinationChainId - The chain ID of the destination network
+         * @returns The atomic allowance of the ERC20 token contract
+         */
+        _BridgeController_getUSDTMainnetAllowance.set(this, async (walletAddress, contractAddress, destinationChainId) => {
+            const networkClient = __classPrivateFieldGet(this, _BridgeController_instances, "m", _BridgeController_getNetworkClientByChainId).call(this, CHAIN_IDS.MAINNET);
+            const provider = networkClient?.provider;
+            if (!provider) {
+                throw new Error('No provider found');
+            }
+            const ethersProvider = new Web3Provider(provider);
+            const contract = new Contract(contractAddress, abiERC20, ethersProvider);
+            const spenderAddress = isCrossChain(CHAIN_IDS.MAINNET, destinationChainId)
+                ? METABRIDGE_ETHEREUM_ADDRESS
+                : SWAPS_CONTRACT_ADDRESSES[CHAIN_IDS.MAINNET];
+            const allowance = await contract.allowance(walletAddress, spenderAddress);
+            return allowance.toString();
+        });
+        this.setIntervalLength(REFRESH_INTERVAL_MS);
+        __classPrivateFieldSet(this, _BridgeController_abortController, new AbortController(), "f");
+        __classPrivateFieldSet(this, _BridgeController_getLayer1GasFee, getLayer1GasFee, "f");
+        __classPrivateFieldSet(this, _BridgeController_clientId, clientId, "f");
+        __classPrivateFieldSet(this, _BridgeController_clientVersion, clientVersion, "f");
+        __classPrivateFieldSet(this, _BridgeController_fetchFn, fetchFn, "f");
+        __classPrivateFieldSet(this, _BridgeController_trackMetaMetricsFn, trackMetaMetricsFn, "f");
+        __classPrivateFieldSet(this, _BridgeController_config, config ?? {}, "f");
+        __classPrivateFieldSet(this, _BridgeController_trace, traceFn ?? ((_request, fn) => fn?.()), "f");
+        __classPrivateFieldSet(this, _BridgeController_getUseAssetsControllerForRates, getUseAssetsControllerForRates ?? (() => false), "f");
+        this.messenger.registerMethodActionHandlers(this, MESSENGER_EXPOSED_METHODS);
+    }
+}
+_BridgeController_abortController = new WeakMap(), _BridgeController_batchSellTradesAbortController = new WeakMap(), _BridgeController_quotesFirstFetched = new WeakMap(), _BridgeController_location = new WeakMap(), _BridgeController_clientId = new WeakMap(), _BridgeController_clientVersion = new WeakMap(), _BridgeController_getLayer1GasFee = new WeakMap(), _BridgeController_fetchFn = new WeakMap(), _BridgeController_trackMetaMetricsFn = new WeakMap(), _BridgeController_trace = new WeakMap(), _BridgeController_config = new WeakMap(), _BridgeController_getUseAssetsControllerForRates = new WeakMap(), _BridgeController_trackQuoteValidationFailures = new WeakMap(), _BridgeController_fetchAssetExchangeRates = new WeakMap(), _BridgeController_hasInsufficientBalance = new WeakMap(), _BridgeController_appendInsufficientBalAndResetApproval = new WeakMap(), _BridgeController_shouldResetApproval = new WeakMap(), _BridgeController_fetchBridgeQuotes = new WeakMap(), _BridgeController_handleQuoteStreaming = new WeakMap(), _BridgeController_setMinimumBalanceForRentExemptionInLamports = new WeakMap(), _BridgeController_getJwt = new WeakMap(), _BridgeController_getRequestMetadata = new WeakMap(), _BridgeController_getQuoteFetchData = new WeakMap(), _BridgeController_getEventProperties = new WeakMap(), _BridgeController_trackInputChangedEvents = new WeakMap(), _BridgeController_getUSDTMainnetAllowance = new WeakMap(), _BridgeController_instances = new WeakSet(), _BridgeController_getMultichainSelectedAccount = function _BridgeController_getMultichainSelectedAccount(walletAddress) {
+    // Assume that all quotes in a batch are for the same account
+    const addressToUse = walletAddress ?? this.state.quoteRequest[0].walletAddress;
+    if (!addressToUse) {
+        throw new Error('Account address is required');
+    }
+    const selectedAccount = this.messenger.call('AccountsController:getAccountByAddress', addressToUse);
+    return selectedAccount;
+}, _BridgeController_getNetworkClientByChainId = function _BridgeController_getNetworkClientByChainId(chainId) {
+    const networkClientId = this.messenger.call('NetworkController:findNetworkClientIdByChainId', chainId);
+    if (!networkClientId) {
+        throw new Error(`No network client found for chainId: ${chainId}`);
+    }
+    const networkClient = this.messenger.call('NetworkController:getNetworkClientById', networkClientId);
+    return networkClient;
+};
+//# sourceMappingURL=bridge-controller.mjs.map