@metamask-previews/assets-controller 14.0.2-preview-3866c0ff1 → 14.0.2-preview-e3275932a

package/dist/data-sources/AccountsApiDataSource.mjs

@@ -0,0 +1,581 @@
+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 _AccountsApiDataSource_instances, _AccountsApiDataSource_onActiveChainsUpdated, _AccountsApiDataSource_pollInterval, _AccountsApiDataSource_fetchTimeoutMs, _AccountsApiDataSource_tokenDetectionEnabled, _AccountsApiDataSource_messenger, _AccountsApiDataSource_apiClient, _AccountsApiDataSource_chainsRefreshTimer, _AccountsApiDataSource_getAssetsState, _AccountsApiDataSource_handleMigrationFeatureFlagsChanged, _AccountsApiDataSource_isBalanceV6Enabled, _AccountsApiDataSource_initializeActiveChains, _AccountsApiDataSource_refreshActiveChains, _AccountsApiDataSource_fetchActiveChains, _AccountsApiDataSource_fetchV5Balances, _AccountsApiDataSource_fetchV6Balances, _AccountsApiDataSource_buildAddressToAccountIdMap, _AccountsApiDataSource_processV5Balances, _AccountsApiDataSource_processV6Balances;
+import { ApiPlatformClient } from "@metamask/core-backend";
+import { isCaipChainId, KnownCaipNamespace, toCaipChainId } from "@metamask/utils";
+import { projectLogger, createModuleLogger } from "../logger.mjs";
+import { fetchWithTimeout, normalizeAssetId } from "../utils/index.mjs";
+import { getMigrationStages, shouldSupportChain } from "../utils/snaps-assets-migration.mjs";
+import { AbstractDataSource } from "./AbstractDataSource.mjs";
+import { isStakingContractAssetId } from "./evm-rpc-services/index.mjs";
+// ============================================================================
+// CONSTANTS
+// ============================================================================
+const CONTROLLER_NAME = 'AccountsApiDataSource';
+const DEFAULT_POLL_INTERVAL = 30000;
+const DEFAULT_FETCH_TIMEOUT_MS = 15000;
+const log = createModuleLogger(projectLogger, CONTROLLER_NAME);
+const defaultState = {
+    activeChains: [],
+};
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+function decimalToChainId(decimalChainId) {
+    // Handle both decimal numbers and already-formatted CAIP chain IDs
+    if (typeof decimalChainId === 'string') {
+        if (isCaipChainId(decimalChainId)) {
+            return decimalChainId;
+        }
+        return toCaipChainId(KnownCaipNamespace.Eip155, decimalChainId);
+    }
+    return toCaipChainId(KnownCaipNamespace.Eip155, String(decimalChainId));
+}
+/**
+ * Convert a CAIP-2 chain ID from the API response to our ChainId type.
+ * Handles both formats: "eip155:1" or just "1" (decimal).
+ * Uses @metamask/utils for CAIP parsing.
+ *
+ * @param chainIdStr - The chain ID string to convert.
+ * @returns The normalized ChainId.
+ */
+function caipChainIdToChainId(chainIdStr) {
+    if (isCaipChainId(chainIdStr)) {
+        return chainIdStr;
+    }
+    return toCaipChainId(KnownCaipNamespace.Eip155, chainIdStr);
+}
+/**
+ * Filter a response to only include balances for assets already in state.
+ * Used when tokenDetectionEnabled is false to prevent adding new tokens.
+ *
+ * @param response - The fetch response to filter.
+ * @param assetsState - Current assets controller state to check existing balances against.
+ * @returns A new response with only known asset balances.
+ */
+export function filterResponseToKnownAssets(response, assetsState) {
+    if (!response.assetsBalance) {
+        return response;
+    }
+    const filteredBalance = {};
+    for (const [accountId, accountBalances] of Object.entries(response.assetsBalance)) {
+        const existingBalances = assetsState.assetsBalance[accountId];
+        if (!existingBalances) {
+            // Account has no balances in state yet — skip all its tokens
+            continue;
+        }
+        const filtered = {};
+        for (const [assetId, balance] of Object.entries(accountBalances)) {
+            // Only include assets already tracked in state
+            if (assetId in existingBalances) {
+                filtered[assetId] = balance;
+            }
+        }
+        if (Object.keys(filtered).length > 0) {
+            filteredBalance[accountId] = filtered;
+        }
+    }
+    return {
+        ...response,
+        assetsBalance: Object.keys(filteredBalance).length > 0 ? filteredBalance : undefined,
+    };
+}
+// ============================================================================
+// ACCOUNTS API DATA SOURCE
+// ============================================================================
+/**
+ * Data source for fetching balances from the MetaMask Accounts API.
+ *
+ * Uses ApiPlatformClient (queryApiClient) for all API calls. Does not use the
+ * messenger. Reports active chains via onActiveChainsUpdated callback.
+ */
+export class AccountsApiDataSource extends AbstractDataSource {
+    constructor(options) {
+        super(CONTROLLER_NAME, {
+            ...defaultState,
+            ...options.state,
+        });
+        _AccountsApiDataSource_instances.add(this);
+        _AccountsApiDataSource_onActiveChainsUpdated.set(this, void 0);
+        _AccountsApiDataSource_pollInterval.set(this, void 0);
+        _AccountsApiDataSource_fetchTimeoutMs.set(this, void 0);
+        /** Getter avoids stale value when user toggles token detection at runtime. */
+        _AccountsApiDataSource_tokenDetectionEnabled.set(this, void 0);
+        /** Shared AssetsController messenger, used to read remote feature flags. */
+        _AccountsApiDataSource_messenger.set(this, void 0);
+        /** ApiPlatformClient for cached API calls */
+        _AccountsApiDataSource_apiClient.set(this, void 0);
+        /** Chains refresh timer */
+        _AccountsApiDataSource_chainsRefreshTimer.set(this, null);
+        /** State accessor from subscriptions (for filtering when tokenDetectionEnabled is false) */
+        _AccountsApiDataSource_getAssetsState.set(this, void 0);
+        __classPrivateFieldSet(this, _AccountsApiDataSource_onActiveChainsUpdated, options.onActiveChainsUpdated, "f");
+        __classPrivateFieldSet(this, _AccountsApiDataSource_pollInterval, options.pollInterval ?? DEFAULT_POLL_INTERVAL, "f");
+        __classPrivateFieldSet(this, _AccountsApiDataSource_fetchTimeoutMs, options.fetchTimeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS, "f");
+        __classPrivateFieldSet(this, _AccountsApiDataSource_tokenDetectionEnabled, options.tokenDetectionEnabled ?? (() => true), "f");
+        __classPrivateFieldSet(this, _AccountsApiDataSource_messenger, options.messenger, "f");
+        __classPrivateFieldSet(this, _AccountsApiDataSource_apiClient, options.queryApiClient, "f");
+        // The Snaps → AssetsController migration flags gate which migration networks
+        // (Solana, Stellar, Tron) are surfaced as active chains (see
+        // `#shouldSupportChain`). Mirror core-backend's AccountActivityService and
+        // react to remote feature flag changes so newly-enabled chains are picked up
+        // (and disabled ones dropped) without waiting for the periodic refresh.
+        __classPrivateFieldGet(this, _AccountsApiDataSource_messenger, "f").subscribe(
+        // eslint-disable-next-line no-restricted-syntax
+        'RemoteFeatureFlagController:stateChange', 
+        // Promise result intentionally not awaited
+        // eslint-disable-next-line @typescript-eslint/no-misused-promises
+        async () => await __classPrivateFieldGet(this, _AccountsApiDataSource_instances, "m", _AccountsApiDataSource_handleMigrationFeatureFlagsChanged).call(this), 
+        // Only react to changes in the set of migration stages. The messenger
+        // compares selector results with strict equality, so the selector must
+        // return a primitive rather than a fresh object.
+        (state) => getMigrationStages(state.remoteFeatureFlags).join(','));
+        __classPrivateFieldGet(this, _AccountsApiDataSource_instances, "m", _AccountsApiDataSource_initializeActiveChains).call(this).catch(console.error);
+    }
+    /**
+     * Re-fetch supported networks from the Accounts API and update `activeChains`
+     * when the list changed. Used when the selected EVM network switches so
+     * chain claiming is not stuck on an empty init-time list.
+     *
+     * @returns Resolves when supported networks have been re-fetched.
+     */
+    refreshActiveChains() {
+        return __classPrivateFieldGet(this, _AccountsApiDataSource_instances, "m", _AccountsApiDataSource_refreshActiveChains).call(this);
+    }
+    // ============================================================================
+    // ACCOUNT SCOPE HELPERS
+    // ============================================================================
+    // ============================================================================
+    // FETCH
+    // ============================================================================
+    async fetch(request) {
+        let response = {};
+        // Filter to only chains supported by Accounts API
+        const supportedChains = new Set(this.state.activeChains);
+        const chainsToFetch = request.chainIds.filter((chainId) => supportedChains.has(chainId));
+        if (chainsToFetch.length === 0) {
+            // Mark unsupported chains as errors so they pass to next middleware
+            for (const chainId of request.chainIds) {
+                if (!supportedChains.has(chainId)) {
+                    response.errors = response.errors ?? {};
+                    response.errors[chainId] = 'Chain not supported by Accounts API';
+                }
+            }
+            return response;
+        }
+        try {
+            // Build CAIP-10 account IDs (e.g., "eip155:1:0x1234...")
+            // Use pre-computed supportedChains per account from the request
+            const accountIds = request.accountsWithSupportedChains.flatMap(({ account, supportedChains: accountChains }) => chainsToFetch
+                .filter((chainId) => accountChains.includes(chainId))
+                .map((chainId) => `${chainId}:${account.address}`));
+            // Skip API call if no valid account-chain combinations
+            if (accountIds.length === 0) {
+                return response;
+            }
+            const fetchOptions = request.forceUpdate
+                ? { staleTime: 0, gcTime: 0 }
+                : undefined;
+            // Feature-flagged: v6 endpoint with a fallback to legacy v5. The flag is
+            // read here (not cached) so a runtime toggle can revert v6 -> v5.
+            const { unprocessedNetworks, assetsBalance } = __classPrivateFieldGet(this, _AccountsApiDataSource_instances, "m", _AccountsApiDataSource_isBalanceV6Enabled).call(this)
+                ? await __classPrivateFieldGet(this, _AccountsApiDataSource_instances, "m", _AccountsApiDataSource_fetchV6Balances).call(this, accountIds, fetchOptions, request)
+                : await __classPrivateFieldGet(this, _AccountsApiDataSource_instances, "m", _AccountsApiDataSource_fetchV5Balances).call(this, accountIds, fetchOptions, request);
+            // Handle unprocessed networks - these will be passed to next middleware
+            if (unprocessedNetworks.length > 0) {
+                const unprocessedChainIds = unprocessedNetworks.map(caipChainIdToChainId);
+                // Add unprocessed chains to errors so middleware passes them to next data source
+                response.errors = response.errors ?? {};
+                for (const chainId of unprocessedChainIds) {
+                    response.errors[chainId] = 'Unprocessed by Accounts API';
+                }
+            }
+            response.assetsBalance = assetsBalance;
+            response.updateMode = 'merge';
+        }
+        catch (error) {
+            log('Fetch FAILED', { error, chains: chainsToFetch });
+            // On error, mark all chains as errors so they can be handled by next middleware
+            response.errors = response.errors ?? {};
+            for (const chainId of chainsToFetch) {
+                response.errors[chainId] =
+                    `Fetch failed: ${error instanceof Error ? error.message : String(error)}`;
+            }
+        }
+        // Mark unsupported chains as errors so they pass to next middleware
+        for (const chainId of request.chainIds) {
+            if (!supportedChains.has(chainId)) {
+                response.errors = response.errors ?? {};
+                response.errors[chainId] = 'Chain not supported by Accounts API';
+            }
+        }
+        // When token detection is disabled, filter out tokens not already in state
+        if (!__classPrivateFieldGet(this, _AccountsApiDataSource_tokenDetectionEnabled, "f").call(this) && __classPrivateFieldGet(this, _AccountsApiDataSource_getAssetsState, "f")) {
+            response = filterResponseToKnownAssets(response, __classPrivateFieldGet(this, _AccountsApiDataSource_getAssetsState, "f").call(this));
+        }
+        return response;
+    }
+    // ============================================================================
+    // MIDDLEWARE
+    // ============================================================================
+    /**
+     * Get the middleware for fetching balances via Accounts API.
+     * This middleware:
+     * - Supports multiple accounts in a single request
+     * - Uses unprocessedNetworks from API response to determine what to pass to next middleware
+     * - 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;
+            // Price/metadata-only requests must not hit the Accounts API.
+            if (!request.dataTypes.includes('balance')) {
+                return next(context);
+            }
+            // If no chains requested, skip to next middleware
+            if (request.chainIds.length === 0) {
+                return next(context);
+            }
+            let successfullyHandledChains = [];
+            try {
+                const response = await this.fetch(request);
+                // 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,
+                        };
+                    }
+                }
+                // Determine successfully handled chains (exclude unprocessed/error chains)
+                const unprocessedChains = new Set(Object.keys(response.errors ?? {}));
+                successfullyHandledChains = request.chainIds.filter((chainId) => !unprocessedChains.has(chainId));
+                // When token detection is off and we filtered out all balance data (e.g. new
+                // account with empty state), do not claim any chain as handled so that RPC
+                // middleware can still process them and fetch native balances (ETH, MATIC, etc.).
+                if (!__classPrivateFieldGet(this, _AccountsApiDataSource_tokenDetectionEnabled, "f").call(this) &&
+                    (!response.assetsBalance ||
+                        Object.keys(response.assetsBalance).length === 0)) {
+                    successfullyHandledChains = [];
+                }
+            }
+            catch (error) {
+                log('Middleware fetch failed', { error });
+                successfullyHandledChains = [];
+            }
+            // Remove successfully handled chains from request for next middleware
+            if (successfullyHandledChains.length > 0) {
+                const remainingChains = request.chainIds.filter((chainId) => !successfullyHandledChains.includes(chainId));
+                return next({
+                    ...context,
+                    request: {
+                        ...request,
+                        chainIds: remainingChains,
+                    },
+                });
+            }
+            // No chains handled - pass context unchanged
+            return next(context);
+        };
+    }
+    // ============================================================================
+    // SUBSCRIBE
+    // ============================================================================
+    async subscribe(subscriptionRequest) {
+        const { request, subscriptionId, isUpdate, skipInitialFetch } = subscriptionRequest;
+        // Store state accessor for filtering when tokenDetectionEnabled is false
+        if (subscriptionRequest.getAssetsState) {
+            __classPrivateFieldSet(this, _AccountsApiDataSource_getAssetsState, subscriptionRequest.getAssetsState, "f");
+        }
+        // Try all requested chains - API will handle unsupported ones via unprocessedNetworks
+        const chainsToSubscribe = request.chainIds;
+        if (chainsToSubscribe.length === 0) {
+            return;
+        }
+        // Handle subscription update - update both chains AND request (for accounts)
+        if (isUpdate) {
+            const existing = this.activeSubscriptions.get(subscriptionId);
+            if (existing) {
+                const previousChains = existing.chains;
+                existing.chains = chainsToSubscribe;
+                existing.request = request;
+                // Chains handed off from another data source (e.g. the websocket
+                // source releasing a chain that went down) would otherwise stay
+                // stale until the next poll tick — fetch them immediately.
+                const addedChains = chainsToSubscribe.filter((chainId) => !previousChains.includes(chainId));
+                if (addedChains.length > 0) {
+                    try {
+                        const fetchResponse = await this.fetch({
+                            ...request,
+                            chainIds: addedChains,
+                            forceUpdate: true,
+                        });
+                        await existing.onAssetsUpdate(fetchResponse);
+                    }
+                    catch (error) {
+                        log('Initial fetch for added chains failed', {
+                            subscriptionId,
+                            addedChains,
+                            error,
+                        });
+                    }
+                }
+                return;
+            }
+        }
+        // Clean up existing subscription if any
+        await this.unsubscribe(subscriptionId);
+        const pollInterval = request.updateInterval ?? __classPrivateFieldGet(this, _AccountsApiDataSource_pollInterval, "f");
+        // Create poll function for this subscription
+        const pollFn = async () => {
+            try {
+                const subscription = this.activeSubscriptions.get(subscriptionId);
+                if (!subscription?.request) {
+                    return;
+                }
+                // Use stored request (which gets updated on account changes).
+                // forceUpdate so we don't get a stale response from the cache
+                // (STALE_TIMES.BALANCES is 60s, longer than our 30s poll interval).
+                const fetchResponse = await this.fetch({
+                    ...subscription.request,
+                    chainIds: subscription.chains,
+                    forceUpdate: true,
+                });
+                // Report update to AssetsController via callback
+                await subscription.onAssetsUpdate(fetchResponse);
+            }
+            catch (error) {
+                log('Subscription poll failed', { subscriptionId, error });
+            }
+        };
+        // Set up polling
+        const timer = setInterval(() => {
+            pollFn().catch(console.error);
+        }, pollInterval);
+        // Store subscription with request for account updates
+        this.activeSubscriptions.set(subscriptionId, {
+            cleanup: () => {
+                clearInterval(timer);
+            },
+            chains: chainsToSubscribe,
+            request,
+            onAssetsUpdate: subscriptionRequest.onAssetsUpdate,
+        });
+        // Interval above still polls on the normal cadence. This only skips the
+        // one-shot fetch at subscribe time when the controller already ran a
+        // force getAssets for the same scope (startup / group refresh).
+        if (!skipInitialFetch) {
+            await pollFn();
+        }
+    }
+    // ============================================================================
+    // CLEANUP
+    // ============================================================================
+    destroy() {
+        if (__classPrivateFieldGet(this, _AccountsApiDataSource_chainsRefreshTimer, "f")) {
+            clearInterval(__classPrivateFieldGet(this, _AccountsApiDataSource_chainsRefreshTimer, "f"));
+        }
+        super.destroy();
+    }
+}
+_AccountsApiDataSource_onActiveChainsUpdated = new WeakMap(), _AccountsApiDataSource_pollInterval = new WeakMap(), _AccountsApiDataSource_fetchTimeoutMs = new WeakMap(), _AccountsApiDataSource_tokenDetectionEnabled = new WeakMap(), _AccountsApiDataSource_messenger = new WeakMap(), _AccountsApiDataSource_apiClient = new WeakMap(), _AccountsApiDataSource_chainsRefreshTimer = new WeakMap(), _AccountsApiDataSource_getAssetsState = new WeakMap(), _AccountsApiDataSource_instances = new WeakSet(), _AccountsApiDataSource_handleMigrationFeatureFlagsChanged = 
+/**
+ * Handle a change to the Snaps → AssetsController migration flags: re-fetch
+ * active chains so newly-enabled migration networks are surfaced (and disabled
+ * ones dropped) without waiting for the periodic refresh. The refresh invokes
+ * `onActiveChainsUpdated` when the set changes, which drives re-subscription.
+ */
+async function _AccountsApiDataSource_handleMigrationFeatureFlagsChanged() {
+    try {
+        await __classPrivateFieldGet(this, _AccountsApiDataSource_instances, "m", _AccountsApiDataSource_refreshActiveChains).call(this);
+    }
+    catch (error) {
+        log('Failed to refresh active chains after feature flag change', {
+            error,
+        });
+    }
+}, _AccountsApiDataSource_isBalanceV6Enabled = function _AccountsApiDataSource_isBalanceV6Enabled() {
+    try {
+        const { remoteFeatureFlags } = __classPrivateFieldGet(this, _AccountsApiDataSource_messenger, "f").call('RemoteFeatureFlagController:getState');
+        const flag = remoteFeatureFlags?.assetsAccountsApiV6;
+        return (typeof flag === 'object' &&
+            flag !== null &&
+            Boolean(flag.value));
+    }
+    catch {
+        return false;
+    }
+}, _AccountsApiDataSource_initializeActiveChains = 
+// ============================================================================
+// INITIALIZATION
+// ============================================================================
+async function _AccountsApiDataSource_initializeActiveChains() {
+    try {
+        const chains = await __classPrivateFieldGet(this, _AccountsApiDataSource_instances, "m", _AccountsApiDataSource_fetchActiveChains).call(this);
+        const previous = [...this.state.activeChains];
+        this.updateActiveChains(chains, (updatedChains) => __classPrivateFieldGet(this, _AccountsApiDataSource_onActiveChainsUpdated, "f").call(this, this.getName(), updatedChains, previous));
+        // Periodically refresh active chains (every 20 minutes)
+        __classPrivateFieldSet(this, _AccountsApiDataSource_chainsRefreshTimer, setInterval(() => {
+            __classPrivateFieldGet(this, _AccountsApiDataSource_instances, "m", _AccountsApiDataSource_refreshActiveChains).call(this).catch(console.error);
+        }, 20 * 60 * 1000), "f");
+    }
+    catch (error) {
+        log('Failed to fetch active chains', error);
+    }
+}, _AccountsApiDataSource_refreshActiveChains = async function _AccountsApiDataSource_refreshActiveChains() {
+    try {
+        const chains = await __classPrivateFieldGet(this, _AccountsApiDataSource_instances, "m", _AccountsApiDataSource_fetchActiveChains).call(this);
+        const previousChains = new Set(this.state.activeChains);
+        const newChains = new Set(chains);
+        // Check if chains changed
+        const added = chains.filter((chain) => !previousChains.has(chain));
+        const removed = Array.from(previousChains).filter((chain) => !newChains.has(chain));
+        if (added.length > 0 || removed.length > 0) {
+            const previous = [...this.state.activeChains];
+            this.updateActiveChains(chains, (updatedChains) => __classPrivateFieldGet(this, _AccountsApiDataSource_onActiveChainsUpdated, "f").call(this, this.getName(), updatedChains, previous));
+        }
+    }
+    catch (error) {
+        log('Failed to refresh active chains', error);
+    }
+}, _AccountsApiDataSource_fetchActiveChains = async function _AccountsApiDataSource_fetchActiveChains() {
+    const response = await __classPrivateFieldGet(this, _AccountsApiDataSource_apiClient, "f").accounts.fetchV2SupportedNetworks();
+    // Use fullSupport networks as active chains, gated by the Snaps →
+    // AssetsController migration FF: non-migration namespaces (e.g. `eip155`)
+    // are always surfaced, while migration networks (Solana, Stellar, Tron) are
+    // only surfaced once their per-network stage reaches
+    // ReadAssetsControllerWithFallback.
+    const { remoteFeatureFlags } = __classPrivateFieldGet(this, _AccountsApiDataSource_messenger, "f").call('RemoteFeatureFlagController:getState');
+    return response.fullSupport
+        .map(decimalToChainId)
+        .filter((chainId) => shouldSupportChain(chainId, remoteFeatureFlags));
+}, _AccountsApiDataSource_fetchV5Balances = 
+/**
+ * Fetch balances from the legacy v5 endpoint and process them.
+ *
+ * @param accountIds - CAIP-10 account IDs to fetch balances for.
+ * @param fetchOptions - Cache/fetch options (e.g. force update settings).
+ * @param request - The original data request containing accounts to map.
+ * @returns Unprocessed networks and processed asset balances by account.
+ */
+async function _AccountsApiDataSource_fetchV5Balances(accountIds, fetchOptions, request) {
+    const apiResponse = await fetchWithTimeout(() => __classPrivateFieldGet(this, _AccountsApiDataSource_apiClient, "f").accounts.fetchV5MultiAccountBalances(accountIds, undefined, fetchOptions), __classPrivateFieldGet(this, _AccountsApiDataSource_fetchTimeoutMs, "f"));
+    const { assetsBalance } = __classPrivateFieldGet(this, _AccountsApiDataSource_instances, "m", _AccountsApiDataSource_processV5Balances).call(this, apiResponse.balances, request);
+    return {
+        unprocessedNetworks: apiResponse.unprocessedNetworks,
+        assetsBalance,
+    };
+}, _AccountsApiDataSource_fetchV6Balances = 
+/**
+ * Fetch balances from the v6 endpoint and process them.
+ *
+ * @param accountIds - CAIP-10 account IDs to fetch balances for.
+ * @param fetchOptions - Cache/fetch options (e.g. force update settings).
+ * @param request - The original data request containing accounts to map.
+ * @returns Unprocessed networks and processed asset balances by account.
+ */
+async function _AccountsApiDataSource_fetchV6Balances(accountIds, fetchOptions, request) {
+    const apiResponse = await fetchWithTimeout(() => __classPrivateFieldGet(this, _AccountsApiDataSource_apiClient, "f").accounts.fetchV6MultiAccountBalances(accountIds, undefined, fetchOptions), __classPrivateFieldGet(this, _AccountsApiDataSource_fetchTimeoutMs, "f"));
+    const { assetsBalance } = __classPrivateFieldGet(this, _AccountsApiDataSource_instances, "m", _AccountsApiDataSource_processV6Balances).call(this, apiResponse.balances, request);
+    return {
+        unprocessedNetworks: apiResponse.unprocessedNetworks,
+        assetsBalance,
+    };
+}, _AccountsApiDataSource_buildAddressToAccountIdMap = function _AccountsApiDataSource_buildAddressToAccountIdMap(request) {
+    const addressToAccountId = new Map();
+    for (const { account } of request.accountsWithSupportedChains) {
+        if (account.address) {
+            addressToAccountId.set(account.address.toLowerCase(), account.id);
+        }
+    }
+    return addressToAccountId;
+}, _AccountsApiDataSource_processV5Balances = function _AccountsApiDataSource_processV5Balances(balances, request) {
+    const assetsBalance = {};
+    // Build a map of lowercase addresses to account IDs for efficient lookup
+    const addressToAccountId = __classPrivateFieldGet(this, _AccountsApiDataSource_instances, "m", _AccountsApiDataSource_buildAddressToAccountIdMap).call(this, request);
+    // V5 response: array of { accountId, assetId, balance, ... }
+    for (const item of balances) {
+        // Extract address from CAIP-10 account ID (e.g., "eip155:1:0x1234..." -> "0x1234...")
+        const addressParts = item.accountId.split(':');
+        if (addressParts.length < 3) {
+            continue;
+        }
+        const address = addressParts[2].toLowerCase();
+        // Find the matching account ID from request
+        const accountId = addressToAccountId.get(address);
+        if (!accountId) {
+            // This is normal - API returns balances for all chains, but request may only have one account
+            continue;
+        }
+        if (!assetsBalance[accountId]) {
+            assetsBalance[accountId] = {};
+        }
+        // Normalize asset ID (checksum EVM addresses for ERC20 tokens)
+        const normalizedAssetId = normalizeAssetId(item.assetId);
+        // Staked balances are owned by StakedBalanceDataSource. Accounts API may
+        // return the vault share token as a normal ERC-20 (often 0 or stale),
+        // which would overwrite or wipe the on-chain staked amount on merge.
+        if (isStakingContractAssetId(normalizedAssetId)) {
+            continue;
+        }
+        // Store balance as returned by API
+        assetsBalance[accountId][normalizedAssetId] = {
+            amount: item.balance,
+        };
+    }
+    return { assetsBalance };
+}, _AccountsApiDataSource_processV6Balances = function _AccountsApiDataSource_processV6Balances(balances, request) {
+    const assetsBalance = Object.create(null);
+    // Build a map of lowercase addresses to account IDs for efficient lookup
+    const addressToAccountId = __classPrivateFieldGet(this, _AccountsApiDataSource_instances, "m", _AccountsApiDataSource_buildAddressToAccountIdMap).call(this, request);
+    for (const item of balances) {
+        // Extract address from CAIP-10 account ID (e.g., "eip155:1:0x1234..." -> "0x1234...")
+        const addressParts = item.accountId.split(':');
+        if (addressParts.length < 3) {
+            continue;
+        }
+        const address = addressParts[2].toLowerCase();
+        // Find the matching account ID from request
+        const accountId = addressToAccountId.get(address);
+        if (!accountId) {
+            // This is normal - API returns balances for all chains, but request may only have one account
+            continue;
+        }
+        // Only consume token balances; DeFi positions are handled elsewhere.
+        if (item.object !== 'token') {
+            continue;
+        }
+        if (!assetsBalance[accountId]) {
+            assetsBalance[accountId] = Object.create(null);
+        }
+        // Normalize asset ID (checksum EVM addresses for ERC20 tokens)
+        const normalizedAssetId = normalizeAssetId(item.assetId);
+        // Staked balances are owned by StakedBalanceDataSource. Accounts API may
+        // return the vault share token as a normal ERC-20 (often 0 or stale),
+        // which would overwrite or wipe the on-chain staked amount on merge.
+        if (isStakingContractAssetId(normalizedAssetId)) {
+            continue;
+        }
+        // Store balance as returned by API
+        assetsBalance[accountId][normalizedAssetId] = {
+            amount: item.balance,
+        };
+    }
+    return { assetsBalance };
+};
+//# sourceMappingURL=AccountsApiDataSource.mjs.map