@subwallet/extension-base 1.1.51-2 → 1.1.53-0

package/services/balance-service/helpers/subscribe/{balance.js → index.js}

@@ -3,9 +3,8 @@
 
 import { _AssetType } from '@subwallet/chain-list/types';
 import { APIItemState } from '@subwallet/extension-base/background/KoniTypes';
-import { state } from '@subwallet/extension-base/koni/background/handlers';
 import { _getSubstrateGenesisHash, _isChainEvmCompatible, _isPureEvmChain } from '@subwallet/extension-base/services/chain-service/utils';
-import { categoryAddresses } from '@subwallet/extension-base/utils';
+import { categoryAddresses, filterAssetsByChainAndType } from '@subwallet/extension-base/utils';
 import keyring from '@subwallet/ui-keyring';
 import { subscribeEVMBalance } from "./evm.js";
 import { subscribeSubstrateBalance } from "./substrate/index.js";
@@ -36,6 +35,8 @@ export const getAccountJsonByAddress = address => {
     return null;
   }
 };
+
+/** Filter addresses to subscribe by chain info */
 const filterAddress = (addresses, chainInfo) => {
   const isEvmChain = _isChainEvmCompatible(chainInfo);
   const [substrateAddresses, evmAddresses] = categoryAddresses(addresses);
@@ -66,38 +67,50 @@ const filterAddress = (addresses, chainInfo) => {
   }
 };
 
