@subwallet/extension-base 1.1.51-1 → 1.1.52-0

package/cjs/services/balance-service/index.js

@@ -1,18 +1,23 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.BalanceService = void 0;
 var _BalanceError = require("@subwallet/extension-base/background/errors/BalanceError");
 var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
-var _group = require("@subwallet/extension-base/services/balance-service/helpers/group");
-var _evm = require("@subwallet/extension-base/services/balance-service/helpers/subscribe/evm");
-var _substrate = require("@subwallet/extension-base/services/balance-service/helpers/subscribe/substrate");
-var _constants = require("@subwallet/extension-base/services/chain-service/constants");
+var _constants = require("@subwallet/extension-base/constants");
+var _types = require("@subwallet/extension-base/services/base/types");
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _DetectAccountBalance = _interopRequireDefault(require("@subwallet/extension-base/stores/DetectAccountBalance"));
 var _utils2 = require("@subwallet/extension-base/utils");
+var _uiKeyring = _interopRequireDefault(require("@subwallet/ui-keyring"));
 var _i18next = require("i18next");
+var _rxjs = require("rxjs");
+var _util = require("@polkadot/util");
+var _BalanceMapImpl = require("./BalanceMapImpl");
+var _helpers = require("./helpers");
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
@@ -21,23 +26,146 @@ var _i18next = require("i18next");
  * @class
 */
 class BalanceService {
+  balanceUpdateCache = [];
+  startPromiseHandler = (0, _utils2.createPromiseHandler)();
+  stopPromiseHandler = (0, _utils2.createPromiseHandler)();
+  status = _types.ServiceStatus.NOT_INITIALIZED;
+  isReload = false;
+  detectAccountBalanceStore = new _DetectAccountBalance.default();
+  balanceDetectSubject = new _rxjs.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.balanceMap = new _BalanceMapImpl.BalanceMapImpl();
+  }
+
+  /** Init service */
+  async init() {
+    this.status = _types.ServiceStatus.INITIALIZING;
+    await this.state.eventService.waitChainReady;
+    await this.state.eventService.waitAccountReady;
+
+    // Load data from db to balanceSubject
+    await this.loadData();
+    this.status = _types.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 === _types.ServiceStatus.STOPPING) {
+      await this.waitForStopped();
+    }
+    if (this.status === _types.ServiceStatus.STARTED || this.status === _types.ServiceStatus.STARTING) {
+      return await this.waitForStarted();
+    }
+    this.status = _types.ServiceStatus.STARTING;
+    await this.startScanBalance();
+
+    // Run subscribe balance
+    await this.runSubscribeBalances();
+
+    // Update status
+    this.stopPromiseHandler = (0, _utils2.createPromiseHandler)();
+    this.status = _types.ServiceStatus.STARTED;
+    this.startPromiseHandler.resolve();
+  }
+
+  /** Stop service */
+  async stop() {
+    if (this.status === _types.ServiceStatus.STARTING) {
+      await this.waitForStarted();
+    }
+    if (this.status === _types.ServiceStatus.STOPPED || this.status === _types.ServiceStatus.STOPPING) {
+      return await this.waitForStopped();
+    }
+    this.runUnsubscribeBalances();
+    this.stopScanBalance();
+
+    // Update status
+    this.startPromiseHandler = (0, _utils2.createPromiseHandler)();
+    this.status = _types.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;
+      }
+    }
+    events.forEach(event => {
+      if (event.type === 'account.remove') {
+        removedAddresses.push(event.data[0]);
+        lazyTime = 1000;
+      }
+    });
+    if (removedAddresses.length > 0) {
+      this.balanceMap.removeBalanceItems([...removedAddresses, _constants.ALL_ACCOUNT_KEY]); // Add all account key to recalculate all account balances
+      needReload = true;
+    }
+    if (needReload) {
+      (0, _utils2.addLazy)('reloadBalanceByEvents', () => {
+        if (!this.isReload) {
+          this.runSubscribeBalances().catch(console.error);
+        }
+      }, lazyTime, undefined, true);
+    }
+  }
+  getBalanceDetectCache(update) {
+    this.detectAccountBalanceStore.get('DetectBalanceCache', value => {
+      update(value);
+    });
+  }
+  setBalanceDetectCache(addresses) {
+    this.detectAccountBalanceStore.get('DetectBalanceCache', value => {
+      const rs = {
+        ...value
+      };
+      for (const address of addresses) {
+        rs[address] = Date.now();
+      }
+      this.detectAccountBalanceStore.set('DetectBalanceCache', rs);
+    });
   }
 
