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

package/services/balance-service/index.d.ts

@@ -1,25 +1,50 @@
 import { AmountData, DetectBalanceCache } from '@subwallet/extension-base/background/KoniTypes';
 import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
-import { BalanceItem } from '@subwallet/extension-base/types';
+import { ServiceStatus, StoppableServiceInterface } from '@subwallet/extension-base/services/base/types';
+import { EventItem, EventType } from '@subwallet/extension-base/services/event-service/types';
+import { BalanceItem, BalanceJson } from '@subwallet/extension-base/types';
+import { PromiseHandler } from '@subwallet/extension-base/utils';
+import { BehaviorSubject } from 'rxjs';
 /**
  * Balance service
  * @class
 */
-export declare class BalanceService {
-    private readonly state;
+export declare class BalanceService implements StoppableServiceInterface {
+    private state;
+    private balanceMap;
+    private balanceUpdateCache;
+    startPromiseHandler: PromiseHandler<void>;
+    stopPromiseHandler: PromiseHandler<void>;
+    status: ServiceStatus;
+    private isReload;
     private readonly detectAccountBalanceStore;
     private readonly balanceDetectSubject;
     private readonly intervalTime;
     private readonly cacheTime;
-    private readonly startHandler;
     /**
      * @constructor
      * @param {KoniState} state - The state of extension.
      */
     constructor(state: KoniState);
-    startDetectBalance(): Promise<void>;
+    /** Init service */
+    init(): Promise<void>;
+    /** Restore balance map */
+    loadData(): Promise<void>;
+    /** Start service */
+    start(): Promise<void>;
+    /** Stop service */
+    stop(): Promise<void>;
+    /** Wait service start */
+    waitForStarted(): Promise<void>;
+    /** Wait service stop */
+    waitForStopped(): Promise<void>;
+    /**
+     *  Handle when data change
+     *  */
+    handleEvents(events: EventItem<EventType>[], eventTypes: EventType[]): void;
     getBalanceDetectCache(update: (value: DetectBalanceCache) => void): void;
     setBalanceDetectCache(addresses: string[]): void;
+    /** Subscribe token free balance of a address on chain */
     subscribeTokenFreeBalance(address: string, chain: string, tokenSlug: string | undefined, callback?: (rs: AmountData) => void): Promise<[() => void, AmountData]>;
     /**
      * @public
@@ -32,6 +57,39 @@ export declare class BalanceService {
      * @return {Promise<AmountData>} - Free token balance of address on chain
     */
     getTokenFreeBalance(address: string, chain: string, tokenSlug?: string): Promise<AmountData>;
-    subscribeBalance(addresses: string[], chains: string[] | null, _callback: (rs: BalanceItem) => void): () => void;
+    /** Remove balance from the subject object by addresses */
+    removeBalanceByAddresses(addresses: string[]): void;
+    /** Remove inactive asset from the balance map */
+    removeInactiveChainBalances(): Promise<void>;
+    getBalance(reset?: boolean): Promise<BalanceJson>;
+    /** Get stored balance from db */
+    getStoredBalance(address: string): Promise<BalanceItem[]>;
+    handleResetBalance(forceRefresh?: boolean): Promise<void>;
+    /**
+     * Update value for balance map
+     * Note: items must be same tokenSlug */
+    setBalanceItem(items: BalanceItem[]): void;
+    /**
+     * Store balance map to db
+     * */
+    private updateBalanceStore;
+    /**
+     * Subscribe balance map with subject object
+     * */
+    subscribeBalanceMap(): BehaviorSubject<import("@subwallet/extension-base/types").BalanceMap>;
+    /** Subscribe area */
+    private _unsubscribeBalance;
+    /** Subscribe balance subscription */
+    runSubscribeBalances(): Promise<void>;
+    /** Unsubscribe balance subscription */
+    runUnsubscribeBalances(): void;
+    /** Reload balance subscription */
+    reloadBalance(): Promise<void>;
+    /** Subscribe area */
     autoEnableChains(addresses: string[]): Promise<void>;
+    private _intervalScan;
+    private _unsubscribeBalanceDetectCache;
+    private startBalanceDetectCache;
+    private startScanBalance;
+    private stopScanBalance;
 }

package/services/balance-service/index.js

@@ -3,73 +3,144 @@
 
 import { BalanceError } from '@subwallet/extension-base/background/errors/BalanceError';
 import { BalanceErrorType } from '@subwallet/extension-base/background/KoniTypes';
-import { groupBalance } from '@subwallet/extension-base/services/balance-service/helpers/group';
-import { subscribeEVMBalance } from '@subwallet/extension-base/services/balance-service/helpers/subscribe/evm';
-import { subscribeSubstrateBalance } from '@subwallet/extension-base/services/balance-service/helpers/subscribe/substrate';
-import { _PURE_EVM_CHAINS } from '@subwallet/extension-base/services/chain-service/constants';
-import { _getChainNativeTokenSlug, _isChainEvmCompatible, _isPureEvmChain } from '@subwallet/extension-base/services/chain-service/utils';
+import { ALL_ACCOUNT_KEY } from '@subwallet/extension-base/constants';
+import { ServiceStatus } from '@subwallet/extension-base/services/base/types';
+import { _getChainNativeTokenSlug } from '@subwallet/extension-base/services/chain-service/utils';
 import DetectAccountBalanceStore from '@subwallet/extension-base/stores/DetectAccountBalance';
-import { categoryAddresses, createPromiseHandler } from '@subwallet/extension-base/utils';
+import { addLazy, createPromiseHandler, isAccountAll, waitTimeout } from '@subwallet/extension-base/utils';
 import keyring from '@subwallet/ui-keyring';
 import { t } from 'i18next';
 import { BehaviorSubject } from 'rxjs';
 import { noop } from '@polkadot/util';
+import { BalanceMapImpl } from "./BalanceMapImpl.js";
+import { subscribeBalance } from "./helpers/index.js";
 
 /**
  * Balance service
  * @class
 */
 export class BalanceService {
+  balanceUpdateCache = [];
+  startPromiseHandler = createPromiseHandler();
+  stopPromiseHandler = createPromiseHandler();
+  status = ServiceStatus.NOT_INITIALIZED;
+  isReload = false;
   detectAccountBalanceStore = new DetectAccountBalanceStore();
   balanceDetectSubject = new BehaviorSubject({});
   intervalTime = 3 * 60 * 1000;
   cacheTime = 15 * 60 * 1000;
+
   /**
    * @constructor
    * @param {KoniState} state - The state of extension.
    */
   constructor(state) {
     this.state = state;
-    // Todo: Load data from db to balanceSubject
-    // Todo: Start  subscribe balance and data
-    // Todo: Listen change and apply to balanceSubject
-    // Todo: Active/Chain
-    // Todo: Add/remove account
-    // Todo: Add new account
-    // Todo: Optimize get balance for single account and chain with cache
-    // Todo: Move everything of fetching balance to this service
-
-    this.startHandler = createPromiseHandler();
-    const updateBalanceDetectCache = value => {
-      this.startHandler.resolve();
-      this.balanceDetectSubject.next(value || {});
-    };
-    this.getBalanceDetectCache(updateBalanceDetectCache);
-    this.detectAccountBalanceStore.getSubject().subscribe({
-      next: updateBalanceDetectCache
-    });
-    this.startDetectBalance().catch(console.error);
+    this.balanceMap = new BalanceMapImpl();
   }
-  async startDetectBalance() {
-    const scanBalance = () => {
-      const addresses = keyring.getPairs().map(account => account.address);
-      const cache = this.balanceDetectSubject.value;
-      const now = Date.now();
-      const needDetectAddresses = [];
-      for (const address of addresses) {
-        if (!cache[address] || now - cache[address] > this.cacheTime) {
-          needDetectAddresses.push(address);
-        }
+
+  /** Init service */
+  async init() {
+    this.status = ServiceStatus.INITIALIZING;
+    await this.state.eventService.waitChainReady;
+    await this.state.eventService.waitAccountReady;
+
+    // Load data from db to balanceSubject
+    await this.loadData();
+    this.status = ServiceStatus.INITIALIZED;
+
+    // Start service
+    await this.start();
+
+    // Handle events
+    this.state.eventService.onLazy(this.handleEvents.bind(this));
+  }
+
+  /** Restore balance map */
+  async loadData() {
+    const backupBalanceData = await this.state.dbService.getStoredBalance();
+    this.balanceMap.updateBalanceItems(backupBalanceData, true);
+  }
+
+  /** Start service */
+  async start() {
+    if (this.status === ServiceStatus.STOPPING) {
+      await this.waitForStopped();
+    }
+    if (this.status === ServiceStatus.STARTED || this.status === ServiceStatus.STARTING) {
+      return await this.waitForStarted();
+    }
+    this.status = ServiceStatus.STARTING;
+    await this.startScanBalance();
+
+    // Run subscribe balance
+    await this.runSubscribeBalances();
+
+    // Update status
+    this.stopPromiseHandler = createPromiseHandler();
+    this.status = ServiceStatus.STARTED;
+    this.startPromiseHandler.resolve();
+  }
+
+  /** Stop service */
+  async stop() {
+    if (this.status === ServiceStatus.STARTING) {
+      await this.waitForStarted();
+    }
+    if (this.status === ServiceStatus.STOPPED || this.status === ServiceStatus.STOPPING) {
+      return await this.waitForStopped();
+    }
+    this.runUnsubscribeBalances();
+    this.stopScanBalance();
+
+    // Update status
+    this.startPromiseHandler = createPromiseHandler();
+    this.status = ServiceStatus.STOPPING;
+    this.stopPromiseHandler.resolve();
+  }
+
+  /** Wait service start */
+  waitForStarted() {
+    return this.startPromiseHandler.promise;
+  }
+
+  /** Wait service stop */
+  waitForStopped() {
+    return this.stopPromiseHandler.promise;
+  }
+
+  /**
+   *  Handle when data change
+   *  */
+  handleEvents(events, eventTypes) {
+    const removedAddresses = [];
+    let needReload = false;
+    let lazyTime = 2000;
+
+    // Account changed or chain changed (active or inactive)
+    if (eventTypes.includes('account.updateCurrent') || eventTypes.includes('account.add') || eventTypes.includes('chain.updateState') || eventTypes.includes('asset.updateState')) {
+      needReload = true;
+      if (eventTypes.includes('account.updateCurrent')) {
+        lazyTime = 1000;
       }
-      if (needDetectAddresses.length) {
-        this.autoEnableChains(needDetectAddresses).finally(noop);
+    }
+    events.forEach(event => {
+      if (event.type === 'account.remove') {
+        removedAddresses.push(event.data[0]);
+        lazyTime = 1000;
       }
-    };
-    await this.state.eventService.waitAccountReady;
-    await this.state.eventService.waitChainReady;
-    await this.startHandler.promise;
-    scanBalance();
-    setInterval(scanBalance, this.intervalTime);
+    });
+    if (removedAddresses.length > 0) {
+      this.balanceMap.removeBalanceItems([...removedAddresses, ALL_ACCOUNT_KEY]); // Add all account key to recalculate all account balances
+      needReload = true;
+    }
+    if (needReload) {
+      addLazy('reloadBalanceByEvents', () => {
+        if (!this.isReload) {
+          this.runSubscribeBalances().catch(console.error);
+        }
+      }, lazyTime, undefined, true);
+    }
   }
   getBalanceDetectCache(update) {
     this.detectAccountBalanceStore.get('DetectBalanceCache', value => {
@@ -88,7 +159,7 @@ export class BalanceService {
     });
   }
 
-  /* Subscribe token free balance on chain */
+  /** Subscribe token free balance of a address on chain */
   async subscribeTokenFreeBalance(address, chain, tokenSlug, callback) {
     const chainInfo = this.state.chainService.getChainInfoByKey(chain);
     const chainState = this.state.chainService.getChainStateByKey(chain);
@@ -110,7 +181,12 @@ export class BalanceService {
     }
     return new Promise((resolve, reject) => {
       let hasError = true;
-      const unsub = this.subscribeBalance([address], [chain], rs => {
+      const assetMap = this.state.chainService.getAssetRegistry();
+      const chainInfoMap = this.state.chainService.getChainInfoMap();
+      const evmApiMap = this.state.chainService.getEvmApiMap();
+      const substrateApiMap = this.state.chainService.getSubstrateApiMap();
+      const unsub = subscribeBalance([address], [chain], [tSlug], assetMap, chainInfoMap, substrateApiMap, evmApiMap, result => {
+        const rs = result[0];
         if (rs.tokenSlug === tSlug) {
           hasError = false;
           const balance = {
@@ -150,45 +226,131 @@ export class BalanceService {
     const [, balance] = await this.subscribeTokenFreeBalance(address, chain, tokenSlug);
     return balance;
   }
-  subscribeBalance(addresses, chains, _callback) {
-    const [substrateAddresses, evmAddresses] = categoryAddresses(addresses);
-    const chainInfoMap = this.state.chainService.getChainInfoMap();
-    const chainStateMap = this.state.chainService.getChainStateMap();
-    const substrateApiMap = this.state.chainService.getSubstrateApiMap();
-    const evmApiMap = this.state.chainService.getEvmApiMap();
 
-    // Get data from chain or all chains
-    const chainList = chains || Object.keys(chainInfoMap);
-    // Filter active chain only
-    const useChainInfos = chainList.filter(c => chainStateMap[c] && chainStateMap[c].active).map(c => chainInfoMap[c]);
-    const callback = items => {
-      if (items.length) {
-        _callback(groupBalance(items, 'GROUPED', items[0].tokenSlug));
-      }
+  /** Remove balance from the subject object by addresses */
+  removeBalanceByAddresses(addresses) {
+    this.balanceMap.removeBalanceItems([...addresses, ALL_ACCOUNT_KEY]);
+  }
+
+  /** Remove inactive asset from the balance map */
+  async removeInactiveChainBalances() {
+    const assetSettings = await this.state.chainService.getAssetSettings();
+    this.balanceMap.removeBalanceItemByFilter(item => {
+      return !assetSettings[item.tokenSlug];
+    });
+  }
+  async getBalance(reset) {
+    await this.removeInactiveChainBalances();
+    return {
+      details: this.balanceMap.map,
+      reset
     };
+  }
 
-    // Looping over each chain
-    const unsubList = useChainInfos.map(async chainInfo => {
-      const chainSlug = chainInfo.slug;
-      const useAddresses = _isChainEvmCompatible(chainInfo) ? evmAddresses : substrateAddresses;
-      if (_isPureEvmChain(chainInfo)) {
-        const nativeTokenInfo = this.state.getNativeTokenInfo(chainSlug);
-        return subscribeEVMBalance(chainSlug, useAddresses, evmApiMap, callback, nativeTokenInfo);
-      }
-      if (!useAddresses || useAddresses.length === 0 || _PURE_EVM_CHAINS.indexOf(chainSlug) > -1) {
-        return undefined;
+  /** Get stored balance from db */
+  async getStoredBalance(address) {
+    return await this.state.dbService.stores.balance.getBalanceMapByAddresses(address);
+  }
+  async handleResetBalance(forceRefresh) {
+    if (forceRefresh) {
+      this.balanceMap.setData({});
+      await this.state.dbService.stores.balance.clear();
+    } else {
+      await Promise.all([this.removeInactiveChainBalances()]);
+    }
+  }
+
+  /**
+   * Update value for balance map
+   * Note: items must be same tokenSlug */
+  setBalanceItem(items) {
+    if (items.length) {
+      const nowTime = new Date().getTime();
+      for (const item of items) {
+        const balance = {
+          timestamp: nowTime,
+          ...item
+        };
+        this.balanceUpdateCache.push(balance);
       }
-      const networkAPI = await substrateApiMap[chainSlug].isReady;
-      return subscribeSubstrateBalance(useAddresses, chainInfo, chainSlug, networkAPI, evmApiMap, callback);
+      addLazy('updateBalanceStore', () => {
+        const isAllAccount = isAccountAll(this.state.keyringService.currentAccount.address);
+        this.balanceMap.updateBalanceItems(this.balanceUpdateCache, isAllAccount);
+        if (isAllAccount) {
+          this.balanceUpdateCache = [...this.balanceUpdateCache, ...Object.values(this.balanceMap.map[ALL_ACCOUNT_KEY])];
+        }
+        this.updateBalanceStore(this.balanceUpdateCache);
+        this.balanceUpdateCache = [];
+      }, 300, 1800);
+    }
+  }
+
+  /**
+   * Store balance map to db
+   * */
+  updateBalanceStore(items) {
+    this.state.dbService.updateBulkBalanceStore(items).catch(console.warn);
+  }
+
+  /**
+   * Subscribe balance map with subject object
+   * */
+  subscribeBalanceMap() {
+    return this.balanceMap.mapSubject;
+  }
+
+  /** Subscribe area */
+
+  /** Subscribe balance subscription */
+  async runSubscribeBalances() {
+    await Promise.all([this.state.eventService.waitKeyringReady, this.state.eventService.waitChainReady]);
+    this.runUnsubscribeBalances();
+    const addresses = this.state.getDecodedAddresses();
+    if (!addresses.length) {
+      return;
+    }
+
+    // Reset balance before subscribe
+    await this.handleResetBalance();
+    let cancel = false;
+    const assetMap = this.state.chainService.getAssetRegistry();
+    const chainInfoMap = this.state.chainService.getChainInfoMap();
+    const evmApiMap = this.state.chainService.getEvmApiMap();
+    const substrateApiMap = this.state.chainService.getSubstrateApiMap();
+    const activeChainSlugs = Object.keys(this.state.getActiveChainInfoMap());
+    const assetState = this.state.chainService.subscribeAssetSettings().value;
+    const assets = Object.values(assetMap).filter(asset => {
+      var _assetState$asset$slu;
+      return activeChainSlugs.includes(asset.originChain) && ((_assetState$asset$slu = assetState[asset.slug]) === null || _assetState$asset$slu === void 0 ? void 0 : _assetState$asset$slu.visible);
+    }).map(asset => asset.slug);
+    const unsub = subscribeBalance(addresses, activeChainSlugs, assets, assetMap, chainInfoMap, substrateApiMap, evmApiMap, result => {
+      !cancel && this.setBalanceItem(result);
     });
-    return () => {
-      unsubList.forEach(subProm => {
-        subProm.then(unsub => {
-          unsub && unsub();
-        }).catch(console.error);
-      });
+    const unsub2 = this.state.subscribeMantaPayBalance();
+    this._unsubscribeBalance = () => {
+      cancel = true;
+      unsub && unsub();
+      unsub2 && unsub2();
     };
   }
+
+  /** Unsubscribe balance subscription */
+  runUnsubscribeBalances() {
+    this._unsubscribeBalance && this._unsubscribeBalance();
+    this._unsubscribeBalance = undefined;
+  }
+
+  /** Reload balance subscription */
+  async reloadBalance() {
+    this.isReload = true;
+    await this.handleResetBalance(true);
+    await this.runSubscribeBalances();
+    await waitTimeout(1800);
+    this.isReload = false;
+  }
+
+  /** Subscribe area */
+
   async autoEnableChains(addresses) {
     this.setBalanceDetectCache(addresses);
     const assetMap = this.state.chainService.getAssetRegistry();
@@ -257,4 +419,44 @@ export class BalanceService {
       });
     }
   }
+  async startScanBalance() {
+    var _this$startBalanceDet2;
+    await Promise.all([this.state.eventService.waitAccountReady, this.state.eventService.waitChainReady]);
+    this.stopScanBalance();
+    this.startBalanceDetectCache = createPromiseHandler();
+    const updateBalanceDetectCache = value => {
+      var _this$startBalanceDet;
+      (_this$startBalanceDet = this.startBalanceDetectCache) === null || _this$startBalanceDet === void 0 ? void 0 : _this$startBalanceDet.resolve();
+      this.balanceDetectSubject.next(value || {});
+    };
+    this.getBalanceDetectCache(updateBalanceDetectCache);
+    const subscription = this.detectAccountBalanceStore.getSubject().subscribe({
+      next: updateBalanceDetectCache
+    });
+    this._unsubscribeBalanceDetectCache = subscription.unsubscribe;
+    const scanBalance = () => {
+      const addresses = keyring.getPairs().map(account => account.address);
+      const cache = this.balanceDetectSubject.value;
+      const now = Date.now();
+      const needDetectAddresses = [];
+      for (const address of addresses) {
+        if (!cache[address] || now - cache[address] > this.cacheTime) {
+          needDetectAddresses.push(address);
+        }
+      }
+      if (needDetectAddresses.length) {
+        this.autoEnableChains(needDetectAddresses).finally(noop);
+      }
+    };
+    await ((_this$startBalanceDet2 = this.startBalanceDetectCache) === null || _this$startBalanceDet2 === void 0 ? void 0 : _this$startBalanceDet2.promise);
+    scanBalance();
+    this._intervalScan = setInterval(scanBalance, this.intervalTime);
+  }
+  stopScanBalance() {
+    this._intervalScan && clearInterval(this._intervalScan);
+    this._unsubscribeBalanceDetectCache && this._unsubscribeBalanceDetectCache();
+    this._intervalScan = undefined;
+    this._unsubscribeBalanceDetectCache = undefined;
+    this.startBalanceDetectCache = undefined;
+  }
 }

package/services/chain-service/constants.js

@@ -240,7 +240,8 @@ export const _DEFAULT_ACTIVE_CHAINS = [..._DEFAULT_CHAINS, 'vara_network'];
 export const EVM_PASS_CONNECT_STATUS = {
   arbitrum_one: ['*'],
   okxTest: ['*'],
-  astarZkEvm: ['*']
+  astarZkEvm: ['*'],
+  xlayer: ['*']
 };
 export const EVM_REFORMAT_DECIMALS = {
   acala: ['acala_evm', 'karura_evm']

package/services/chain-service/health-check/utils/asset-info.js

@@ -216,9 +216,7 @@ export const getEvmNativeInfo = async api => {
 };
 export const getErc20AssetInfo = async (asset, api) => {
   const contractAddress = _getContractAddressOfToken(asset);
-  const tokenContract = getERC20Contract('chain', contractAddress, {
-    chain: api
-  });
+  const tokenContract = getERC20Contract(contractAddress, api);
   const [_decimals, _symbol, _name] = await Promise.all([
   // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
   tokenContract.methods.decimals().call(),

package/services/chain-service/index.js

@@ -11,7 +11,7 @@ import { _CHAIN_VALIDATION_ERROR } from '@subwallet/extension-base/services/chai
 import { _ChainConnectionStatus, _CUSTOM_PREFIX, _NFT_CONTRACT_STANDARDS, _SMART_CONTRACT_STANDARDS } from '@subwallet/extension-base/services/chain-service/types';
 import { _isAssetAutoEnable, _isAssetFungibleToken, _isChainEnabled, _isCustomAsset, _isCustomChain, _isCustomProvider, _isEqualContractAddress, _isEqualSmartContractAsset, _isMantaZkAsset, _isPureEvmChain, _isPureSubstrateChain, _parseAssetRefKey, fetchPatchData, randomizeProvider, updateLatestChainInfo } from '@subwallet/extension-base/services/chain-service/utils';
 import AssetSettingStore from '@subwallet/extension-base/stores/AssetSetting';
-import { addLazy, fetchStaticData, MODULE_SUPPORT } from '@subwallet/extension-base/utils';
+import { addLazy, fetchStaticData, filterAssetsByChainAndType, MODULE_SUPPORT } from '@subwallet/extension-base/utils';
 import { BehaviorSubject, Subject } from 'rxjs';
 import Web3 from 'web3';
 import { logger as createLogger } from '@polkadot/util/logger';
@@ -271,13 +271,7 @@ export class ChainService {
     return destinationTokenInfo;
   }
   getAssetByChainAndType(chainSlug, assetTypes) {
-    const result = {};
-    Object.values(this.getAssetRegistry()).forEach(assetInfo => {
-      if (assetTypes.includes(assetInfo.assetType) && assetInfo.originChain === chainSlug) {
-        result[assetInfo.slug] = assetInfo;
-      }
-    });
-    return result;
+    return filterAssetsByChainAndType(this.getAssetRegistry(), chainSlug, assetTypes);
   }
   getSmartContractNfts() {
     const result = [];
@@ -561,8 +555,6 @@ export class ChainService {
       const chainState = chainStateMap[originChain];
       if (!assetState) {
         // If this asset not has asset setting, this token is not enabled before (not turned off before)
-        // @ts-ignore
-        // TODO: Merge issue detect balance to define manualTurnOff props
         if (!chainState || !chainState.manualTurnOff) {
           await this.updateAssetSetting(assetSlug, {
             visible: true

package/services/chain-service/utils/patch.js

@@ -5,7 +5,7 @@ import fetch from 'cross-fetch';
 const PRODUCTION_BRANCHES = ['master', 'webapp', 'webapp-dev'];
 const branchName = process.env.BRANCH_NAME || 'subwallet-dev';
 const fetchDomain = PRODUCTION_BRANCHES.indexOf(branchName) > -1 ? 'https://chain-list-assets.subwallet.app' : 'https://dev.sw-chain-list-assets.pages.dev';
-const ChainListVersion = '0.2.53';
+const ChainListVersion = '0.2.54';
 export async function fetchPatchData(slug) {
   try {
     const fetchPromise = fetch(`${fetchDomain}/patch/${ChainListVersion}/${slug}`);

package/services/earning-service/handlers/liquid-staking/stella-swap.js

@@ -192,7 +192,7 @@ export default class StellaSwapLiquidStakingPoolHandler extends BaseLiquidStakin
     const derivativeTokenInfo = this.state.getAssetBySlug(derivativeTokenSlug);
     const inputTokenSlug = this.inputAsset;
     const inputTokenInfo = this.state.getAssetBySlug(inputTokenSlug);
-    const inputTokenContract = getERC20Contract(this.chain, _getContractAddressOfToken(inputTokenInfo), this.state.getEvmApiMap());
+    const inputTokenContract = getERC20Contract(_getContractAddressOfToken(inputTokenInfo), evmApi);
     // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
     const allowanceCall = inputTokenContract.methods.allowance(params.address, _getContractAddressOfToken(derivativeTokenInfo));
     const [allowance, gasPrice] = await Promise.all([
@@ -257,7 +257,7 @@ export default class StellaSwapLiquidStakingPoolHandler extends BaseLiquidStakin
     const derivativeTokenInfo = this.state.getAssetBySlug(this.derivativeAssets[0]);
     const derivativeTokenContractAddress = _getContractAddressOfToken(derivativeTokenInfo);
     const evmApi = this.evmApi;
-    const inputTokenContract = getERC20Contract(this.chain, _getContractAddressOfToken(inputTokenInfo), this.state.getEvmApiMap());
+    const inputTokenContract = getERC20Contract(_getContractAddressOfToken(inputTokenInfo), evmApi);
 
     // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
     const approveCall = inputTokenContract.methods.approve(derivativeTokenContractAddress, MAX_INT); // TODO: need test

package/services/request-service/handler/ConnectWCRequestHandler.js

@@ -51,7 +51,6 @@ export default class ConnectWCRequestHandler {
       ...request
     };
     this.updateIconConnectWC();
-    this.#requestService.popupOpen();
   }
   resetWallet() {
     for (const request of Object.values(this.#connectWCRequests)) {

package/services/storage-service/DatabaseService.js

@@ -11,6 +11,7 @@ import NominatorMetadataStore from '@subwallet/extension-base/services/storage-s
 import YieldPoolStore from '@subwallet/extension-base/services/storage-service/db-stores/YieldPoolStore';
 import YieldPositionStore from '@subwallet/extension-base/services/storage-service/db-stores/YieldPositionStore';
 import { reformatAddress } from '@subwallet/extension-base/utils';
+import keyring from '@subwallet/ui-keyring';
 import { exportDB } from 'dexie-export-import';
 import { logger as createLogger } from '@polkadot/util';
 export const DEXIE_BACKUP_TABLES = ['chain', 'asset', 'migrations', 'transactions', 'campaign'];
@@ -63,7 +64,12 @@ export default class DatabaseService {
 
   // Balance
   async getStoredBalance() {
-    return this.stores.balance.table.toArray();
+    const addresses = keyring.getPairs().map(({
+      address
+    }) => address);
+
+    // Filter not exist address
+    return this.stores.balance.table.filter(obj => addresses.includes(obj.address)).toArray();
   }
   async updateBalanceStore(item) {
     if (item.state === APIItemState.READY) {

package/services/wallet-connect-service/helpers.js

@@ -11,7 +11,7 @@ export const getWCId = id => {
 export const convertConnectRequest = request => {
   return {
     id: getWCId(request.id),
-    isInternal: false,
+    isInternal: true,
     request: request,
     url: request.params.proposer.metadata.url
   };

package/services/wallet-connect-service/index.d.ts

@@ -16,4 +16,5 @@ export default class WalletConnectService {
     responseRequest(response: EngineTypes.RespondParams): Promise<void>;
     resetWallet(resetAll: boolean): Promise<void>;
     disconnect(topic: string): Promise<void>;
+    private findMethodsMissing;
 }