@metamask-previews/assets-controller 11.2.1-preview-2dc3d26a4 → 11.2.1-preview-aa202ec10

package/dist/data-sources/BackendWebsocketDataSource.mjs

@@ -0,0 +1,592 @@
+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 _BackendWebsocketDataSource_instances, _BackendWebsocketDataSource_messenger, _BackendWebsocketDataSource_apiClient, _BackendWebsocketDataSource_onActiveChainsUpdated, _BackendWebsocketDataSource_getAssetType, _BackendWebsocketDataSource_chainsRefreshTimer, _BackendWebsocketDataSource_supportedChains, _BackendWebsocketDataSource_isConnected, _BackendWebsocketDataSource_wsSubscriptions, _BackendWebsocketDataSource_pendingSubscriptions, _BackendWebsocketDataSource_subscriptionRequests, _BackendWebsocketDataSource_registeredChannelCallbacks, _BackendWebsocketDataSource_subscribeLock, _BackendWebsocketDataSource_initializeActiveChains, _BackendWebsocketDataSource_refreshActiveChains, _BackendWebsocketDataSource_fetchActiveChains, _BackendWebsocketDataSource_subscribeToEvents, _BackendWebsocketDataSource_handleDisconnect, _BackendWebsocketDataSource_handleReconnect, _BackendWebsocketDataSource_subscribeInternal, _BackendWebsocketDataSource_handleNotification, _BackendWebsocketDataSource_processBalanceUpdates, _BackendWebsocketDataSource_teardownSubscription, _BackendWebsocketDataSource_registerChannelCallbacks, _BackendWebsocketDataSource_unregisterChannelCallback, _BackendWebsocketDataSource_removeChannelCallbacks;
+import { isCaipChainId, KnownCaipNamespace, toCaipChainId } from "@metamask/utils";
+import { projectLogger, createModuleLogger } from "../logger.mjs";
+import { processAccountActivityBalanceUpdates } from "../utils/processAccountActivityBalanceUpdates.mjs";
+import { AbstractDataSource } from "./AbstractDataSource.mjs";
+// ============================================================================
+// CONSTANTS
+// ============================================================================
+const CONTROLLER_NAME = 'BackendWebsocketDataSource';
+const CHANNEL_TYPE = 'account-activity.v1';
+const log = createModuleLogger(projectLogger, CONTROLLER_NAME);
+const defaultState = {
+    activeChains: [],
+};
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+/**
+ * Extract namespace from a CAIP-2 chain ID.
+ * E.g., "eip155:1" -> "eip155", "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp" -> "solana"
+ *
+ * @param chainId - The CAIP-2 chain ID to extract namespace from.
+ * @returns The namespace portion of the chain ID.
+ */
+function extractNamespace(chainId) {
+    const [namespace] = chainId.split(':');
+    return namespace;
+}
+/** Namespaces we always subscribe to for account activity (EVM + Solana). */
+const ACCOUNT_ACTIVITY_NAMESPACES = ['eip155', 'solana'];
+/**
+ * Get unique namespaces for account-activity subscriptions.
+ * Always includes eip155 and solana so we subscribe to both EVM and Solana account activity,
+ * plus any additional namespaces from the requested chain IDs.
+ *
+ * @param chainIds - Array of CAIP-2 chain IDs (from the subscription request).
+ * @returns Array of unique namespaces (at least eip155 and solana).
+ */
+function getNamespacesForAccountActivity(chainIds) {
+    const namespaces = new Set(ACCOUNT_ACTIVITY_NAMESPACES);
+    for (const chainId of chainIds) {
+        namespaces.add(extractNamespace(chainId));
+    }
+    return Array.from(namespaces);
+}
+/**
+ * Returns the address to use for account-activity subscription in the given namespace.
+ * EIP-155 accounts use hex (0x...) address; Solana accounts use base58.
+ * Returns null if this account type does not have an address in that namespace.
+ *
+ * @param account - Internal account (type + address).
+ * @param account.type - Account type (e.g. "eip155:eoa", "solana:data-account").
+ * @param account.address - Account address (hex for eip155, base58 for solana).
+ * @param namespace - The chain namespace (e.g., "eip155", "solana").
+ * @returns The address for that namespace, or null if the account does not support the namespace.
+ */
+function getAddressForAccountActivity(account, namespace) {
+    if (namespace === 'eip155') {
+        return account.type.startsWith('eip155') ? account.address : null;
+    }
+    if (namespace === 'solana') {
+        return account.type.startsWith('solana') ? account.address : null;
+    }
+    // Other namespaces (e.g. from chainIds): use address if account type matches namespace
+    const typePrefix = `${namespace}:`;
+    return account.type.startsWith(typePrefix) ? account.address : null;
+}
+/**
+ * Build WebSocket channel name for account activity using CAIP-10 wildcard format.
+ * Uses 0 as the chain reference to subscribe to all chains in the namespace.
+ * EIP-155 addresses are lowercased (hex); Solana addresses are left as-is (base58).
+ *
+ * @param namespace - The chain namespace (e.g., "eip155", "solana").
+ * @param address - The account address (hex for eip155, base58 for solana).
+ * @returns The WebSocket channel name.
+ */
+function buildAccountActivityChannel(namespace, address) {
+    const formatted = namespace === 'eip155' ? address.toLowerCase() : address;
+    return `${CHANNEL_TYPE}.${namespace}:0:${formatted}`;
+}
+/**
+ * Normalize addresses for stable comparison when detecting account changes.
+ *
+ * @param address - Account address (hex or base58).
+ * @returns Normalized address for comparison.
+ */
+function normalizeAddressForComparison(address) {
+    return address.startsWith('0x') ? address.toLowerCase() : address;
+}
+/**
+ * Check whether subscribed account addresses changed (case-insensitive for EVM).
+ *
+ * @param nextAddresses - Addresses from the incoming subscribe request.
+ * @param existingAddresses - Addresses from the active subscription.
+ * @returns True when the address sets differ.
+ */
+function haveAddressesChanged(nextAddresses, existingAddresses) {
+    if (nextAddresses.length !== existingAddresses.length) {
+        return true;
+    }
+    const normalizedNext = nextAddresses
+        .map(normalizeAddressForComparison)
+        .sort();
+    const normalizedExisting = existingAddresses
+        .map(normalizeAddressForComparison)
+        .sort();
+    return normalizedNext.some((address, index) => address !== normalizedExisting[index]);
+}
+/**
+ * Normalize API chain identifier to CAIP-2 ChainId.
+ * Passes through strings already in CAIP-2 form (e.g. eip155:1, solana:5eykt...).
+ * Converts bare decimals to eip155:decimal.
+ * Uses @metamask/utils for CAIP parsing.
+ *
+ * @param chainIdOrDecimal - Chain ID string (CAIP-2 or decimal) or decimal number.
+ * @returns CAIP-2 ChainId.
+ */
+function toChainId(chainIdOrDecimal) {
+    if (typeof chainIdOrDecimal === 'string') {
+        if (isCaipChainId(chainIdOrDecimal)) {
+            return chainIdOrDecimal;
+        }
+        return toCaipChainId(KnownCaipNamespace.Eip155, chainIdOrDecimal);
+    }
+    return toCaipChainId(KnownCaipNamespace.Eip155, String(chainIdOrDecimal));
+}
+// Note: AccountActivityMessage and BalanceUpdate types are imported from @metamask/core-backend
+// ============================================================================
+// BACKEND WEBSOCKET DATA SOURCE
+// ============================================================================
+/**
+ * Data source for receiving real-time balance updates via WebSocket.
+ *
+ * This data source connects directly to BackendWebSocketService to receive
+ * push notifications for account balance changes. Unlike AccountsApiDataSource
+ * which polls for data, this provides instant updates.
+ *
+ * Uses Messenger pattern for all interactions:
+ * - Calls BackendWebSocketService methods via messenger actions
+ * - Exposes its own actions for AssetsController to call
+ * - Publishes events for AssetsController to subscribe to
+ *
+ * Actions exposed:
+ * - BackendWebsocketDataSource:getActiveChains
+ * - BackendWebsocketDataSource:subscribe
+ * - BackendWebsocketDataSource:unsubscribe
+ *
+ * Events published:
+ * - BackendWebsocketDataSource:activeChainsUpdated
+ * - BackendWebsocketDataSource:assetsUpdated
+ *
+ * Actions called (from BackendWebSocketService):
+ * - BackendWebSocketService:subscribe
+ * - BackendWebSocketService:getConnectionInfo
+ * - BackendWebSocketService:findSubscriptionsByChannelPrefix
+ * - BackendWebSocketService:addChannelCallback
+ * - BackendWebSocketService:removeChannelCallback
+ */
+const DEFAULT_CHAINS_REFRESH_INTERVAL_MS = 20 * 60 * 1000; // 20 minutes
+export class BackendWebsocketDataSource extends AbstractDataSource {
+    constructor(options) {
+        super(CONTROLLER_NAME, {
+            ...defaultState,
+            ...options.state,
+        });
+        _BackendWebsocketDataSource_instances.add(this);
+        _BackendWebsocketDataSource_messenger.set(this, void 0);
+        _BackendWebsocketDataSource_apiClient.set(this, void 0);
+        _BackendWebsocketDataSource_onActiveChainsUpdated.set(this, void 0);
+        _BackendWebsocketDataSource_getAssetType.set(this, void 0);
+        /** Chains refresh timer */
+        _BackendWebsocketDataSource_chainsRefreshTimer.set(this, null);
+        /** Chains the backend API reports as supported (preserved across disconnects). */
+        _BackendWebsocketDataSource_supportedChains.set(this, []);
+        /** Whether the WebSocket is currently connected. Chains are only claimed when true. */
+        _BackendWebsocketDataSource_isConnected.set(this, false);
+        /** WebSocket subscriptions by our internal subscription ID */
+        _BackendWebsocketDataSource_wsSubscriptions.set(this, new Map());
+        /** Pending subscription requests to process when WebSocket connects */
+        _BackendWebsocketDataSource_pendingSubscriptions.set(this, new Map());
+        /** Store original subscription requests for reconnection */
+        _BackendWebsocketDataSource_subscriptionRequests.set(this, new Map());
+        /** Channels with registered BackendWebSocketService channel callbacks */
+        _BackendWebsocketDataSource_registeredChannelCallbacks.set(this, new Set());
+        /** Serializes subscribe/unsubscribe so account switches cannot interleave. */
+        _BackendWebsocketDataSource_subscribeLock.set(this, Promise.resolve());
+        __classPrivateFieldSet(this, _BackendWebsocketDataSource_messenger, options.messenger, "f");
+        __classPrivateFieldSet(this, _BackendWebsocketDataSource_apiClient, options.queryApiClient, "f");
+        __classPrivateFieldSet(this, _BackendWebsocketDataSource_onActiveChainsUpdated, options.onActiveChainsUpdated, "f");
+        __classPrivateFieldSet(this, _BackendWebsocketDataSource_getAssetType, options.getAssetType, "f");
+        __classPrivateFieldGet(this, _BackendWebsocketDataSource_instances, "m", _BackendWebsocketDataSource_subscribeToEvents).call(this);
+        __classPrivateFieldGet(this, _BackendWebsocketDataSource_instances, "m", _BackendWebsocketDataSource_initializeActiveChains).call(this).catch(console.error);
+    }
+    /**
+     * Re-fetch supported networks and refresh `activeChains` when connected.
+     * When disconnected, only `#supportedChains` is updated so reconnect can
+     * reclaim chains. Called on EVM network switch from AssetsController.
+     *
+     * @returns Resolves when supported networks have been re-fetched.
+     */
+    refreshActiveChains() {
+        return __classPrivateFieldGet(this, _BackendWebsocketDataSource_instances, "m", _BackendWebsocketDataSource_refreshActiveChains).call(this);
+    }
+    /**
+     * Sync active chains from AccountsApiDataSource.
+     * When the data source invokes the onActiveChainsUpdated callback, the
+     * controller processes the active chains update (no messenger call; controller already updated).
+     *
+     * @param chains - Updated active chain IDs from AccountsApiDataSource.
+     */
+    setActiveChainsFromAccountsApi(chains) {
+        this.updateActiveChains(chains, () => undefined);
+    }
+    // ============================================================================
+    // ACTIVE CHAINS
+    // ============================================================================
+    /**
+     * Update active chains when AccountsApiDataSource reports new supported chains.
+     *
+     * @param chains - Array of supported chain IDs.
+     */
+    updateSupportedChains(chains) {
+        const previous = [...this.state.activeChains];
+        this.updateActiveChains(chains, (updatedChains) => __classPrivateFieldGet(this, _BackendWebsocketDataSource_onActiveChainsUpdated, "f").call(this, this.getName(), updatedChains, previous));
+    }
+    // ============================================================================
+    // SUBSCRIBE
+    // ============================================================================
+    async subscribe(subscriptionRequest) {
+        const previousLock = __classPrivateFieldGet(this, _BackendWebsocketDataSource_subscribeLock, "f");
+        let releaseLock = () => undefined;
+        __classPrivateFieldSet(this, _BackendWebsocketDataSource_subscribeLock, new Promise((resolve) => {
+            releaseLock = resolve;
+        }), "f");
+        await previousLock;
+        try {
+            await __classPrivateFieldGet(this, _BackendWebsocketDataSource_instances, "m", _BackendWebsocketDataSource_subscribeInternal).call(this, subscriptionRequest);
+        }
+        finally {
+            releaseLock();
+        }
+    }
+    // ============================================================================
+    // UNSUBSCRIBE
+    // ============================================================================
+    /**
+     * Unsubscribe and await server-side teardown so a re-subscribe does not race
+     * with stale subscription IDs on incoming notifications.
+     *
+     * @param subscriptionId - The ID of the subscription to cancel.
+     */
+    async unsubscribe(subscriptionId) {
+        const previousLock = __classPrivateFieldGet(this, _BackendWebsocketDataSource_subscribeLock, "f");
+        let releaseLock = () => undefined;
+        __classPrivateFieldSet(this, _BackendWebsocketDataSource_subscribeLock, new Promise((resolve) => {
+            releaseLock = resolve;
+        }), "f");
+        await previousLock;
+        try {
+            await __classPrivateFieldGet(this, _BackendWebsocketDataSource_instances, "m", _BackendWebsocketDataSource_teardownSubscription).call(this, subscriptionId);
+        }
+        finally {
+            releaseLock();
+        }
+    }
+    // ============================================================================
+    // CLEANUP
+    // ============================================================================
+    destroy() {
+        if (__classPrivateFieldGet(this, _BackendWebsocketDataSource_chainsRefreshTimer, "f")) {
+            clearInterval(__classPrivateFieldGet(this, _BackendWebsocketDataSource_chainsRefreshTimer, "f"));
+            __classPrivateFieldSet(this, _BackendWebsocketDataSource_chainsRefreshTimer, null, "f");
+        }
+        const subscriptionIds = [
+            ...new Set([
+                ...__classPrivateFieldGet(this, _BackendWebsocketDataSource_wsSubscriptions, "f").keys(),
+                ...this.activeSubscriptions.keys(),
+            ]),
+        ];
+        for (const subscriptionId of subscriptionIds) {
+            __classPrivateFieldGet(this, _BackendWebsocketDataSource_instances, "m", _BackendWebsocketDataSource_teardownSubscription).call(this, subscriptionId).catch(() => undefined);
+        }
+        // Clean up base class subscriptions (no-op if already torn down)
+        super.destroy();
+    }
+}
+_BackendWebsocketDataSource_messenger = new WeakMap(), _BackendWebsocketDataSource_apiClient = new WeakMap(), _BackendWebsocketDataSource_onActiveChainsUpdated = new WeakMap(), _BackendWebsocketDataSource_getAssetType = new WeakMap(), _BackendWebsocketDataSource_chainsRefreshTimer = new WeakMap(), _BackendWebsocketDataSource_supportedChains = new WeakMap(), _BackendWebsocketDataSource_isConnected = new WeakMap(), _BackendWebsocketDataSource_wsSubscriptions = new WeakMap(), _BackendWebsocketDataSource_pendingSubscriptions = new WeakMap(), _BackendWebsocketDataSource_subscriptionRequests = new WeakMap(), _BackendWebsocketDataSource_registeredChannelCallbacks = new WeakMap(), _BackendWebsocketDataSource_subscribeLock = new WeakMap(), _BackendWebsocketDataSource_instances = new WeakSet(), _BackendWebsocketDataSource_initializeActiveChains = 
+// ============================================================================
+// INITIALIZATION
+// ============================================================================
+async function _BackendWebsocketDataSource_initializeActiveChains() {
+    try {
+        const chains = await __classPrivateFieldGet(this, _BackendWebsocketDataSource_instances, "m", _BackendWebsocketDataSource_fetchActiveChains).call(this);
+        __classPrivateFieldSet(this, _BackendWebsocketDataSource_supportedChains, chains, "f");
+        // Only claim chains if the websocket is already connected.
+        // If not connected, chains stay unclaimed so AccountsApiDataSource
+        // can pick them up via polling. They'll be claimed on reconnect.
+        if (__classPrivateFieldGet(this, _BackendWebsocketDataSource_isConnected, "f")) {
+            const previous = [...this.state.activeChains];
+            this.updateActiveChains(chains, (updatedChains) => __classPrivateFieldGet(this, _BackendWebsocketDataSource_onActiveChainsUpdated, "f").call(this, this.getName(), updatedChains, previous));
+        }
+        __classPrivateFieldSet(this, _BackendWebsocketDataSource_chainsRefreshTimer, setInterval(() => {
+            __classPrivateFieldGet(this, _BackendWebsocketDataSource_instances, "m", _BackendWebsocketDataSource_refreshActiveChains).call(this).catch(console.error);
+        }, DEFAULT_CHAINS_REFRESH_INTERVAL_MS), "f");
+    }
+    catch (error) {
+        log('Failed to fetch active chains', error);
+    }
+}, _BackendWebsocketDataSource_refreshActiveChains = async function _BackendWebsocketDataSource_refreshActiveChains() {
+    try {
+        const chains = await __classPrivateFieldGet(this, _BackendWebsocketDataSource_instances, "m", _BackendWebsocketDataSource_fetchActiveChains).call(this);
+        __classPrivateFieldSet(this, _BackendWebsocketDataSource_supportedChains, chains, "f");
+        // Only update activeChains if connected; otherwise keep them unclaimed.
+        if (!__classPrivateFieldGet(this, _BackendWebsocketDataSource_isConnected, "f")) {
+            return;
+        }
+        const previousChains = new Set(this.state.activeChains);
+        const newChains = new Set(chains);
+        const added = chains.filter((chain) => !previousChains.has(chain));
+        const removed = Array.from(previousChains).filter((chain) => !newChains.has(chain));
+        if (added.length > 0 || removed.length > 0) {
+            const previous = [...this.state.activeChains];
+            this.updateActiveChains(chains, (updatedChains) => __classPrivateFieldGet(this, _BackendWebsocketDataSource_onActiveChainsUpdated, "f").call(this, this.getName(), updatedChains, previous));
+        }
+    }
+    catch (error) {
+        log('Failed to refresh active chains', error);
+    }
+}, _BackendWebsocketDataSource_fetchActiveChains = async function _BackendWebsocketDataSource_fetchActiveChains() {
+    const response = await __classPrivateFieldGet(this, _BackendWebsocketDataSource_apiClient, "f").accounts.fetchV2SupportedNetworks();
+    return response.fullSupport.map(toChainId);
+}, _BackendWebsocketDataSource_subscribeToEvents = function _BackendWebsocketDataSource_subscribeToEvents() {
+    // Listen for WebSocket connection state changes (event not in AssetsControllerEvents).
+    __classPrivateFieldGet(this, _BackendWebsocketDataSource_messenger, "f").subscribe('BackendWebSocketService:connectionStateChanged', (connectionInfo) => {
+        if (connectionInfo.state === 'connected') {
+            __classPrivateFieldSet(this, _BackendWebsocketDataSource_isConnected, true, "f");
+            __classPrivateFieldGet(this, _BackendWebsocketDataSource_instances, "m", _BackendWebsocketDataSource_handleReconnect).call(this);
+        }
+        else if (connectionInfo.state === 'disconnected') {
+            __classPrivateFieldSet(this, _BackendWebsocketDataSource_isConnected, false, "f");
+            __classPrivateFieldGet(this, _BackendWebsocketDataSource_instances, "m", _BackendWebsocketDataSource_handleDisconnect).call(this);
+        }
+    });
+}, _BackendWebsocketDataSource_handleDisconnect = function _BackendWebsocketDataSource_handleDisconnect() {
+    log('WebSocket disconnected, releasing chains for fallback', {
+        activeSubscriptionCount: this.activeSubscriptions.size,
+        wsSubscriptionCount: __classPrivateFieldGet(this, _BackendWebsocketDataSource_wsSubscriptions, "f").size,
+        chainCount: this.state.activeChains.length,
+    });
+    // Move active subscriptions to pending for re-subscription
+    for (const [subscriptionId] of this.activeSubscriptions) {
+        const originalRequest = __classPrivateFieldGet(this, _BackendWebsocketDataSource_subscriptionRequests, "f").get(subscriptionId);
+        if (originalRequest) {
+            __classPrivateFieldGet(this, _BackendWebsocketDataSource_pendingSubscriptions, "f").set(subscriptionId, {
+                ...originalRequest,
+                isUpdate: false,
+            });
+        }
+    }
+    // Clear WebSocket subscriptions (server-side already cleared)
+    __classPrivateFieldGet(this, _BackendWebsocketDataSource_wsSubscriptions, "f").clear();
+    // Clear active subscriptions (they're no longer valid)
+    this.activeSubscriptions.clear();
+    // Release chains so the chain-claiming loop assigns them to
+    // AccountsApiDataSource (polling fallback) on the next #subscribeAssets.
+    const previous = [...this.state.activeChains];
+    if (previous.length > 0) {
+        this.updateActiveChains([], (updatedChains) => __classPrivateFieldGet(this, _BackendWebsocketDataSource_onActiveChainsUpdated, "f").call(this, this.getName(), updatedChains, previous));
+    }
+}, _BackendWebsocketDataSource_handleReconnect = function _BackendWebsocketDataSource_handleReconnect() {
+    log('WebSocket reconnected, reclaiming chains', {
+        supportedChainCount: __classPrivateFieldGet(this, _BackendWebsocketDataSource_supportedChains, "f").length,
+        pendingSubscriptionCount: __classPrivateFieldGet(this, _BackendWebsocketDataSource_pendingSubscriptions, "f").size,
+    });
+    // Discard stale pending subscriptions captured at disconnect time.
+    // The chain reclaim below triggers #onActiveChainsUpdated →
+    // #subscribeAssets() in AssetsController, which creates fresh
+    // subscriptions with current accounts and chains. Processing the
+    // stale pending entries afterwards would overwrite those with
+    // outdated request data.
+    __classPrivateFieldGet(this, _BackendWebsocketDataSource_pendingSubscriptions, "f").clear();
+    if (__classPrivateFieldGet(this, _BackendWebsocketDataSource_supportedChains, "f").length > 0) {
+        const previous = [...this.state.activeChains];
+        this.updateActiveChains(__classPrivateFieldGet(this, _BackendWebsocketDataSource_supportedChains, "f"), (updatedChains) => __classPrivateFieldGet(this, _BackendWebsocketDataSource_onActiveChainsUpdated, "f").call(this, this.getName(), updatedChains, previous));
+    }
+}, _BackendWebsocketDataSource_subscribeInternal = async function _BackendWebsocketDataSource_subscribeInternal(subscriptionRequest) {
+    const { request, subscriptionId, isUpdate } = subscriptionRequest;
+    // Filter to active chains only
+    const chainsToSubscribe = request.chainIds.filter((chainId) => this.state.activeChains.includes(chainId));
+    const addresses = request.accountsWithSupportedChains.map((a) => a.account.address);
+    if (addresses.length === 0) {
+        return;
+    }
+    // Check WebSocket connection status
+    try {
+        const connectionInfo = __classPrivateFieldGet(this, _BackendWebsocketDataSource_messenger, "f").call('BackendWebSocketService:getConnectionInfo');
+        if (connectionInfo.state !== 'connected') {
+            // Store the subscription request to process when WebSocket connects
+            __classPrivateFieldGet(this, _BackendWebsocketDataSource_pendingSubscriptions, "f").set(subscriptionId, subscriptionRequest);
+            return;
+        }
+    }
+    catch {
+        // Store anyway - will be processed when we can connect
+        __classPrivateFieldGet(this, _BackendWebsocketDataSource_pendingSubscriptions, "f").set(subscriptionId, subscriptionRequest);
+        return;
+    }
+    // Remove from pending if it was there (we're processing it now)
+    __classPrivateFieldGet(this, _BackendWebsocketDataSource_pendingSubscriptions, "f").delete(subscriptionId);
+    // Handle subscription update
+    if (isUpdate) {
+        const existing = this.activeSubscriptions.get(subscriptionId);
+        if (existing) {
+            // Check if accounts changed - if so, we need to re-subscribe to different channels
+            const existingAddresses = existing.addresses ?? [];
+            const addressesChanged = haveAddressesChanged(addresses, existingAddresses);
+            if (!addressesChanged) {
+                // Only chains changed - update chains, request, and callback
+                existing.chains = chainsToSubscribe;
+                existing.onAssetsUpdate = subscriptionRequest.onAssetsUpdate;
+                __classPrivateFieldGet(this, _BackendWebsocketDataSource_subscriptionRequests, "f").set(subscriptionId, subscriptionRequest);
+                return;
+            }
+            // Accounts changed - fall through to re-subscribe with new channels
+        }
+    }
+    // Clean up existing subscription if any (inline teardown — subscribe holds the lock)
+    await __classPrivateFieldGet(this, _BackendWebsocketDataSource_instances, "m", _BackendWebsocketDataSource_teardownSubscription).call(this, subscriptionId);
+    // Always subscribe to eip155 and solana account activity, plus any namespaces from requested chains
+    const namespaces = getNamespacesForAccountActivity(chainsToSubscribe);
+    // Build channel names: use namespace-appropriate address per account (eip155 = hex, solana = base58)
+    const channels = [];
+    for (const namespace of namespaces) {
+        for (const { account } of request.accountsWithSupportedChains) {
+            const address = getAddressForAccountActivity(account, namespace);
+            if (address) {
+                channels.push(buildAccountActivityChannel(namespace, address));
+            }
+        }
+    }
+    if (channels.length === 0) {
+        return;
+    }
+    try {
+        // Register request/callback before awaiting server subscribe so notifications
+        // that arrive during the subscribe handshake are not dropped.
+        __classPrivateFieldGet(this, _BackendWebsocketDataSource_subscriptionRequests, "f").set(subscriptionId, subscriptionRequest);
+        this.activeSubscriptions.set(subscriptionId, {
+            cleanup: () => {
+                __classPrivateFieldGet(this, _BackendWebsocketDataSource_instances, "m", _BackendWebsocketDataSource_teardownSubscription).call(this, subscriptionId).catch(() => undefined);
+            },
+            chains: chainsToSubscribe,
+            addresses,
+            onAssetsUpdate: subscriptionRequest.onAssetsUpdate,
+        });
+        // Create WebSocket subscription
+        const wsSubscription = await __classPrivateFieldGet(this, _BackendWebsocketDataSource_messenger, "f").call('BackendWebSocketService:subscribe', {
+            channels,
+            channelType: CHANNEL_TYPE,
+            callback: (notification) => {
+                __classPrivateFieldGet(this, _BackendWebsocketDataSource_instances, "m", _BackendWebsocketDataSource_handleNotification).call(this, notification, subscriptionId);
+            },
+        });
+        __classPrivateFieldGet(this, _BackendWebsocketDataSource_wsSubscriptions, "f").set(subscriptionId, wsSubscription);
+        try {
+            __classPrivateFieldGet(this, _BackendWebsocketDataSource_instances, "m", _BackendWebsocketDataSource_registerChannelCallbacks).call(this, subscriptionId, channels);
+        }
+        catch (channelCallbackError) {
+            log('Channel callback registration failed; ws subscription still active', { subscriptionId, error: channelCallbackError });
+        }
+    }
+    catch (error) {
+        this.activeSubscriptions.delete(subscriptionId);
+        __classPrivateFieldGet(this, _BackendWebsocketDataSource_subscriptionRequests, "f").delete(subscriptionId);
+        log('WebSocket subscription FAILED', {
+            subscriptionId,
+            error,
+            chains: chainsToSubscribe,
+        });
+    }
+}, _BackendWebsocketDataSource_handleNotification = function _BackendWebsocketDataSource_handleNotification(notification, subscriptionId) {
+    try {
+        const activityMessage = notification.data;
+        const storedSubscription = __classPrivateFieldGet(this, _BackendWebsocketDataSource_subscriptionRequests, "f").get(subscriptionId);
+        const request = storedSubscription?.request;
+        const onAssetsUpdate = this.activeSubscriptions.get(subscriptionId)?.onAssetsUpdate ??
+            storedSubscription?.onAssetsUpdate;
+        if (!request) {
+            return;
+        }
+        const { address, tx, updates } = activityMessage;
+        if (!address || !tx || !updates) {
+            return;
+        }
+        // Extract chain ID from transaction (CAIP-2 format, e.g., "eip155:8453")
+        const chainId = tx.chain;
+        // Find matching account in request (eip155: case-insensitive hex; solana: exact base58)
+        const account = request.accountsWithSupportedChains
+            .map((entry) => entry.account)
+            .find((a) => a.address.startsWith('0x')
+            ? a.address.toLowerCase() === address.toLowerCase()
+            : a.address === address);
+        if (!account) {
+            return;
+        }
+        const accountId = account.id;
+        // Process all balance updates from the activity message
+        const response = __classPrivateFieldGet(this, _BackendWebsocketDataSource_instances, "m", _BackendWebsocketDataSource_processBalanceUpdates).call(this, updates, chainId, accountId);
+        const balanceEntries = response.assetsBalance?.[accountId] ?? {};
+        const hasBalances = Object.keys(balanceEntries).length > 0;
+        if (hasBalances && onAssetsUpdate) {
+            Promise.resolve(onAssetsUpdate(response, request)).catch((error) => {
+                console.error(error);
+            });
+        }
+    }
+    catch (error) {
+        log('Error handling notification', error);
+    }
+}, _BackendWebsocketDataSource_processBalanceUpdates = function _BackendWebsocketDataSource_processBalanceUpdates(updates, _chainId, accountId) {
+    return processAccountActivityBalanceUpdates(updates, accountId, (assetId) => __classPrivateFieldGet(this, _BackendWebsocketDataSource_getAssetType, "f").call(this, assetId));
+}, _BackendWebsocketDataSource_teardownSubscription = async function _BackendWebsocketDataSource_teardownSubscription(subscriptionId) {
+    const wsSub = __classPrivateFieldGet(this, _BackendWebsocketDataSource_wsSubscriptions, "f").get(subscriptionId);
+    if (wsSub) {
+        const channels = [...wsSub.channels];
+        try {
+            await wsSub.unsubscribe();
+        }
+        catch (unsubErr) {
+            log('Error unsubscribing', { subscriptionId, error: unsubErr });
+        }
+        __classPrivateFieldGet(this, _BackendWebsocketDataSource_wsSubscriptions, "f").delete(subscriptionId);
+        __classPrivateFieldGet(this, _BackendWebsocketDataSource_instances, "m", _BackendWebsocketDataSource_removeChannelCallbacks).call(this, channels);
+    }
+    __classPrivateFieldGet(this, _BackendWebsocketDataSource_subscriptionRequests, "f").delete(subscriptionId);
+    this.activeSubscriptions.delete(subscriptionId);
+}, _BackendWebsocketDataSource_registerChannelCallbacks = function _BackendWebsocketDataSource_registerChannelCallbacks(subscriptionId, channels) {
+    for (const channel of channels) {
+        __classPrivateFieldGet(this, _BackendWebsocketDataSource_instances, "m", _BackendWebsocketDataSource_unregisterChannelCallback).call(this, channel);
+        try {
+            __classPrivateFieldGet(this, _BackendWebsocketDataSource_messenger, "f").call('BackendWebSocketService:addChannelCallback', {
+                channelName: channel,
+                callback: (notification) => {
+                    __classPrivateFieldGet(this, _BackendWebsocketDataSource_instances, "m", _BackendWebsocketDataSource_handleNotification).call(this, notification, subscriptionId);
+                },
+            });
+            __classPrivateFieldGet(this, _BackendWebsocketDataSource_registeredChannelCallbacks, "f").add(channel);
+        }
+        catch {
+            // Channel callbacks are optional; ws subscription still works without them.
+        }
+    }
+}, _BackendWebsocketDataSource_unregisterChannelCallback = function _BackendWebsocketDataSource_unregisterChannelCallback(channel) {
+    if (!__classPrivateFieldGet(this, _BackendWebsocketDataSource_registeredChannelCallbacks, "f").has(channel)) {
+        return;
+    }
+    try {
+        __classPrivateFieldGet(this, _BackendWebsocketDataSource_messenger, "f").call('BackendWebSocketService:removeChannelCallback', channel);
+    }
+    catch {
+        // Best-effort cleanup when the channel callback was never registered.
+    }
+    __classPrivateFieldGet(this, _BackendWebsocketDataSource_registeredChannelCallbacks, "f").delete(channel);
+}, _BackendWebsocketDataSource_removeChannelCallbacks = function _BackendWebsocketDataSource_removeChannelCallbacks(channels) {
+    for (const channel of channels) {
+        __classPrivateFieldGet(this, _BackendWebsocketDataSource_instances, "m", _BackendWebsocketDataSource_unregisterChannelCallback).call(this, channel);
+    }
+};
+// ============================================================================
+// FACTORY FUNCTION
+// ============================================================================
+/**
+ * Creates a BackendWebsocketDataSource instance.
+ *
+ * @param options - Configuration options for the data source.
+ * @returns A new BackendWebsocketDataSource instance.
+ */
+export function createBackendWebsocketDataSource(options) {
+    return new BackendWebsocketDataSource(options);
+}
+//# sourceMappingURL=BackendWebsocketDataSource.mjs.map