@metamask-previews/assets-controller 0.0.0-preview-903db2da → 0.0.0-preview-3ec2a74

package/dist/data-sources/SnapDataSource.cjs

@@ -0,0 +1,734 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _SnapDataSource_instances, _SnapDataSource_messenger, _SnapDataSource_snapProvider, _SnapDataSource_subscribeToSnapKeyringEvents, _SnapDataSource_handleSnapBalancesUpdated, _SnapDataSource_registerActionHandlers, _SnapDataSource_getInstalledSnaps, _SnapDataSource_checkSnapAvailabilityOnDemand, _SnapDataSource_checkAllSnapsAvailability, _SnapDataSource_accountSupportsChain, _SnapDataSource_groupChainsBySnap, _SnapDataSource_fetchFromSnap;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSnapDataSource = exports.SnapDataSource = exports.isTronChain = exports.isBitcoinChain = exports.isSolanaChain = exports.extractChainFromAssetId = exports.isSnapSupportedChain = exports.getSnapTypeForChain = exports.SNAP_REGISTRY = exports.ALL_DEFAULT_NETWORKS = exports.DEFAULT_SNAP_POLL_INTERVAL = exports.DEFAULT_TRON_POLL_INTERVAL = exports.DEFAULT_BITCOIN_POLL_INTERVAL = exports.DEFAULT_SOLANA_POLL_INTERVAL = exports.TRON_NILE_HEX = exports.TRON_SHASTA_HEX = exports.TRON_MAINNET_HEX = exports.TRON_NILE = exports.TRON_SHASTA = exports.TRON_MAINNET = exports.BITCOIN_TESTNET = exports.BITCOIN_MAINNET = exports.SOLANA_TESTNET = exports.SOLANA_DEVNET = exports.SOLANA_MAINNET = exports.TRON_CHAIN_PREFIX = exports.BITCOIN_CHAIN_PREFIX = exports.SOLANA_CHAIN_PREFIX = exports.TRON_SNAP_ID = exports.BITCOIN_SNAP_ID = exports.SOLANA_SNAP_ID = exports.SNAP_DATA_SOURCE_NAME = void 0;
+const AbstractDataSource_1 = require("./AbstractDataSource.cjs");
+const logger_1 = require("../logger.cjs");
+const log = (0, logger_1.createModuleLogger)(logger_1.projectLogger, 'SnapDataSource');
+// ============================================================================
+// CONSTANTS
+// ============================================================================
+exports.SNAP_DATA_SOURCE_NAME = 'SnapDataSource';
+// Snap IDs
+exports.SOLANA_SNAP_ID = 'npm:@metamask/solana-wallet-snap';
+exports.BITCOIN_SNAP_ID = 'npm:@metamask/bitcoin-wallet-snap';
+exports.TRON_SNAP_ID = 'npm:@metamask/tron-wallet-snap';
+// Chain prefixes for detection
+exports.SOLANA_CHAIN_PREFIX = 'solana:';
+exports.BITCOIN_CHAIN_PREFIX = 'bip122:';
+exports.TRON_CHAIN_PREFIX = 'tron:';
+// Default networks
+exports.SOLANA_MAINNET = 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp';
+exports.SOLANA_DEVNET = 'solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1';
+exports.SOLANA_TESTNET = 'solana:4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z';
+exports.BITCOIN_MAINNET = 'bip122:000000000019d6689c085ae165831e93';
+exports.BITCOIN_TESTNET = 'bip122:000000000933ea01ad0ee984209779ba';
+exports.TRON_MAINNET = 'tron:728126428';
+exports.TRON_SHASTA = 'tron:2494104990';
+exports.TRON_NILE = 'tron:3448148188';
+// Hex format alternatives for Tron
+exports.TRON_MAINNET_HEX = 'tron:0x2b6653dc';
+exports.TRON_SHASTA_HEX = 'tron:0x94a9059e';
+exports.TRON_NILE_HEX = 'tron:0xcd8690dc';
+// Default poll intervals
+exports.DEFAULT_SOLANA_POLL_INTERVAL = 30000; // 30 seconds
+exports.DEFAULT_BITCOIN_POLL_INTERVAL = 60000; // 1 minute
+exports.DEFAULT_TRON_POLL_INTERVAL = 30000; // 30 seconds
+exports.DEFAULT_SNAP_POLL_INTERVAL = 30000; // Default for unknown snaps
+// All default networks
+exports.ALL_DEFAULT_NETWORKS = [
+    exports.SOLANA_MAINNET,
+    exports.SOLANA_DEVNET,
+    exports.SOLANA_TESTNET,
+    exports.BITCOIN_MAINNET,
+    exports.BITCOIN_TESTNET,
+    exports.TRON_MAINNET,
+    exports.TRON_SHASTA,
+    exports.TRON_NILE,
+    exports.TRON_MAINNET_HEX,
+    exports.TRON_SHASTA_HEX,
+    exports.TRON_NILE_HEX,
+];
+exports.SNAP_REGISTRY = {
+    solana: {
+        snapId: exports.SOLANA_SNAP_ID,
+        chainPrefix: exports.SOLANA_CHAIN_PREFIX,
+        pollInterval: exports.DEFAULT_SOLANA_POLL_INTERVAL,
+    },
+    bitcoin: {
+        snapId: exports.BITCOIN_SNAP_ID,
+        chainPrefix: exports.BITCOIN_CHAIN_PREFIX,
+        pollInterval: exports.DEFAULT_BITCOIN_POLL_INTERVAL,
+    },
+    tron: {
+        snapId: exports.TRON_SNAP_ID,
+        chainPrefix: exports.TRON_CHAIN_PREFIX,
+        pollInterval: exports.DEFAULT_TRON_POLL_INTERVAL,
+    },
+};
+/**
+ * Get the snap type for a chain ID based on its prefix.
+ *
+ * @param chainId - The CAIP-2 chain ID to check.
+ * @returns The snap type for the chain, or null if not supported.
+ */
+function getSnapTypeForChain(chainId) {
+    if (chainId.startsWith(exports.SOLANA_CHAIN_PREFIX)) {
+        return 'solana';
+    }
+    if (chainId.startsWith(exports.BITCOIN_CHAIN_PREFIX)) {
+        return 'bitcoin';
+    }
+    if (chainId.startsWith(exports.TRON_CHAIN_PREFIX)) {
+        return 'tron';
+    }
+    return null;
+}
+exports.getSnapTypeForChain = getSnapTypeForChain;
+/**
+ * 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.
+ */
+function isSnapSupportedChain(chainId) {
+    return getSnapTypeForChain(chainId) !== null;
+}
+exports.isSnapSupportedChain = isSnapSupportedChain;
+/**
+ * Extract chain ID from a CAIP-19 asset ID.
+ * e.g., "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp/slip44:501" -> "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp"
+ *
+ * @param assetId - The CAIP-19 asset ID to extract chain from.
+ * @returns The CAIP-2 chain ID portion of the asset ID.
+ */
+function extractChainFromAssetId(assetId) {
+    const parts = assetId.split('/');
+    return parts[0];
+}
+exports.extractChainFromAssetId = extractChainFromAssetId;
+// Helper functions for specific chain types
+function isSolanaChain(chainId) {
+    return chainId.startsWith(exports.SOLANA_CHAIN_PREFIX);
+}
+exports.isSolanaChain = isSolanaChain;
+function isBitcoinChain(chainId) {
+    return chainId.startsWith(exports.BITCOIN_CHAIN_PREFIX);
+}
+exports.isBitcoinChain = isBitcoinChain;
+function isTronChain(chainId) {
+    return chainId.startsWith(exports.TRON_CHAIN_PREFIX);
+}
+exports.isTronChain = isTronChain;
+const defaultSnapState = {
+    activeChains: exports.ALL_DEFAULT_NETWORKS,
+    snaps: {
+        solana: { version: null, available: false },
+        bitcoin: { version: null, available: false },
+        tron: { version: null, available: false },
+    },
+};
+// ============================================================================
+// SNAP DATA SOURCE
+// ============================================================================
+/**
+ * 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
+ * await snapDataSource.fetch({
+ *   chainIds: ['solana:mainnet', 'bip122:000000000019d6689c085ae165831e93'],
+ *   accountIds: ['account1'],
+ * });
+ * ```
+ */
+class SnapDataSource extends AbstractDataSource_1.AbstractDataSource {
+    constructor(options) {
+        const configuredNetworks = options.configuredNetworks ?? exports.ALL_DEFAULT_NETWORKS;
+        super(exports.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);
+        __classPrivateFieldSet(this, _SnapDataSource_messenger, options.messenger, "f");
+        __classPrivateFieldSet(this, _SnapDataSource_snapProvider, options.snapProvider, "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(exports.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);
+    }
+    // ============================================================================
+    // 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', exports.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', exports.SNAP_DATA_SOURCE_NAME, updatedChains));
+        }
+    }
+    // ============================================================================
+    // FETCH - Routes to appropriate snap(s)
+    // ============================================================================
+    async fetch(request) {
+        // Guard against undefined request or chainIds
+        if (!request?.chainIds) {
+            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,
+                };
+            }
+            if (result.assetsMetadata) {
+                mergedResponse.assetsMetadata = {
+                    ...mergedResponse.assetsMetadata,
+                    ...result.assetsMetadata,
+                };
+            }
+            if (result.assetsPrice) {
+                mergedResponse.assetsPrice = {
+                    ...mergedResponse.assetsPrice,
+                    ...result.assetsPrice,
+                };
+            }
+            if (result.errors) {
+                mergedResponse.errors = { ...mergedResponse.errors, ...result.errors };
+            }
+        }
+        return mergedResponse;
+    }
+    // ============================================================================
+    // MIDDLEWARE
+    // ============================================================================
+    /**
+     * Get the middleware for fetching balances via Snaps.
+     * This middleware:
+     * - Supports multiple accounts in a single request
+     * - Filters request to only chains this data source supports
+     * - Fetches balances for those chains for all accounts
+     * - Merges response into context
+     * - Removes handled chains from request for next middleware
+     *
+     * @returns The middleware function for the assets pipeline.
+     */
+    get assetsMiddleware() {
+        return async (context, next) => {
+            var _a;
+            const { request } = context;
+            // Filter to chains this data source supports
+            const supportedChains = request.chainIds.filter((chainId) => this.state.activeChains.includes(chainId));
+            // If no supported chains, skip and pass to next middleware
+            if (supportedChains.length === 0) {
+                return next(context);
+            }
+            let successfullyHandledChains = [];
+            try {
+                // Fetch for supported chains
+                const response = await this.fetch({
+                    ...request,
+                    chainIds: supportedChains,
+                });
+                // Merge response into context
+                if (response.assetsBalance) {
+                    (_a = context.response).assetsBalance ?? (_a.assetsBalance = {});
+                    for (const [accountId, accountBalances] of Object.entries(response.assetsBalance)) {
+                        context.response.assetsBalance[accountId] = {
+                            ...context.response.assetsBalance[accountId],
+                            ...accountBalances,
+                        };
+                    }
+                }
+                if (response.assetsMetadata) {
+                    context.response.assetsMetadata = {
+                        ...context.response.assetsMetadata,
+                        ...response.assetsMetadata,
+                    };
+                }
+                if (response.assetsPrice) {
+                    context.response.assetsPrice = {
+                        ...context.response.assetsPrice,
+                        ...response.assetsPrice,
+                    };
+                }
+                // Determine successfully handled chains (exclude errors)
+                const failedChains = new Set(Object.keys(response.errors ?? {}));
+                successfullyHandledChains = supportedChains.filter((chainId) => !failedChains.has(chainId));
+            }
+            catch (error) {
+                log('Middleware fetch failed', { error });
+                successfullyHandledChains = [];
+            }
+            // Prepare context for next middleware
+            let nextContext = context;
+            if (successfullyHandledChains.length > 0) {
+                const remainingChains = request.chainIds.filter((chainId) => !successfullyHandledChains.includes(chainId));
+                nextContext = {
+                    ...context,
+                    request: {
+                        ...request,
+                        chainIds: remainingChains,
+                    },
+                };
+            }
+            // Call next middleware
+            return next(nextContext);
+        };
+    }
+    // ============================================================================
+    // SUBSCRIBE - Routes to appropriate snap(s)
+    // ============================================================================
+    async subscribe(subscriptionRequest) {
+        const { request, subscriptionId, isUpdate } = subscriptionRequest;
+        // Guard against undefined request or chainIds
+        if (!request?.chainIds) {
+            return;
+        }
+        // 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 = snapChains;
+                // Do a fetch to get latest data on subscription update
+                this.fetch({
+                    ...request,
+                    chainIds: snapChains,
+                })
+                    .then(async (fetchResponse) => {
+                    if (Object.keys(fetchResponse.assetsBalance ?? {}).length > 0) {
+                        await __classPrivateFieldGet(this, _SnapDataSource_messenger, "f").call('AssetsController:assetsUpdate', fetchResponse, exports.SNAP_DATA_SOURCE_NAME);
+                    }
+                    return fetchResponse;
+                })
+                    .catch((error) => {
+                    log('Subscription update fetch failed', { subscriptionId, error });
+                });
+                return;
+            }
+        }
+        await this.unsubscribe(subscriptionId);
+        // Snaps provide real-time updates via AccountsController:accountBalancesUpdated
+        // We only need to track the subscription and do an initial fetch
+        // No polling needed - updates come through #handleSnapBalancesUpdated
+        this.activeSubscriptions.set(subscriptionId, {
+            cleanup: () => {
+                // No timer to clear - we use event-based updates
+            },
+            chains: snapChains,
+        });
+        // Initial fetch to get current balances
+        try {
+            const fetchResponse = await this.fetch({
+                ...request,
+                chainIds: snapChains,
+            });
+            if (Object.keys(fetchResponse.assetsBalance ?? {}).length > 0) {
+                await __classPrivateFieldGet(this, _SnapDataSource_messenger, "f").call('AssetsController:assetsUpdate', fetchResponse, exports.SNAP_DATA_SOURCE_NAME);
+            }
+        }
+        catch (error) {
+            log('Initial fetch failed', { subscriptionId, error });
+        }
+    }
+    // ============================================================================
+    // CLEANUP
+    // ============================================================================
+    destroy() {
+        for (const [subscriptionId] of this.activeSubscriptions) {
+            this.unsubscribe(subscriptionId).catch(() => {
+                // Ignore cleanup errors
+            });
+        }
+    }
+}
+exports.SnapDataSource = SnapDataSource;
+_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
+    const response = {
+        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];
+            }
+        }
+    }
+    // Only report if we have snap-related updates
+    if (Object.keys(response.assetsBalance ?? {}).length > 0) {
+        __classPrivateFieldGet(this, _SnapDataSource_messenger, "f")
+            .call('AssetsController:assetsUpdate', response, exports.SNAP_DATA_SOURCE_NAME)
+            .catch(console.error);
+    }
+}, _SnapDataSource_registerActionHandlers = function _SnapDataSource_registerActionHandlers() {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const messenger = __classPrivateFieldGet(this, _SnapDataSource_messenger, "f");
+    messenger.registerActionHandler('SnapDataSource:getAssetsMiddleware', () => this.assetsMiddleware);
+    messenger.registerActionHandler('SnapDataSource:getActiveChains', async () => this.getActiveChains());
+    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() {
+    try {
+        const snaps = await __classPrivateFieldGet(this, _SnapDataSource_snapProvider, "f").request({
+            method: 'wallet_getSnaps',
+            params: {},
+        });
+        return snaps;
+    }
+    catch (error) {
+        log('Failed to get installed 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 = exports.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 {
+        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 {
+        return false;
+    }
+}, _SnapDataSource_checkAllSnapsAvailability = async function _SnapDataSource_checkAllSnapsAvailability() {
+    try {
+        const snaps = await __classPrivateFieldGet(this, _SnapDataSource_instances, "m", _SnapDataSource_getInstalledSnaps).call(this);
+        for (const [snapType, config] of Object.entries(exports.SNAP_REGISTRY)) {
+            const snap = snaps[config.snapId];
+            if (snap) {
+                this.state.snaps[snapType] = {
+                    version: snap.version,
+                    available: true,
+                };
+            }
+            else {
+                this.state.snaps[snapType] = {
+                    version: null,
+                    available: false,
+                };
+            }
+        }
+    }
+    catch {
+        // Mark all snaps as unavailable on error
+        for (const snapType of Object.keys(exports.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);
+            }
+        }
+    }
+    return groups;
+}, _SnapDataSource_fetchFromSnap = async function _SnapDataSource_fetchFromSnap(snapType, request) {
+    var _a;
+    const config = exports.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 {
+            // 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 (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,
+            });
+        }
+    }
+    log(`${snapType} snap fetch completed`, {
+        chains: request.chainIds.length,
+        accountsWithBalances: Object.keys(results.assetsBalance ?? {}).length,
+    });
+    return results;
+};
+// ============================================================================
+// FACTORY
+// ============================================================================
+function createSnapDataSource(options) {
+    return new SnapDataSource(options);
+}
+exports.createSnapDataSource = createSnapDataSource;
+//# sourceMappingURL=SnapDataSource.cjs.map