@metamask-previews/assets-controller 0.0.0-preview-2aeb1204 → 0.0.0-preview-40468f94

package/dist/data-sources/SnapDataSource.mjs

@@ -9,9 +9,7 @@ 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 _SnapDataSource_instances, _SnapDataSource_messenger, _SnapDataSource_handleSnapBalancesUpdatedBound, _SnapDataSource_handlePermissionStateChangeBound, _SnapDataSource_keyringClientCache, _SnapDataSource_subscribeToEvents, _SnapDataSource_handleSnapBalancesUpdated, _SnapDataSource_isChainSupportedBySnap, _SnapDataSource_registerActionHandlers, _SnapDataSource_getRunnableSnaps, _SnapDataSource_getSnapPermissions, _SnapDataSource_discoverKeyringSnaps, _SnapDataSource_getKeyringClient;
-import { KeyringClient } from "@metamask/keyring-snap-client";
-import { HandlerType, SnapCaveatType } from "@metamask/snaps-utils";
+var _SnapDataSource_instances, _SnapDataSource_messenger, _SnapDataSource_snapProvider, _SnapDataSource_subscribeToSnapKeyringEvents, _SnapDataSource_handleSnapBalancesUpdated, _SnapDataSource_registerActionHandlers, _SnapDataSource_getInstalledSnaps, _SnapDataSource_checkSnapAvailabilityOnDemand, _SnapDataSource_checkAllSnapsAvailability, _SnapDataSource_accountSupportsChain, _SnapDataSource_groupChainsBySnap, _SnapDataSource_fetchFromSnap;
 import { AbstractDataSource } from "./AbstractDataSource.mjs";
 import { projectLogger, createModuleLogger } from "../logger.mjs";
 const log = createModuleLogger(projectLogger, 'SnapDataSource');
@@ -19,29 +17,89 @@ const log = createModuleLogger(projectLogger, 'SnapDataSource');
 // CONSTANTS
 // ============================================================================
 export const SNAP_DATA_SOURCE_NAME = 'SnapDataSource';
-/** The permission name for snap keyring endowment */
-export const KEYRING_PERMISSION = 'endowment:keyring';
-/** The permission name for snap assets endowment (contains chainIds) */
-export const ASSETS_PERMISSION = 'endowment:assets';
-// ============================================================================
-// PERMISSION UTILITIES
-// ============================================================================
+// Snap IDs
+export const SOLANA_SNAP_ID = 'npm:@metamask/solana-wallet-snap';
+export const BITCOIN_SNAP_ID = 'npm:@metamask/bitcoin-wallet-snap';
+export const TRON_SNAP_ID = 'npm:@metamask/tron-wallet-snap';
+// Chain prefixes for detection
+export const SOLANA_CHAIN_PREFIX = 'solana:';
+export const BITCOIN_CHAIN_PREFIX = 'bip122:';
+export const TRON_CHAIN_PREFIX = 'tron:';
+// Default networks
+export const SOLANA_MAINNET = 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp';
+export const SOLANA_DEVNET = 'solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1';
+export const SOLANA_TESTNET = 'solana:4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z';
+export const BITCOIN_MAINNET = 'bip122:000000000019d6689c085ae165831e93';
+export const BITCOIN_TESTNET = 'bip122:000000000933ea01ad0ee984209779ba';
+export const TRON_MAINNET = 'tron:728126428';
+export const TRON_SHASTA = 'tron:2494104990';
+export const TRON_NILE = 'tron:3448148188';
+// Hex format alternatives for Tron
+export const TRON_MAINNET_HEX = 'tron:0x2b6653dc';
+export const TRON_SHASTA_HEX = 'tron:0x94a9059e';
+export const TRON_NILE_HEX = 'tron:0xcd8690dc';
+// Default poll intervals
+export const DEFAULT_SOLANA_POLL_INTERVAL = 30000; // 30 seconds
+export const DEFAULT_BITCOIN_POLL_INTERVAL = 60000; // 1 minute
+export const DEFAULT_TRON_POLL_INTERVAL = 30000; // 30 seconds
+export const DEFAULT_SNAP_POLL_INTERVAL = 30000; // Default for unknown snaps
+// All default networks
+export const ALL_DEFAULT_NETWORKS = [
+    SOLANA_MAINNET,
+    SOLANA_DEVNET,
+    SOLANA_TESTNET,
+    BITCOIN_MAINNET,
+    BITCOIN_TESTNET,
+    TRON_MAINNET,
+    TRON_SHASTA,
+    TRON_NILE,
+    TRON_MAINNET_HEX,
+    TRON_SHASTA_HEX,
+    TRON_NILE_HEX,
+];
+export const SNAP_REGISTRY = {
+    solana: {
+        snapId: SOLANA_SNAP_ID,
+        chainPrefix: SOLANA_CHAIN_PREFIX,
+        pollInterval: DEFAULT_SOLANA_POLL_INTERVAL,
+    },
+    bitcoin: {
+        snapId: BITCOIN_SNAP_ID,
+        chainPrefix: BITCOIN_CHAIN_PREFIX,
+        pollInterval: DEFAULT_BITCOIN_POLL_INTERVAL,
+    },
+    tron: {
+        snapId: TRON_SNAP_ID,
+        chainPrefix: TRON_CHAIN_PREFIX,
+        pollInterval: DEFAULT_TRON_POLL_INTERVAL,
+    },
+};
 /**
- * Getter function to get the chainIds caveat from a permission.
- *
- * This does basic validation of the caveat, but does not validate the type or
- * value of the namespaces object itself, as this is handled by the
- * `PermissionsController` when the permission is requested.
+ * Get the snap type for a chain ID based on its prefix.
  *
- * @param permission - The permission to get the `chainIds` caveat from.
- * @returns An array of `chainIds` that the snap supports, or null if none.
+ * @param chainId - The CAIP-2 chain ID to check.
+ * @returns The snap type for the chain, or null if not supported.
  */
