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

package/dist/data-sources/SnapDataSource.mjs

@@ -9,7 +9,9 @@ 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_snapProvider, _SnapDataSource_subscribeToSnapKeyringEvents, _SnapDataSource_handleSnapBalancesUpdated, _SnapDataSource_registerActionHandlers, _SnapDataSource_getInstalledSnaps, _SnapDataSource_checkSnapAvailabilityOnDemand, _SnapDataSource_checkAllSnapsAvailability, _SnapDataSource_accountSupportsChain, _SnapDataSource_groupChainsBySnap, _SnapDataSource_fetchFromSnap;
+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";
 import { AbstractDataSource } from "./AbstractDataSource.mjs";
 import { projectLogger, createModuleLogger } from "../logger.mjs";
 const log = createModuleLogger(projectLogger, 'SnapDataSource');
@@ -17,89 +19,29 @@ const log = createModuleLogger(projectLogger, 'SnapDataSource');
 // CONSTANTS
 // ============================================================================
 export const SNAP_DATA_SOURCE_NAME = 'SnapDataSource';
-// 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,
-    },
-};
+/** 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
+// ============================================================================
 /**
- * Get the snap type for a chain ID based on its prefix.
+ * Getter function to get the chainIds caveat from a permission.
  *
- * @param chainId - The CAIP-2 chain ID to check.
- * @returns The snap type for the chain, or null if not supported.
- */
-export function getSnapTypeForChain(chainId) {
-    if (chainId.startsWith(SOLANA_CHAIN_PREFIX)) {
-        return 'solana';
-    }
-    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.
+ * 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.
  *
- * @param chainId - The CAIP-2 chain ID to check.
- * @returns True if the chain is supported by a snap.
+ * @param permission - The permission to get the `chainIds` caveat from.
+ * @returns An array of `chainIds` that the snap supports, or null if none.
  */
-export function isSnapSupportedChain(chainId) {
-    return getSnapTypeForChain(chainId) !== null;
+export function getChainIdsCaveat(permission) {
+    if (!permission?.caveats) {
+        return null;
+    }
+    const caveat = permission.caveats.find((permCaveat) => permCaveat.type === SnapCaveatType.ChainIds);
+    return caveat ? caveat.value : null;
 }
 /**
  * Extract chain ID from a CAIP-19 asset ID.
@@ -112,23 +54,9 @@ 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: ALL_DEFAULT_NETWORKS,
-    snaps: {
-        solana: { version: null, available: false },
-        bitcoin: { version: null, available: false },
-        tron: { version: null, available: false },
-    },
+    activeChains: [],
+    chainToSnap: {},
 };
 // ============================================================================
 // SNAP DATA SOURCE
@@ -137,16 +65,10 @@ 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
@@ -158,122 +80,81 @@ 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);
-        _SnapDataSource_snapProvider.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());
         __classPrivateFieldSet(this, _SnapDataSource_messenger, options.messenger, "f");
-        __classPrivateFieldSet(this, _SnapDataSource_snapProvider, options.snapProvider, "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");
         __classPrivateFieldGet(this, _SnapDataSource_instances, "m", _SnapDataSource_registerActionHandlers).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);
+        __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);
     }
     // ============================================================================
-    // 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)
+    // FETCH
     // ============================================================================
     async fetch(request) {
-        // Guard against undefined request or chainIds
-        if (!request?.chainIds) {
+        var _a;
+        // Guard against undefined request
+        // Note: chainIds filtering is done by middleware/subscribe before calling fetch
+        if (!request?.accounts || !request?.chainIds?.length) {
             return {};
         }
-        // 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,
-                };
+        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;
             }
-            if (result.assetsMetadata) {
-                mergedResponse.assetsMetadata = {
-                    ...mergedResponse.assetsMetadata,
-                    ...result.assetsMetadata,
-                };
+            // 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.assetsPrice) {
-                mergedResponse.assetsPrice = {
-                    ...mergedResponse.assetsPrice,
-                    ...result.assetsPrice,
-                };
+            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.errors) {
-                mergedResponse.errors = { ...mergedResponse.errors, ...result.errors };
+            catch {
+                // Expected when account doesn't belong to this snap
             }
         }
-        return mergedResponse;
+        return results;
     }
     // ============================================================================
     // MIDDLEWARE
@@ -361,19 +242,19 @@ export class SnapDataSource extends AbstractDataSource {
         if (!request?.chainIds) {
             return;
         }
-        // Filter to only snap-supported chains
-        const snapChains = request.chainIds.filter(isSnapSupportedChain);
-        if (snapChains.length === 0) {
+        // 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) {
             return;
         }
         if (isUpdate) {
             const existing = this.activeSubscriptions.get(subscriptionId);
             if (existing) {
-                existing.chains = snapChains;
+                existing.chains = supportedChains;
                 // Do a fetch to get latest data on subscription update
                 this.fetch({
                     ...request,
-                    chainIds: snapChains,
+                    chainIds: supportedChains,
                 })
                     .then(async (fetchResponse) => {
                     if (Object.keys(fetchResponse.assetsBalance ?? {}).length > 0) {
@@ -395,13 +276,13 @@ export class SnapDataSource extends AbstractDataSource {
             cleanup: () => {
                 // No timer to clear - we use event-based updates
             },
-            chains: snapChains,
+            chains: supportedChains,
         });
         // Initial fetch to get current balances
         try {
             const fetchResponse = await this.fetch({
                 ...request,
-                chainIds: snapChains,
+                chainIds: supportedChains,
             });
             if (Object.keys(fetchResponse.assetsBalance ?? {}).length > 0) {
                 await __classPrivateFieldGet(this, _SnapDataSource_messenger, "f").call('AssetsController:assetsUpdate', fetchResponse, SNAP_DATA_SOURCE_NAME);
@@ -415,52 +296,68 @@ 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_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_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_handleSnapBalancesUpdated = function _SnapDataSource_handleSnapBalancesUpdated(payload) {
     // Transform the snap keyring payload to DataResponse format
-    const response = {
-        assetsBalance: {},
-    };
+    let assetsBalance;
     for (const [accountId, assets] of Object.entries(payload.balances)) {
-        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];
+        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 (accountAssets) {
+            assetsBalance ?? (assetsBalance = {});
+            assetsBalance[accountId] = accountAssets;
+        }
     }
     // Only report if we have snap-related updates
-    if (Object.keys(response.assetsBalance ?? {}).length > 0) {
+    if (assetsBalance) {
+        const response = { assetsBalance };
         __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");
@@ -469,250 +366,86 @@ _SnapDataSource_messenger = new WeakMap(), _SnapDataSource_snapProvider = new We
     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_getInstalledSnaps = 
-// ============================================================================
-// SNAP AVAILABILITY
-// ============================================================================
-/**
- * Get all installed snaps from the snap provider.
- *
- * @returns A map of snap IDs to their versions.
- */
-async function _SnapDataSource_getInstalledSnaps() {
+}, _SnapDataSource_getRunnableSnaps = function _SnapDataSource_getRunnableSnaps() {
     try {
-        const snaps = await __classPrivateFieldGet(this, _SnapDataSource_snapProvider, "f").request({
-            method: 'wallet_getSnaps',
-            params: {},
-        });
-        return snaps;
+        return __classPrivateFieldGet(this, _SnapDataSource_messenger, "f").call('SnapController:getRunnableSnaps');
     }
     catch (error) {
-        log('Failed to get installed snaps', error);
-        return {};
+        log('Failed to get runnable snaps', error);
+        return [];
     }
-}, _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)
+}, _SnapDataSource_getSnapPermissions = function _SnapDataSource_getSnapPermissions(snapId) {
     try {
-        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;
+        return __classPrivateFieldGet(this, _SnapDataSource_messenger, "f").call('PermissionController:getPermissions', snapId);
     }
-    catch {
-        return false;
+    catch (error) {
+        log('Failed to get permissions for snap', { snapId, error });
+        return undefined;
     }
-}, _SnapDataSource_checkAllSnapsAvailability = async function _SnapDataSource_checkAllSnapsAvailability() {
+}, _SnapDataSource_discoverKeyringSnaps = function _SnapDataSource_discoverKeyringSnaps() {
     try {
-        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,
-                };
+        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;
             }
-            else {
-                this.state.snaps[snapType] = {
-                    version: null,
-                    available: false,
-                };
+            // 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);
+                    }
+                }
             }
         }
