@subwallet/extension-base 1.1.25-1 → 1.1.27-0

package/koni/api/xcm/xTokens.js

@@ -19,6 +19,6 @@ function getCurrencyId(tokenInfo) {
 }
 export function getExtrinsicByXtokensPallet(tokenInfo, originChainInfo, destinationChainInfo, recipientAddress, value, api) {
   const weightParam = ['pioneer'].includes(originChainInfo.slug) ? FOUR_INSTRUCTIONS_WEIGHT : getDestWeight();
-  const destVersion = ['moonbeam', 'moonriver', 'bifrost_dot', 'interlay', 'hydradx_main', 'acala', 'parallel', 'astar', 'shiden'].includes(originChainInfo.slug) ? 'V3' : undefined;
+  const destVersion = ['moonbeam', 'moonriver', 'bifrost_dot', 'interlay', 'hydradx_main', 'acala', 'parallel', 'astar', 'shiden', 'centrifuge'].includes(originChainInfo.slug) ? 'V3' : undefined;
   return api.tx.xTokens.transfer(getCurrencyId(tokenInfo), value, getDestMultilocation(destinationChainInfo, recipientAddress, destVersion), weightParam);
 }

package/koni/background/handlers/Extension.js

@@ -1000,21 +1000,24 @@ export default class KoniExtension {
     });
     return this.getPrice();
   }
-  getBalance(reset) {
+  async getBalance(reset) {
     return this.#koniState.getBalance(reset);
   }
-  subscribeBalance(id, port) {
+  async subscribeBalance(id, port) {
     const cb = createSubscription(id, port);
     const balanceSubscription = this.#koniState.subscribeBalance().subscribe({
       next: rs => {
-        cb(rs);
+        const data = {
+          details: rs
+        };
+        cb(data);
       }
     });
     this.createUnsubscriptionHandle(id, balanceSubscription.unsubscribe);
     port.onDisconnect.addListener(() => {
       this.cancelSubscription(id);
     });
-    return this.getBalance(true);
+    return await this.getBalance(true);
   }
   getCrowdloan(reset) {
     return this.#koniState.getCrowdloan(reset);
@@ -3204,6 +3207,10 @@ export default class KoniExtension {
       return await this.#koniState.reloadNft();
     } else if (data === 'staking') {
       return await this.#koniState.reloadStaking();
+    } else if (data === 'balance') {
+      return await this.#koniState.reloadBalance();
+    } else if (data === 'crowdloan') {
+      return await this.#koniState.reloadCrowdloan();
     }
     return Promise.resolve(false);
   }
