@metamask/assets-controller 9.1.0 → 10.0.1

package/dist/data-sources/BackendWebsocketDataSource.mjs

@@ -9,10 +9,10 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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_initializeActiveChains, _BackendWebsocketDataSource_refreshActiveChains, _BackendWebsocketDataSource_fetchActiveChains, _BackendWebsocketDataSource_subscribeToEvents, _BackendWebsocketDataSource_handleDisconnect, _BackendWebsocketDataSource_handleReconnect, _BackendWebsocketDataSource_handleNotification, _BackendWebsocketDataSource_processBalanceUpdates;
+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 BigNumberJS from "bignumber.js";
 import { projectLogger, createModuleLogger } from "../logger.mjs";
+import { processAccountActivityBalanceUpdates } from "../utils/processAccountActivityBalanceUpdates.mjs";
 import { AbstractDataSource } from "./AbstractDataSource.mjs";
 // ============================================================================
 // CONSTANTS
@@ -89,6 +89,34 @@ 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...).
@@ -136,6 +164,8 @@ function toChainId(chainIdOrDecimal) {
  * - 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 {
@@ -161,6 +191,10 @@ export class BackendWebsocketDataSource extends AbstractDataSource {
         _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");
@@ -168,6 +202,16 @@ export class BackendWebsocketDataSource extends AbstractDataSource {
         __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
@@ -194,96 +238,40 @@ export class BackendWebsocketDataSource extends AbstractDataSource {
     // SUBSCRIBE
     // ============================================================================
     async subscribe(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
+        const previousLock = __classPrivateFieldGet(this, _BackendWebsocketDataSource_subscribeLock, "f");
+        let releaseLock = () => undefined;
+        __classPrivateFieldSet(this, _BackendWebsocketDataSource_subscribeLock, new Promise((resolve) => {
+            releaseLock = resolve;
+        }), "f");
+        await previousLock;
         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;
+            await __classPrivateFieldGet(this, _BackendWebsocketDataSource_instances, "m", _BackendWebsocketDataSource_subscribeInternal).call(this, subscriptionRequest);
         }
-        // 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 = addresses.length !== existingAddresses.length ||
-                    addresses.some((addr) => !existingAddresses.includes(addr));
-                if (!addressesChanged) {
-                    // Only chains changed - just update chains and return
-                    existing.chains = chainsToSubscribe;
-                    return;
-                }
-                // Accounts changed - fall through to re-subscribe with new channels
-            }
-        }
-        // Clean up existing subscription if any
-        await this.unsubscribe(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));
-                }
-            }
+        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 {
-            // 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);
-                },
-            });
-            // Store WebSocket subscription
-            __classPrivateFieldGet(this, _BackendWebsocketDataSource_wsSubscriptions, "f").set(subscriptionId, wsSubscription);
-            // Store in abstract class tracking
-            this.activeSubscriptions.set(subscriptionId, {
-                cleanup: () => {
-                    const wsSub = __classPrivateFieldGet(this, _BackendWebsocketDataSource_wsSubscriptions, "f").get(subscriptionId);
-                    if (wsSub) {
-                        wsSub.unsubscribe().catch((unsubErr) => {
-                            log('Error unsubscribing', { subscriptionId, error: unsubErr });
-                        });
-                        __classPrivateFieldGet(this, _BackendWebsocketDataSource_wsSubscriptions, "f").delete(subscriptionId);
-                    }
-                    // Also clean up the stored request
-                    __classPrivateFieldGet(this, _BackendWebsocketDataSource_subscriptionRequests, "f").delete(subscriptionId);
-                },
-                chains: chainsToSubscribe,
-                addresses,
-                onAssetsUpdate: subscriptionRequest.onAssetsUpdate,
-            });
-            // Store original request for reconnection
-            __classPrivateFieldGet(this, _BackendWebsocketDataSource_subscriptionRequests, "f").set(subscriptionId, subscriptionRequest);
+            await __classPrivateFieldGet(this, _BackendWebsocketDataSource_instances, "m", _BackendWebsocketDataSource_teardownSubscription).call(this, subscriptionId);
         }
