@metamask/assets-controller 0.2.0 → 2.0.0

package/dist/data-sources/RpcDataSource.mjs

@@ -9,12 +9,12 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _RpcDataSource_instances, _RpcDataSource_timeout, _RpcDataSource_tokenDetectionEnabled, _RpcDataSource_activeChains, _RpcDataSource_chainStatuses, _RpcDataSource_providerCache, _RpcDataSource_activeSubscriptions, _RpcDataSource_multicallClient, _RpcDataSource_balanceFetcher, _RpcDataSource_tokenDetector, _RpcDataSource_convertToHumanReadable, _RpcDataSource_collectMetadataForBalances, _RpcDataSource_handleBalanceUpdate, _RpcDataSource_handleDetectionUpdate, _RpcDataSource_registerActionHandlers, _RpcDataSource_subscribeToNetworkController, _RpcDataSource_initializeFromNetworkController, _RpcDataSource_updateFromNetworkState, _RpcDataSource_getProvider, _RpcDataSource_getMulticallProvider, _RpcDataSource_clearProviderCache, _RpcDataSource_accountSupportsChain, _RpcDataSource_buildNativeAssetId, _RpcDataSource_getExistingAssetsMetadata, _RpcDataSource_getTokenMetadataFromTokenList;
+var _RpcDataSource_instances, _RpcDataSource_messenger, _RpcDataSource_onActiveChainsUpdated, _RpcDataSource_timeout, _RpcDataSource_tokenDetectionEnabled, _RpcDataSource_useExternalService, _RpcDataSource_activeChains, _RpcDataSource_chainStatuses, _RpcDataSource_providerCache, _RpcDataSource_activeSubscriptions, _RpcDataSource_unsubscribeTransactionConfirmed, _RpcDataSource_unsubscribeIncomingTransactions, _RpcDataSource_multicallClient, _RpcDataSource_balanceFetcher, _RpcDataSource_tokenDetector, _RpcDataSource_convertToHumanReadable, _RpcDataSource_collectMetadataForBalances, _RpcDataSource_handleBalanceUpdate, _RpcDataSource_handleDetectionUpdate, _RpcDataSource_subscribeToNetworkController, _RpcDataSource_subscribeToTransactionEvents, _RpcDataSource_onTransactionConfirmed, _RpcDataSource_onIncomingTransactions, _RpcDataSource_refreshBalanceForChains, _RpcDataSource_initializeFromNetworkController, _RpcDataSource_updateFromNetworkState, _RpcDataSource_getProvider, _RpcDataSource_getMulticallProvider, _RpcDataSource_clearProviderCache, _RpcDataSource_buildNativeAssetId, _RpcDataSource_getExistingAssetsMetadata, _RpcDataSource_getTokenMetadataFromTokenList;
 import { Web3Provider } from "@ethersproject/providers";
-import { BaseController } from "@metamask/base-controller";
 import { toHex } from "@metamask/controller-utils";
-import { isStrictHexString, isCaipChainId, parseCaipChainId } from "@metamask/utils";
+import { isStrictHexString, isCaipChainId, numberToHex, parseCaipAssetType, parseCaipChainId } from "@metamask/utils";
 import BigNumberJS from "bignumber.js";
+import { AbstractDataSource } from "./AbstractDataSource.mjs";
 import { BalanceFetcher, MulticallClient, TokenDetector } from "./evm-rpc-services/index.mjs";
 import { projectLogger, createModuleLogger } from "../logger.mjs";
 const CONTROLLER_NAME = 'RpcDataSource';
