@subwallet/extension-base 1.1.28-1 → 1.1.28-beta.2

package/koni/background/handlers/State.js

@@ -14,10 +14,12 @@ import CampaignService from '@subwallet/extension-base/services/campaign-service
 import { ChainService } from '@subwallet/extension-base/services/chain-service';
 import { _DEFAULT_MANTA_ZK_CHAIN, _MANTA_ZK_CHAIN_GROUP, _PREDEFINED_SINGLE_MODES } from '@subwallet/extension-base/services/chain-service/constants';
 import { _getEvmChainId, _getSubstrateGenesisHash, _getTokenOnChainAssetId, _isAssetFungibleToken, _isChainEnabled, _isChainTestNet, _parseMetadataForSmartContractAsset } from '@subwallet/extension-base/services/chain-service/utils';
+import EarningService from '@subwallet/extension-base/services/earning-service/service';
 import { EventService } from '@subwallet/extension-base/services/event-service';
 import { HistoryService } from '@subwallet/extension-base/services/history-service';
 import { KeyringService } from '@subwallet/extension-base/services/keyring-service';
 import MigrationService from '@subwallet/extension-base/services/migration-service';
+import MintCampaignService from '@subwallet/extension-base/services/mint-campaign-service';
 import NotificationService from '@subwallet/extension-base/services/notification-service/NotificationService';
 import { PriceService } from '@subwallet/extension-base/services/price-service';
 import RequestService from '@subwallet/extension-base/services/request-service';
@@ -75,6 +77,10 @@ export default class KoniState {
     ready: false,
     data: {}
   };
+
+  // earning
+  yieldPoolInfoSubject = new Subject();
+  yieldPositionSubject = new Subject();
   lazyMap = {};
   // Handle the general status of the extension
   generalStatus = ServiceStatus.INITIALIZING;
