@metamask-previews/assets-controller 1.0.0-preview-ee8f1b28b → 2.0.0-preview-33dbba4f3

package/dist/data-sources/StakedBalanceDataSource.cjs

@@ -0,0 +1,609 @@
+"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 _StakedBalanceDataSource_instances, _StakedBalanceDataSource_messenger, _StakedBalanceDataSource_onActiveChainsUpdated, _StakedBalanceDataSource_pollInterval, _StakedBalanceDataSource_enabled, _StakedBalanceDataSource_stakedBalanceFetcher, _StakedBalanceDataSource_activeSubscriptions, _StakedBalanceDataSource_providerCache, _StakedBalanceDataSource_supportedChainIds, _StakedBalanceDataSource_unsubscribeTransactionConfirmed, _StakedBalanceDataSource_unsubscribeIncomingTransactions, _StakedBalanceDataSource_unsubscribeNetworkStateChange, _StakedBalanceDataSource_unsubscribeNetworkEnablementControllerStateChange, _StakedBalanceDataSource_onNetworkStateChange, _StakedBalanceDataSource_onNetworkEnablementControllerStateChange, _StakedBalanceDataSource_isTransactionInvolvingStakingContract, _StakedBalanceDataSource_onTransactionConfirmed, _StakedBalanceDataSource_onIncomingTransactions, _StakedBalanceDataSource_getToRefreshForChains, _StakedBalanceDataSource_getToRefreshAll, _StakedBalanceDataSource_refreshStakedBalanceAfterTransaction, _StakedBalanceDataSource_initializeActiveChains, _StakedBalanceDataSource_initializeActiveChainsFromEnabledMap, _StakedBalanceDataSource_getProvider, _StakedBalanceDataSource_handleStakedBalanceUpdate;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StakedBalanceDataSource = void 0;
+const util_1 = require("@ethereumjs/util");
+const providers_1 = require("@ethersproject/providers");
+const utils_1 = require("@metamask/utils");
+const AbstractDataSource_1 = require("./AbstractDataSource.cjs");
+const evm_rpc_services_1 = require("./evm-rpc-services/index.cjs");
+const logger_1 = require("../logger.cjs");
+const CONTROLLER_NAME = 'StakedBalanceDataSource';
+const DEFAULT_POLL_INTERVAL = 180000; // 3 minutes
+/** Metadata for staked ETH (same symbol and decimals as native ETH). */
+const STAKED_ETH_METADATA = {
+    type: 'erc20',
+    name: 'staked ethereum',
+    symbol: 'ETH',
+    decimals: 18,
+};
+const log = (0, logger_1.createModuleLogger)(logger_1.projectLogger, CONTROLLER_NAME);
+/**
+ * Convert CAIP chain ID or hex chain ID to hex chain ID.
+ *
+ * @param chainId - CAIP chain ID or hex chain ID.
+ * @returns Hex chain ID.
+ */
+function caipChainIdToHex(chainId) {
+    if ((0, utils_1.isStrictHexString)(chainId)) {
+        return chainId;
+    }
+    if ((0, utils_1.isCaipChainId)(chainId)) {
+        const ref = (0, utils_1.parseCaipChainId)(chainId).reference;
+        return (0, utils_1.numberToHex)(parseInt(ref, 10));
+    }
+    throw new Error('caipChainIdToHex - Failed to provide CAIP-2 or Hex chainId');
+}
+/**
+ * Build the CAIP-19 asset ID for staked balance (same format as ERC20).
+ * Uses the staking contract address (checksummed) so it is consistent with
+ * other token assets.
+ * Example: "eip155:1/erc20:0x4fef9d741011476750a243ac70b9789a63dd47df"
+ *
+ * @param chainId - CAIP-2 chain ID (e.g. "eip155:1").
+ * @param contractAddress - Staking contract address (hex).
+ * @returns The staked asset CAIP-19 ID with checksummed address.
+ */
+function stakedAssetId(chainId, contractAddress) {
+    const checksummed = (0, util_1.toChecksumAddress)(contractAddress);
+    return `${chainId}/erc20:${checksummed}`;
+}
+/**
+ * Data source for fetching staked ETH balances via on-chain staking contracts.
+ *
+ * Delegates to {@link StakedBalanceFetcher} for the actual RPC calls
+ * (getShares + convertToAssets on ERC-4626-style staking contracts).
+ * Reports balances as CAIP-19 asset IDs using the ERC20 format with the
+ * staking contract address (e.g. "eip155:1/erc20:0x4fef9d741011476750a243ac70b9789a63dd47df").
+ *
+ * Only supports chains with known staking contracts (mainnet, Hoodi).
+ * Polling is managed by StakedBalanceFetcher via startPolling/stopPollingByPollingToken.
+ */
+class StakedBalanceDataSource extends AbstractDataSource_1.AbstractDataSource {
+    constructor(options) {
+        super(CONTROLLER_NAME, { activeChains: [] });
+        _StakedBalanceDataSource_instances.add(this);
+        _StakedBalanceDataSource_messenger.set(this, void 0);
+        _StakedBalanceDataSource_onActiveChainsUpdated.set(this, void 0);
+        _StakedBalanceDataSource_pollInterval.set(this, void 0);
+        _StakedBalanceDataSource_enabled.set(this, void 0);
+        /** The StakedBalanceFetcher that handles polling and RPC calls. */
+        _StakedBalanceDataSource_stakedBalanceFetcher.set(this, void 0);
+        /** Active subscriptions by ID. */
+        _StakedBalanceDataSource_activeSubscriptions.set(this, new Map());
+        /** Cache of Web3Provider instances by hex chain ID. */
+        _StakedBalanceDataSource_providerCache.set(this, new Map());
+        /** CAIP-2 chain IDs that have known staking contracts. */
+        _StakedBalanceDataSource_supportedChainIds.set(this, void 0);
+        _StakedBalanceDataSource_unsubscribeTransactionConfirmed.set(this, undefined);
+        _StakedBalanceDataSource_unsubscribeIncomingTransactions.set(this, undefined);
+        _StakedBalanceDataSource_unsubscribeNetworkStateChange.set(this, undefined);
+        _StakedBalanceDataSource_unsubscribeNetworkEnablementControllerStateChange.set(this, undefined);
+        __classPrivateFieldSet(this, _StakedBalanceDataSource_messenger, options.messenger, "f");
+        __classPrivateFieldSet(this, _StakedBalanceDataSource_onActiveChainsUpdated, options.onActiveChainsUpdated, "f");
+        __classPrivateFieldSet(this, _StakedBalanceDataSource_pollInterval, options.pollInterval ?? DEFAULT_POLL_INTERVAL, "f");
+        __classPrivateFieldSet(this, _StakedBalanceDataSource_enabled, options.enabled !== false, "f");
+        __classPrivateFieldSet(this, _StakedBalanceDataSource_supportedChainIds, (0, evm_rpc_services_1.getSupportedStakingChainIds)(), "f");
+        log('Initializing StakedBalanceDataSource', {
+            enabled: __classPrivateFieldGet(this, _StakedBalanceDataSource_enabled, "f"),
+            pollInterval: __classPrivateFieldGet(this, _StakedBalanceDataSource_pollInterval, "f"),
+        });
+        // Create StakedBalanceFetcher with provider getter
+        __classPrivateFieldSet(this, _StakedBalanceDataSource_stakedBalanceFetcher, new evm_rpc_services_1.StakedBalanceFetcher({
+            pollingInterval: __classPrivateFieldGet(this, _StakedBalanceDataSource_pollInterval, "f"),
+            getNetworkProvider: (hexChainId) => __classPrivateFieldGet(this, _StakedBalanceDataSource_instances, "m", _StakedBalanceDataSource_getProvider).call(this, hexChainId),
+        }), "f");
+        // Wire the callback so polling results flow back to subscriptions
+        __classPrivateFieldGet(this, _StakedBalanceDataSource_stakedBalanceFetcher, "f").setOnStakedBalanceUpdate(__classPrivateFieldGet(this, _StakedBalanceDataSource_instances, "m", _StakedBalanceDataSource_handleStakedBalanceUpdate).bind(this));
+        const unsubConfirmed = __classPrivateFieldGet(this, _StakedBalanceDataSource_messenger, "f").subscribe('TransactionController:transactionConfirmed', __classPrivateFieldGet(this, _StakedBalanceDataSource_instances, "m", _StakedBalanceDataSource_onTransactionConfirmed).bind(this));
+        __classPrivateFieldSet(this, _StakedBalanceDataSource_unsubscribeTransactionConfirmed, typeof unsubConfirmed === 'function' ? unsubConfirmed : undefined, "f");
+        const unsubIncoming = __classPrivateFieldGet(this, _StakedBalanceDataSource_messenger, "f").subscribe('TransactionController:incomingTransactionsReceived', __classPrivateFieldGet(this, _StakedBalanceDataSource_instances, "m", _StakedBalanceDataSource_onIncomingTransactions).bind(this));
+        __classPrivateFieldSet(this, _StakedBalanceDataSource_unsubscribeIncomingTransactions, typeof unsubIncoming === 'function' ? unsubIncoming : undefined, "f");
+        const unsubNetwork = __classPrivateFieldGet(this, _StakedBalanceDataSource_messenger, "f").subscribe('NetworkController:stateChange', __classPrivateFieldGet(this, _StakedBalanceDataSource_instances, "m", _StakedBalanceDataSource_onNetworkStateChange).bind(this));
+        __classPrivateFieldSet(this, _StakedBalanceDataSource_unsubscribeNetworkStateChange, typeof unsubNetwork === 'function' ? unsubNetwork : undefined, "f");
+        const unsubEnablement = __classPrivateFieldGet(this, _StakedBalanceDataSource_messenger, "f").subscribe('NetworkEnablementController:stateChange', __classPrivateFieldGet(this, _StakedBalanceDataSource_instances, "m", _StakedBalanceDataSource_onNetworkEnablementControllerStateChange).bind(this));
+        __classPrivateFieldSet(this, _StakedBalanceDataSource_unsubscribeNetworkEnablementControllerStateChange, typeof unsubEnablement === 'function' ? unsubEnablement : undefined, "f");
+        __classPrivateFieldGet(this, _StakedBalanceDataSource_instances, "m", _StakedBalanceDataSource_initializeActiveChains).call(this);
+    }
+    /**
+     * Refresh staked balance for all currently subscribed accounts and chains, then
+     * push updates to the controller. Can be called from UI or after transaction events.
+     */
+    async refreshStakedBalance() {
+        if (!__classPrivateFieldGet(this, _StakedBalanceDataSource_enabled, "f")) {
+            return;
+        }
+        const toRefresh = __classPrivateFieldGet(this, _StakedBalanceDataSource_instances, "m", _StakedBalanceDataSource_getToRefreshAll).call(this);
+        if (toRefresh.length > 0) {
+            await __classPrivateFieldGet(this, _StakedBalanceDataSource_instances, "m", _StakedBalanceDataSource_refreshStakedBalanceAfterTransaction).call(this, toRefresh);
+        }
+    }
+    /**
+     * Fetch staked balances for all accounts on supported chains.
+     *
+     * @param request - The data request with accounts and chains.
+     * @returns DataResponse with staked balance data.
+     */
+    async fetch(request) {
+        var _a;
+        if (!__classPrivateFieldGet(this, _StakedBalanceDataSource_enabled, "f")) {
+            return {};
+        }
+        const response = {};
+        const activeChainsSet = new Set(this.state.activeChains);
+        const chainsToFetch = request.chainIds.filter((chainId) => activeChainsSet.has(chainId));
+        if (chainsToFetch.length === 0) {
+            return response;
+        }
+        const balances = {};
+        for (const { account, supportedChains: accountChains, } of request.accountsWithSupportedChains) {
+            const chains = chainsToFetch.filter((chain) => accountChains.includes(chain));
+            for (const chainId of chains) {
+                try {
+                    const hexChainId = caipChainIdToHex(chainId);
+                    const contractAddress = (0, evm_rpc_services_1.getStakingContractAddress)(hexChainId);
+                    if (!contractAddress) {
+                        continue;
+                    }
+                    const input = {
+                        chainId: hexChainId,
+                        accountId: account.id,
+                        accountAddress: account.address,
+                    };
+                    const result = await __classPrivateFieldGet(this, _StakedBalanceDataSource_stakedBalanceFetcher, "f").fetchStakedBalance(input);
+                    // Include zero amounts so merged updates clear prior non-zero state.
+                    balances[_a = account.id] ?? (balances[_a] = {});
+                    const assetId = stakedAssetId(chainId, contractAddress);
+                    balances[account.id][assetId] = { amount: result.amount };
+                }
+                catch (error) {
+                    log('Failed to fetch staked balance', {
+                        chainId,
+                        accountId: account.id,
+                        error,
+                    });
+                }
+            }
+        }
+        if (Object.keys(balances).length > 0) {
+            response.assetsBalance = balances;
+            // Add metadata for each staked asset ID present in balances
+            const assetIds = new Set();
+            for (const accountBalances of Object.values(balances)) {
+                for (const assetId of Object.keys(accountBalances)) {
+                    assetIds.add(assetId);
+                }
+            }
+            response.assetsInfo = {};
+            for (const assetId of assetIds) {
+                response.assetsInfo[assetId] = STAKED_ETH_METADATA;
+            }
+        }
+        return response;
+    }
+    /**
+     * Assets middleware for the fetch pipeline.
+     * Fetches staked balances and merges them into the response, then passes
+     * all chains to the next middleware (staked balance doesn't claim chains).
+     *
+     * @returns The middleware function for the assets pipeline.
+     */
+    get assetsMiddleware() {
+        return async (context, next) => {
+            var _a, _b;
+            if (!__classPrivateFieldGet(this, _StakedBalanceDataSource_enabled, "f")) {
+                return next(context);
+            }
+            const { request } = context;
+            if (!request.dataTypes.includes('balance')) {
+                return next(context);
+            }
+            if (request.chainIds.length === 0) {
+                return next(context);
+            }
+            try {
+                const fetchResponse = await this.fetch(request);
+                if (fetchResponse.assetsInfo) {
+                    (_a = context.response).assetsInfo ?? (_a.assetsInfo = {});
+                    Object.assign(context.response.assetsInfo, fetchResponse.assetsInfo);
+                }
+                if (fetchResponse.assetsBalance) {
+                    (_b = context.response).assetsBalance ?? (_b.assetsBalance = {});
+                    for (const [accountId, accountBalances] of Object.entries(fetchResponse.assetsBalance)) {
+                        context.response.assetsBalance[accountId] = {
+                            ...context.response.assetsBalance[accountId],
+                            ...accountBalances,
+                        };
+                    }
+                }
+            }
+            catch (error) {
+                log('Middleware fetch failed', { error });
+            }
+            // Pass all chains through (staked balance doesn't claim chains)
+            return next(context);
+        };
+    }
+    /**
+     * Subscribe to staked balance updates with polling.
+     * Starts polling via StakedBalanceFetcher for each account/chain combination.
+     *
+     * @param subscriptionRequest - The subscription request details.
+     */
+    async subscribe(subscriptionRequest) {
+        const { request, subscriptionId, isUpdate } = subscriptionRequest;
+        const activeChainsSet = new Set(this.state.activeChains);
+        const chainsToSubscribe = request.chainIds.filter((chainId) => activeChainsSet.has(chainId));
+        log('Subscribe requested', {
+            subscriptionId,
+            isUpdate,
+            chainsToSubscribe,
+        });
+        if (chainsToSubscribe.length === 0) {
+            log('No staking chains to subscribe');
+            return;
+        }
+        // Handle subscription update - restart polling for new chains
+        if (isUpdate) {
+            const existing = __classPrivateFieldGet(this, _StakedBalanceDataSource_activeSubscriptions, "f").get(subscriptionId);
+            if (existing) {
+                log('Updating existing subscription - restarting polling', {
+                    subscriptionId,
+                });
+            }
+        }
+        // Clean up existing subscription (stops old polling)
+        await this.unsubscribe(subscriptionId);
+        // Build subscription data first so it is available when the first poll runs
+        const accountsWithSupportedChains = request.accountsWithSupportedChains
+            .map(({ account, supportedChains }) => ({
+            account,
+            supportedChains: chainsToSubscribe.filter((chain) => supportedChains.includes(chain)),
+        }))
+            .filter(({ supportedChains }) => supportedChains.length > 0);
+        const accounts = accountsWithSupportedChains.map((entry) => entry.account);
+        const pollingTokens = [];
+        // Store subscription before startPolling so first poll (setTimeout 0) has the callback
+        __classPrivateFieldGet(this, _StakedBalanceDataSource_activeSubscriptions, "f").set(subscriptionId, {
+            pollingTokens,
+            chains: chainsToSubscribe,
+            accounts,
+            accountsWithSupportedChains,
+            onAssetsUpdate: subscriptionRequest.onAssetsUpdate,
+        });
+        this.activeSubscriptions.set(subscriptionId, {
+            cleanup: () => {
+                for (const token of pollingTokens) {
+                    __classPrivateFieldGet(this, _StakedBalanceDataSource_stakedBalanceFetcher, "f").stopPollingByPollingToken(token);
+                }
+                __classPrivateFieldGet(this, _StakedBalanceDataSource_activeSubscriptions, "f").delete(subscriptionId);
+            },
+            chains: chainsToSubscribe,
+            request,
+            onAssetsUpdate: subscriptionRequest.onAssetsUpdate,
+        });
+        // Start polling for each account/chain (first poll runs on next tick)
+        for (const { account, supportedChains: accountChains, } of request.accountsWithSupportedChains) {
+            const chainsForAccount = chainsToSubscribe.filter((chain) => accountChains.includes(chain));
+            for (const chainId of chainsForAccount) {
+                const hexChainId = caipChainIdToHex(chainId);
+                const input = {
+                    chainId: hexChainId,
+                    accountId: account.id,
+                    accountAddress: account.address,
+                };
+                const pollingToken = __classPrivateFieldGet(this, _StakedBalanceDataSource_stakedBalanceFetcher, "f").startPolling(input);
+                pollingTokens.push(pollingToken);
+            }
+        }
+        // Immediate initial fetch so state is updated without waiting for first poll
+        try {
+            const initialRequest = {
+                accountsWithSupportedChains,
+                chainIds: chainsToSubscribe,
+                dataTypes: ['balance'],
+            };
+            const initialResponse = await this.fetch(initialRequest);
+            if (initialResponse.assetsBalance &&
+                Object.keys(initialResponse.assetsBalance).length > 0) {
+                subscriptionRequest
+                    .onAssetsUpdate?.(initialResponse)
+                    ?.catch((error) => {
+                    log('Initial staked balance update failed', { error });
+                });
+            }
+        }
+        catch (error) {
+            log('Initial staked balance fetch failed', { error });
+        }
+        log('Subscription SUCCESS', {
+            subscriptionId,
+            chains: chainsToSubscribe,
+            pollingCount: pollingTokens.length,
+        });
+    }
+    /**
+     * Unsubscribe from staked balance updates and stop polling.
+     *
+     * @param subscriptionId - The subscription ID to unsubscribe.
+     */
+    async unsubscribe(subscriptionId) {
+        const subscription = __classPrivateFieldGet(this, _StakedBalanceDataSource_activeSubscriptions, "f").get(subscriptionId);
+        if (subscription) {
+            for (const token of subscription.pollingTokens) {
+                __classPrivateFieldGet(this, _StakedBalanceDataSource_stakedBalanceFetcher, "f").stopPollingByPollingToken(token);
+            }
+            __classPrivateFieldGet(this, _StakedBalanceDataSource_activeSubscriptions, "f").delete(subscriptionId);
+        }
+        await super.unsubscribe(subscriptionId);
+    }
+    /**
+     * Destroy the data source and clean up all resources.
+     */
+    destroy() {
+        __classPrivateFieldGet(this, _StakedBalanceDataSource_unsubscribeTransactionConfirmed, "f")?.call(this);
+        __classPrivateFieldGet(this, _StakedBalanceDataSource_unsubscribeIncomingTransactions, "f")?.call(this);
+        __classPrivateFieldGet(this, _StakedBalanceDataSource_unsubscribeNetworkStateChange, "f")?.call(this);
+        __classPrivateFieldGet(this, _StakedBalanceDataSource_unsubscribeNetworkEnablementControllerStateChange, "f")?.call(this);
+        for (const subscription of __classPrivateFieldGet(this, _StakedBalanceDataSource_activeSubscriptions, "f").values()) {
+            for (const token of subscription.pollingTokens) {
+                __classPrivateFieldGet(this, _StakedBalanceDataSource_stakedBalanceFetcher, "f").stopPollingByPollingToken(token);
+            }
+        }
+        __classPrivateFieldGet(this, _StakedBalanceDataSource_activeSubscriptions, "f").clear();
+        __classPrivateFieldGet(this, _StakedBalanceDataSource_providerCache, "f").clear();
+        super.destroy();
+    }
+}
+exports.StakedBalanceDataSource = StakedBalanceDataSource;
+_StakedBalanceDataSource_messenger = new WeakMap(), _StakedBalanceDataSource_onActiveChainsUpdated = new WeakMap(), _StakedBalanceDataSource_pollInterval = new WeakMap(), _StakedBalanceDataSource_enabled = new WeakMap(), _StakedBalanceDataSource_stakedBalanceFetcher = new WeakMap(), _StakedBalanceDataSource_activeSubscriptions = new WeakMap(), _StakedBalanceDataSource_providerCache = new WeakMap(), _StakedBalanceDataSource_supportedChainIds = new WeakMap(), _StakedBalanceDataSource_unsubscribeTransactionConfirmed = new WeakMap(), _StakedBalanceDataSource_unsubscribeIncomingTransactions = new WeakMap(), _StakedBalanceDataSource_unsubscribeNetworkStateChange = new WeakMap(), _StakedBalanceDataSource_unsubscribeNetworkEnablementControllerStateChange = new WeakMap(), _StakedBalanceDataSource_instances = new WeakSet(), _StakedBalanceDataSource_onNetworkStateChange = function _StakedBalanceDataSource_onNetworkStateChange() {
+    __classPrivateFieldGet(this, _StakedBalanceDataSource_providerCache, "f").clear();
+    log('Provider cache cleared after network state change');
+}, _StakedBalanceDataSource_onNetworkEnablementControllerStateChange = function _StakedBalanceDataSource_onNetworkEnablementControllerStateChange(state) {
+    const { enabledNetworkMap } = state ?? {};
+    if (!enabledNetworkMap) {
+        return;
+    }
+    __classPrivateFieldGet(this, _StakedBalanceDataSource_instances, "m", _StakedBalanceDataSource_initializeActiveChainsFromEnabledMap).call(this, enabledNetworkMap);
+}, _StakedBalanceDataSource_isTransactionInvolvingStakingContract = function _StakedBalanceDataSource_isTransactionInvolvingStakingContract(payload) {
+    const hexChainId = payload?.chainId;
+    if (!hexChainId) {
+        return false;
+    }
+    const contractAddress = (0, evm_rpc_services_1.getStakingContractAddress)(hexChainId);
+    if (!contractAddress) {
+        return false;
+    }
+    const contractLower = contractAddress.toLowerCase();
+    const from = payload.txParams?.from?.toLowerCase();
+    const to = payload.txParams?.to?.toLowerCase();
+    return from === contractLower || to === contractLower;
+}, _StakedBalanceDataSource_onTransactionConfirmed = function _StakedBalanceDataSource_onTransactionConfirmed(payload) {
+    if (!__classPrivateFieldGet(this, _StakedBalanceDataSource_enabled, "f")) {
+        return;
+    }
+    if (!__classPrivateFieldGet(this, _StakedBalanceDataSource_instances, "m", _StakedBalanceDataSource_isTransactionInvolvingStakingContract).call(this, payload)) {
+        return;
+    }
+    const hexChainId = payload?.chainId;
+    if (!hexChainId) {
+        return;
+    }
+    const caipChainId = `eip155:${parseInt(hexChainId, 16)}`;
+    const toRefresh = __classPrivateFieldGet(this, _StakedBalanceDataSource_instances, "m", _StakedBalanceDataSource_getToRefreshForChains).call(this, [caipChainId]);
+    if (toRefresh.length > 0) {
+        __classPrivateFieldGet(this, _StakedBalanceDataSource_instances, "m", _StakedBalanceDataSource_refreshStakedBalanceAfterTransaction).call(this, toRefresh).catch((error) => {
+            log('Failed to refresh staked balance after transaction', { error });
+        });
+    }
+}, _StakedBalanceDataSource_onIncomingTransactions = function _StakedBalanceDataSource_onIncomingTransactions(payload) {
+    if (!__classPrivateFieldGet(this, _StakedBalanceDataSource_enabled, "f")) {
+        return;
+    }
+    const chainIdsToRefresh = new Set();
+    for (const item of payload ?? []) {
+        if (!item?.chainId) {
+            continue;
+        }
+        if (__classPrivateFieldGet(this, _StakedBalanceDataSource_instances, "m", _StakedBalanceDataSource_isTransactionInvolvingStakingContract).call(this, item)) {
+            chainIdsToRefresh.add(item.chainId);
+        }
+    }
+    const caipChainIds = [...chainIdsToRefresh].map((hexChainId) => `eip155:${parseInt(hexChainId, 16)}`);
+    if (caipChainIds.length === 0) {
+        return;
+    }
+    const toRefresh = __classPrivateFieldGet(this, _StakedBalanceDataSource_instances, "m", _StakedBalanceDataSource_getToRefreshForChains).call(this, caipChainIds);
+    if (toRefresh.length > 0) {
+        __classPrivateFieldGet(this, _StakedBalanceDataSource_instances, "m", _StakedBalanceDataSource_refreshStakedBalanceAfterTransaction).call(this, toRefresh).catch((error) => {
+            log('Failed to refresh staked balance after incoming transactions', {
+                error,
+            });
+        });
+    }
+}, _StakedBalanceDataSource_getToRefreshForChains = function _StakedBalanceDataSource_getToRefreshForChains(chainIds) {
+    const toRefresh = [];
+    const chainSet = new Set(chainIds);
+    for (const subscription of __classPrivateFieldGet(this, _StakedBalanceDataSource_activeSubscriptions, "f").values()) {
+        for (const { account, supportedChains, } of subscription.accountsWithSupportedChains) {
+            for (const chainId of supportedChains) {
+                if (chainSet.has(chainId)) {
+                    toRefresh.push({ account, chainId });
+                }
+            }
+        }
+    }
+    return toRefresh;
+}, _StakedBalanceDataSource_getToRefreshAll = function _StakedBalanceDataSource_getToRefreshAll() {
+    const toRefresh = [];
+    for (const subscription of __classPrivateFieldGet(this, _StakedBalanceDataSource_activeSubscriptions, "f").values()) {
+        for (const { account, supportedChains, } of subscription.accountsWithSupportedChains) {
+            for (const chainId of supportedChains) {
+                toRefresh.push({ account, chainId });
+            }
+        }
+    }
+    return toRefresh;
+}, _StakedBalanceDataSource_refreshStakedBalanceAfterTransaction = 
+/**
+ * Fetch staked balance for the given account/chain pairs and push a single
+ * DataResponse to all active subscriptions.
+ *
+ * @param toRefresh - List of { account, chainId } to refresh.
+ */
+async function _StakedBalanceDataSource_refreshStakedBalanceAfterTransaction(toRefresh) {
+    const assetsInfo = {};
+    const assetsBalance = {};
+    for (const { account, chainId } of toRefresh) {
+        try {
+            const hexChainId = caipChainIdToHex(chainId);
+            const contractAddress = (0, evm_rpc_services_1.getStakingContractAddress)(hexChainId);
+            if (!contractAddress) {
+                continue;
+            }
+            const input = {
+                chainId: hexChainId,
+                accountId: account.id,
+                accountAddress: account.address,
+            };
+            const result = await __classPrivateFieldGet(this, _StakedBalanceDataSource_stakedBalanceFetcher, "f").fetchStakedBalance(input);
+            const assetId = stakedAssetId(chainId, contractAddress);
+            assetsInfo[assetId] = STAKED_ETH_METADATA;
+            const existing = assetsBalance[account.id];
+            assetsBalance[account.id] = {
+                ...existing,
+                [assetId]: { amount: result.amount },
+            };
+        }
+        catch (error) {
+            log('Failed to fetch staked balance in transaction refresh', {
+                chainId,
+                accountId: account.id,
+                error,
+            });
+        }
+    }
+    if (Object.keys(assetsBalance).length > 0) {
+        const response = { assetsInfo, assetsBalance };
+        for (const subscription of __classPrivateFieldGet(this, _StakedBalanceDataSource_activeSubscriptions, "f").values()) {
+            subscription.onAssetsUpdate(response)?.catch((error) => {
+                log('Failed to report staked balance update after transaction', {
+                    error,
+                });
+            });
+        }
+    }
+}, _StakedBalanceDataSource_initializeActiveChains = function _StakedBalanceDataSource_initializeActiveChains() {
+    try {
+        const state = __classPrivateFieldGet(this, _StakedBalanceDataSource_messenger, "f").call('NetworkEnablementController:getState');
+        __classPrivateFieldGet(this, _StakedBalanceDataSource_instances, "m", _StakedBalanceDataSource_initializeActiveChainsFromEnabledMap).call(this, state?.enabledNetworkMap ?? {});
+    }
+    catch (error) {
+        log('Failed to get NetworkEnablementController state', { error });
+        __classPrivateFieldGet(this, _StakedBalanceDataSource_instances, "m", _StakedBalanceDataSource_initializeActiveChainsFromEnabledMap).call(this, {});
+    }
+}, _StakedBalanceDataSource_initializeActiveChainsFromEnabledMap = function _StakedBalanceDataSource_initializeActiveChainsFromEnabledMap(enabledNetworkMap) {
+    if (!__classPrivateFieldGet(this, _StakedBalanceDataSource_enabled, "f")) {
+        const previous = [...this.state.activeChains];
+        this.updateActiveChains([], (updatedChains) => __classPrivateFieldGet(this, _StakedBalanceDataSource_onActiveChainsUpdated, "f").call(this, this.getName(), updatedChains, previous));
+        return;
+    }
+    const activeChains = [];
+    const eip155Map = enabledNetworkMap.eip155;
+    if (eip155Map) {
+        for (const caip2 of __classPrivateFieldGet(this, _StakedBalanceDataSource_supportedChainIds, "f")) {
+            if (!(0, utils_1.isCaipChainId)(caip2)) {
+                continue;
+            }
+            const { reference } = (0, utils_1.parseCaipChainId)(caip2);
+            const storageKey = (0, utils_1.numberToHex)(parseInt(reference, 10));
+            if (eip155Map[storageKey]) {
+                activeChains.push(caip2);
+            }
+        }
+    }
+    const previous = [...this.state.activeChains];
+    this.updateActiveChains(activeChains, (updatedChains) => __classPrivateFieldGet(this, _StakedBalanceDataSource_onActiveChainsUpdated, "f").call(this, this.getName(), updatedChains, previous));
+}, _StakedBalanceDataSource_getProvider = function _StakedBalanceDataSource_getProvider(hexChainId) {
+    const cached = __classPrivateFieldGet(this, _StakedBalanceDataSource_providerCache, "f").get(hexChainId);
+    if (cached) {
+        return cached;
+    }
+    try {
+        const networkState = __classPrivateFieldGet(this, _StakedBalanceDataSource_messenger, "f").call('NetworkController:getState');
+        const { networkConfigurationsByChainId } = networkState;
+        if (!networkConfigurationsByChainId) {
+            return undefined;
+        }
+        const chainConfig = networkConfigurationsByChainId[hexChainId];
+        if (!chainConfig) {
+            return undefined;
+        }
+        // Use the network's configured default RPC endpoint (same as RpcDataSource).
+        const { rpcEndpoints, defaultRpcEndpointIndex } = chainConfig;
+        if (!rpcEndpoints || rpcEndpoints.length === 0) {
+            return undefined;
+        }
+        const index = typeof defaultRpcEndpointIndex === 'number' &&
+            defaultRpcEndpointIndex >= 0 &&
+            defaultRpcEndpointIndex < rpcEndpoints.length
+            ? defaultRpcEndpointIndex
+            : 0;
+        const defaultEndpoint = rpcEndpoints[index];
+        const networkClientId = defaultEndpoint?.networkClientId;
+        if (!networkClientId) {
+            return undefined;
+        }
+        const networkClient = __classPrivateFieldGet(this, _StakedBalanceDataSource_messenger, "f").call('NetworkController:getNetworkClientById', networkClientId);
+        if (!networkClient?.provider) {
+            return undefined;
+        }
+        const provider = new providers_1.Web3Provider(networkClient.provider);
+        __classPrivateFieldGet(this, _StakedBalanceDataSource_providerCache, "f").set(hexChainId, provider);
+        return provider;
+    }
+    catch (error) {
+        log('Failed to get provider for chain', { hexChainId, error });
+        return undefined;
+    }
+}, _StakedBalanceDataSource_handleStakedBalanceUpdate = function _StakedBalanceDataSource_handleStakedBalanceUpdate(result) {
+    const contractAddress = (0, evm_rpc_services_1.getStakingContractAddress)(result.chainId);
+    if (!contractAddress) {
+        return;
+    }
+    const chainIdDecimal = parseInt(result.chainId, 16);
+    const caipChainId = `eip155:${chainIdDecimal}`;
+    const assetId = stakedAssetId(caipChainId, contractAddress);
+    const response = {
+        assetsInfo: {
+            [assetId]: STAKED_ETH_METADATA,
+        },
+        assetsBalance: {
+            [result.accountId]: {
+                [assetId]: { amount: result.balance.amount },
+            },
+        },
+    };
+    log('Staked balance update', {
+        accountId: result.accountId,
+        chainId: caipChainId,
+        amount: result.balance.amount,
+    });
+    for (const subscription of __classPrivateFieldGet(this, _StakedBalanceDataSource_activeSubscriptions, "f").values()) {
+        subscription.onAssetsUpdate(response)?.catch((error) => {
+            log('Failed to report staked balance update', { error });
+        });
+    }
+};
+//# sourceMappingURL=StakedBalanceDataSource.cjs.map