-        catch (error) {
-            log('WebSocket subscription FAILED', {
-                subscriptionId,
-                error,
-                chains: chainsToSubscribe,
-            });
+        finally {
+            releaseLock();
         }
     }
     // ============================================================================
@@ -294,26 +282,20 @@ export class BackendWebsocketDataSource extends AbstractDataSource {
             clearInterval(__classPrivateFieldGet(this, _BackendWebsocketDataSource_chainsRefreshTimer, "f"));
             __classPrivateFieldSet(this, _BackendWebsocketDataSource_chainsRefreshTimer, null, "f");
         }
-        // Clean up WebSocket subscriptions
-        // Convert to array first to avoid modifying map during iteration
-        const subscriptions = [...__classPrivateFieldGet(this, _BackendWebsocketDataSource_wsSubscriptions, "f").values()];
-        for (const wsSub of subscriptions) {
-            try {
-                // Fire and forget - don't await in destroy
-                wsSub.unsubscribe().catch(() => {
-                    // Ignore errors during cleanup
-                });
-            }
-            catch {
-                // Ignore errors during cleanup
-            }
+        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);
         }
-        __classPrivateFieldGet(this, _BackendWebsocketDataSource_wsSubscriptions, "f").clear();
-        // Clean up base class subscriptions
+        // 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_instances = new WeakSet(), _BackendWebsocketDataSource_initializeActiveChains = 
+_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
 // ============================================================================
@@ -412,14 +394,111 @@ async function _BackendWebsocketDataSource_initializeActiveChains() {
         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 subscription = this.activeSubscriptions.get(subscriptionId);
-        const request = __classPrivateFieldGet(this, _BackendWebsocketDataSource_subscriptionRequests, "f").get(subscriptionId)?.request;
+        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 activityMessage = notification.data;
         const { address, tx, updates } = activityMessage;
         if (!address || !tx || !updates) {
             return;
@@ -438,54 +517,65 @@ async function _BackendWebsocketDataSource_initializeActiveChains() {
         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);
-        if (Object.keys(response).length > 0 && subscription) {
-            Promise.resolve(subscription.onAssetsUpdate(response)).catch(console.error);
+        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) {
-    const assetsBalance = {
-        [accountId]: {},
-    };
-    const assetsMetadata = {};
-    for (const update of updates) {
-        const { asset, postBalance } = update;
-        if (!asset || !postBalance) {
-            continue;
+    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);
         }
-        // Asset type is in CAIP format: "eip155:1/erc20:0x..." or "eip155:1/slip44:60"
-        // We can use it directly as the asset ID
-        const assetId = asset.type;
-        const tokenType = __classPrivateFieldGet(this, _BackendWebsocketDataSource_getAssetType, "f").call(this, assetId);
-        // We assume decimals are always present; skip malformed updates
-        if (asset.decimals === undefined) {
-            continue;
+        catch {
+            // Channel callbacks are optional; ws subscription still works without them.
         }
-        // Parse raw balance (hex like "0x26f0e5" or decimal string)
-        const rawBalanceStr = postBalance.amount.startsWith('0x')
-            ? BigInt(postBalance.amount).toString()
-            : postBalance.amount;
-        const humanReadableAmount = new BigNumberJS(rawBalanceStr)
-            .dividedBy(new BigNumberJS(10).pow(asset.decimals))
-            .toFixed();
-        assetsBalance[accountId][assetId] = {
-            amount: humanReadableAmount,
-        };
-        assetsMetadata[assetId] = {
-            type: tokenType,
-            symbol: asset.unit,
-            name: asset.unit, // Use unit as name (actual name may not be in the message)
-            decimals: asset.decimals,
-        };
-    }
-    const response = { updateMode: 'merge' };
-    if (Object.keys(assetsBalance[accountId]).length > 0) {
-        response.assetsBalance = assetsBalance;
-        response.assetsInfo = assetsMetadata;
-    }
-    return response;
+    }
+}, _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