@@ -3730,9 +3737,9 @@ export default class KoniExtension {
       case 'pri(price.getSubscription)':
         return await this.subscribePrice(id, port);
       case 'pri(balance.getBalance)':
-        return this.getBalance();
+        return await this.getBalance();
       case 'pri(balance.getSubscription)':
-        return this.subscribeBalance(id, port);
+        return await this.subscribeBalance(id, port);
       case 'pri(crowdloan.getCrowdloan)':
         return this.getCrowdloan();
       case 'pri(crowdloan.getSubscription)':
@@ -4068,8 +4075,8 @@ export default class KoniExtension {
         return this.#koniState.dbService.exportDB();
       case 'pri(database.import)':
         return this.#koniState.dbService.importDB(request);
-      case 'pri(database.checkMetadata)':
-        return this.#koniState.dbService.checkImportMetadata(request);
+      case 'pri(database.exportJson)':
+        return this.#koniState.dbService.getExportJson();
       /* Database */
       // Default
       default:

package/koni/background/handlers/Mobile.d.ts

@@ -2,9 +2,13 @@
 import { ActiveCronAndSubscriptionMap, CronServiceType, MobileData, RequestCronAndSubscriptionAction, RequestInitCronAndSubscription, SubscriptionServiceType } from '@subwallet/extension-base/background/KoniTypes';
 import { MessageTypes, RequestTypes, ResponseType } from '@subwallet/extension-base/background/types';
 import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
+export declare function isLocalStorageReset(): boolean;
+export declare function isIndexedDBReset(): Promise<boolean>;
+export declare function isWebRunnerDataReset(): Promise<boolean>;
 export default class Mobile {
     private state;
     private restoreHandler;
+    private lastRestoreData;
     constructor(state: KoniState);
     ping(): string;
     initCronAndSubscription({ cron: { activeServices, intervalMap }, subscription: { activeServices } }: RequestInitCronAndSubscription): ActiveCronAndSubscriptionMap;
@@ -18,6 +22,8 @@ export default class Mobile {
     startSubscriptionServices(services: SubscriptionServiceType[]): void;
     stopSubscriptionServices(services: SubscriptionServiceType[]): void;
     restartSubscriptionServices(services: SubscriptionServiceType[]): void;
+    private _getLocalStorageExportData;
+    private _getDexieExportData;
     mobileBackup(): Promise<MobileData>;
     mobileRestore({ indexedDB, storage }: Partial<MobileData>): Promise<void>;
     waitRestore(): Promise<void>;

package/koni/background/handlers/Mobile.js

@@ -1,7 +1,31 @@
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import { state } from '@subwallet/extension-base/koni/background/handlers/index';
+import { SWStorage } from '@subwallet/extension-base/storage';
+import { listMerge } from '@subwallet/extension-base/utils';
 import { createPromiseHandler } from '@subwallet/extension-base/utils/promise';
+export function isLocalStorageReset() {
+  var _window;
+  if ((_window = window) !== null && _window !== void 0 && _window.localStorage) {
+    return !window.localStorage.getItem('keyring:subwallet');
+  } else {
+    return false;
+  }
+}
+export async function isIndexedDBReset() {
+  try {
+    return (await state.dbService.stores.migration.table.count()) < 1;
+  } catch (e) {
+    return true;
+  }
+}
+
+// Detect problems on the web-runner
+export async function isWebRunnerDataReset() {
+  return isLocalStorageReset() || (await isIndexedDBReset());
+}
+const swStorage = SWStorage.instance;
 const DEFAULT_SERVICE_MAP = {
   subscription: {
     chainRegistry: true,
@@ -22,8 +46,17 @@ export default class Mobile {
   // @ts-ignore
 
   restoreHandler = createPromiseHandler();
+  lastRestoreData = {};
   constructor(state) {
     this.state = state;
+    if (!isLocalStorageReset()) {
+      this.lastRestoreData.storage = swStorage.copy();
+    }
+    (async () => {
+      if (!(await isIndexedDBReset())) {
+        this.lastRestoreData.indexedDB = await state.dbService.getExportJson();
+      }
+    })().catch(console.error);
   }
   ping() {
     return 'mobile:ping';
@@ -94,10 +127,46 @@ export default class Mobile {
   restartSubscriptionServices(services) {
     console.log('restartSubscriptionServices');
   }
-  async mobileBackup() {
+  async _getLocalStorageExportData() {
+    return Promise.resolve(JSON.stringify(swStorage.copy()));
+  }
+  async _getDexieExportData() {
     const indexedDB = await this.state.dbService.exportDB();
+    if ((await isIndexedDBReset()) && this.lastRestoreData.indexedDB) {
+      // Merge with latest restore DexieData
+      const exportData = await this.state.dbService.getExportJson();
+      const exportTables = exportData === null || exportData === void 0 ? void 0 : exportData.data.data;
+      const existedData = this.lastRestoreData.indexedDB;
+      const existedTableMap = Object.fromEntries(existedData.data.data.map(table => [table.tableName, table]));
+      if ((exportTables === null || exportTables === void 0 ? void 0 : exportTables.length) > 0) {
+        exportTables.forEach(({
+          inbound,
+          rows,
+          tableName
+        }) => {
+          const latestTable = existedTableMap[tableName];
+
+          // chain & asset & campaign
+          if (tableName === 'chain' || tableName === 'asset' || tableName === 'campaign') {
+            latestTable.rows = listMerge('slug', latestTable.rows, rows);
+
+            // Todo: Campaign still doesn't work
+          } else if (tableName === 'migrations') {
+            latestTable.rows = listMerge('key', latestTable.rows, rows);
+          } else if (tableName === 'transactions') {
+            latestTable.rows = listMerge(['chain', 'address', 'extrinsicHash'], latestTable.rows, rows);
+          }
+        });
+      }
+      return JSON.stringify(existedData);
+    }
+    return indexedDB;
+  }
+  async mobileBackup() {
+    const storage = await this._getLocalStorageExportData();
+    const indexedDB = await this._getDexieExportData();
     return {
-      storage: JSON.stringify(localStorage),
+      storage,
       indexedDB
     };
   }
@@ -108,10 +177,13 @@ export default class Mobile {
     if (storage) {
       const storageData = JSON.parse(storage);
       for (const key in storageData) {
-        localStorage.setItem(key, storageData[key]);
+        swStorage.setItem(key, storageData[key]);
       }
     }
     if (indexedDB) {
+      // Backup the last restore data to memory
+      this.lastRestoreData.indexedDB = JSON.parse(indexedDB);
+      // Backup the last restore data to memory
       await this.state.dbService.importDB(indexedDB);
     }
     this.restoreHandler.resolve();

package/koni/background/handlers/State.d.ts

@@ -36,7 +36,6 @@ export default class KoniState {
     private readonly accountRefStore;
     private externalRequest;
     private balanceMap;
-    private balanceSubject;
     private crowdloanMap;
     private crowdloanSubject;
     private nftSubject;
@@ -84,7 +83,7 @@ export default class KoniState {
     saveMetadata(meta: MetadataDef): void;
     sign(url: string, request: RequestSign, account: AccountJson): Promise<ResponseSigning>;
     get authSubjectV2(): BehaviorSubject<import("@subwallet/extension-base/background/types").AuthorizeRequest[]>;
-    generateDefaultBalanceMap(): BalanceMap;
+    generateDefaultBalanceMap(_addresses?: string[]): BalanceMap;
     private afterChainServiceInit;
     init(): Promise<void>;
     initMantaPay(password: string): Promise<void>;
@@ -150,17 +149,18 @@ export default class KoniState {
     getAccountAddress(): string | null;
     getDecodedAddresses(address?: string): string[];
     getAllAddresses(): string[];
-    private removeInactiveChainBalances;
-    getBalance(reset?: boolean): BalanceJson;
-    getStoredBalance(address: string): Promise<BalanceMap>;
-    handleSwitchAccount(newAddress: string): Promise<void>;
-    resetBalanceMap(newAddress: string): Promise<void>;
+    removeInactiveChainBalances(): Promise<void>;
+    getBalance(reset?: boolean): Promise<BalanceJson>;
+    getStoredBalance(address: string): Promise<BalanceItem[]>;
+    private isFirstLoad;
+    handleResetBalance(newAddress: string, forceRefresh?: boolean): Promise<void>;
     resetCrowdloanMap(newAddress: string): Promise<void>;
     resetStaking(newAddress: string): void;
+    private balanceUpdateCache;
     /** Note: items must be same tokenSlug */
     setBalanceItem(items: BalanceItem[]): void;
     private updateBalanceStore;
-    subscribeBalance(): Subject<BalanceJson>;
+    subscribeBalance(): BehaviorSubject<BalanceMap>;
     getCrowdloan(reset?: boolean): CrowdloanJson;
     getStoredCrowdloan(address: string): Promise<Record<string, import("../../../services/storage-service/databases").ICrowdloanItem>>;
     setCrowdloanItem(networkKey: string, item: CrowdloanItem): void;
@@ -210,7 +210,6 @@ export default class KoniState {
     cleanExternalRequest(): void;
     pauseAllNetworks(code?: number, reason?: string): Promise<void>;
     resumeAllNetworks(): Promise<void>;
-    private publishBalance;
     private publishCrowdloan;
     findNetworkKeyByGenesisHash(genesisHash?: string | null): [string | undefined, _ChainInfo | undefined];
     findChainIdGenesisHash(genesisHash?: string | null): number | undefined;
@@ -236,6 +235,8 @@ export default class KoniState {
     onAccountRemove(): void;
     reloadNft(): Promise<boolean>;
     reloadStaking(): Promise<boolean>;
+    reloadBalance(): Promise<boolean>;
+    reloadCrowdloan(): Promise<boolean>;
     approvePassPhishingPage(_url: string): Promise<boolean>;
     resetWallet(resetAll: boolean): Promise<void>;
     enableMantaPay(updateStore: boolean, address: string, password: string, seedPhrase?: string): Promise<string | undefined>;

package/koni/background/handlers/State.js

@@ -7,7 +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 { BalanceMapImpl } from '@subwallet/extension-base/services/balance-service/BalanceMapImpl';
 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';
@@ -28,7 +28,7 @@ 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 { isAccountAll, isSameAddress, stripUrl, TARGET_ENV } from '@subwallet/extension-base/utils';
+import { addLazy, isAccountAll, 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';
@@ -61,8 +61,7 @@ export default class KoniState {
   unsubscriptionMap = {};
   accountRefStore = new AccountRefStore();
   externalRequest = {};
-  balanceMap = {};
-  balanceSubject = new Subject();
+  balanceMap = new BalanceMapImpl();
   crowdloanMap = generateDefaultCrowdloanMap();
   crowdloanSubject = new Subject();
   nftSubject = new Subject();
@@ -186,11 +185,11 @@ export default class KoniState {
   get authSubjectV2() {
     return this.requestService.authSubjectV2;
   }
-  generateDefaultBalanceMap() {
+  generateDefaultBalanceMap(_addresses) {
     const balanceMap = {};
     const activeChains = this.chainService.getActiveChainInfoMap();
     const isAllAccount = isAccountAll(this.keyringService.currentAccount.address);
-    const addresses = isAllAccount ? Object.keys(this.keyringService.accounts) : [this.keyringService.currentAccount.address];
+    const addresses = _addresses || (isAllAccount ? Object.keys(this.keyringService.accounts) : [this.keyringService.currentAccount.address]);
     addresses.forEach(address => {
       const temp = {};
       Object.values(activeChains).forEach(chainInfo => {
@@ -217,6 +216,7 @@ export default class KoniState {
     await this.chainService.init();
     this.afterChainServiceInit();
     await this.migrationService.run();
+    this.campaignService.init();
     this.eventService.emit('chain.ready', true);
     this.onReady();
     this.onAccountAdd();
@@ -673,70 +673,29 @@ export default class KoniState {
   getAllAddresses() {
     return keyring.getAccounts().map(account => account.address);
   }
-  removeInactiveChainBalances(balanceMap) {
-    const activeBalanceMap = {};
-    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;
-          }
-        }
-      });
+  async removeInactiveChainBalances() {
+    const assetSettings = await this.chainService.getAssetSettings();
+    this.balanceMap.removeBalanceItemByFilter(item => {
+      return !assetSettings[item.tokenSlug];
     });
-    return activeBalanceMap;
   }
-  getBalance(reset) {
-    const activeData = this.removeInactiveChainBalances(this.balanceMap);
+  async getBalance(reset) {
+    await this.removeInactiveChainBalances();
     return {
-      details: activeData,
+      details: this.balanceMap.map,
       reset
     };
   }
   async getStoredBalance(address) {
-    const items = await this.dbService.stores.balance.getBalanceMapByAddresses(address);
-    return items || {};
+    return await this.dbService.stores.balance.getBalanceMapByAddresses(address);
   }
-  async handleSwitchAccount(newAddress) {
-    await Promise.all([this.resetBalanceMap(newAddress), this.resetCrowdloanMap(newAddress)]);
-  }
-  async resetBalanceMap(newAddress) {
-    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
-        };
-      }
+  isFirstLoad = true;
+  async handleResetBalance(newAddress, forceRefresh) {
+    if (this.isFirstLoad || forceRefresh) {
+      const backupBalanceData = await this.dbService.getStoredBalance();
+      this.balanceMap.updateBalanceItems(backupBalanceData, isAccountAll(newAddress));
     }
-    this.balanceMap = {
-      ...defaultData,
-      ...storedData
-    };
-    this.publishBalance(true);
+    await Promise.all([this.removeInactiveChainBalances()]);
   }
   async resetCrowdloanMap(newAddress) {
     const defaultData = generateDefaultCrowdloanMap();
@@ -759,62 +718,35 @@ export default class KoniState {
       });
     });
   }
+  balanceUpdateCache = [];
 
   /** Note: items must be same tokenSlug */
   setBalanceItem(items) {
     if (items.length) {
-      const tokens = [];
-      const updates = [];
+      const nowTime = new Date().getTime();
       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(),
+        const balance = {
+          timestamp: nowTime,
           ...item
         };
-        this.balanceMap[address][tokenSlug] = data;
-        updates.push(data);
+        this.balanceUpdateCache.push(balance);
       }
-      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);
+      addLazy('updateBalanceStore', () => {
+        const isAllAccount = isAccountAll(this.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(updates);
-      this.lazyNext('setBalanceItem', () => {
-        this.publishBalance();
-      });
+        this.updateBalanceStore(this.balanceUpdateCache);
+        this.balanceUpdateCache = [];
+      }, 300, 1800);
     }
   }
   updateBalanceStore(items) {
     this.dbService.updateBulkBalanceStore(items).catch(e => this.logger.warn(e));
   }
   subscribeBalance() {
-    return this.balanceSubject;
+    return this.balanceMap.mapSubject;
   }
   getCrowdloan(reset) {
     return {
@@ -1064,9 +996,6 @@ export default class KoniState {
   async resumeAllNetworks() {
     return this.chainService.resumeAllChainApis();
   }
-  publishBalance(reset) {
-    this.balanceSubject.next(this.getBalance(reset));
-  }
   publishCrowdloan(reset) {
     this.crowdloanSubject.next(this.getCrowdloan(reset));
   }
@@ -1593,6 +1522,7 @@ export default class KoniState {
       // Remove Balance
       stores.balance.removeAllByAddress(address).catch(console.error);
       stores.balance.removeAllByAddress(ALL_ACCOUNT_KEY).catch(console.error);
+      this.balanceMap.removeBalanceItems([address, ALL_ACCOUNT_KEY]);
 
       // Remove NFT
       stores.nft.deleteNftByAddress([address]).catch(console.error);
@@ -1610,6 +1540,14 @@ export default class KoniState {
     await this.subscription.reloadStaking();
     return true;
   }
+  async reloadBalance() {
+    await this.subscription.reloadBalance();
+    return true;
+  }
+  async reloadCrowdloan() {
+    await this.subscription.reloadCrowdloan();
+    return true;
+  }
   async approvePassPhishingPage(_url) {
     return new Promise(resolve => {
       this.settingService.getPassPhishingList(value => {

package/koni/background/handlers/index.js

@@ -44,7 +44,7 @@ export default function handlers({
   const isMobile = port.name === PORT_MOBILE;
   const isExtension = port.name === extensionPortName;
   const sender = port.sender;
-  const from = isExtension ? 'extension' : sender.tab && sender.tab.url || sender.url || '<unknown>';
+  const from = isExtension ? 'extension' : sender.url || sender.tab && sender.tab.url || '<unknown>';
   const source = `${from}: ${id}: ${message}`;
 
   // console.log(` [in] ${source}`); // :: ${JSON.stringify(request)}`);

package/koni/background/subscription.d.ts

@@ -16,7 +16,8 @@ export declare class KoniSubscription {
     stopAllSubscription(): void;
     start(): Promise<void>;
     stop(): Promise<void>;
-    subscribeBalancesAndCrowdloans(address: string, chainInfoMap: Record<string, _ChainInfo>, chainStateMap: Record<string, _ChainState>, substrateApiMap: Record<string, _SubstrateApi>, web3ApiMap: Record<string, _EvmApi>, onlyRunOnFirstTime?: boolean): void;
+    subscribeBalances(address: string, chainInfoMap: Record<string, _ChainInfo>, chainStateMap: Record<string, _ChainState>, substrateApiMap: Record<string, _SubstrateApi>, web3ApiMap: Record<string, _EvmApi>, onlyRunOnFirstTime?: boolean): void;
+    subscribeCrowdloans(address: string, substrateApiMap: Record<string, _SubstrateApi>, onlyRunOnFirstTime?: boolean): void;
     subscribeStakingOnChain(address: string, substrateApiMap: Record<string, _SubstrateApi>, onlyRunOnFirstTime?: boolean): void;
     initStakingOnChainSubscription(addresses: string[], substrateApiMap: Record<string, _SubstrateApi>, onlyRunOnFirstTime?: boolean): (() => void) | undefined;
     initEssentialChainStakingMetadataSubscription(substrateApiMap: Record<string, _SubstrateApi>, onlyRunOnFirstTime?: boolean): (() => void) | undefined;
@@ -27,5 +28,7 @@ export declare class KoniSubscription {
     subscribeStakingReward(address: string): Promise<void>;
     subscribeStakingRewardFastInterval(address: string): Promise<void>;
     reloadStaking(): Promise<void>;
+    reloadBalance(): Promise<void>;
+    reloadCrowdloan(): Promise<void>;
 }
 export {};

package/koni/background/subscription.js

@@ -50,10 +50,11 @@ export class KoniSubscription {
   }
   async start() {
     var _this$state$keyringSe;
-    await Promise.all([this.state.eventService.waitKeyringReady, this.state.eventService.waitAssetReady]);
+    await Promise.all([this.state.eventService.waitCryptoReady, this.state.eventService.waitKeyringReady, this.state.eventService.waitAssetReady]);
     const currentAddress = (_this$state$keyringSe = this.state.keyringService.currentAccount) === null || _this$state$keyringSe === void 0 ? void 0 : _this$state$keyringSe.address;
     if (currentAddress) {
-      this.subscribeBalancesAndCrowdloans(currentAddress, this.state.getChainInfoMap(), this.state.getChainStateMap(), this.state.getSubstrateApiMap(), this.state.getEvmApiMap());
+      this.subscribeBalances(currentAddress, this.state.getChainInfoMap(), this.state.getChainStateMap(), this.state.getSubstrateApiMap(), this.state.getEvmApiMap());
+      this.subscribeCrowdloans(currentAddress, this.state.getSubstrateApiMap());
       this.subscribeStakingOnChain(currentAddress, this.state.getSubstrateApiMap());
     }
     this.eventHandler = (events, eventTypes) => {
@@ -67,10 +68,11 @@ export class KoniSubscription {
       if (!address) {
         return;
       }
-      this.subscribeBalancesAndCrowdloans(address, serviceInfo.chainInfoMap, serviceInfo.chainStateMap, serviceInfo.chainApiMap.substrate, serviceInfo.chainApiMap.evm);
+      this.subscribeBalances(address, serviceInfo.chainInfoMap, serviceInfo.chainStateMap, serviceInfo.chainApiMap.substrate, serviceInfo.chainApiMap.evm);
+      this.subscribeCrowdloans(address, serviceInfo.chainApiMap.substrate);
       this.subscribeStakingOnChain(address, serviceInfo.chainApiMap.substrate);
     };
-    this.state.eventService.onLazy(this.eventHandler);
+    this.state.eventService.onLazy(this.eventHandler.bind(this));
   }
   async stop() {
     if (this.eventHandler) {
@@ -80,16 +82,24 @@ export class KoniSubscription {
     this.stopAllSubscription();
     return Promise.resolve();
   }
-  subscribeBalancesAndCrowdloans(address, chainInfoMap, chainStateMap, substrateApiMap, web3ApiMap, onlyRunOnFirstTime) {
-    this.state.handleSwitchAccount(address).then(() => {
-      const addresses = this.state.getDecodedAddresses(address);
-      if (!addresses.length) {
-        return;
-      }
+  subscribeBalances(address, chainInfoMap, chainStateMap, substrateApiMap, web3ApiMap, onlyRunOnFirstTime) {
+    const addresses = this.state.getDecodedAddresses(address);
+    if (!addresses.length) {
+      return;
+    }
+    this.state.handleResetBalance(address).then(() => {
       this.updateSubscription('balance', this.initBalanceSubscription(addresses, chainInfoMap, chainStateMap, substrateApiMap, web3ApiMap, onlyRunOnFirstTime));
-      this.updateSubscription('crowdloan', this.initCrowdloanSubscription(addresses, substrateApiMap, onlyRunOnFirstTime));
     }).catch(err => this.logger.warn(err));
   }
+  subscribeCrowdloans(address, substrateApiMap, onlyRunOnFirstTime) {
+    const addresses = this.state.getDecodedAddresses(address);
+    if (!addresses.length) {
+      return;
+    }
+    this.state.resetCrowdloanMap(address).then(() => {
+      this.updateSubscription('crowdloan', this.initCrowdloanSubscription(addresses, substrateApiMap, onlyRunOnFirstTime));
+    }).catch(console.error);
+  }
   subscribeStakingOnChain(address, substrateApiMap, onlyRunOnFirstTime) {
     this.state.resetStaking(address);
     const addresses = this.state.getDecodedAddresses(address);
@@ -242,4 +252,17 @@ export class KoniSubscription {
     this.subscribeStakingOnChain(currentAddress, this.state.getSubstrateApiMap());
     await waitTimeout(1800);
   }
+  async reloadBalance() {
+    var _this$state$keyringSe3;
+    const currentAddress = (_this$state$keyringSe3 = this.state.keyringService.currentAccount) === null || _this$state$keyringSe3 === void 0 ? void 0 : _this$state$keyringSe3.address;
+    this.subscribeBalances(currentAddress, this.state.getChainInfoMap(), this.state.getChainStateMap(), this.state.getSubstrateApiMap(), this.state.getEvmApiMap());
+    await waitTimeout(1800);
+  }
+  async reloadCrowdloan() {
+    var _this$state$keyringSe4;
+    const currentAddress = (_this$state$keyringSe4 = this.state.keyringService.currentAccount) === null || _this$state$keyringSe4 === void 0 ? void 0 : _this$state$keyringSe4.address;
+    await this.state.handleResetBalance(currentAddress, true);
+    this.subscribeCrowdloans(currentAddress, this.state.getSubstrateApiMap());
+    await waitTimeout(1800);
+  }
 }