-// main subscription
-export function subscribeBalance(addresses, chainInfoMap, substrateApiMap, evmApiMap, callback) {
+// interface SubscribeBlanceOptions {
+//   addresses: string[];
+//   chains: string[];
+//   tokens: string[];
+//   chainInfoMap: Record<string, _ChainInfo>;
+//   substrateApiMap: Record<string, _SubstrateApi>;
+//   evmApiMap: Record<string, _EvmApi>;
+//   callback: (rs: BalanceItem[]) => void;
+// }
+
+// main subscription, use for multiple chains, multiple addresses and multiple tokens
+export function subscribeBalance(addresses, chains, tokens, _chainAssetMap, _chainInfoMap, substrateApiMap, evmApiMap, callback) {
+  // Filter chain and token
+  const chainAssetMap = Object.fromEntries(Object.entries(_chainAssetMap).filter(([token]) => tokens.includes(token)));
+  const chainInfoMap = Object.fromEntries(Object.entries(_chainInfoMap).filter(([chain]) => chains.includes(chain)));
+
   // Looping over each chain
-  const unsubList = Object.entries(chainInfoMap).map(async ([chainSlug, chainInfo]) => {
+  const unsubList = Object.values(chainInfoMap).map(async chainInfo => {
+    const chainSlug = chainInfo.slug;
     const [useAddresses, notSupportAddresses] = filterAddress(addresses, chainInfo);
     if (notSupportAddresses.length) {
-      const tokens = state.chainService.getAssetByChainAndType(chainSlug, [_AssetType.NATIVE, _AssetType.ERC20, _AssetType.PSP22, _AssetType.LOCAL]);
-      const assetSetting = await state.chainService.getAssetSettings();
-      const filtered = Object.values(tokens).filter(({
-        slug
-      }) => {
-        var _assetSetting$slug;
-        return (_assetSetting$slug = assetSetting[slug]) === null || _assetSetting$slug === void 0 ? void 0 : _assetSetting$slug.visible;
-      });
+      const tokens = filterAssetsByChainAndType(chainAssetMap, chainSlug, [_AssetType.NATIVE, _AssetType.ERC20, _AssetType.PSP22, _AssetType.LOCAL]);
       const now = new Date().getTime();
-      notSupportAddresses.forEach(address => {
-        const items = filtered.map(token => {
-          return {
-            address,
-            tokenSlug: token.slug,
-            free: '0',
-            locked: '0',
-            state: APIItemState.NOT_SUPPORT,
-            timestamp: now
-          };
-        });
+      Object.values(tokens).forEach(token => {
+        const items = notSupportAddresses.map(address => ({
+          address,
+          tokenSlug: token.slug,
+          free: '0',
+          locked: '0',
+          state: APIItemState.NOT_SUPPORT,
+          timestamp: now
+        }));
         callback(items);
       });
     }
+    const evmApi = evmApiMap[chainSlug];
     if (_isPureEvmChain(chainInfo)) {
-      const nativeTokenInfo = state.getNativeTokenInfo(chainSlug);
-      return subscribeEVMBalance(chainSlug, useAddresses, evmApiMap, callback, nativeTokenInfo);
+      return subscribeEVMBalance({
+        addresses: useAddresses,
+        assetMap: chainAssetMap,
+        callback,
+        chainInfo,
+        evmApi
+      });
     }
 
     // if (!useAddresses || useAddresses.length === 0 || _PURE_EVM_CHAINS.indexOf(chainSlug) > -1) {
@@ -117,8 +130,8 @@ export function subscribeBalance(addresses, chainInfoMap, substrateApiMap, evmAp
     //   return undefined;
     // }
 
-    const networkAPI = await substrateApiMap[chainSlug].isReady;
-    return subscribeSubstrateBalance(useAddresses, chainInfo, chainSlug, networkAPI, evmApiMap, callback);
+    const substrateApi = await substrateApiMap[chainSlug].isReady;
+    return subscribeSubstrateBalance(useAddresses, chainInfo, chainAssetMap, substrateApi, evmApi, callback);
   });
   return () => {
     unsubList.forEach(subProm => {

package/services/balance-service/helpers/subscribe/substrate/equilibrium.d.ts

@@ -1,4 +1,3 @@
-import { BalanceItem } from '@subwallet/extension-base/types';
-import { ApiPromise } from '@polkadot/api';
-export declare function subscribeEquilibriumTokenBalance(addresses: string[], chain: string, api: ApiPromise, callBack: (rs: BalanceItem[]) => void, includeNativeToken?: boolean): Promise<() => void>;
-export declare function subscribeEqBalanceAccountPallet(addresses: string[], chain: string, api: ApiPromise, callBack: (rs: BalanceItem[]) => void, includeNativeToken?: boolean): Promise<() => void>;
+import { SubscribeSubstratePalletBalance } from '@subwallet/extension-base/types';
+export declare const subscribeEquilibriumTokenBalance: ({ addresses, assetMap, callback, chainInfo, includeNativeToken, substrateApi }: SubscribeSubstratePalletBalance) => Promise<() => void>;
+export declare const subscribeEqBalanceAccountPallet: ({ addresses, assetMap, callback, chainInfo, includeNativeToken, substrateApi }: SubscribeSubstratePalletBalance) => Promise<() => void>;

package/services/balance-service/helpers/subscribe/substrate/equilibrium.js

@@ -3,15 +3,23 @@
 
 import { _AssetType } from '@subwallet/chain-list/types';
 import { APIItemState } from '@subwallet/extension-base/background/KoniTypes';
-import { state } from '@subwallet/extension-base/koni/background/handlers';
 import { _getTokenOnChainAssetId } from '@subwallet/extension-base/services/chain-service/utils';
+import { filterAssetsByChainAndType } from '@subwallet/extension-base/utils';
 import BigN from 'bignumber.js';
 import { BN, BN_ZERO } from '@polkadot/util';
-export async function subscribeEquilibriumTokenBalance(addresses, chain, api, callBack, includeNativeToken) {
+export const subscribeEquilibriumTokenBalance = async ({
+  addresses,
+  assetMap,
+  callback,
+  chainInfo,
+  includeNativeToken,
+  substrateApi
+}) => {
+  const chain = chainInfo.slug;
   const tokenTypes = includeNativeToken ? [_AssetType.NATIVE, _AssetType.LOCAL] : [_AssetType.LOCAL];
-  const tokenMap = state.getAssetByChainAndAsset(chain, tokenTypes);
+  const tokenMap = filterAssetsByChainAndType(assetMap, chain, tokenTypes);
   try {
-    const unsub = await api.query.system.account.multi(addresses, balances => {
+    const unsub = await substrateApi.query.system.account.multi(addresses, balances => {
       // Equilibrium customizes the SystemAccount pallet
       Object.values(tokenMap).forEach(tokenInfo => {
         const assetId = _getTokenOnChainAssetId(tokenInfo);
@@ -32,7 +40,7 @@ export async function subscribeEquilibriumTokenBalance(addresses, chain, api, ca
             tokenSlug: tokenInfo.slug
           };
         });
-        callBack(items);
+        callback(items);
       });
     });
     return () => {
@@ -50,22 +58,30 @@ export async function subscribeEquilibriumTokenBalance(addresses, chain, api, ca
           tokenSlug: tokenInfo.slug
         };
       });
-      callBack(items);
+      callback(items);
     });
     return () => {
       // Empty
     };
   }
-}
+};
 
 // eslint-disable-next-line @typescript-eslint/require-await
-export async function subscribeEqBalanceAccountPallet(addresses, chain, api, callBack, includeNativeToken) {
+export const subscribeEqBalanceAccountPallet = async ({
+  addresses,
+  assetMap,
+  callback,
+  chainInfo,
+  includeNativeToken,
+  substrateApi
+}) => {
+  const chain = chainInfo.slug;
   const tokenTypes = includeNativeToken ? [_AssetType.NATIVE, _AssetType.LOCAL] : [_AssetType.LOCAL];
-  const tokenMap = state.getAssetByChainAndAsset(chain, tokenTypes);
+  const tokenMap = filterAssetsByChainAndType(assetMap, chain, tokenTypes);
   const unsubList = Object.values(tokenMap).map(async tokenInfo => {
     try {
       const assetId = _getTokenOnChainAssetId(tokenInfo);
-      const unsub = await api.query.eqBalances.account.multi(addresses.map(address => [address, [assetId]]), balances => {
+      const unsub = await substrateApi.query.eqBalances.account.multi(addresses.map(address => [address, [assetId]]), balances => {
         const items = balances.map((balance, index) => {
           return {
             address: addresses[index],
@@ -76,7 +92,7 @@ export async function subscribeEqBalanceAccountPallet(addresses, chain, api, cal
             tokenSlug: tokenInfo.slug
           };
         });
-        callBack(items);
+        callback(items);
       });
       return unsub;
     } catch (err) {
@@ -91,7 +107,7 @@ export async function subscribeEqBalanceAccountPallet(addresses, chain, api, cal
           tokenSlug: tokenInfo.slug
         };
       });
-      callBack(items);
+      callback(items);
       return undefined;
     }
   });
@@ -102,4 +118,4 @@ export async function subscribeEqBalanceAccountPallet(addresses, chain, api, cal
       }).catch(console.error);
     });
   };
-}
+};

package/services/balance-service/helpers/subscribe/substrate/index.d.ts

@@ -1,4 +1,4 @@
-import { _ChainInfo } from '@subwallet/chain-list/types';
+import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
 import { _EvmApi, _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
 import { BalanceItem } from '@subwallet/extension-base/types';
-export declare function subscribeSubstrateBalance(addresses: string[], chainInfo: _ChainInfo, chain: string, networkAPI: _SubstrateApi, evmApiMap: Record<string, _EvmApi>, callBack: (rs: BalanceItem[]) => void): Promise<() => void>;
+export declare const subscribeSubstrateBalance: (addresses: string[], chainInfo: _ChainInfo, assetMap: Record<string, _ChainAsset>, substrateApi: _SubstrateApi, evmApi: _EvmApi, callback: (rs: BalanceItem[]) => void) => Promise<() => void>;

package/services/balance-service/helpers/subscribe/substrate/index.js

@@ -6,42 +6,63 @@ import { APIItemState } from '@subwallet/extension-base/background/KoniTypes';
 import { SUB_TOKEN_REFRESH_BALANCE_INTERVAL } from '@subwallet/extension-base/constants';
 import { getPSP22ContractPromise } from '@subwallet/extension-base/koni/api/tokens/wasm';
 import { getDefaultWeightV2 } from '@subwallet/extension-base/koni/api/tokens/wasm/utils';
-import { state } from '@subwallet/extension-base/koni/background/handlers';
-import { subscribeERC20Interval } from '@subwallet/extension-base/services/balance-service/helpers/subscribe/evm';
 import { _BALANCE_CHAIN_GROUP, _MANTA_ZK_CHAIN_GROUP, _ZK_ASSET_PREFIX } from '@subwallet/extension-base/services/chain-service/constants';
 import { _checkSmartContractSupportByChain, _getChainNativeTokenSlug, _getContractAddressOfToken, _getTokenOnChainAssetId, _getTokenOnChainInfo, _getXcmAssetMultilocation, _isBridgedToken, _isChainEvmCompatible, _isSubstrateRelayChain } from '@subwallet/extension-base/services/chain-service/utils';
+import { filterAssetsByChainAndType } from '@subwallet/extension-base/utils';
+import { combineLatest, Observable } from 'rxjs';
 import { BN, BN_ZERO } from '@polkadot/util';
+import { subscribeERC20Interval } from "../evm.js";
 import { subscribeEquilibriumTokenBalance } from "./equilibrium.js";
-export async function subscribeSubstrateBalance(addresses, chainInfo, chain, networkAPI, evmApiMap, callBack) {
+export const subscribeSubstrateBalance = async (addresses, chainInfo, assetMap, substrateApi, evmApi, callback) => {
   let unsubNativeToken;
-  if (!_BALANCE_CHAIN_GROUP.kintsugi.includes(chain) && !_BALANCE_CHAIN_GROUP.genshiro.includes(chain) && !_BALANCE_CHAIN_GROUP.equilibrium_parachain.includes(chain)) {
-    unsubNativeToken = await subscribeWithSystemAccountPallet(addresses, chainInfo, networkAPI.api, callBack);
-  }
   let unsubLocalToken;
   let unsubEvmContractToken;
   let unsubWasmContractToken;
   let unsubBridgedToken;
+  const chain = chainInfo.slug;
+  const baseParams = {
+    addresses,
+    chainInfo,
+    assetMap,
+    callback
+  };
+  const substrateParams = {
+    ...baseParams,
+    substrateApi: substrateApi.api
+  };
+  if (!_BALANCE_CHAIN_GROUP.kintsugi.includes(chain) && !_BALANCE_CHAIN_GROUP.genshiro.includes(chain) && !_BALANCE_CHAIN_GROUP.equilibrium_parachain.includes(chain)) {
+    unsubNativeToken = await subscribeWithSystemAccountPallet(substrateParams);
+  }
   try {
     if (_BALANCE_CHAIN_GROUP.bifrost.includes(chain)) {
-      unsubLocalToken = await subscribeTokensAccountsPallet(addresses, chain, networkAPI.api, callBack);
+      unsubLocalToken = await subscribeTokensAccountsPallet(substrateParams);
     } else if (_BALANCE_CHAIN_GROUP.kintsugi.includes(chain)) {
-      unsubLocalToken = await subscribeTokensAccountsPallet(addresses, chain, networkAPI.api, callBack, true);
+      unsubLocalToken = await subscribeTokensAccountsPallet({
+        ...substrateParams,
+        includeNativeToken: true
+      });
     } else if (_BALANCE_CHAIN_GROUP.statemine.includes(chain)) {
-      unsubLocalToken = await subscribeAssetsAccountPallet(addresses, chain, networkAPI.api, callBack);
+      unsubLocalToken = await subscribeAssetsAccountPallet(substrateParams);
     } else if (_BALANCE_CHAIN_GROUP.genshiro.includes(chain) || _BALANCE_CHAIN_GROUP.equilibrium_parachain.includes(chain)) {
-      unsubLocalToken = await subscribeEquilibriumTokenBalance(addresses, chain, networkAPI.api, callBack, true);
+      unsubLocalToken = await subscribeEquilibriumTokenBalance({
+        ...substrateParams,
+        includeNativeToken: true
+      });
     } else if (_BALANCE_CHAIN_GROUP.centrifuge.includes(chain)) {
-      unsubLocalToken = await subscribeOrmlTokensPallet(addresses, chain, networkAPI.api, callBack);
+      unsubLocalToken = await subscribeOrmlTokensPallet(substrateParams);
     }
     if (_BALANCE_CHAIN_GROUP.supportBridged.includes(chain)) {
-      unsubBridgedToken = await subscribeBridgedBalance(addresses, chain, networkAPI.api, callBack);
+      unsubBridgedToken = await subscribeBridgedBalance(substrateParams);
     }
     if (_isChainEvmCompatible(chainInfo)) {
-      unsubEvmContractToken = subscribeERC20Interval(addresses, chain, evmApiMap, callBack);
+      unsubEvmContractToken = subscribeERC20Interval({
+        ...baseParams,
+        evmApi: evmApi
+      });
     }
     if (_checkSmartContractSupportByChain(chainInfo, _AssetType.PSP22)) {
       // Get sub-token for substrate-based chains
-      unsubWasmContractToken = subscribePSP22Balance(addresses, chain, networkAPI.api, callBack);
+      unsubWasmContractToken = subscribePSP22Balance(substrateParams);
     }
   } catch (err) {
     console.warn(err);
@@ -53,31 +74,51 @@ export async function subscribeSubstrateBalance(addresses, chainInfo, chain, net
     unsubWasmContractToken && unsubWasmContractToken();
     unsubBridgedToken && unsubBridgedToken();
   };
-}
+};
 
 // handler according to different logic
-async function subscribeWithSystemAccountPallet(addresses, chainInfo, networkAPI, callBack) {
+// eslint-disable-next-line @typescript-eslint/require-await
+const subscribeWithSystemAccountPallet = async ({
+  addresses,
+  callback,
+  chainInfo,
+  substrateApi
+}) => {
   const chainNativeTokenSlug = _getChainNativeTokenSlug(chainInfo);
-
-  // TODO: Need handle case error
-  const unsub = await networkAPI.query.system.account.multi(addresses, async balances => {
-    const pooledStakingBalances = [];
-    if (_isSubstrateRelayChain(chainInfo) && networkAPI.query.nominationPools) {
-      var _networkAPI$query$nom;
-      const poolMemberDatas = await ((_networkAPI$query$nom = networkAPI.query.nominationPools.poolMembers) === null || _networkAPI$query$nom === void 0 ? void 0 : _networkAPI$query$nom.multi(addresses));
-      if (poolMemberDatas) {
-        for (const _poolMemberData of poolMemberDatas) {
-          const poolMemberData = _poolMemberData.toPrimitive();
-          if (poolMemberData) {
-            let pooled = new BN(poolMemberData.points.toString());
-            Object.entries(poolMemberData.unbondingEras).forEach(([, amount]) => {
-              pooled = pooled.add(new BN(amount));
-            });
-            pooledStakingBalances.push(pooled);
-          } else {
-            pooledStakingBalances.push(BN_ZERO);
-          }
+  const balanceSubscribe = substrateApi.rx.query.system.account.multi(addresses);
+  let poolSubscribe;
+  if (_isSubstrateRelayChain(chainInfo) && substrateApi.query.nominationPools) {
+    var _substrateApi$rx$quer;
+    poolSubscribe = (_substrateApi$rx$quer = substrateApi.rx.query.nominationPools.poolMembers) === null || _substrateApi$rx$quer === void 0 ? void 0 : _substrateApi$rx$quer.multi(addresses);
+  }
+  if (!poolSubscribe) {
+    poolSubscribe = new Observable(subscriber => {
+      subscriber.next(addresses.map(() => ({
+        toPrimitive() {
+          return null;
         }
+      })));
+    });
+  }
+  const subscription = combineLatest({
+    balances: balanceSubscribe,
+    pools: poolSubscribe
+  }).subscribe(({
+    balances: _balances,
+    pools: poolMemberDatas
+  }) => {
+    const balances = _balances;
+    const pooledStakingBalances = [];
+    for (const _poolMemberData of poolMemberDatas) {
+      const poolMemberData = _poolMemberData.toPrimitive();
+      if (poolMemberData) {
+        let pooled = new BN(poolMemberData.points.toString());
+        Object.entries(poolMemberData.unbondingEras).forEach(([, amount]) => {
+          pooled = pooled.add(new BN(amount));
+        });
+        pooledStakingBalances.push(pooled);
+      } else {
+        pooledStakingBalances.push(BN_ZERO);
       }
     }
     const items = balances.map((balance, index) => {
@@ -109,14 +150,21 @@ async function subscribeWithSystemAccountPallet(addresses, chainInfo, networkAPI
         }
       };
     });
-    callBack(items);
+    callback(items);
   });
   return () => {
-    unsub();
+    subscription.unsubscribe();
   };
-}
-async function subscribeBridgedBalance(addresses, chain, api, callBack) {
-  const tokenMap = state.getAssetByChainAndAsset(chain, [_AssetType.LOCAL]);
+};
+const subscribeBridgedBalance = async ({
+  addresses,
+  assetMap,
+  callback,
+  chainInfo,
+  substrateApi
+}) => {
+  const chain = chainInfo.slug;
+  const tokenMap = filterAssetsByChainAndType(assetMap, chain, [_AssetType.LOCAL]);
 
   // @ts-ignore
   const unsubList = await Promise.all(Object.values(tokenMap).map(async tokenInfo => {
@@ -124,7 +172,7 @@ async function subscribeBridgedBalance(addresses, chain, api, callBack) {
       const isBridgedToken = _isBridgedToken(tokenInfo);
       if (isBridgedToken) {
         const multiLocation = _getXcmAssetMultilocation(tokenInfo);
-        return await api.query.foreignAssets.account.multi(addresses.map(address => [multiLocation, address]), balances => {
+        return await substrateApi.query.foreignAssets.account.multi(addresses.map(address => [multiLocation, address]), balances => {
           const items = balances.map((balance, index) => {
             const bdata = balance === null || balance === void 0 ? void 0 : balance.toHuman();
             let frozen = BN_ZERO;
@@ -154,7 +202,7 @@ async function subscribeBridgedBalance(addresses, chain, api, callBack) {
               }
             };
           });
-          callBack(items);
+          callback(items);
         });
       }
     } catch (err) {
@@ -167,10 +215,20 @@ async function subscribeBridgedBalance(addresses, chain, api, callBack) {
       unsub && unsub();
     });
   };
-}
-function subscribePSP22Balance(addresses, chain, api, callBack) {
-  let tokenList = {};
+};
+const subscribePSP22Balance = ({
+  addresses,
+  assetMap,
+  callback,
+  chainInfo,
+  substrateApi
+}) => {
+  const chain = chainInfo.slug;
   const psp22ContractMap = {};
+  const tokenList = filterAssetsByChainAndType(assetMap, chain, [_AssetType.PSP22]);
+  Object.entries(tokenList).forEach(([slug, tokenInfo]) => {
+    psp22ContractMap[slug] = getPSP22ContractPromise(substrateApi, _getContractAddressOfToken(tokenInfo));
+  });
   const getTokenBalances = () => {
     Object.values(tokenList).map(async tokenInfo => {
       try {
@@ -179,7 +237,7 @@ function subscribePSP22Balance(addresses, chain, api, callBack) {
           try {
             var _balanceOf$output, _ref;
             const _balanceOf = await contract.query['psp22::balanceOf'](address, {
-              gasLimit: getDefaultWeightV2(api)
+              gasLimit: getDefaultWeightV2(substrateApi)
             }, address);
             const balanceObj = _balanceOf === null || _balanceOf === void 0 ? void 0 : (_balanceOf$output = _balanceOf.output) === null || _balanceOf$output === void 0 ? void 0 : _balanceOf$output.toPrimitive();
             return {
@@ -200,26 +258,30 @@ function subscribePSP22Balance(addresses, chain, api, callBack) {
             };
           }
         }));
-        callBack(balances);
+        callback(balances);
       } catch (err) {
         console.warn(tokenInfo.slug, err); // TODO: error createType
       }
     });
   };
 
-  tokenList = state.getAssetByChainAndAsset(chain, [_AssetType.PSP22]);
-  Object.entries(tokenList).forEach(([slug, tokenInfo]) => {
-    psp22ContractMap[slug] = getPSP22ContractPromise(api, _getContractAddressOfToken(tokenInfo));
-  });
   getTokenBalances();
   const interval = setInterval(getTokenBalances, SUB_TOKEN_REFRESH_BALANCE_INTERVAL);
   return () => {
     clearInterval(interval);
   };
-}
-async function subscribeTokensAccountsPallet(addresses, chain, api, callBack, includeNativeToken) {
+};
+const subscribeTokensAccountsPallet = async ({
+  addresses,
+  assetMap,
+  callback,
+  chainInfo,
+  includeNativeToken,
+  substrateApi
+}) => {
+  const chain = chainInfo.slug;
   const tokenTypes = includeNativeToken ? [_AssetType.NATIVE, _AssetType.LOCAL] : [_AssetType.LOCAL];
-  const tokenMap = state.getAssetByChainAndAsset(chain, tokenTypes);
+  const tokenMap = filterAssetsByChainAndType(assetMap, chain, tokenTypes);
   const unsubList = await Promise.all(Object.values(tokenMap).map(async tokenInfo => {
     try {
       const onChainInfo = _getTokenOnChainInfo(tokenInfo);
@@ -227,7 +289,7 @@ async function subscribeTokensAccountsPallet(addresses, chain, api, callBack, in
 
       // Get Token Balance
       // @ts-ignore
-      return await api.query.tokens.accounts.multi(addresses.map(address => [address, onChainInfo || assetId]), balances => {
+      return await substrateApi.query.tokens.accounts.multi(addresses.map(address => [address, onChainInfo || assetId]), balances => {
         const items = balances.map((balance, index) => {
           const tokenBalance = {
             reserved: balance.reserved || new BN(0),
@@ -249,7 +311,7 @@ async function subscribeTokensAccountsPallet(addresses, chain, api, callBack, in
             }
           };
         });
-        callBack(items);
+        callback(items);
       });
     } catch (err) {
       console.warn(err);
@@ -261,9 +323,17 @@ async function subscribeTokensAccountsPallet(addresses, chain, api, callBack, in
       unsub && unsub();
     });
   };
-}
-async function subscribeAssetsAccountPallet(addresses, chain, api, callBack) {
-  const tokenMap = state.getAssetByChainAndAsset(chain, [_AssetType.LOCAL]);
+};
+const subscribeAssetsAccountPallet = async ({
+  addresses,
+  assetMap,
+  callback,
+  chainInfo,
+  includeNativeToken,
+  substrateApi
+}) => {
+  const chain = chainInfo.slug;
+  const tokenMap = filterAssetsByChainAndType(assetMap, chain, [_AssetType.LOCAL]);
   Object.values(tokenMap).forEach(token => {
     if (_MANTA_ZK_CHAIN_GROUP.includes(token.originChain) && token.symbol.startsWith(_ZK_ASSET_PREFIX)) {
       delete tokenMap[token.slug];
@@ -274,7 +344,7 @@ async function subscribeAssetsAccountPallet(addresses, chain, api, callBack) {
       const assetIndex = _getTokenOnChainAssetId(tokenInfo);
 
       // Get Token Balance
-      return await api.query.assets.account.multi(addresses.map(address => [assetIndex, address]), balances => {
+      return await substrateApi.query.assets.account.multi(addresses.map(address => [assetIndex, address]), balances => {
         const items = balances.map((balance, index) => {
           const bdata = balance === null || balance === void 0 ? void 0 : balance.toPrimitive();
           let frozen = BN_ZERO;
@@ -303,7 +373,7 @@ async function subscribeAssetsAccountPallet(addresses, chain, api, callBack) {
             }
           };
         });
-        callBack(items);
+        callback(items);
       });
     } catch (err) {
       console.warn(err);
@@ -315,19 +385,26 @@ async function subscribeAssetsAccountPallet(addresses, chain, api, callBack) {
       unsub && unsub();
     });
   };
-}
+};
 
 // eslint-disable-next-line @typescript-eslint/require-await
-async function subscribeOrmlTokensPallet(addresses, chain, api, callBack) {
+const subscribeOrmlTokensPallet = async ({
+  addresses,
+  assetMap,
+  callback,
+  chainInfo,
+  substrateApi
+}) => {
+  const chain = chainInfo.slug;
   const tokenTypes = [_AssetType.LOCAL];
-  const tokenMap = state.getAssetByChainAndAsset(chain, tokenTypes);
+  const tokenMap = filterAssetsByChainAndType(assetMap, chain, tokenTypes);
   const unsubList = Object.values(tokenMap).map(async tokenInfo => {
     try {
       const onChainInfo = _getTokenOnChainInfo(tokenInfo);
 
       // Get Token Balance
       // @ts-ignore
-      const unsub = await api.query.ormlTokens.accounts.multi(addresses.map(address => [address, onChainInfo]), balances => {
+      const unsub = await substrateApi.query.ormlTokens.accounts.multi(addresses.map(address => [address, onChainInfo]), balances => {
         const items = balances.map((balance, index) => {
           const tokenBalance = {
             reserved: balance.reserved || new BN(0),
@@ -351,7 +428,7 @@ async function subscribeOrmlTokensPallet(addresses, chain, api, callBack) {
             }
           };
         });
-        callBack(items);
+        callback(items);
       });
       return unsub;
     } catch (err) {
@@ -366,4 +443,4 @@ async function subscribeOrmlTokensPallet(addresses, chain, api, callBack) {
       }).catch(console.error);
     });
   };
-}
+};