-    }
-    catch {
-        // Mark all snaps as unavailable on error
-        for (const snapType of Object.keys(SNAP_REGISTRY)) {
-            this.state.snaps[snapType] = {
-                version: null,
-                available: false,
-            };
-        }
-    }
-}, _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;
-        }
-    }
-    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);
-            }
+        // 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);
+            });
         }
-    }
-    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`;
+        catch {
+            // AssetsController not ready yet - expected during initialization
         }
-        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;
+    catch (error) {
+        log('Keyring snap discovery failed', { error });
+        this.state.chainToSnap = {};
         try {
-            // 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,
+            this.updateActiveChains([], (updatedChains) => {
+                __classPrivateFieldGet(this, _SnapDataSource_messenger, "f").call('AssetsController:activeChainsUpdate', SNAP_DATA_SOURCE_NAME, updatedChains);
             });
-            // 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 (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,
-            });
+        catch {
+            // AssetsController not ready yet - expected during initialization
         }
     }
-    log(`${snapType} snap fetch completed`, {
-        chains: request.chainIds.length,
-        accountsWithBalances: Object.keys(results.assetsBalance ?? {}).length,
+}, _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,
+        })),
     });
-    return results;
+    __classPrivateFieldGet(this, _SnapDataSource_keyringClientCache, "f").set(snapId, client);
+    return client;
 };
 // ============================================================================
 // FACTORY