-export function getChainIdsCaveat(permission) {
-    if (!permission?.caveats) {
-        return null;
+export function getSnapTypeForChain(chainId) {
+    if (chainId.startsWith(SOLANA_CHAIN_PREFIX)) {
+        return 'solana';
     }
-    const caveat = permission.caveats.find((permCaveat) => permCaveat.type === SnapCaveatType.ChainIds);
-    return caveat ? caveat.value : null;
+    if (chainId.startsWith(BITCOIN_CHAIN_PREFIX)) {
+        return 'bitcoin';
+    }
+    if (chainId.startsWith(TRON_CHAIN_PREFIX)) {
+        return 'tron';
+    }
+    return null;
+}
+/**
+ * Check if a chain ID is supported by a snap.
+ *
+ * @param chainId - The CAIP-2 chain ID to check.
+ * @returns True if the chain is supported by a snap.
+ */
+export function isSnapSupportedChain(chainId) {
+    return getSnapTypeForChain(chainId) !== null;
 }
 /**
  * Extract chain ID from a CAIP-19 asset ID.
@@ -54,9 +112,23 @@ export function extractChainFromAssetId(assetId) {
     const parts = assetId.split('/');
     return parts[0];
 }
+// Helper functions for specific chain types
+export function isSolanaChain(chainId) {
+    return chainId.startsWith(SOLANA_CHAIN_PREFIX);
+}
+export function isBitcoinChain(chainId) {
+    return chainId.startsWith(BITCOIN_CHAIN_PREFIX);
+}
+export function isTronChain(chainId) {
+    return chainId.startsWith(TRON_CHAIN_PREFIX);
+}
 const defaultSnapState = {
-    activeChains: [],
-    chainToSnap: {},
+    activeChains: ALL_DEFAULT_NETWORKS,
+    snaps: {
+        solana: { version: null, available: false },
+        bitcoin: { version: null, available: false },
+        tron: { version: null, available: false },
+    },
 };
 // ============================================================================
 // SNAP DATA SOURCE
@@ -65,10 +137,16 @@ const defaultSnapState = {
  * Unified Snap data source that routes requests to the appropriate wallet snap
  * based on the chain ID prefix.
  *
+ * Supports:
+ * - Solana chains (solana:*) → @metamask/solana-wallet-snap
+ * - Bitcoin chains (bip122:*) → @metamask/bitcoin-wallet-snap
+ * - Tron chains (tron:*) → @metamask/tron-wallet-snap
+ *
  * @example
  * ```typescript
  * const snapDataSource = new SnapDataSource({
  *   messenger,
+ *   snapProvider: metamaskProvider,
  * });
  *
  * // Fetch will automatically route to the correct snap
@@ -80,81 +158,122 @@ const defaultSnapState = {
  */
 export class SnapDataSource extends AbstractDataSource {
     constructor(options) {
+        const configuredNetworks = options.configuredNetworks ?? ALL_DEFAULT_NETWORKS;
         super(SNAP_DATA_SOURCE_NAME, {
             ...defaultSnapState,
             ...options.state,
+            activeChains: configuredNetworks,
         });
         _SnapDataSource_instances.add(this);
         _SnapDataSource_messenger.set(this, void 0);
-        /** Bound handler for snap keyring balance updates, stored for cleanup */
-        _SnapDataSource_handleSnapBalancesUpdatedBound.set(this, void 0);
-        _SnapDataSource_handlePermissionStateChangeBound.set(this, void 0);
-        /** Cache of KeyringClient instances per snap ID to avoid re-instantiation */
-        _SnapDataSource_keyringClientCache.set(this, new Map());
+        _SnapDataSource_snapProvider.set(this, void 0);
         __classPrivateFieldSet(this, _SnapDataSource_messenger, options.messenger, "f");
-        // Bind handlers for cleanup in destroy()
-        __classPrivateFieldSet(this, _SnapDataSource_handleSnapBalancesUpdatedBound, __classPrivateFieldGet(this, _SnapDataSource_instances, "m", _SnapDataSource_handleSnapBalancesUpdated).bind(this), "f");
-        __classPrivateFieldSet(this, _SnapDataSource_handlePermissionStateChangeBound, __classPrivateFieldGet(this, _SnapDataSource_instances, "m", _SnapDataSource_discoverKeyringSnaps).bind(this), "f");
+        __classPrivateFieldSet(this, _SnapDataSource_snapProvider, options.snapProvider, "f");
         __classPrivateFieldGet(this, _SnapDataSource_instances, "m", _SnapDataSource_registerActionHandlers).call(this);
-        __classPrivateFieldGet(this, _SnapDataSource_instances, "m", _SnapDataSource_subscribeToEvents).call(this);
-        // Discover keyring-capable snaps and populate activeChains dynamically
-        __classPrivateFieldGet(this, _SnapDataSource_instances, "m", _SnapDataSource_discoverKeyringSnaps).call(this);
+        __classPrivateFieldGet(this, _SnapDataSource_instances, "m", _SnapDataSource_subscribeToSnapKeyringEvents).call(this);
+        // Check availability for all snaps on initialization
+        __classPrivateFieldGet(this, _SnapDataSource_instances, "m", _SnapDataSource_checkAllSnapsAvailability).call(this).catch(() => {
+            // Silently ignore availability check failures on init
+        });
+    }
+    /**
+     * Get info about all snaps.
+     *
+     * @returns Record of snap info keyed by snap type.
+     */
+    getSnapsInfo() {
+        const result = {};
+        for (const [snapType, config] of Object.entries(SNAP_REGISTRY)) {
+            const state = this.state.snaps[snapType];
+            result[snapType] = {
+                ...config,
+                version: state.version,
+                available: state.available,
+            };
+        }
+        return result;
+    }
+    /**
+     * Check if a specific snap is available.
+     *
+     * @param snapType - The snap type to check (solana, bitcoin, tron).
+     * @returns True if the snap is available.
+     */
+    isSnapAvailable(snapType) {
+        return this.state.snaps[snapType]?.available ?? false;
+    }
+    /**
+     * Force refresh snap availability check.
+     */
+    async refreshSnapsStatus() {
+        await __classPrivateFieldGet(this, _SnapDataSource_instances, "m", _SnapDataSource_checkAllSnapsAvailability).call(this);
     }
     // ============================================================================
-    // FETCH
+    // CHAIN MANAGEMENT
+    // ============================================================================
+    addNetworks(chainIds) {
+        const snapChains = chainIds.filter(isSnapSupportedChain);
+        const newChains = snapChains.filter((chain) => !this.state.activeChains.includes(chain));
+        if (newChains.length > 0) {
+            const updated = [...this.state.activeChains, ...newChains];
+            this.updateActiveChains(updated, (updatedChains) => __classPrivateFieldGet(this, _SnapDataSource_messenger, "f").call('AssetsController:activeChainsUpdate', SNAP_DATA_SOURCE_NAME, updatedChains));
+        }
+    }
+    removeNetworks(chainIds) {
+        const chainSet = new Set(chainIds);
+        const updated = this.state.activeChains.filter((chain) => !chainSet.has(chain));
+        if (updated.length !== this.state.activeChains.length) {
+            this.updateActiveChains(updated, (updatedChains) => __classPrivateFieldGet(this, _SnapDataSource_messenger, "f").call('AssetsController:activeChainsUpdate', SNAP_DATA_SOURCE_NAME, updatedChains));
+        }
+    }
+    // ============================================================================
+    // FETCH - Routes to appropriate snap(s)
     // ============================================================================
     async fetch(request) {
-        var _a;
-        // Guard against undefined request
-        // Note: chainIds filtering is done by middleware/subscribe before calling fetch
-        if (!request?.accounts || !request?.chainIds?.length) {
+        // Guard against undefined request or chainIds
+        if (!request?.chainIds) {
             return {};
         }
-        const results = {
-            assetsBalance: {},
-            assetsMetadata: {},
-        };
-        // Fetch balances for each account using its snap ID from metadata
-        for (const account of request.accounts) {
-            // Skip accounts without snap metadata (non-snap accounts)
-            const snapId = account.metadata.snap?.id;
-            if (!snapId) {
-                continue;
+        // Filter to only snap-supported chains
+        const snapChains = request.chainIds.filter(isSnapSupportedChain);
+        if (snapChains.length === 0) {
+            return {};
+        }
+        // Group chains by snap type
+        const chainsBySnap = __classPrivateFieldGet(this, _SnapDataSource_instances, "m", _SnapDataSource_groupChainsBySnap).call(this, snapChains);
+        // Fetch from each snap in parallel
+        const results = await Promise.all(Object.entries(chainsBySnap).map(async ([snapType, chains]) => {
+            return __classPrivateFieldGet(this, _SnapDataSource_instances, "m", _SnapDataSource_fetchFromSnap).call(this, snapType, {
+                ...request,
+                chainIds: chains,
+            });
+        }));
+        // Merge all results
+        const mergedResponse = {};
+        for (const result of results) {
+            if (result.assetsBalance) {
+                mergedResponse.assetsBalance = {
+                    ...mergedResponse.assetsBalance,
+                    ...result.assetsBalance,
+                };
             }
-            // Skip accounts whose snap doesn't support any of the requested chains
-            const snapSupportsRequestedChains = request.chainIds.some((chainId) => this.state.chainToSnap[chainId] === snapId);
-            if (!snapSupportsRequestedChains) {
-                continue;
+            if (result.assetsMetadata) {
+                mergedResponse.assetsMetadata = {
+                    ...mergedResponse.assetsMetadata,
+                    ...result.assetsMetadata,
+                };
             }
-            const accountId = account.id;
-            try {
-                const client = __classPrivateFieldGet(this, _SnapDataSource_instances, "m", _SnapDataSource_getKeyringClient).call(this, snapId);
-                // Step 1: Get the list of assets for this account
-                const accountAssets = await client.listAccountAssets(accountId);
-                // If no assets, skip to next account
-                if (!accountAssets || accountAssets.length === 0) {
-                    continue;
-                }
-                // Step 2: Get balances for those specific assets
-                const balances = await client.getAccountBalances(accountId, accountAssets);
-                // Transform keyring response to DataResponse format
-                if (balances && typeof balances === 'object' && results.assetsBalance) {
-                    for (const [assetId, balance] of Object.entries(balances)) {
-                        (_a = results.assetsBalance)[accountId] ?? (_a[accountId] = {});
-                        const accountBalances = results.assetsBalance[accountId];
-                        if (accountBalances) {
-                            accountBalances[assetId] = {
-                                amount: balance.amount,
-                            };
-                        }
-                    }
-                }
+            if (result.assetsPrice) {
+                mergedResponse.assetsPrice = {
+                    ...mergedResponse.assetsPrice,
+                    ...result.assetsPrice,
+                };
             }
-            catch {
-                // Expected when account doesn't belong to this snap
+            if (result.errors) {
+                mergedResponse.errors = { ...mergedResponse.errors, ...result.errors };
             }
         }
-        return results;
+        return mergedResponse;
     }
     // ============================================================================
     // MIDDLEWARE
@@ -242,19 +361,19 @@ export class SnapDataSource extends AbstractDataSource {
         if (!request?.chainIds) {
             return;
         }
-        // Filter to chains we have a snap for
-        const supportedChains = request.chainIds.filter((chainId) => __classPrivateFieldGet(this, _SnapDataSource_instances, "m", _SnapDataSource_isChainSupportedBySnap).call(this, chainId));
-        if (supportedChains.length === 0) {
+        // Filter to only snap-supported chains
+        const snapChains = request.chainIds.filter(isSnapSupportedChain);
+        if (snapChains.length === 0) {
             return;
         }
         if (isUpdate) {
             const existing = this.activeSubscriptions.get(subscriptionId);
             if (existing) {
-                existing.chains = supportedChains;
+                existing.chains = snapChains;
                 // Do a fetch to get latest data on subscription update
                 this.fetch({
                     ...request,
-                    chainIds: supportedChains,
+                    chainIds: snapChains,
                 })
                     .then(async (fetchResponse) => {
                     if (Object.keys(fetchResponse.assetsBalance ?? {}).length > 0) {
@@ -276,13 +395,13 @@ export class SnapDataSource extends AbstractDataSource {
             cleanup: () => {
                 // No timer to clear - we use event-based updates
             },
-            chains: supportedChains,
+            chains: snapChains,
         });
         // Initial fetch to get current balances
         try {
             const fetchResponse = await this.fetch({
                 ...request,
-                chainIds: supportedChains,
+                chainIds: snapChains,
             });
             if (Object.keys(fetchResponse.assetsBalance ?? {}).length > 0) {
                 await __classPrivateFieldGet(this, _SnapDataSource_messenger, "f").call('AssetsController:assetsUpdate', fetchResponse, SNAP_DATA_SOURCE_NAME);
@@ -296,68 +415,52 @@ export class SnapDataSource extends AbstractDataSource {
     // CLEANUP
     // ============================================================================
     destroy() {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const messenger = __classPrivateFieldGet(this, _SnapDataSource_messenger, "f");
-        // Unsubscribe from snap keyring events
-        try {
-            messenger.unsubscribe('AccountsController:accountBalancesUpdated', __classPrivateFieldGet(this, _SnapDataSource_handleSnapBalancesUpdatedBound, "f"));
-        }
-        catch (error) {
-            log('Failed to unsubscribe from snap keyring events', { error });
-        }
-        // Unsubscribe from permission changes
-        try {
-            messenger.unsubscribe('PermissionController:stateChange', __classPrivateFieldGet(this, _SnapDataSource_handlePermissionStateChangeBound, "f"));
-        }
-        catch (error) {
-            log('Failed to unsubscribe from permission changes', { error });
-        }
-        // Clean up active subscriptions
         for (const [subscriptionId] of this.activeSubscriptions) {
             this.unsubscribe(subscriptionId).catch(() => {
                 // Ignore cleanup errors
             });
         }
-        // Clear keyring client cache
-        __classPrivateFieldGet(this, _SnapDataSource_keyringClientCache, "f").clear();
     }
 }
-_SnapDataSource_messenger = new WeakMap(), _SnapDataSource_handleSnapBalancesUpdatedBound = new WeakMap(), _SnapDataSource_handlePermissionStateChangeBound = new WeakMap(), _SnapDataSource_keyringClientCache = new WeakMap(), _SnapDataSource_instances = new WeakSet(), _SnapDataSource_subscribeToEvents = function _SnapDataSource_subscribeToEvents() {
-    // Subscribe to snap keyring events for real-time balance updates.
-    // The snaps emit AccountBalancesUpdated events when balances change,
-    // which are re-published by AccountsController.
-    __classPrivateFieldGet(this, _SnapDataSource_messenger, "f").subscribe('AccountsController:accountBalancesUpdated', __classPrivateFieldGet(this, _SnapDataSource_handleSnapBalancesUpdatedBound, "f"));
-    // Subscribe to permission changes to detect new keyring snaps at runtime.
-    // Re-runs snap discovery when permissions change.
-    __classPrivateFieldGet(this, _SnapDataSource_messenger, "f").subscribe('PermissionController:stateChange', __classPrivateFieldGet(this, _SnapDataSource_handlePermissionStateChangeBound, "f"));
+_SnapDataSource_messenger = new WeakMap(), _SnapDataSource_snapProvider = new WeakMap(), _SnapDataSource_instances = new WeakSet(), _SnapDataSource_subscribeToSnapKeyringEvents = function _SnapDataSource_subscribeToSnapKeyringEvents() {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const messenger = __classPrivateFieldGet(this, _SnapDataSource_messenger, "f");
+    try {
+        messenger.subscribe('AccountsController:accountBalancesUpdated', (payload) => {
+            __classPrivateFieldGet(this, _SnapDataSource_instances, "m", _SnapDataSource_handleSnapBalancesUpdated).call(this, payload);
+        });
+    }
+    catch (error) {
+        log('Failed to subscribe to snap keyring events', { error });
+    }
 }, _SnapDataSource_handleSnapBalancesUpdated = function _SnapDataSource_handleSnapBalancesUpdated(payload) {
     // Transform the snap keyring payload to DataResponse format
-    let assetsBalance;
+    const response = {
+        assetsBalance: {},
+    };
     for (const [accountId, assets] of Object.entries(payload.balances)) {
-        let accountAssets;
-        for (const [assetId, balance] of Object.entries(assets)) {
-            const chainId = extractChainFromAssetId(assetId);
-            if (__classPrivateFieldGet(this, _SnapDataSource_instances, "m", _SnapDataSource_isChainSupportedBySnap).call(this, chainId)) {
-                accountAssets ?? (accountAssets = {});
-                accountAssets[assetId] = {
-                    amount: balance.amount,
-                };
+        if (response.assetsBalance) {
+            response.assetsBalance[accountId] = {};
+            for (const [assetId, balance] of Object.entries(assets)) {
+                // Only include snap-supported assets (solana, bitcoin, tron)
+                if (isSnapSupportedChain(extractChainFromAssetId(assetId))) {
+                    response.assetsBalance[accountId][assetId] = {
+                        amount: balance.amount,
+                    };
+                }
+            }
+            // Remove account if no snap assets
+            if (Object.keys(response.assetsBalance[accountId]).length === 0) {
+                delete response.assetsBalance[accountId];
             }
-        }
-        if (accountAssets) {
-            assetsBalance ?? (assetsBalance = {});
-            assetsBalance[accountId] = accountAssets;
         }
     }
     // Only report if we have snap-related updates
-    if (assetsBalance) {
-        const response = { assetsBalance };
+    if (Object.keys(response.assetsBalance ?? {}).length > 0) {
         __classPrivateFieldGet(this, _SnapDataSource_messenger, "f")
             .call('AssetsController:assetsUpdate', response, SNAP_DATA_SOURCE_NAME)
             .catch(console.error);
     }
-}, _SnapDataSource_isChainSupportedBySnap = function _SnapDataSource_isChainSupportedBySnap(chainId) {
-    return this.state.activeChains.includes(chainId);
 }, _SnapDataSource_registerActionHandlers = function _SnapDataSource_registerActionHandlers() {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const messenger = __classPrivateFieldGet(this, _SnapDataSource_messenger, "f");
@@ -366,86 +469,250 @@ _SnapDataSource_messenger = new WeakMap(), _SnapDataSource_handleSnapBalancesUpd
     messenger.registerActionHandler('SnapDataSource:fetch', async (request) => this.fetch(request));
     messenger.registerActionHandler('SnapDataSource:subscribe', async (request) => this.subscribe(request));
     messenger.registerActionHandler('SnapDataSource:unsubscribe', async (subscriptionId) => this.unsubscribe(subscriptionId));
-}, _SnapDataSource_getRunnableSnaps = function _SnapDataSource_getRunnableSnaps() {
+}, _SnapDataSource_getInstalledSnaps = 
+// ============================================================================
+// SNAP AVAILABILITY
+// ============================================================================
+/**
+ * Get all installed snaps from the snap provider.
+ *
+ * @returns A map of snap IDs to their versions.
+ */
+async function _SnapDataSource_getInstalledSnaps() {
     try {
-        return __classPrivateFieldGet(this, _SnapDataSource_messenger, "f").call('SnapController:getRunnableSnaps');
+        const snaps = await __classPrivateFieldGet(this, _SnapDataSource_snapProvider, "f").request({
+            method: 'wallet_getSnaps',
+            params: {},
+        });
+        return snaps;
     }
     catch (error) {
-        log('Failed to get runnable snaps', error);
-        return [];
+        log('Failed to get installed snaps', error);
+        return {};
     }
-}, _SnapDataSource_getSnapPermissions = function _SnapDataSource_getSnapPermissions(snapId) {
+}, _SnapDataSource_checkSnapAvailabilityOnDemand = 
+/**
+ * Check availability for a single snap type on-demand.
+ * This is called before each fetch to ensure we have the latest availability status.
+ *
+ * @param snapType - The snap type to check (solana, bitcoin, tron)
+ * @returns True if the snap is available, false otherwise
+ */
+async function _SnapDataSource_checkSnapAvailabilityOnDemand(snapType) {
+    const config = SNAP_REGISTRY[snapType];
+    const currentState = this.state.snaps[snapType];
+    // If already marked as available, return true (snap was found previously)
+    if (currentState.available) {
+        return true;
+    }
+    // Check if snap is now available (handles timing issues where snap wasn't ready at init)
     try {
-        return __classPrivateFieldGet(this, _SnapDataSource_messenger, "f").call('PermissionController:getPermissions', snapId);
+        const snaps = await __classPrivateFieldGet(this, _SnapDataSource_instances, "m", _SnapDataSource_getInstalledSnaps).call(this);
+        const snap = snaps[config.snapId];
+        if (snap) {
+            // Snap is now available - update state
+            this.state.snaps[snapType] = {
+                version: snap.version,
+                available: true,
+            };
+            return true;
+        }
+        return false;
     }
-    catch (error) {
-        log('Failed to get permissions for snap', { snapId, error });
-        return undefined;
+    catch {
+        return false;
     }
-}, _SnapDataSource_discoverKeyringSnaps = function _SnapDataSource_discoverKeyringSnaps() {
+}, _SnapDataSource_checkAllSnapsAvailability = async function _SnapDataSource_checkAllSnapsAvailability() {
     try {
-        const runnableSnaps = __classPrivateFieldGet(this, _SnapDataSource_instances, "m", _SnapDataSource_getRunnableSnaps).call(this);
-        const chainToSnap = {};
-        const supportedChains = [];
-        for (const snap of runnableSnaps) {
-            const permissions = __classPrivateFieldGet(this, _SnapDataSource_instances, "m", _SnapDataSource_getSnapPermissions).call(this, snap.id);
-            // Must have endowment:keyring permission to be a keyring snap
-            if (!permissions?.[KEYRING_PERMISSION]) {
-                continue;
+        const snaps = await __classPrivateFieldGet(this, _SnapDataSource_instances, "m", _SnapDataSource_getInstalledSnaps).call(this);
+        for (const [snapType, config] of Object.entries(SNAP_REGISTRY)) {
+            const snap = snaps[config.snapId];
+            if (snap) {
+                this.state.snaps[snapType] = {
+                    version: snap.version,
+                    available: true,
+                };
             }
-            // Get chainIds caveat from the assets permission (not keyring permission)
-            // The chainIds are stored in endowment:assets
-            const assetsPermission = permissions[ASSETS_PERMISSION];
-            const chainIds = getChainIdsCaveat(assetsPermission);
-            // Map each chain to this snap (first snap wins if multiple support same chain)
-            if (chainIds) {
-                for (const chainId of chainIds) {
-                    if (!(chainId in chainToSnap)) {
-                        chainToSnap[chainId] = snap.id;
-                        supportedChains.push(chainId);
-                    }
-                }
+            else {
+                this.state.snaps[snapType] = {
+                    version: null,
+                    available: false,
+                };
             }
         }
-        // Update chainToSnap mapping
-        this.state.chainToSnap = chainToSnap;
-        // Notify if chains changed
-        try {
-            this.updateActiveChains(supportedChains, (updatedChains) => {
-                __classPrivateFieldGet(this, _SnapDataSource_messenger, "f").call('AssetsController:activeChainsUpdate', SNAP_DATA_SOURCE_NAME, updatedChains);
-            });
+    }
+    catch {
+        // Mark all snaps as unavailable on error
+        for (const snapType of Object.keys(SNAP_REGISTRY)) {
+            this.state.snaps[snapType] = {
+                version: null,
+                available: false,
+            };
         }
-        catch {
-            // AssetsController not ready yet - expected during initialization
+    }
+}, _SnapDataSource_accountSupportsChain = function _SnapDataSource_accountSupportsChain(account, chainId) {
+    const scopes = account.scopes ?? [];
+    // If no scopes defined, assume it supports the chain (backward compatibility)
+    if (scopes.length === 0) {
+        return true;
+    }
+    // Extract namespace and reference from chainId
+    const [chainNamespace, chainReference] = chainId.split(':');
+    for (const scope of scopes) {
+        const [scopeNamespace, scopeReference] = scope.split(':');
+        // Check if namespaces match
+        if (scopeNamespace !== chainNamespace) {
+            continue;
+        }
+        // Wildcard scope (e.g., "solana:0" means all chains in that namespace)
+        if (scopeReference === '0') {
+            return true;
+        }
+        // Exact match check
+        if (scopeReference === chainReference) {
+            return true;
         }
     }
-    catch (error) {
-        log('Keyring snap discovery failed', { error });
-        this.state.chainToSnap = {};
+    return false;
+}, _SnapDataSource_groupChainsBySnap = function _SnapDataSource_groupChainsBySnap(chainIds) {
+    const groups = {};
+    for (const chainId of chainIds) {
+        const snapType = getSnapTypeForChain(chainId);
+        if (snapType) {
+            groups[snapType] ?? (groups[snapType] = []);
+            const snapChains = groups[snapType];
+            if (snapChains) {
+                snapChains.push(chainId);
+            }
+        }
+    }
+    return groups;
+}, _SnapDataSource_fetchFromSnap = async function _SnapDataSource_fetchFromSnap(snapType, request) {
+    var _a;
+    const config = SNAP_REGISTRY[snapType];
+    // Check snap availability on-demand - handles timing issues where snap
+    // wasn't ready during initialization but is now available
+    const isAvailable = await __classPrivateFieldGet(this, _SnapDataSource_instances, "m", _SnapDataSource_checkSnapAvailabilityOnDemand).call(this, snapType);
+    if (!isAvailable) {
+        log(`${snapType} snap not available, skipping fetch`);
+        // Return errors for these chains so they can fallback to other data sources
+        const errors = {};
+        for (const chainId of request.chainIds) {
+            errors[chainId] = `${snapType} snap not available`;
+        }
+        return { errors };
+    }
+    const results = {
+        assetsBalance: {},
+        assetsMetadata: {},
+    };
+    // Fetch balances for each account using Keyring API
+    // Important: Must first get account assets, then request balances for those specific assets
+    for (const account of request.accounts) {
+        // Filter to only process accounts that support the chains being fetched
+        const accountSupportedChains = request.chainIds.filter((chainId) => __classPrivateFieldGet(this, _SnapDataSource_instances, "m", _SnapDataSource_accountSupportsChain).call(this, account, chainId));
+        // Skip accounts that don't support any of the requested chains
+        if (accountSupportedChains.length === 0) {
+            continue;
+        }
+        const accountId = account.id;
         try {
-            this.updateActiveChains([], (updatedChains) => {
-                __classPrivateFieldGet(this, _SnapDataSource_messenger, "f").call('AssetsController:activeChainsUpdate', SNAP_DATA_SOURCE_NAME, updatedChains);
+            // Step 1: Get the list of assets for this account
+            log(`${snapType} snap calling keyring_listAccountAssets`, {
+                snapId: config.snapId,
+                accountId,
+            });
+            const accountAssets = await __classPrivateFieldGet(this, _SnapDataSource_snapProvider, "f").request({
+                method: 'wallet_invokeSnap',
+                params: {
+                    snapId: config.snapId,
+                    request: {
+                        method: 'keyring_listAccountAssets',
+                        params: {
+                            id: accountId, // Account UUID
+                        },
+                    },
+                },
+            });
+            log(`${snapType} snap keyring_listAccountAssets response`, {
+                accountId,
+                assetCount: accountAssets?.length ?? 0,
+                assets: accountAssets,
+            });
+            // If no assets, skip to next account
+            if (!accountAssets || accountAssets.length === 0) {
+                log(`${snapType} snap: account has no assets, skipping balance fetch`, {
+                    accountId,
+                });
+                continue;
+            }
+            // Step 2: Get balances for those specific assets
+            log(`${snapType} snap calling keyring_getAccountBalances`, {
+                snapId: config.snapId,
+                accountId,
+                requestedAssets: accountAssets.length,
+            });
+            const balances = await __classPrivateFieldGet(this, _SnapDataSource_snapProvider, "f").request({
+                method: 'wallet_invokeSnap',
+                params: {
+                    snapId: config.snapId,
+                    request: {
+                        method: 'keyring_getAccountBalances',
+                        params: {
+                            id: accountId, // Account UUID (the keyring API uses 'id' not 'accountId')
+                            assets: accountAssets, // Must pass specific asset types from listAccountAssets
+                        },
+                    },
+                },
+            });
+            log(`${snapType} snap keyring_getAccountBalances response`, {
+                accountId,
+                balances,
+                balancesType: typeof balances,
+                isNull: balances === null,
+                isUndefined: balances === undefined,
+                assetCount: balances ? Object.keys(balances).length : 0,
             });
+            // Transform keyring response to DataResponse format
+            // Note: snap may return null/undefined if account doesn't belong to this snap
+            if (balances && typeof balances === 'object' && results.assetsBalance) {
+                const balanceEntries = Object.entries(balances);
+                log(`${snapType} snap processing ${balanceEntries.length} balances for account ${accountId}`);
+                for (const [assetId, balance] of balanceEntries) {
+                    // Initialize account balances if not exists
+                    (_a = results.assetsBalance)[accountId] ?? (_a[accountId] = {});
+                    // Store raw balance for this asset
+                    // Use rawAmount if available (preferred - smallest unit), fall back to amount
+                    // Note: Snaps should return rawAmount in smallest unit (satoshis, lamports, etc.)
+                    const accountBalances = results.assetsBalance[accountId];
+                    if (accountBalances) {
+                        accountBalances[assetId] = {
+                            amount: balance.rawAmount ?? balance.amount,
+                        };
+                    }
+                }
+            }
+            else if (!balances) {
+                log(`${snapType} snap returned empty/null for account (account may not belong to this snap)`, {
+                    accountId,
+                    balances,
+                });
+            }
         }
-        catch {
-            // AssetsController not ready yet - expected during initialization
+        catch (error) {
+            // This is expected when querying a snap with an account it doesn't manage
+            log(`${snapType} snap fetch FAILED for account`, {
+                accountId,
+                error: error instanceof Error ? error.message : String(error),
+                errorStack: error instanceof Error ? error.stack : undefined,
+            });
         }
     }
-}, _SnapDataSource_getKeyringClient = function _SnapDataSource_getKeyringClient(snapId) {
-    const cachedClient = __classPrivateFieldGet(this, _SnapDataSource_keyringClientCache, "f").get(snapId);
-    if (cachedClient) {
-        return cachedClient;
-    }
-    const client = new KeyringClient({
-        send: async (request) => (await __classPrivateFieldGet(this, _SnapDataSource_messenger, "f").call('SnapController:handleRequest', {
-            snapId: snapId,
-            origin: 'metamask',
-            handler: HandlerType.OnKeyringRequest,
-            request,
-        })),
+    log(`${snapType} snap fetch completed`, {
+        chains: request.chainIds.length,
+        accountsWithBalances: Object.keys(results.assetsBalance ?? {}).length,
     });
-    __classPrivateFieldGet(this, _SnapDataSource_keyringClientCache, "f").set(snapId, client);
-    return client;
+    return results;
 };
 // ============================================================================
 // FACTORY