@@ -54,17 +54,15 @@ export const caipChainIdToHex = (chainId) => {
  * - RpcDataSource:activeChainsUpdated
  * - RpcDataSource:assetsUpdated
  */
-export class RpcDataSource extends BaseController {
+export class RpcDataSource extends AbstractDataSource {
     constructor(options) {
-        super({
-            name: CONTROLLER_NAME,
-            metadata: {},
-            state: {},
-            messenger: options.messenger,
-        });
+        super(CONTROLLER_NAME, { activeChains: [] });
         _RpcDataSource_instances.add(this);
+        _RpcDataSource_messenger.set(this, void 0);
+        _RpcDataSource_onActiveChainsUpdated.set(this, void 0);
         _RpcDataSource_timeout.set(this, void 0);
         _RpcDataSource_tokenDetectionEnabled.set(this, void 0);
+        _RpcDataSource_useExternalService.set(this, void 0);
         /** Currently active chains */
         _RpcDataSource_activeChains.set(this, []);
         /** Network status for each active chain */
@@ -73,19 +71,25 @@ export class RpcDataSource extends BaseController {
         _RpcDataSource_providerCache.set(this, new Map());
         /** Active subscriptions by ID */
         _RpcDataSource_activeSubscriptions.set(this, new Map());
+        _RpcDataSource_unsubscribeTransactionConfirmed.set(this, undefined);
+        _RpcDataSource_unsubscribeIncomingTransactions.set(this, undefined);
         // Rpc-datasource components
         _RpcDataSource_multicallClient.set(this, void 0);
         _RpcDataSource_balanceFetcher.set(this, void 0);
         _RpcDataSource_tokenDetector.set(this, void 0);
+        __classPrivateFieldSet(this, _RpcDataSource_messenger, options.messenger, "f");
+        __classPrivateFieldSet(this, _RpcDataSource_onActiveChainsUpdated, options.onActiveChainsUpdated, "f");
         __classPrivateFieldSet(this, _RpcDataSource_timeout, options.timeout ?? 10000, "f");
-        __classPrivateFieldSet(this, _RpcDataSource_tokenDetectionEnabled, options.tokenDetectionEnabled ?? false, "f");
+        __classPrivateFieldSet(this, _RpcDataSource_tokenDetectionEnabled, options.tokenDetectionEnabled ?? (() => true), "f");
+        __classPrivateFieldSet(this, _RpcDataSource_useExternalService, options.useExternalService ?? (() => true), "f");
         const balanceInterval = options.balanceInterval ?? DEFAULT_BALANCE_INTERVAL;
         const detectionInterval = options.detectionInterval ?? DEFAULT_DETECTION_INTERVAL;
         log('Initializing RpcDataSource', {
             timeout: __classPrivateFieldGet(this, _RpcDataSource_timeout, "f"),
             balanceInterval,
             detectionInterval,
-            tokenDetectionEnabled: __classPrivateFieldGet(this, _RpcDataSource_tokenDetectionEnabled, "f"),
+            tokenDetectionEnabled: __classPrivateFieldGet(this, _RpcDataSource_tokenDetectionEnabled, "f").call(this),
+            useExternalService: __classPrivateFieldGet(this, _RpcDataSource_useExternalService, "f").call(this),
         });
         // Initialize MulticallClient with a provider getter
         __classPrivateFieldSet(this, _RpcDataSource_multicallClient, new MulticallClient((hexChainId) => {
@@ -94,7 +98,7 @@ export class RpcDataSource extends BaseController {
         // Create messenger adapters for BalanceFetcher and TokenDetector
         const balanceFetcherMessenger = {
             call: (_action) => {
-                const state = this.messenger.call('AssetsController:getState');
+                const state = __classPrivateFieldGet(this, _RpcDataSource_messenger, "f").call('AssetsController:getState');
                 return {
                     assetsBalance: (state.assetsBalance ?? {}),
                 };
@@ -102,17 +106,21 @@ export class RpcDataSource extends BaseController {
         };
         const tokenDetectorMessenger = {
             call: (_action) => {
-                return this.messenger.call('TokenListController:getState');
+                return __classPrivateFieldGet(this, _RpcDataSource_messenger, "f").call('TokenListController:getState');
             },
         };
         // Initialize BalanceFetcher with polling interval
         __classPrivateFieldSet(this, _RpcDataSource_balanceFetcher, new BalanceFetcher(__classPrivateFieldGet(this, _RpcDataSource_multicallClient, "f"), balanceFetcherMessenger, { pollingInterval: balanceInterval }), "f");
         __classPrivateFieldGet(this, _RpcDataSource_balanceFetcher, "f").setOnBalanceUpdate(__classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_handleBalanceUpdate).bind(this));
         // Initialize TokenDetector with polling interval
-        __classPrivateFieldSet(this, _RpcDataSource_tokenDetector, new TokenDetector(__classPrivateFieldGet(this, _RpcDataSource_multicallClient, "f"), tokenDetectorMessenger, { pollingInterval: detectionInterval }), "f");
+        __classPrivateFieldSet(this, _RpcDataSource_tokenDetector, new TokenDetector(__classPrivateFieldGet(this, _RpcDataSource_multicallClient, "f"), tokenDetectorMessenger, {
+            pollingInterval: detectionInterval,
+            tokenDetectionEnabled: __classPrivateFieldGet(this, _RpcDataSource_tokenDetectionEnabled, "f"),
+            useExternalService: __classPrivateFieldGet(this, _RpcDataSource_useExternalService, "f"),
+        }), "f");
         __classPrivateFieldGet(this, _RpcDataSource_tokenDetector, "f").setOnDetectionUpdate(__classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_handleDetectionUpdate).bind(this));
-        __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_registerActionHandlers).call(this);
         __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_subscribeToNetworkController).call(this);
+        __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_subscribeToTransactionEvents).call(this);
         __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_initializeFromNetworkController).call(this);
     }
     /**
@@ -120,17 +128,6 @@ export class RpcDataSource extends BaseController {
      *
      * @returns The name of this data source.
      */
-    getName() {
-        return this.name;
-    }
-    /**
-     * Get currently active chains.
-     *
-     * @returns Promise resolving to array of active chain IDs.
-     */
-    async getActiveChains() {
-        return __classPrivateFieldGet(this, _RpcDataSource_activeChains, "f");
-    }
     /**
      * Get the status of all configured chains.
      *
@@ -186,7 +183,7 @@ export class RpcDataSource extends BaseController {
         const response = {};
         const chainsToFetch = request.chainIds.filter((chainId) => __classPrivateFieldGet(this, _RpcDataSource_activeChains, "f").includes(chainId));
         log('Fetch requested', {
-            accounts: request.accounts.map((a) => a.id),
+            accounts: request.accountsWithSupportedChains.map((a) => a.account.id),
             requestedChains: request.chainIds,
             chainsToFetch,
         });
@@ -195,16 +192,17 @@ export class RpcDataSource extends BaseController {
             return response;
         }
         const assetsBalance = {};
-        const assetsMetadata = {};
+        const assetsInfo = {};
         const failedChains = [];
-        // Fetch balances for each chain using BalanceFetcher
-        for (const chainId of chainsToFetch) {
-            const hexChainId = caipChainIdToHex(chainId);
-            for (const account of request.accounts) {
-                if (!__classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_accountSupportsChain).call(this, account, chainId)) {
-                    continue;
-                }
-                const { address, id: accountId } = account;
+        // Fetch balances for each account and its supported chains (pre-computed in request)
+        for (const { account, supportedChains, } of request.accountsWithSupportedChains) {
+            const chainsForAccount = chainsToFetch.filter((chain) => supportedChains.includes(chain));
+            if (chainsForAccount.length === 0) {
+                continue;
+            }
+            const { address, id: accountId } = account;
+            for (const chainId of chainsForAccount) {
+                const hexChainId = caipChainIdToHex(chainId);
                 try {
                     // Use BalanceFetcher for batched balance fetching
                     const result = await __classPrivateFieldGet(this, _RpcDataSource_balanceFetcher, "f").fetchBalancesForTokens(hexChainId, accountId, address, [], // Empty array means just native token
@@ -214,10 +212,10 @@ export class RpcDataSource extends BaseController {
                     }
                     // Collect metadata for all balances
                     const balanceMetadata = __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_collectMetadataForBalances).call(this, result.balances, chainId);
-                    Object.assign(assetsMetadata, balanceMetadata);
+                    Object.assign(assetsInfo, balanceMetadata);
                     // Convert balances to human-readable format
                     for (const balance of result.balances) {
-                        const metadata = assetsMetadata[balance.assetId];
+                        const metadata = assetsInfo[balance.assetId];
                         // Default to 18 decimals (ERC20 standard) for consistent human-readable format
                         const decimals = metadata?.decimals ?? 18;
                         const humanReadableAmount = __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_convertToHumanReadable).call(this, balance.balance, decimals);
@@ -236,7 +234,7 @@ export class RpcDataSource extends BaseController {
                     // Even on error, include native token metadata
                     const chainStatus = __classPrivateFieldGet(this, _RpcDataSource_chainStatuses, "f")[chainId];
                     if (chainStatus) {
-                        assetsMetadata[nativeAssetId] = {
+                        assetsInfo[nativeAssetId] = {
                             type: 'native',
                             symbol: chainStatus.nativeCurrency,
                             name: chainStatus.nativeCurrency,
@@ -267,8 +265,8 @@ export class RpcDataSource extends BaseController {
         }
         response.assetsBalance = assetsBalance;
         // Include metadata for native tokens if we have any
-        if (Object.keys(assetsMetadata).length > 0) {
-            response.assetsMetadata = assetsMetadata;
+        if (Object.keys(assetsInfo).length > 0) {
+            response.assetsInfo = assetsInfo;
         }
         return response;
     }
@@ -280,14 +278,17 @@ export class RpcDataSource extends BaseController {
      * @returns Promise resolving to a DataResponse with detected assets.
      */
     async detectTokens(chainId, account) {
-        if (!__classPrivateFieldGet(this, _RpcDataSource_tokenDetectionEnabled, "f")) {
+        if (!__classPrivateFieldGet(this, _RpcDataSource_tokenDetectionEnabled, "f").call(this) || !__classPrivateFieldGet(this, _RpcDataSource_useExternalService, "f").call(this)) {
             return {};
         }
         const hexChainId = caipChainIdToHex(chainId);
         const { address, id: accountId } = account;
         log('Running token detection', { chainId, accountId });
         try {
-            const result = await __classPrivateFieldGet(this, _RpcDataSource_tokenDetector, "f").detectTokens(hexChainId, accountId, address);
+            const result = await __classPrivateFieldGet(this, _RpcDataSource_tokenDetector, "f").detectTokens(hexChainId, accountId, address, {
+                tokenDetectionEnabled: __classPrivateFieldGet(this, _RpcDataSource_tokenDetectionEnabled, "f").call(this),
+                useExternalService: __classPrivateFieldGet(this, _RpcDataSource_useExternalService, "f").call(this),
+            });
             if (result.detectedAssets.length === 0) {
                 log('No new tokens detected');
                 return {};
@@ -299,11 +300,11 @@ export class RpcDataSource extends BaseController {
             });
             // Convert detected assets to DataResponse format
             const balances = {};
-            const assetsMetadata = {};
+            const assetsInfo = {};
             // Build metadata from detected assets
             for (const asset of result.detectedAssets) {
                 if (asset.symbol && asset.decimals !== undefined) {
-                    assetsMetadata[asset.assetId] = {
+                    assetsInfo[asset.assetId] = {
                         type: 'erc20',
                         symbol: asset.symbol,
                         name: asset.name ?? asset.symbol,
@@ -331,8 +332,8 @@ export class RpcDataSource extends BaseController {
                 },
             };
             // Include metadata if we have any
-            if (Object.keys(assetsMetadata).length > 0) {
-                response.assetsMetadata = assetsMetadata;
+            if (Object.keys(assetsInfo).length > 0) {
+                response.assetsInfo = assetsInfo;
             }
             return response;
         }
@@ -352,7 +353,7 @@ export class RpcDataSource extends BaseController {
             let successfullyHandledChains = [];
             log('Middleware fetching', {
                 chains: supportedChains,
-                accounts: request.accounts.map((a) => a.id),
+                accounts: request.accountsWithSupportedChains.map((a) => a.account.id),
             });
             const response = await this.fetch({
                 ...request,
@@ -368,11 +369,11 @@ export class RpcDataSource extends BaseController {
                     };
                 }
             }
-            if (response.assetsMetadata) {
-                (_c = context.response).assetsMetadata ?? (_c.assetsMetadata = {});
-                context.response.assetsMetadata = {
-                    ...context.response.assetsMetadata,
-                    ...response.assetsMetadata,
+            if (response.assetsInfo) {
+                (_c = context.response).assetsInfo ?? (_c.assetsInfo = {});
+                context.response.assetsInfo = {
+                    ...context.response.assetsInfo,
+                    ...response.assetsInfo,
                 };
             }
             const failedChains = new Set(Object.keys(response.errors ?? {}));
@@ -402,7 +403,7 @@ export class RpcDataSource extends BaseController {
         log('Subscribe requested', {
             subscriptionId,
             isUpdate,
-            accounts: request.accounts.map((a) => a.id),
+            accounts: request.accountsWithSupportedChains.map((a) => a.account.id),
             chainsToSubscribe,
         });
         if (chainsToSubscribe.length === 0) {
@@ -423,16 +424,17 @@ export class RpcDataSource extends BaseController {
         }
         // Clean up existing subscription (stops old polling)
         await this.unsubscribe(subscriptionId);
-        // Start polling through BalanceFetcher and TokenDetector
+        // Start polling through BalanceFetcher and TokenDetector (use pre-computed supportedChains per account)
         const balancePollingTokens = [];
         const detectionPollingTokens = [];
-        for (const chainId of chainsToSubscribe) {
-            const hexChainId = caipChainIdToHex(chainId);
-            for (const account of request.accounts) {
-                if (!__classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_accountSupportsChain).call(this, account, chainId)) {
-                    continue;
-                }
-                const { address, id: accountId } = account;
+        for (const { account, supportedChains, } of request.accountsWithSupportedChains) {
+            const chainsForAccount = chainsToSubscribe.filter((chain) => supportedChains.includes(chain));
+            if (chainsForAccount.length === 0) {
+                continue;
+            }
+            const { address, id: accountId } = account;
+            for (const chainId of chainsForAccount) {
+                const hexChainId = caipChainIdToHex(chainId);
                 // Start balance polling
                 const balanceInput = {
                     chainId: hexChainId,
@@ -441,8 +443,8 @@ export class RpcDataSource extends BaseController {
                 };
                 const balanceToken = __classPrivateFieldGet(this, _RpcDataSource_balanceFetcher, "f").startPolling(balanceInput);
                 balancePollingTokens.push(balanceToken);
-                // Start detection polling if enabled
-                if (__classPrivateFieldGet(this, _RpcDataSource_tokenDetectionEnabled, "f")) {
+                // Start detection polling if enabled and external services allowed
+                if (__classPrivateFieldGet(this, _RpcDataSource_tokenDetectionEnabled, "f").call(this) && __classPrivateFieldGet(this, _RpcDataSource_useExternalService, "f").call(this)) {
                     const detectionInput = {
                         chainId: hexChainId,
                         accountId,
@@ -454,11 +456,13 @@ export class RpcDataSource extends BaseController {
             }
         }
         // Store subscription data
+        const accounts = request.accountsWithSupportedChains.map((entry) => entry.account);
         __classPrivateFieldGet(this, _RpcDataSource_activeSubscriptions, "f").set(subscriptionId, {
             balancePollingTokens,
             detectionPollingTokens,
             chains: chainsToSubscribe,
-            accounts: request.accounts,
+            accounts,
+            onAssetsUpdate: subscriptionRequest.onAssetsUpdate,
         });
         log('Subscription SUCCESS', {
             subscriptionId,
@@ -492,6 +496,8 @@ export class RpcDataSource extends BaseController {
      */
     destroy() {
         log('Destroying RpcDataSource');
+        __classPrivateFieldGet(this, _RpcDataSource_unsubscribeTransactionConfirmed, "f")?.call(this);
+        __classPrivateFieldGet(this, _RpcDataSource_unsubscribeIncomingTransactions, "f")?.call(this);
         // Stop all polling
         __classPrivateFieldGet(this, _RpcDataSource_balanceFetcher, "f").stopAllPolling();
         __classPrivateFieldGet(this, _RpcDataSource_tokenDetector, "f").stopAllPolling();
@@ -501,19 +507,19 @@ export class RpcDataSource extends BaseController {
         __classPrivateFieldGet(this, _RpcDataSource_providerCache, "f").clear();
     }
 }
-_RpcDataSource_timeout = new WeakMap(), _RpcDataSource_tokenDetectionEnabled = new WeakMap(), _RpcDataSource_activeChains = new WeakMap(), _RpcDataSource_chainStatuses = new WeakMap(), _RpcDataSource_providerCache = new WeakMap(), _RpcDataSource_activeSubscriptions = new WeakMap(), _RpcDataSource_multicallClient = new WeakMap(), _RpcDataSource_balanceFetcher = new WeakMap(), _RpcDataSource_tokenDetector = new WeakMap(), _RpcDataSource_instances = new WeakSet(), _RpcDataSource_convertToHumanReadable = function _RpcDataSource_convertToHumanReadable(rawBalance, decimals) {
+_RpcDataSource_messenger = new WeakMap(), _RpcDataSource_onActiveChainsUpdated = new WeakMap(), _RpcDataSource_timeout = new WeakMap(), _RpcDataSource_tokenDetectionEnabled = new WeakMap(), _RpcDataSource_useExternalService = new WeakMap(), _RpcDataSource_activeChains = new WeakMap(), _RpcDataSource_chainStatuses = new WeakMap(), _RpcDataSource_providerCache = new WeakMap(), _RpcDataSource_activeSubscriptions = new WeakMap(), _RpcDataSource_unsubscribeTransactionConfirmed = new WeakMap(), _RpcDataSource_unsubscribeIncomingTransactions = new WeakMap(), _RpcDataSource_multicallClient = new WeakMap(), _RpcDataSource_balanceFetcher = new WeakMap(), _RpcDataSource_tokenDetector = new WeakMap(), _RpcDataSource_instances = new WeakSet(), _RpcDataSource_convertToHumanReadable = function _RpcDataSource_convertToHumanReadable(rawBalance, decimals) {
     const rawAmount = new BigNumberJS(rawBalance);
     const divisor = new BigNumberJS(10).pow(decimals);
     return rawAmount.dividedBy(divisor).toString();
 }, _RpcDataSource_collectMetadataForBalances = function _RpcDataSource_collectMetadataForBalances(balances, chainId) {
-    const assetsMetadata = {};
+    const assetsInfo = {};
     const existingMetadata = __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_getExistingAssetsMetadata).call(this);
     for (const balance of balances) {
         const isNative = balance.assetId.includes('/slip44:');
         if (isNative) {
             const chainStatus = __classPrivateFieldGet(this, _RpcDataSource_chainStatuses, "f")[chainId];
             if (chainStatus) {
-                assetsMetadata[balance.assetId] = {
+                assetsInfo[balance.assetId] = {
                     type: 'native',
                     symbol: chainStatus.nativeCurrency,
                     name: chainStatus.nativeCurrency,
@@ -525,19 +531,19 @@ _RpcDataSource_timeout = new WeakMap(), _RpcDataSource_tokenDetectionEnabled = n
             // For ERC20 tokens, try existing metadata from state first
             const existingMeta = existingMetadata[balance.assetId];
             if (existingMeta) {
-                assetsMetadata[balance.assetId] = existingMeta;
+                assetsInfo[balance.assetId] = existingMeta;
             }
             else {
                 // Fallback to token list if not in state
                 const tokenListMeta = __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_getTokenMetadataFromTokenList).call(this, balance.assetId);
                 if (tokenListMeta) {
-                    assetsMetadata[balance.assetId] = tokenListMeta;
+                    assetsInfo[balance.assetId] = tokenListMeta;
                 }
                 else {
                     // Default metadata for unknown ERC20 tokens.
                     // Use 18 decimals (the standard for most ERC20 tokens)
                     // to ensure consistent human-readable balance format.
-                    assetsMetadata[balance.assetId] = {
+                    assetsInfo[balance.assetId] = {
                         type: 'erc20',
                         symbol: '',
                         name: '',
@@ -547,17 +553,17 @@ _RpcDataSource_timeout = new WeakMap(), _RpcDataSource_tokenDetectionEnabled = n
             }
         }
     }
-    return assetsMetadata;
+    return assetsInfo;
 }, _RpcDataSource_handleBalanceUpdate = function _RpcDataSource_handleBalanceUpdate(result) {
     const newBalances = {};
     // Convert hex chain ID to CAIP-2 format
     const chainIdDecimal = parseInt(result.chainId, 16);
     const caipChainId = `eip155:${chainIdDecimal}`;
     // Collect metadata for all balances
-    const assetsMetadata = __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_collectMetadataForBalances).call(this, result.balances, caipChainId);
+    const assetsInfo = __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_collectMetadataForBalances).call(this, result.balances, caipChainId);
     // Convert balances to human-readable format using metadata
     for (const balance of result.balances) {
-        const metadata = assetsMetadata[balance.assetId];
+        const metadata = assetsInfo[balance.assetId];
         // Default to 18 decimals (ERC20 standard) for consistent human-readable format
         const decimals = metadata?.decimals ?? 18;
         const humanReadableAmount = __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_convertToHumanReadable).call(this, balance.balance, decimals);
@@ -571,17 +577,17 @@ _RpcDataSource_timeout = new WeakMap(), _RpcDataSource_tokenDetectionEnabled = n
         assetsBalance: {
             [result.accountId]: newBalances,
         },
-        assetsMetadata,
+        assetsInfo,
     };
     log('Balance update response', {
         accountId: result.accountId,
         newBalanceCount: Object.keys(newBalances).length,
     });
-    this.messenger
-        .call('AssetsController:assetsUpdate', response, CONTROLLER_NAME)
-        .catch((error) => {
-        log('Failed to update assets', { error });
-    });
+    for (const subscription of __classPrivateFieldGet(this, _RpcDataSource_activeSubscriptions, "f").values()) {
+        subscription.onAssetsUpdate(response)?.catch((error) => {
+            log('Failed to update assets', { error });
+        });
+    }
 }, _RpcDataSource_handleDetectionUpdate = function _RpcDataSource_handleDetectionUpdate(result) {
     log('Detected new tokens', {
         count: result.detectedAssets.length,
@@ -622,37 +628,93 @@ _RpcDataSource_timeout = new WeakMap(), _RpcDataSource_tokenDetectionEnabled = n
         detectedAssets: {
             [result.accountId]: result.detectedAssets.map((asset) => asset.assetId),
         },
-        assetsMetadata: newMetadata,
+        assetsInfo: newMetadata,
         assetsBalance: {
             [result.accountId]: newBalances,
         },
     };
-    this.messenger
-        .call('AssetsController:assetsUpdate', response, CONTROLLER_NAME)
-        .catch((error) => {
-        log('Failed to update detected assets', { error });
-    });
-}, _RpcDataSource_registerActionHandlers = function _RpcDataSource_registerActionHandlers() {
-    const getAssetsMiddlewareHandler = () => this.assetsMiddleware;
-    const getActiveChainsHandler = async () => this.getActiveChains();
-    const fetchHandler = async (request) => this.fetch(request);
-    const subscribeHandler = async (request) => this.subscribe(request);
-    const unsubscribeHandler = async (subscriptionId) => this.unsubscribe(subscriptionId);
-    this.messenger.registerActionHandler('RpcDataSource:getAssetsMiddleware', getAssetsMiddlewareHandler);
-    this.messenger.registerActionHandler('RpcDataSource:getActiveChains', getActiveChainsHandler);
-    this.messenger.registerActionHandler('RpcDataSource:fetch', fetchHandler);
-    this.messenger.registerActionHandler('RpcDataSource:subscribe', subscribeHandler);
-    this.messenger.registerActionHandler('RpcDataSource:unsubscribe', unsubscribeHandler);
+    for (const subscription of __classPrivateFieldGet(this, _RpcDataSource_activeSubscriptions, "f").values()) {
+        subscription.onAssetsUpdate(response)?.catch((error) => {
+            log('Failed to update detected assets', { error });
+        });
+    }
 }, _RpcDataSource_subscribeToNetworkController = function _RpcDataSource_subscribeToNetworkController() {
-    this.messenger.subscribe('NetworkController:stateChange', (networkState) => {
+    __classPrivateFieldGet(this, _RpcDataSource_messenger, "f").subscribe('NetworkController:stateChange', (networkState) => {
         log('NetworkController state changed');
         __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_clearProviderCache).call(this);
         __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_updateFromNetworkState).call(this, networkState);
     });
+}, _RpcDataSource_subscribeToTransactionEvents = function _RpcDataSource_subscribeToTransactionEvents() {
+    const unsubConfirmed = __classPrivateFieldGet(this, _RpcDataSource_messenger, "f").subscribe('TransactionController:transactionConfirmed', __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_onTransactionConfirmed).bind(this));
+    __classPrivateFieldSet(this, _RpcDataSource_unsubscribeTransactionConfirmed, typeof unsubConfirmed === 'function' ? unsubConfirmed : undefined, "f");
+    const unsubIncoming = __classPrivateFieldGet(this, _RpcDataSource_messenger, "f").subscribe('TransactionController:incomingTransactionsReceived', __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_onIncomingTransactions).bind(this));
+    __classPrivateFieldSet(this, _RpcDataSource_unsubscribeIncomingTransactions, typeof unsubIncoming === 'function' ? unsubIncoming : undefined, "f");
+}, _RpcDataSource_onTransactionConfirmed = function _RpcDataSource_onTransactionConfirmed(payload) {
+    const hexChainId = payload?.chainId;
+    if (!hexChainId) {
+        return;
+    }
+    const caipChainId = `eip155:${parseInt(hexChainId, 16)}`;
+    __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_refreshBalanceForChains).call(this, [caipChainId]).catch((error) => {
+        log('Failed to refresh balance after transaction confirmed', { error });
+    });
+}, _RpcDataSource_onIncomingTransactions = function _RpcDataSource_onIncomingTransactions(payload) {
+    const chainIds = Array.from(new Set((payload ?? [])
+        .map((item) => item?.chainId)
+        .filter((id) => Boolean(id))));
+    const caipChainIds = chainIds.map((hexChainId) => `eip155:${parseInt(hexChainId, 16)}`);
+    const toRefresh = caipChainIds.length > 0 ? caipChainIds : [...__classPrivateFieldGet(this, _RpcDataSource_activeChains, "f")];
+    __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_refreshBalanceForChains).call(this, toRefresh).catch((error) => {
+        log('Failed to refresh balance after incoming transactions', { error });
+    });
+}, _RpcDataSource_refreshBalanceForChains = 
+/**
+ * Fetch balances for the given chains across all active subscriptions and
+ * push updates to the controller.
+ *
+ * @param chainIds - CAIP-2 chain IDs to refresh.
+ */
+async function _RpcDataSource_refreshBalanceForChains(chainIds) {
+    const chainIdsSet = new Set(chainIds);
+    const chainsToFetch = chainIds.filter((chainId) => __classPrivateFieldGet(this, _RpcDataSource_activeChains, "f").includes(chainId));
+    if (chainsToFetch.length === 0) {
+        return;
+    }
+    for (const subscription of __classPrivateFieldGet(this, _RpcDataSource_activeSubscriptions, "f").values()) {
+        const subscriptionChains = subscription.chains.filter((chainId) => chainIdsSet.has(chainId));
+        if (subscriptionChains.length === 0) {
+            continue;
+        }
+        const request = {
+            accountsWithSupportedChains: subscription.accounts.map((account) => ({
+                account,
+                supportedChains: subscriptionChains,
+            })),
+            chainIds: subscriptionChains,
+            dataTypes: ['balance'],
+        };
+        try {
+            const response = await this.fetch(request);
+            if (response.assetsBalance &&
+                Object.keys(response.assetsBalance).length > 0) {
+                subscription.onAssetsUpdate(response)?.catch((error) => {
+                    log('Failed to report balance update after transaction', {
+                        error,
+                    });
+                });
+            }
+        }
+        catch (error) {
+            log('Failed to fetch balance after transaction', {
+                chains: subscriptionChains,
+                error,
+            });
+        }
+    }
 }, _RpcDataSource_initializeFromNetworkController = function _RpcDataSource_initializeFromNetworkController() {
     log('Initializing from NetworkController');
     try {
-        const networkState = this.messenger.call('NetworkController:getState');
+        const networkState = __classPrivateFieldGet(this, _RpcDataSource_messenger, "f").call('NetworkController:getState');
         __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_updateFromNetworkState).call(this, networkState);
     }
     catch (error) {
@@ -688,14 +750,18 @@ _RpcDataSource_timeout = new WeakMap(), _RpcDataSource_tokenDetectionEnabled = n
         activeChains,
     });
     // Check if chains changed
-    const previousChains = new Set(__classPrivateFieldGet(this, _RpcDataSource_activeChains, "f"));
-    const hasChanges = previousChains.size !== activeChains.length ||
-        activeChains.some((chain) => !previousChains.has(chain));
-    // Update internal state
+    const previousChains = [...__classPrivateFieldGet(this, _RpcDataSource_activeChains, "f")];
+    const previousSet = new Set(previousChains);
+    const hasChanges = previousChains.length !== activeChains.length ||
+        activeChains.some((chain) => !previousSet.has(chain));
+    // Update internal state and data source state before notifying, so that
+    // when the controller handles the callback and calls getActiveChainsSync(),
+    // it receives the updated chains (same order as AbstractDataSource.updateActiveChains).
     __classPrivateFieldSet(this, _RpcDataSource_chainStatuses, chainStatuses, "f");
     __classPrivateFieldSet(this, _RpcDataSource_activeChains, activeChains, "f");
+    this.state.activeChains = activeChains;
     if (hasChanges) {
-        this.messenger.call('AssetsController:activeChainsUpdate', CONTROLLER_NAME, activeChains);
+        __classPrivateFieldGet(this, _RpcDataSource_onActiveChainsUpdated, "f").call(this, this.getName(), activeChains, previousChains);
     }
 }, _RpcDataSource_getProvider = function _RpcDataSource_getProvider(chainId) {
     const cached = __classPrivateFieldGet(this, _RpcDataSource_providerCache, "f").get(chainId);
@@ -707,7 +773,10 @@ _RpcDataSource_timeout = new WeakMap(), _RpcDataSource_tokenDetectionEnabled = n
         return undefined;
     }
     try {
-        const networkClient = this.messenger.call('NetworkController:getNetworkClientById', chainStatus.networkClientId);
+        const networkClient = __classPrivateFieldGet(this, _RpcDataSource_messenger, "f").call('NetworkController:getNetworkClientById', chainStatus.networkClientId);
+        if (!networkClient?.provider) {
+            return undefined;
+        }
         const web3Provider = new Web3Provider(networkClient.provider);
         __classPrivateFieldGet(this, _RpcDataSource_providerCache, "f").set(chainId, web3Provider);
         return web3Provider;
@@ -737,39 +806,14 @@ _RpcDataSource_timeout = new WeakMap(), _RpcDataSource_tokenDetectionEnabled = n
     };
 }, _RpcDataSource_clearProviderCache = function _RpcDataSource_clearProviderCache() {
     __classPrivateFieldGet(this, _RpcDataSource_providerCache, "f").clear();
-}, _RpcDataSource_accountSupportsChain = function _RpcDataSource_accountSupportsChain(account, chainId) {
-    const scopes = account.scopes ?? [];
-    if (scopes.length === 0) {
-        return true;
-    }
-    const [chainNamespace, chainReference] = chainId.split(':');
-    for (const scope of scopes) {
-        const [scopeNamespace, scopeReference] = scope.split(':');
-        if (scopeNamespace !== chainNamespace) {
-            continue;
-        }
-        // Wildcard scope (e.g., eip155:0) matches all chains in the namespace
-        if (scopeReference === '0') {
-            return true;
-        }
-        // RpcDataSource only handles eip155 (EVM) chains
-        // Normalize hex chain references (e.g., 0x1 -> 1) for comparison
-        const normalizedScopeRef = scopeReference?.startsWith('0x')
-            ? parseInt(scopeReference, 16).toString()
-            : scopeReference;
-        if (normalizedScopeRef === chainReference) {
-            return true;
-        }
-    }
-    return false;
 }, _RpcDataSource_buildNativeAssetId = function _RpcDataSource_buildNativeAssetId(chainId) {
-    const { nativeAssetIdentifiers } = this.messenger.call('NetworkEnablementController:getState');
+    const { nativeAssetIdentifiers } = __classPrivateFieldGet(this, _RpcDataSource_messenger, "f").call('NetworkEnablementController:getState');
     return (nativeAssetIdentifiers[chainId] ??
         `${chainId}/slip44:60`);
 }, _RpcDataSource_getExistingAssetsMetadata = function _RpcDataSource_getExistingAssetsMetadata() {
     try {
-        const state = this.messenger.call('AssetsController:getState');
-        return (state.assetsMetadata ?? {});
+        const state = __classPrivateFieldGet(this, _RpcDataSource_messenger, "f").call('AssetsController:getState');
+        return state.assetsInfo ?? {};
     }
     catch {
         // If AssetsController:getState fails, return empty metadata
@@ -777,17 +821,15 @@ _RpcDataSource_timeout = new WeakMap(), _RpcDataSource_tokenDetectionEnabled = n
     }
 }, _RpcDataSource_getTokenMetadataFromTokenList = function _RpcDataSource_getTokenMetadataFromTokenList(assetId) {
     try {
-        // Parse asset ID to get chain and token address
-        // Format: eip155:{chainId}/erc20:{address}
-        const [chainPart, assetPart] = assetId.split('/');
-        if (!assetPart?.startsWith('erc20:')) {
+        const parsed = parseCaipAssetType(assetId);
+        if (parsed.assetNamespace !== 'erc20') {
             return undefined;
         }
-        const tokenAddress = assetPart.slice(6); // Remove 'erc20:' prefix
-        const chainIdDecimal = chainPart.split(':')[1];
-        const hexChainId = `0x${parseInt(chainIdDecimal, 10).toString(16)}`;
-        const tokenListState = this.messenger.call('TokenListController:getState');
-        const chainCacheEntry = tokenListState.tokensChainsCache[hexChainId];
+        const tokenAddress = parsed.assetReference;
+        const { reference } = parseCaipChainId(parsed.chainId);
+        const hexChainId = numberToHex(parseInt(reference, 10));
+        const tokenListState = __classPrivateFieldGet(this, _RpcDataSource_messenger, "f").call('TokenListController:getState');
+        const chainCacheEntry = tokenListState?.tokensChainsCache?.[hexChainId];
         const chainTokenList = chainCacheEntry?.data;
         if (!chainTokenList) {
             return undefined;