@subwallet/extension-base 1.1.23-0 → 1.1.24-1

package/koni/background/handlers/State.js

@@ -7,6 +7,7 @@ import { isSubscriptionRunning, unsubscribe } from '@subwallet/extension-base/ba
 import { APIItemState, BasicTxErrorType, ChainType, EvmProviderErrorType, ExternalRequestPromiseStatus, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 import { ALL_ACCOUNT_KEY, ALL_GENESIS_HASH, MANTA_PAY_BALANCE_INTERVAL } from '@subwallet/extension-base/constants';
 import { BalanceService } from '@subwallet/extension-base/services/balance-service';
+import { groupBalance } from '@subwallet/extension-base/services/balance-service/helpers/group';
 import { ServiceStatus } from '@subwallet/extension-base/services/base/types';
 import BuyService from '@subwallet/extension-base/services/buy-service';
 import CampaignService from '@subwallet/extension-base/services/campaign-service';
@@ -27,7 +28,8 @@ import { SUBSCAN_API_CHAIN_MAP, SUBSCAN_BALANCE_CHAIN_MAP_REVERSE } from '@subwa
 import TransactionService from '@subwallet/extension-base/services/transaction-service';
 import WalletConnectService from '@subwallet/extension-base/services/wallet-connect-service';
 import AccountRefStore from '@subwallet/extension-base/stores/AccountRef';
-import { stripUrl } from '@subwallet/extension-base/utils';
+import { isAccountAll, isSameAddress, stripUrl, TARGET_ENV } from '@subwallet/extension-base/utils';
+import { recalculateGasPrice } from '@subwallet/extension-base/utils/eth';
 import { isContractAddress, parseContractInput } from '@subwallet/extension-base/utils/eth/parseTransaction';
 import { createPromiseHandler } from '@subwallet/extension-base/utils/promise';
 import { decodePair } from '@subwallet/keyring/pair/decode';
@@ -90,7 +92,7 @@ export default class KoniState {
     this.settingService = new SettingService();
     this.requestService = new RequestService(this.chainService, this.settingService, this.keyringService);
     this.priceService = new PriceService(this.dbService, this.eventService, this.chainService);
-    this.balanceService = new BalanceService(this.chainService);
+    this.balanceService = new BalanceService(this);
     this.historyService = new HistoryService(this.dbService, this.chainService, this.eventService, this.keyringService, this.subscanService);
     this.transactionService = new TransactionService(this.chainService, this.eventService, this.requestService, this.balanceService, this.historyService, this.notificationService, this.dbService);
     this.walletConnectService = new WalletConnectService(this, this.requestService);
@@ -102,7 +104,9 @@ export default class KoniState {
     this.logger = createLogger('State');
 
     // Init state
-    this.init().catch(console.error);
+    if (TARGET_ENV !== 'mobile') {
+      this.init().catch(console.error);
+    }
   }
 
   // Clone from polkadot.js
@@ -185,16 +189,23 @@ export default class KoniState {
   generateDefaultBalanceMap() {
     const balanceMap = {};
     const activeChains = this.chainService.getActiveChainInfoMap();
-    Object.values(activeChains).forEach(chainInfo => {
-      const chainAssetMap = this.chainService.getFungibleTokensByChain(chainInfo.slug);
-      Object.keys(chainAssetMap).forEach(assetSlug => {
-        balanceMap[assetSlug] = {
-          tokenSlug: assetSlug,
-          free: '',
-          locked: '',
-          state: APIItemState.PENDING
-        };
+    const isAllAccount = isAccountAll(this.keyringService.currentAccount.address);
+    const addresses = isAllAccount ? Object.keys(this.keyringService.accounts) : [this.keyringService.currentAccount.address];
+    addresses.forEach(address => {
+      const temp = {};
+      Object.values(activeChains).forEach(chainInfo => {
+        const chainAssetMap = this.chainService.getFungibleTokensByChain(chainInfo.slug);
+        Object.keys(chainAssetMap).forEach(assetSlug => {
+          temp[assetSlug] = {
+            address,
+            tokenSlug: assetSlug,
+            free: '',
+            locked: '',
+            state: APIItemState.PENDING
+          };
+        });
       });
+      balanceMap[address] = temp;
     });
     return balanceMap;
   }
@@ -664,14 +675,17 @@ export default class KoniState {
   }
   removeInactiveChainBalances(balanceMap) {
     const activeBalanceMap = {};
-    Object.entries(balanceMap).forEach(([tokenSlug, balanceItem]) => {
-      const tokenInfo = this.chainService.getAssetBySlug(tokenSlug);
-      if (tokenInfo) {
-        const chainInfo = this.chainService.getChainInfoByKey(tokenInfo.originChain);
-        if (chainInfo && this.getChainStateByKey(chainInfo.slug).active) {
-          activeBalanceMap[tokenSlug] = balanceItem;
+    Object.entries(balanceMap).forEach(([address, balances]) => {
+      activeBalanceMap[address] = {};
+      Object.entries(balances).forEach(([tokenSlug, item]) => {
+        const tokenInfo = this.chainService.getAssetBySlug(tokenSlug);
+        if (tokenInfo) {
+          const chainInfo = this.chainService.getChainInfoByKey(tokenInfo.originChain);
+          if (chainInfo && this.getChainStateByKey(chainInfo.slug).active) {
+            activeBalanceMap[address][tokenSlug] = item;
+          }
         }
-      }
+      });
     });
     return activeBalanceMap;
   }
@@ -683,7 +697,7 @@ export default class KoniState {
     };
   }
   async getStoredBalance(address) {
-    const items = await this.dbService.stores.balance.getBalanceMapByAddress(address);
+    const items = await this.dbService.stores.balance.getBalanceMapByAddresses(address);
     return items || {};
   }
   async handleSwitchAccount(newAddress) {
@@ -693,6 +707,31 @@ export default class KoniState {
     const defaultData = this.generateDefaultBalanceMap();
     let storedData = await this.getStoredBalance(newAddress);
     storedData = this.removeInactiveChainBalances(storedData);
+    const result = {};
+    for (const [address, balanceInfo] of Object.entries(defaultData)) {
+      result[address] = {
+        ...balanceInfo
+      };
+    }
+    for (const [address, balanceInfo] of Object.entries(storedData)) {
+      if (!result[address]) {
+        result[address] = {
+          ...balanceInfo
+        };
+      } else {
+        const temp = {
+          ...result[address]
+        };
+        for (const [slug, item] of Object.entries(balanceInfo)) {
+          temp[slug] = {
+            ...item
+          };
+        }
+        result[address] = {
+          ...temp
+        };
+      }
+    }
     this.balanceMap = {
       ...defaultData,
       ...storedData
@@ -720,19 +759,59 @@ export default class KoniState {
       });
     });
   }
-  setBalanceItem(tokenSlug, item) {
-    this.balanceMap[tokenSlug] = {
-      timestamp: +new Date(),
-      ...item
-    };
-    this.updateBalanceStore(item);
-    this.lazyNext('setBalanceItem', () => {
-      this.publishBalance();
-    });
+
+  /** Note: items must be same tokenSlug */
+  setBalanceItem(items) {
+    if (items.length) {
+      const tokens = [];
+      const updates = [];
+      for (const item of items) {
+        const address = item.address;
+        const tokenSlug = item.tokenSlug;
+        if (!tokens.includes(tokenSlug)) {
+          tokens.push(tokenSlug);
+        }
+        if (!this.balanceMap[address]) {
+          this.balanceMap[address] = {};
+        }
+        const data = {
+          timestamp: +new Date(),
+          ...item
+        };
+        this.balanceMap[address][tokenSlug] = data;
+        updates.push(data);
+      }
+      const isAllAccount = isAccountAll(this.keyringService.currentAccount.address);
+      if (isAllAccount) {
+        const address = ALL_ACCOUNT_KEY;
+        for (const token of tokens) {
+          const items = [];
+          for (const [_adr, balanceInfo] of Object.entries(this.balanceMap)) {
+            if (!isSameAddress(_adr, address)) {
+              const item = balanceInfo[token];
+              item && items.push(item);
+            }
+          }
+          const _balance = groupBalance(items, address, token);
+          const balance = {
+            timestamp: +new Date(),
+            ..._balance
+          };
+          if (!this.balanceMap[address]) {
+            this.balanceMap[address] = {};
+          }
+          this.balanceMap[address][token] = balance;
+          updates.push(balance);
+        }
+      }
+      this.updateBalanceStore(updates);
+      this.lazyNext('setBalanceItem', () => {
+        this.publishBalance();
+      });
+    }
   }
-  updateBalanceStore(item) {
-    const currentAccountInfo = this.keyringService.currentAccount;
-    this.dbService.updateBalanceStore(currentAccountInfo.address, item).catch(e => this.logger.warn(e));
+  updateBalanceStore(items) {
+    this.dbService.updateBulkBalanceStore(items).catch(e => this.logger.warn(e));
   }
   subscribeBalance() {
     return this.balanceSubject;
@@ -1228,7 +1307,8 @@ export default class KoniState {
       // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
       throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, e === null || e === void 0 ? void 0 : e.message);
     }
-    const gasPrice = await web3.eth.getGasPrice();
+    const _price = await web3.eth.getGasPrice();
+    const gasPrice = recalculateGasPrice(_price, networkKey);
     transaction.gasPrice = gasPrice;
     const estimateGas = new BN(gasPrice.toString()).mul(new BN(transaction.gas)).toString();
 
@@ -1661,7 +1741,7 @@ export default class KoniState {
         };
         balanceItem.free = ((_zkBalances$i = zkBalances[i]) === null || _zkBalances$i === void 0 ? void 0 : _zkBalances$i.toString()) || '0';
         balanceItem.state = APIItemState.READY;
-        this.setBalanceItem(balanceItem.tokenSlug, balanceItem);
+        this.setBalanceItem([balanceItem]);
       }
     }).catch(console.warn);
   }

package/koni/background/subscription.js

@@ -1,12 +1,12 @@
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { subscribeBalance } from '@subwallet/extension-base/koni/api/dotsama/balance';
 import { subscribeCrowdloan } from '@subwallet/extension-base/koni/api/dotsama/crowdloan';
 import { getNominationStakingRewardData, getPoolingStakingRewardData, stakingOnChainApi } from '@subwallet/extension-base/koni/api/staking';
 import { subscribeEssentialChainStakingMetadata } from '@subwallet/extension-base/koni/api/staking/bonding';
 import { getAmplitudeUnclaimedStakingReward } from '@subwallet/extension-base/koni/api/staking/paraChain';
 import { nftHandler } from '@subwallet/extension-base/koni/background/handlers';
+import { subscribeBalance } from '@subwallet/extension-base/services/balance-service/helpers/subscribe/balance';
 import { _isChainEnabled, _isChainSupportSubstrateStaking } from '@subwallet/extension-base/services/chain-service/utils';
 import { COMMON_RELOAD_EVENTS } from '@subwallet/extension-base/services/event-service/types';
 import { waitTimeout } from '@subwallet/extension-base/utils';
@@ -147,7 +147,7 @@ export class KoniSubscription {
       }
     });
     const unsub = subscribeBalance(addresses, filteredChainInfoMap, substrateApiMap, evmApiMap, result => {
-      this.state.setBalanceItem(result.tokenSlug, result);
+      this.state.setBalanceItem(result);
     });
     const unsub2 = this.state.subscribeMantaPayBalance();
     if (onlyRunOnFirstTime) {

package/package.json

@@ -17,7 +17,7 @@
     "./cjs/detectPackage.js"
   ],
   "type": "module",
-  "version": "1.1.23-0",
+  "version": "1.1.24-1",
   "main": "./cjs/index.js",
   "module": "./index.js",
   "types": "./index.d.ts",
@@ -164,11 +164,6 @@
       "require": "./cjs/koni/api/donate.js",
       "default": "./koni/api/donate.js"
     },
-    "./koni/api/dotsama/balance": {
-      "types": "./koni/api/dotsama/balance.d.ts",
-      "require": "./cjs/koni/api/dotsama/balance.js",
-      "default": "./koni/api/dotsama/balance.js"
-    },
     "./koni/api/dotsama/crowdloan": {
       "types": "./koni/api/dotsama/crowdloan.d.ts",
       "require": "./cjs/koni/api/dotsama/crowdloan.js",
@@ -515,6 +510,31 @@
       "require": "./cjs/services/balance-service/index.js",
       "default": "./services/balance-service/index.js"
     },
+    "./services/balance-service/helpers/group": {
+      "types": "./services/balance-service/helpers/group.d.ts",
+      "require": "./cjs/services/balance-service/helpers/group.js",
+      "default": "./services/balance-service/helpers/group.js"
+    },
+    "./services/balance-service/helpers/subscribe/balance": {
+      "types": "./services/balance-service/helpers/subscribe/balance.d.ts",
+      "require": "./cjs/services/balance-service/helpers/subscribe/balance.js",
+      "default": "./services/balance-service/helpers/subscribe/balance.js"
+    },
+    "./services/balance-service/helpers/subscribe/evm": {
+      "types": "./services/balance-service/helpers/subscribe/evm.d.ts",
+      "require": "./cjs/services/balance-service/helpers/subscribe/evm.js",
+      "default": "./services/balance-service/helpers/subscribe/evm.js"
+    },
+    "./services/balance-service/helpers/subscribe/substrate": {
+      "types": "./services/balance-service/helpers/subscribe/substrate/index.d.ts",
+      "require": "./cjs/services/balance-service/helpers/subscribe/substrate/index.js",
+      "default": "./services/balance-service/helpers/subscribe/substrate/index.js"
+    },
+    "./services/balance-service/helpers/subscribe/substrate/equilibrium": {
+      "types": "./services/balance-service/helpers/subscribe/substrate/equilibrium.d.ts",
+      "require": "./cjs/services/balance-service/helpers/subscribe/substrate/equilibrium.js",
+      "default": "./services/balance-service/helpers/subscribe/substrate/equilibrium.js"
+    },
     "./services/base/types": {
       "types": "./services/base/types.d.ts",
       "require": "./cjs/services/base/types.js",
@@ -1203,6 +1223,11 @@
       "require": "./cjs/types/index.js",
       "default": "./types/index.js"
     },
+    "./types/balance": {
+      "types": "./types/balance.d.ts",
+      "require": "./cjs/types/balance.js",
+      "default": "./types/balance.js"
+    },
     "./types/buy": {
       "types": "./types/buy.d.ts",
       "require": "./cjs/types/buy.js",
@@ -1213,10 +1238,10 @@
       "require": "./cjs/utils/index.js",
       "default": "./utils/index.js"
     },
-    "./utils/address": {
-      "types": "./utils/address.d.ts",
-      "require": "./cjs/utils/address.js",
-      "default": "./utils/address.js"
+    "./utils/account": {
+      "types": "./utils/account.d.ts",
+      "require": "./cjs/utils/account.js",
+      "default": "./utils/account.js"
     },
     "./utils/array": {
       "types": "./utils/array.d.ts",
@@ -1323,10 +1348,10 @@
     "@sora-substrate/type-definitions": "^1.17.7",
     "@substrate/connect": "^0.7.26",
     "@subwallet/chain-list": "0.2.26",
-    "@subwallet/extension-base": "^1.1.23-0",
-    "@subwallet/extension-chains": "^1.1.23-0",
-    "@subwallet/extension-dapp": "^1.1.23-0",
-    "@subwallet/extension-inject": "^1.1.23-0",
+    "@subwallet/extension-base": "^1.1.24-1",
+    "@subwallet/extension-chains": "^1.1.24-1",
+    "@subwallet/extension-dapp": "^1.1.24-1",
+    "@subwallet/extension-inject": "^1.1.24-1",
     "@subwallet/keyring": "^0.1.1",
     "@subwallet/ui-keyring": "^0.1.1",
     "@walletconnect/sign-client": "^2.8.4",
@@ -1341,6 +1366,7 @@
     "buffer": "^6.0.3",
     "cross-fetch": "^3.1.5",
     "dexie": "^3.2.2",
+    "dexie-export-import": "^4.0.7",
     "eth-simple-keyring": "^4.2.0",
     "ethereumjs-tx": "^2.1.2",
     "ethereumjs-util": "^7.1.5",

package/packageInfo.js

@@ -7,5 +7,5 @@ export const packageInfo = {
   name: '@subwallet/extension-base',
   path: (import.meta && import.meta.url) ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf('/') + 1) : 'auto',
   type: 'esm',
-  version: '1.1.23-0'
+  version: '1.1.24-1'
 };

package/services/balance-service/helpers/group.d.ts

@@ -0,0 +1,9 @@
+import { BalanceItem } from '@subwallet/extension-base/types';
+/**
+ * Group the balance of {token} from {items} into {address}
+ * @param {BalanceItem[]} items - List balance want to group
+ * @param {string} address - Address will be grouped to
+ * @param {string} token - Slug of token will be group balance
+ * @return {BalanceItem} - Grouped balance information of token
+ */
+export declare const groupBalance: (items: BalanceItem[], address: string, token: string) => BalanceItem;

package/services/balance-service/helpers/group.js

@@ -0,0 +1,46 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { APIItemState } from '@subwallet/extension-base/background/KoniTypes';
+import { sumBN } from '@subwallet/extension-base/utils';
+import BN from 'bn.js';
+
+/**
+ * Group the balance of {token} from {items} into {address}
+ * @param {BalanceItem[]} items - List balance want to group
+ * @param {string} address - Address will be grouped to
+ * @param {string} token - Slug of token will be group balance
+ * @return {BalanceItem} - Grouped balance information of token
+ */
+export const groupBalance = (items, address, token) => {
+  const states = items.map(item => item.state);
+  const result = {
+    address,
+    tokenSlug: token,
+    free: sumBN(items.map(item => new BN(item.free))).toString(),
+    locked: sumBN(items.map(item => new BN(item.locked))).toString(),
+    state: states.every(item => item === APIItemState.NOT_SUPPORT) ? APIItemState.NOT_SUPPORT : states.some(item => item === APIItemState.READY) ? APIItemState.READY : APIItemState.PENDING
+  };
+  for (const item of items) {
+    if (item.substrateInfo) {
+      if (!result.substrateInfo) {
+        result.substrateInfo = {
+          ...item.substrateInfo
+        };
+      } else {
+        const old = {
+          ...result.substrateInfo
+        };
+        const _new = {
+          ...item.substrateInfo
+        };
+        result.substrateInfo = {
+          reserved: new BN(old.reserved || '0').add(new BN(_new.reserved || '0')).toString(),
+          feeFrozen: new BN(old.feeFrozen || '0').add(new BN(_new.feeFrozen || '0')).toString(),
+          miscFrozen: new BN(old.miscFrozen || '0').add(new BN(_new.miscFrozen || '0')).toString()
+        };
+      }
+    }
+  }
+  return result;
+};

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

@@ -0,0 +1,4 @@
+import { _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 subscribeBalance(addresses: string[], chainInfoMap: Record<string, _ChainInfo>, substrateApiMap: Record<string, _SubstrateApi>, evmApiMap: Record<string, _EvmApi>, callback: (rs: BalanceItem[]) => void): () => void;

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

@@ -0,0 +1,103 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+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 { getAccountJsonByAddress } from '@subwallet/extension-base/utils/account';
+import { subscribeEVMBalance } from "./evm.js";
+import { subscribeSubstrateBalance } from "./substrate/index.js";
+const filterAddress = (addresses, chainInfo) => {
+  const isEvmChain = _isChainEvmCompatible(chainInfo);
+  const [substrateAddresses, evmAddresses] = categoryAddresses(addresses);
+  if (isEvmChain) {
+    return [evmAddresses, []];
+  } else {
+    const fetchList = [];
+    const unfetchList = [];
+    substrateAddresses.forEach(address => {
+      const account = getAccountJsonByAddress(address);
+      if (account) {
+        if (account.isHardware) {
+          const availGen = account.availableGenesisHashes || [];
+          const gen = _getSubstrateGenesisHash(chainInfo);
+          if (availGen.includes(gen)) {
+            fetchList.push(address);
+          } else {
+            unfetchList.push(address);
+          }
+        } else {
+          fetchList.push(address);
+        }
+      } else {
+        fetchList.push(address);
+      }
+    });
+    return [fetchList, [...unfetchList, ...evmAddresses]];
+  }
+};
+
+// main subscription
+export function subscribeBalance(addresses, chainInfoMap, substrateApiMap, evmApiMap, callback) {
+  // Looping over each chain
+  const unsubList = Object.entries(chainInfoMap).map(async ([chainSlug, chainInfo]) => {
+    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 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
+          };
+        });
+        callback(items);
+      });
+    }
+    if (_isPureEvmChain(chainInfo)) {
+      const nativeTokenInfo = state.getNativeTokenInfo(chainSlug);
+      return subscribeEVMBalance(chainSlug, useAddresses, evmApiMap, callback, nativeTokenInfo);
+    }
+
+    // if (!useAddresses || useAddresses.length === 0 || _PURE_EVM_CHAINS.indexOf(chainSlug) > -1) {
+    //   const fungibleTokensByChain = state.chainService.getFungibleTokensByChain(chainSlug, true);
+    //   const now = new Date().getTime();
+    //
+    //   Object.values(fungibleTokensByChain).map((token) => {
+    //     return {
+    //       tokenSlug: token.slug,
+    //       free: '0',
+    //       locked: '0',
+    //       state: APIItemState.READY,
+    //       timestamp: now
+    //     } as BalanceItem;
+    //   }).forEach(callback);
+    //
+    //   return undefined;
+    // }
+
+    const networkAPI = await substrateApiMap[chainSlug].isReady;
+    return subscribeSubstrateBalance(useAddresses, chainInfo, chainSlug, networkAPI, evmApiMap, callback);
+  });
+  return () => {
+    unsubList.forEach(subProm => {
+      subProm.then(unsub => {
+        unsub && unsub();
+      }).catch(console.error);
+    });
+  };
+}