-  /* 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);
@@ -59,7 +187,12 @@ 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 = (0, _helpers.subscribeBalance)([address], [chain], [tSlug], assetMap, chainInfoMap, substrateApiMap, evmApiMap, result => {
+        const rs = result[0];
         if (rs.tokenSlug === tSlug) {
           hasError = false;
           const balance = {
@@ -99,44 +232,238 @@ class BalanceService {
     const [, balance] = await this.subscribeTokenFreeBalance(address, chain, tokenSlug);
     return balance;
   }
-  subscribeBalance(addresses, chains, _callback) {
-    const [substrateAddresses, evmAddresses] = (0, _utils2.categoryAddresses)(addresses);
+
+  /** Remove balance from the subject object by addresses */
+  removeBalanceByAddresses(addresses) {
+    this.balanceMap.removeBalanceItems([...addresses, _constants.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
+    };
+  }
+
+  /** 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);
+      }
+      (0, _utils2.addLazy)('updateBalanceStore', () => {
+        const isAllAccount = (0, _utils2.isAccountAll)(this.state.keyringService.currentAccount.address);
+        this.balanceMap.updateBalanceItems(this.balanceUpdateCache, isAllAccount);
+        if (isAllAccount) {
+          this.balanceUpdateCache = [...this.balanceUpdateCache, ...Object.values(this.balanceMap.map[_constants.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 chainStateMap = this.state.chainService.getChainStateMap();
-    const substrateApiMap = this.state.chainService.getSubstrateApiMap();
     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 = (0, _helpers.subscribeBalance)(addresses, activeChainSlugs, assets, assetMap, chainInfoMap, substrateApiMap, evmApiMap, result => {
+      !cancel && this.setBalanceItem(result);
+    });
+    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 (0, _utils2.waitTimeout)(1800);
+    this.isReload = false;
+  }
 
-    // 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((0, _group.groupBalance)(items, 'GROUPED', items[0].tokenSlug));
+  /** Subscribe area */
+
+  async autoEnableChains(addresses) {
+    this.setBalanceDetectCache(addresses);
+    const assetMap = this.state.chainService.getAssetRegistry();
+    const promiseList = addresses.map(address => {
+      return this.state.subscanService.getMultiChainBalance(address).catch(e => {
+        console.error(e);
+        return null;
+      });
+    });
+    const needEnableChains = [];
+    const needActiveTokens = [];
+    const balanceDataList = await Promise.all(promiseList);
+    const currentAssetSettings = await this.state.chainService.getAssetSettings();
+    const chainInfoMap = this.state.chainService.getChainInfoMap();
+    const detectBalanceChainSlugMap = this.state.chainService.detectBalanceChainSlugMap;
+    for (const balanceData of balanceDataList) {
+      if (balanceData) {
+        for (const balanceDatum of balanceData) {
+          var _currentAssetSettings;
+          const {
+            balance,
+            bonded,
+            category,
+            locked,
+            network,
+            symbol
+          } = balanceDatum;
+          const chain = detectBalanceChainSlugMap[network];
+          const chainInfo = chain ? chainInfoMap[chain] : null;
+          const chainState = this.state.chainService.getChainStateByKey(chain);
+          const balanceIsEmpty = (!balance || balance === '0') && (!locked || locked === '0') && (!bonded || bonded === '0');
+          const tokenKey = `${chain}-${category === 'native' ? 'NATIVE' : 'LOCAL'}-${symbol.toUpperCase()}`;
+          const existedKey = Object.keys(assetMap).find(v => v.toLowerCase() === tokenKey.toLowerCase());
+
+          // Cancel if chain is not supported or is testnet
+          if (!chainInfo || chainInfo.isTestnet) {
+            continue;
+          }
+
+          // Cancel is balance is 0
+          if (balanceIsEmpty) {
+            continue;
+          }
+
+          // Cancel is chain is turned off by user
+          if (chainState && chainState.manualTurnOff) {
+            continue;
+          }
+
+          // const a = this.state.chainService.getChainStateByKey(chain);
+
+          if (existedKey && !((_currentAssetSettings = currentAssetSettings[existedKey]) !== null && _currentAssetSettings !== void 0 && _currentAssetSettings.visible)) {
+            needEnableChains.push(chain);
+            needActiveTokens.push(existedKey);
+            currentAssetSettings[existedKey] = {
+              visible: true
+            };
+          }
+        }
       }
+    }
+    if (needActiveTokens.length) {
+      await this.state.chainService.enableChains(needEnableChains);
+      this.state.chainService.setAssetSettings({
+        ...currentAssetSettings
+      });
+    }
+  }
+  async startScanBalance() {
+    var _this$startBalanceDet2;
+    await Promise.all([this.state.eventService.waitAccountReady, this.state.eventService.waitChainReady]);
+    this.stopScanBalance();
+    this.startBalanceDetectCache = (0, _utils2.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 || {});
     };
-
-    // Looping over each chain
-    const unsubList = useChainInfos.map(async chainInfo => {
-      const chainSlug = chainInfo.slug;
-      const useAddresses = (0, _utils._isChainEvmCompatible)(chainInfo) ? evmAddresses : substrateAddresses;
-      if ((0, _utils._isPureEvmChain)(chainInfo)) {
-        const nativeTokenInfo = this.state.getNativeTokenInfo(chainSlug);
-        return (0, _evm.subscribeEVMBalance)(chainSlug, useAddresses, evmApiMap, callback, nativeTokenInfo);
+    this.getBalanceDetectCache(updateBalanceDetectCache);
+    const subscription = this.detectAccountBalanceStore.getSubject().subscribe({
+      next: updateBalanceDetectCache
+    });
+    this._unsubscribeBalanceDetectCache = subscription.unsubscribe;
+    const scanBalance = () => {
+      const addresses = _uiKeyring.default.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 (!useAddresses || useAddresses.length === 0 || _constants._PURE_EVM_CHAINS.indexOf(chainSlug) > -1) {
-        return undefined;
+      if (needDetectAddresses.length) {
+        this.autoEnableChains(needDetectAddresses).finally(_util.noop);
       }
-      const networkAPI = await substrateApiMap[chainSlug].isReady;
-      return (0, _substrate.subscribeSubstrateBalance)(useAddresses, chainInfo, chainSlug, networkAPI, evmApiMap, callback);
-    });
-    return () => {
-      unsubList.forEach(subProm => {
-        subProm.then(unsub => {
-          unsub && unsub();
-        }).catch(console.error);
-      });
     };
+    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;
   }
 }
 exports.BalanceService = BalanceService;

package/cjs/services/chain-service/constants.js

@@ -263,7 +263,8 @@ exports._DEFAULT_ACTIVE_CHAINS = _DEFAULT_ACTIVE_CHAINS;
 const EVM_PASS_CONNECT_STATUS = {
   arbitrum_one: ['*'],
   okxTest: ['*'],
-  astarZkEvm: ['*']
+  astarZkEvm: ['*'],
+  xlayer: ['*']
 };
 exports.EVM_PASS_CONNECT_STATUS = EVM_PASS_CONNECT_STATUS;
 const EVM_REFORMAT_DECIMALS = {

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

@@ -227,9 +227,7 @@ const getEvmNativeInfo = async api => {
 exports.getEvmNativeInfo = getEvmNativeInfo;
 const getErc20AssetInfo = async (asset, api) => {
   const contractAddress = (0, _utils2._getContractAddressOfToken)(asset);
-  const tokenContract = (0, _web.getERC20Contract)('chain', contractAddress, {
-    chain: api
-  });
+  const tokenContract = (0, _web.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(),