@@ -93,11 +99,13 @@ export default class KoniState {
     this.priceService = new PriceService(this.dbService, this.eventService, 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.mintCampaignService = new MintCampaignService(this);
     this.walletConnectService = new WalletConnectService(this, this.requestService);
     this.migrationService = new MigrationService(this, this.eventService);
     this.campaignService = new CampaignService(this);
     this.buyService = new BuyService(this);
+    this.transactionService = new TransactionService(this);
+    this.earningService = new EarningService(this);
     this.subscription = new KoniSubscription(this, this.dbService);
     this.cron = new KoniCron(this, this.subscription, this.dbService);
     this.logger = createLogger('State');
@@ -240,6 +248,7 @@ export default class KoniState {
   }
   async startSubscription() {
     await this.eventService.waitKeyringReady;
+    await this.eventService.waitAssetReady;
     this.dbService.subscribeChainStakingMetadata([], data => {
       this.chainStakingMetadataSubject.next(data);
     });
@@ -250,8 +259,8 @@ export default class KoniState {
     this.keyringService.accountSubject.subscribe(accounts => {
       // TODO: improve this
       unsub && unsub.unsubscribe();
-      unsub = this.dbService.subscribeNominatorMetadata(Object.keys(accounts), data => {
-        this.stakingNominatorMetadataSubject.next(data);
+      unsub = this.dbService.subscribeYieldPosition(Object.keys(accounts), data => {
+        this.yieldPositionSubject.next(data);
       });
     });
   }
@@ -343,6 +352,22 @@ export default class KoniState {
   async getPooledStakingRecordsByAddress(addresses) {
     return this.dbService.getPooledStakings(addresses, this.activeChainSlugs);
   }
+  async getPooledPositionByAddress(addresses) {
+    return this.dbService.getYieldNominationPoolPosition(addresses, this.activeChainSlugs);
+  }
+  subscribeYieldPoolInfo() {
+    return this.yieldPoolInfoSubject;
+  }
+  subscribeYieldPosition() {
+    return this.yieldPositionSubject;
+  }
+  getYieldPoolInfo() {
+    return this.dbService.getYieldPools();
+  }
+  getYieldPositionInfo() {
+    const addresses = this.getDecodedAddresses(this.keyringService.currentAccount.address);
+    return this.dbService.getYieldPositionByAddress(addresses);
+  }
   subscribeMantaPayConfig() {
     return this.mantaPayConfigSubject;
   }
@@ -691,9 +716,14 @@ export default class KoniState {
   }
   isFirstLoad = true;
   async handleResetBalance(newAddress, forceRefresh) {
-    if (this.isFirstLoad || forceRefresh) {
+    if (this.isFirstLoad) {
       const backupBalanceData = await this.dbService.getStoredBalance();
       this.balanceMap.updateBalanceItems(backupBalanceData, isAccountAll(newAddress));
+      this.isFirstLoad = false;
+    }
+    if (forceRefresh) {
+      this.balanceMap.setData({});
+      await this.dbService.stores.balance.clear();
     }
     await Promise.all([this.removeInactiveChainBalances()]);
   }
@@ -1736,4 +1766,26 @@ export default class KoniState {
       specVersion: parseInt((metadata === null || metadata === void 0 ? void 0 : metadata.specVersion) || '0')
     };
   }
+  updateYieldPoolInfo(data) {
+    this.dbService.updateYieldPoolStore(data).catch(e => this.logger.warn(e));
+  }
+  resetYieldPoolInfo(chains) {
+    this.dbService.subscribeYieldPoolInfo(chains, data => {
+      // TODO: no unsub
+      this.yieldPoolInfoSubject.next(data);
+    });
+  }
+  updateYieldPosition(data) {
+    this.dbService.updateYieldPosition(data).catch(e => this.logger.warn(e));
+  }
+  getYieldPoolStakingInfo(chain, poolType) {
+    return this.dbService.getYieldPoolStakingInfo(chain, poolType);
+  }
+  getCrowdloanContributions({
+    address,
+    page,
+    relayChain
+  }) {
+    return this.subscanService.getCrowdloanContributions(relayChain, address, page);
+  }
 }

package/koni/background/handlers/index.js

@@ -58,7 +58,8 @@ export default function handlers({
     assert(port, 'Port has been disconnected');
     port.postMessage({
       id,
-      response
+      response,
+      sender: 'BACKGROUND'
     });
   }).catch(error => {
     console.error(error);
@@ -70,7 +71,8 @@ export default function handlers({
         error: error.message,
         errorCode: error.code,
         errorData: error.data,
-        id
+        id,
+        sender: 'BACKGROUND'
       });
     }
   });

package/koni/background/subscription.d.ts

@@ -1,8 +1,9 @@
 import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
+import { SubstrateApi } from '@subwallet/extension-base/services/chain-service/handler/SubstrateApi';
 import { _ChainState, _EvmApi, _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
 import DatabaseService from '@subwallet/extension-base/services/storage-service/DatabaseService';
 import KoniState from './handlers/State';
-declare type SubscriptionName = 'balance' | 'crowdloan' | 'stakingOnChain' | 'essentialChainStakingMetadata';
+declare type SubscriptionName = 'balance' | 'crowdloan' | 'stakingOnChain' | 'essentialChainStakingMetadata' | 'yieldPoolStats' | 'yieldPosition';
 export declare class KoniSubscription {
     private eventHandler?;
     private subscriptionMap;
@@ -18,6 +19,9 @@ export declare class KoniSubscription {
     stop(): Promise<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;
+    subscribeYieldPools(chainInfoMap: Record<string, _ChainInfo>, assetInfoMap: Record<string, _ChainAsset>, substrateApiMap: Record<string, SubstrateApi>, evmApiMap: Record<string, _EvmApi>, address?: string, onlyRunOnFirstTime?: boolean): void;
+    initYieldPositionSubscription(addresses: string[], substrateApiMap: Record<string, SubstrateApi>, evmApiMap: Record<string, _EvmApi>, chainInfoMap: Record<string, _ChainInfo>, assetInfoMap: Record<string, _ChainAsset>, onlyRunOnFirstTime?: boolean): () => void;
+    initYieldPoolStatsSubscription(substrateApiMap: Record<string, _SubstrateApi>, evmApiMap: Record<string, _EvmApi>, 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;

package/koni/background/subscription.js

@@ -2,21 +2,22 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { subscribeCrowdloan } from '@subwallet/extension-base/koni/api/dotsama/crowdloan';
-import { getNominationStakingRewardData, getPoolingStakingRewardData, stakingOnChainApi } from '@subwallet/extension-base/koni/api/staking';
+import { getNominationStakingRewardData, 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';
-import { logger as createLogger } from '@polkadot/util';
+import { logger as createLogger, noop } from '@polkadot/util';
 export class KoniSubscription {
   subscriptionMap = {
     crowdloan: undefined,
     balance: undefined,
     stakingOnChain: undefined,
-    essentialChainStakingMetadata: undefined
+    essentialChainStakingMetadata: undefined,
+    yieldPoolStats: undefined,
+    yieldPosition: undefined
   };
   constructor(state, dbService) {
     this.dbService = dbService;
@@ -52,6 +53,7 @@ export class KoniSubscription {
     var _this$state$keyringSe;
     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;
+    this.subscribeYieldPools(this.state.getChainInfoMap(), this.state.getAssetRegistry(), this.state.getSubstrateApiMap(), this.state.getEvmApiMap(), currentAddress);
     if (currentAddress) {
       this.subscribeBalances(currentAddress, this.state.getChainInfoMap(), this.state.getChainStateMap(), this.state.getSubstrateApiMap(), this.state.getEvmApiMap());
       this.subscribeCrowdloans(currentAddress, this.state.getSubstrateApiMap());
@@ -65,6 +67,9 @@ export class KoniSubscription {
         return;
       }
       const address = (_serviceInfo$currentA = serviceInfo.currentAccountInfo) === null || _serviceInfo$currentA === void 0 ? void 0 : _serviceInfo$currentA.address;
+
+      // @ts-ignore
+      this.subscribeYieldPools(serviceInfo.chainInfoMap, serviceInfo.assetRegistry, serviceInfo.chainApiMap.substrate, serviceInfo.chainApiMap.evm, address);
       if (!address) {
         return;
       }
@@ -100,6 +105,72 @@ export class KoniSubscription {
       this.updateSubscription('crowdloan', this.initCrowdloanSubscription(addresses, substrateApiMap, onlyRunOnFirstTime));
     }).catch(console.error);
   }
+  subscribeYieldPools(chainInfoMap, assetInfoMap, substrateApiMap, evmApiMap, address, onlyRunOnFirstTime) {
+    this.updateSubscription('yieldPoolStats', this.initYieldPoolStatsSubscription(substrateApiMap, evmApiMap, onlyRunOnFirstTime));
+    if (address) {
+      const addresses = this.state.getDecodedAddresses(address);
+      if (!addresses.length) {
+        return;
+      }
+      this.updateSubscription('yieldPosition', this.initYieldPositionSubscription(addresses, substrateApiMap, evmApiMap, chainInfoMap, assetInfoMap));
+    }
+  }
+  initYieldPositionSubscription(addresses, substrateApiMap, evmApiMap, chainInfoMap, assetInfoMap, onlyRunOnFirstTime) {
+    let cancel = false;
+    const updateYieldPoolStats = data => {
+      this.state.updateYieldPosition(data);
+    };
+    let unsub = noop;
+    this.state.earningService.subscribePoolPositions(addresses, updateYieldPoolStats).then(rs => {
+      if (cancel) {
+        rs();
+      } else {
+        if (onlyRunOnFirstTime) {
+          rs && rs();
+        } else {
+          unsub = rs;
+        }
+      }
+    }).catch(console.error);
+    return () => {
+      cancel = true;
+      unsub && unsub();
+    };
+  }
+  initYieldPoolStatsSubscription(substrateApiMap, evmApiMap, onlyRunOnFirstTime) {
+    let cancel = false;
+    this.state.resetYieldPoolInfo(Object.keys(this.state.getActiveChainInfoMap()));
+    const updateYieldPoolStats = data => {
+      this.state.updateYieldPoolInfo(data);
+    };
+
+    // const unsub = subscribeYieldPoolStats(substrateApiMap, evmApiMap, this.state.getActiveChainInfoMap(), this.state.getAssetRegistry(), updateYieldPoolStats);
+    let unsub = noop;
+    this.state.earningService.subscribePoolsInfo(updateYieldPoolStats).then(rs => {
+      if (cancel) {
+        rs();
+      } else {
+        if (onlyRunOnFirstTime) {
+          rs && rs();
+        } else {
+          unsub = rs;
+        }
+      }
+    }).catch(console.error);
+
+    //
+    // if (onlyRunOnFirstTime) {
+    //   unsub && unsub();
+    //
+    //   return;
+    // }
+
+    return () => {
+      cancel = true;
+      // unsub && unsub();
+      unsub && unsub();
+    };
+  }
   subscribeStakingOnChain(address, substrateApiMap, onlyRunOnFirstTime) {
     this.state.resetStaking(address);
     const addresses = this.state.getDecodedAddresses(address);
@@ -175,15 +246,11 @@ export class KoniSubscription {
       this.state.setCrowdloanItem(networkKey, rs);
     });
     if (onlyRunOnFirstTime) {
-      subscriptionPromise.then(unsub => {
-        unsub && unsub();
-      }).catch(this.logger.warn);
+      subscriptionPromise.then(unsub => unsub === null || unsub === void 0 ? void 0 : unsub()).catch(this.logger.warn);
       return;
     }
     return () => {
-      subscriptionPromise.then(unsub => {
-        unsub && unsub();
-      }).catch(this.logger.warn);
+      subscriptionPromise.then(unsub => unsub === null || unsub === void 0 ? void 0 : unsub()).catch(this.logger.warn);
     };
   }
   subscribeNft(address, substrateApiMap, evmApiMap, smartContractNfts, chainInfoMap) {
@@ -222,7 +289,7 @@ export class KoniSubscription {
     if (!addresses.length) {
       return;
     }
-    const pooledStakingItems = await this.state.getPooledStakingRecordsByAddress(addresses);
+    const pooledStakingItems = await this.state.getPooledPositionByAddress(addresses);
     const pooledAddresses = [];
     pooledStakingItems.forEach(pooledItem => {
       if (!pooledAddresses.includes(pooledItem.address)) {
@@ -242,26 +309,29 @@ export class KoniSubscription {
       activeNetworks.push(key);
     });
     const updateState = result => {
-      this.state.updateStakingReward(result);
+      this.state.earningService.updateEarningReward(result);
     };
-    await Promise.all([getPoolingStakingRewardData(pooledAddresses, targetChainMap, this.state.getSubstrateApiMap(), updateState), getAmplitudeUnclaimedStakingReward(this.state.getSubstrateApiMap(), addresses, chainInfoMap, activeNetworks, updateState)]);
+    await Promise.all([this.state.earningService.getPoolReward(addresses, updateState) // TODO
+    ]);
   }
+
   async reloadStaking() {
-    var _this$state$keyringSe2;
-    const currentAddress = (_this$state$keyringSe2 = this.state.keyringService.currentAccount) === null || _this$state$keyringSe2 === void 0 ? void 0 : _this$state$keyringSe2.address;
-    this.subscribeStakingOnChain(currentAddress, this.state.getSubstrateApiMap());
+    // const currentAddress = this.state.keyringService.currentAccount?.address;
+
+    // this.subscribeYieldPools(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;
+    var _this$state$keyringSe2;
+    const currentAddress = (_this$state$keyringSe2 = this.state.keyringService.currentAccount) === null || _this$state$keyringSe2 === void 0 ? void 0 : _this$state$keyringSe2.address;
+    await this.state.handleResetBalance(currentAddress, true);
     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);
+    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.subscribeCrowdloans(currentAddress, this.state.getSubstrateApiMap());
     await waitTimeout(1800);
   }