package/services/balance-service/helpers/subscribe/evm.d.ts

@@ -0,0 +1,5 @@
+import { _ChainAsset } from '@subwallet/chain-list/types';
+import { _EvmApi } from '@subwallet/extension-base/services/chain-service/types';
+import { BalanceItem } from '@subwallet/extension-base/types';
+export declare function subscribeERC20Interval(addresses: string[], chain: string, evmApiMap: Record<string, _EvmApi>, callBack: (result: BalanceItem[]) => void): () => void;
+export declare function subscribeEVMBalance(chain: string, addresses: string[], evmApiMap: Record<string, _EvmApi>, callback: (rs: BalanceItem[]) => void, tokenInfo: _ChainAsset): () => void;

package/services/balance-service/helpers/subscribe/evm.js

@@ -0,0 +1,87 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { _AssetType } from '@subwallet/chain-list/types';
+import { APIItemState } from '@subwallet/extension-base/background/KoniTypes';
+import { ASTAR_REFRESH_BALANCE_INTERVAL, SUB_TOKEN_REFRESH_BALANCE_INTERVAL } from '@subwallet/extension-base/constants';
+import { getEVMBalance } from '@subwallet/extension-base/koni/api/tokens/evm/balance';
+import { getERC20Contract } from '@subwallet/extension-base/koni/api/tokens/evm/web3';
+import { state } from '@subwallet/extension-base/koni/background/handlers';
+import { _getContractAddressOfToken } from '@subwallet/extension-base/services/chain-service/utils';
+import { BN } from '@polkadot/util';
+export function subscribeERC20Interval(addresses, chain, evmApiMap, callBack) {
+  let tokenList = {};
+  const erc20ContractMap = {};
+  const getTokenBalances = () => {
+    Object.values(tokenList).map(async tokenInfo => {
+      try {
+        const contract = erc20ContractMap[tokenInfo.slug];
+        const balances = await Promise.all(addresses.map(async address => {
+          try {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return,@typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+            return await contract.methods.balanceOf(address).call();
+          } catch (e) {
+            console.error(`Error on get balance of account ${address} for token ${tokenInfo.slug}`, e);
+            return '0';
+          }
+        }));
+        const items = balances.map((balance, index) => {
+          return {
+            address: addresses[index],
+            tokenSlug: tokenInfo.slug,
+            free: new BN(balance || 0).toString(),
+            locked: '0',
+            state: APIItemState.READY
+          };
+        });
+        callBack(items);
+      } catch (err) {
+        console.log(tokenInfo.slug, err);
+      }
+    });
+  };
+  tokenList = state.getAssetByChainAndAsset(chain, [_AssetType.ERC20]);
+  Object.entries(tokenList).forEach(([slug, tokenInfo]) => {
+    erc20ContractMap[slug] = getERC20Contract(chain, _getContractAddressOfToken(tokenInfo), evmApiMap);
+  });
+  getTokenBalances();
+  const interval = setInterval(getTokenBalances, SUB_TOKEN_REFRESH_BALANCE_INTERVAL);
+  return () => {
+    clearInterval(interval);
+  };
+}
+export function subscribeEVMBalance(chain, addresses, evmApiMap, callback, tokenInfo) {
+  function getBalance() {
+    getEVMBalance(chain, addresses, evmApiMap).then(balances => {
+      return balances.map((balance, index) => {
+        return {
+          address: addresses[index],
+          tokenSlug: tokenInfo.slug,
+          state: APIItemState.READY,
+          free: new BN(balance || '0').toString(),
+          locked: '0'
+        };
+      });
+    }).catch(e => {
+      console.error(`Error on get native balance with token ${tokenInfo.slug}`, e);
+      return addresses.map(address => {
+        return {
+          address: address,
+          tokenSlug: tokenInfo.slug,
+          state: APIItemState.READY,
+          free: '0',
+          locked: '0'
+        };
+      });
+    }).then(items => {
+      callback(items);
+    }).catch(console.error);
+  }
+  getBalance();
+  const interval = setInterval(getBalance, ASTAR_REFRESH_BALANCE_INTERVAL);
+  const unsub2 = subscribeERC20Interval(addresses, chain, evmApiMap, callback);
+  return () => {
+    clearInterval(interval);
+    unsub2 && unsub2();
+  };
+}

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

@@ -0,0 +1,4 @@
+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>;