@subwallet/extension-base 1.1.33-beta.1 → 1.1.34-0

package/koni/background/handlers/State.js

@@ -14,12 +14,10 @@ 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';
@@ -95,13 +93,11 @@ 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.mintCampaignService = new MintCampaignService(this);
+    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);
     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');
@@ -222,7 +218,6 @@ export default class KoniState {
     await this.migrationService.run();
     this.campaignService.init();
     this.eventService.emit('chain.ready', true);
-    await this.earningService.init();
     this.onReady();
     this.onAccountAdd();
     this.onAccountRemove();
@@ -245,13 +240,20 @@ export default class KoniState {
   }
   async startSubscription() {
     await this.eventService.waitKeyringReady;
-    await this.eventService.waitAssetReady;
     this.dbService.subscribeChainStakingMetadata([], data => {
       this.chainStakingMetadataSubject.next(data);
     });
     this.dbService.subscribeMantaPayConfig(_DEFAULT_MANTA_ZK_CHAIN, data => {
       this.mantaPayConfigSubject.next(data);
     });
+    let unsub;
+    this.keyringService.accountSubject.subscribe(accounts => {
+      // TODO: improve this
+      unsub && unsub.unsubscribe();
+      unsub = this.dbService.subscribeNominatorMetadata(Object.keys(accounts), data => {
+        this.stakingNominatorMetadataSubject.next(data);
+      });
+    });
   }
   onReady() {
     // Todo: Need optimize in the future to, only run important services onetime to save resources
@@ -1407,7 +1409,7 @@ export default class KoniState {
     // Stopping services
     await Promise.all([this.cron.stop(), this.subscription.stop()]);
     await this.pauseAllNetworks(undefined, 'IDLE mode');
-    await Promise.all([this.historyService.stop(), this.priceService.stop(), this.earningService.stop()]);
+    await Promise.all([this.historyService.stop(), this.priceService.stop()]);
 
     // Complete sleeping
     sleeping.resolve();
@@ -1439,7 +1441,7 @@ export default class KoniState {
     }
 
     // Start services
-    await Promise.all([this.cron.start(), this.subscription.start(), this.historyService.start(), this.priceService.start(), this.earningService.start()]);
+    await Promise.all([this.cron.start(), this.subscription.start(), this.historyService.start(), this.priceService.start()]);
 
     // Complete starting
     starting.resolve();
@@ -1540,7 +1542,7 @@ export default class KoniState {
     return await this.cron.reloadNft();
   }
   async reloadStaking() {
-    await this.earningService.reloadEarning(true);
+    await this.subscription.reloadStaking();
     return true;
   }
   async reloadBalance() {
@@ -1739,11 +1741,4 @@ export default class KoniState {
       specVersion: parseInt((metadata === null || metadata === void 0 ? void 0 : metadata.specVersion) || '0')
     };
   }
-  getCrowdloanContributions({
-    address,
-    page,
-    relayChain
-  }) {
-    return this.subscanService.getCrowdloanContributions(relayChain, address, page);
-  }
 }

package/koni/background/handlers/index.js

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

package/koni/background/subscription.d.ts

@@ -2,7 +2,7 @@ import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
 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' | 'yieldPoolStats' | 'yieldPosition';
+declare type SubscriptionName = 'balance' | 'crowdloan' | 'stakingOnChain' | 'essentialChainStakingMetadata';
 export declare class KoniSubscription {
     private eventHandler?;
     private subscriptionMap;
@@ -18,11 +18,16 @@ 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;
+    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;
     initBalanceSubscription(addresses: string[], chainInfoMap: Record<string, _ChainInfo>, chainStateMap: Record<string, _ChainState>, substrateApiMap: Record<string, _SubstrateApi>, evmApiMap: Record<string, _EvmApi>, onlyRunOnFirstTime?: boolean): (() => void) | undefined;
     initCrowdloanSubscription(addresses: string[], substrateApiMap: Record<string, _SubstrateApi>, onlyRunOnFirstTime?: boolean): (() => void) | undefined;
     subscribeNft(address: string, substrateApiMap: Record<string, _SubstrateApi>, evmApiMap: Record<string, _EvmApi>, smartContractNfts: _ChainAsset[], chainInfoMap: Record<string, _ChainInfo>): void;
     initNftSubscription(addresses: string[], substrateApiMap: Record<string, _SubstrateApi>, evmApiMap: Record<string, _EvmApi>, smartContractNfts: _ChainAsset[], chainInfoMap: Record<string, _ChainInfo>): void;
     subscribeStakingReward(address: string): Promise<void>;
+    subscribeStakingRewardFastInterval(address: string): Promise<void>;
+    reloadStaking(): Promise<void>;
     reloadBalance(): Promise<void>;
     reloadCrowdloan(): Promise<void>;
 }

package/koni/background/subscription.js

@@ -2,7 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { subscribeCrowdloan } from '@subwallet/extension-base/koni/api/dotsama/crowdloan';
-import { getNominationStakingRewardData } from '@subwallet/extension-base/koni/api/staking';
+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';
@@ -13,8 +15,8 @@ export class KoniSubscription {
   subscriptionMap = {
     crowdloan: undefined,
     balance: undefined,
-    yieldPoolStats: undefined,
-    yieldPosition: undefined
+    stakingOnChain: undefined,
+    essentialChainStakingMetadata: undefined
   };
   constructor(state, dbService) {
     this.dbService = dbService;
@@ -41,6 +43,10 @@ export class KoniSubscription {
       this.subscriptionMap.crowdloan();
       delete this.subscriptionMap.crowdloan;
     }
+    if (this.subscriptionMap.stakingOnChain) {
+      this.subscriptionMap.stakingOnChain();
+      delete this.subscriptionMap.stakingOnChain;
+    }
   }
   async start() {
     var _this$state$keyringSe;
@@ -49,6 +55,7 @@ export class KoniSubscription {
     if (currentAddress) {
       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) => {
       var _serviceInfo$currentA;
@@ -63,6 +70,7 @@ export class KoniSubscription {
       }
       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.bind(this));
   }
@@ -92,6 +100,55 @@ export class KoniSubscription {
       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);
+    if (!addresses.length) {
+      return;
+    }
+    this.updateSubscription('stakingOnChain', this.initStakingOnChainSubscription(addresses, substrateApiMap, onlyRunOnFirstTime));
+    this.updateSubscription('essentialChainStakingMetadata', this.initEssentialChainStakingMetadataSubscription(substrateApiMap, onlyRunOnFirstTime)); // TODO: might not need to re-subscribe on changing account
+  }
+
+  initStakingOnChainSubscription(addresses, substrateApiMap, onlyRunOnFirstTime) {
+    const stakingCallback = (networkKey, rs) => {
+      this.state.setStakingItem(networkKey, rs);
+    };
+    const nominatorStateCallback = nominatorMetadata => {
+      this.state.updateStakingNominatorMetadata(nominatorMetadata);
+    };
+    const unsub = stakingOnChainApi(addresses, substrateApiMap, this.state.getActiveChainInfoMap(), stakingCallback, nominatorStateCallback);
+    if (onlyRunOnFirstTime) {
+      unsub && unsub();
+      return;
+    }
+    return () => {
+      unsub && unsub();
+    };
+  }
+  initEssentialChainStakingMetadataSubscription(substrateApiMap, onlyRunOnFirstTime) {
+    const unsub = subscribeEssentialChainStakingMetadata(substrateApiMap, this.state.getActiveChainInfoMap(), (networkKey, rs) => {
+      this.state.updateChainStakingMetadata(rs, {
+        era: rs.era,
+        minStake: rs.minStake,
+        maxValidatorPerNominator: rs.maxValidatorPerNominator,
+        // temporary fix for Astar, there's no limit for now
+        maxWithdrawalRequestPerValidator: rs.maxWithdrawalRequestPerValidator,
+        // by default
+        allowCancelUnstaking: rs.allowCancelUnstaking,
+        unstakingPeriod: rs.unstakingPeriod,
+        expectedReturn: rs.expectedReturn,
+        inflation: rs.inflation
+      });
+    });
+    if (onlyRunOnFirstTime) {
+      unsub && unsub();
+      return;
+    }
+    return () => {
+      unsub && unsub();
+    };
+  }
   initBalanceSubscription(addresses, chainInfoMap, chainStateMap, substrateApiMap, evmApiMap, onlyRunOnFirstTime) {
     const filteredChainInfoMap = {};
     Object.values(chainStateMap).forEach(chainState => {
@@ -118,11 +175,15 @@ export class KoniSubscription {
       this.state.setCrowdloanItem(networkKey, rs);
     });
     if (onlyRunOnFirstTime) {
-      subscriptionPromise.then(unsub => unsub === null || unsub === void 0 ? void 0 : unsub()).catch(this.logger.warn);
+      subscriptionPromise.then(unsub => {
+        unsub && unsub();
+      }).catch(this.logger.warn);
       return;
     }
     return () => {
-      subscriptionPromise.then(unsub => unsub === null || unsub === void 0 ? void 0 : unsub()).catch(this.logger.warn);
+      subscriptionPromise.then(unsub => {
+        unsub && unsub();
+      }).catch(this.logger.warn);
     };
   }
   subscribeNft(address, substrateApiMap, evmApiMap, smartContractNfts, chainInfoMap) {
@@ -156,16 +217,51 @@ export class KoniSubscription {
       this.state.updateStakingReward(rewardItem);
     });
   }
-  async reloadBalance() {
+  async subscribeStakingRewardFastInterval(address) {
+    const addresses = this.state.getDecodedAddresses(address);
+    if (!addresses.length) {
+      return;
+    }
+    const pooledStakingItems = await this.state.getPooledStakingRecordsByAddress(addresses);
+    const pooledAddresses = [];
+    pooledStakingItems.forEach(pooledItem => {
+      if (!pooledAddresses.includes(pooledItem.address)) {
+        pooledAddresses.push(pooledItem.address);
+      }
+    });
+    const chainInfoMap = this.state.getChainInfoMap();
+    const targetChainMap = {};
+    Object.entries(chainInfoMap).forEach(([key, network]) => {
+      const chainState = this.state.getChainStateByKey(key);
+      if (_isChainEnabled(chainState) && _isChainSupportSubstrateStaking(network)) {
+        targetChainMap[key] = network;
+      }
+    });
+    const activeNetworks = [];
+    Object.keys(targetChainMap).forEach(key => {
+      activeNetworks.push(key);
+    });
+    const updateState = result => {
+      this.state.updateStakingReward(result);
+    };
+    await Promise.all([getPoolingStakingRewardData(pooledAddresses, targetChainMap, this.state.getSubstrateApiMap(), updateState), getAmplitudeUnclaimedStakingReward(this.state.getSubstrateApiMap(), addresses, chainInfoMap, activeNetworks, updateState)]);
+  }
+  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());
+    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;
     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$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$keyringSe4;
+    const currentAddress = (_this$state$keyringSe4 = this.state.keyringService.currentAccount) === null || _this$state$keyringSe4 === void 0 ? void 0 : _this$state$keyringSe4.address;
     this.subscribeCrowdloans(currentAddress, this.state.getSubstrateApiMap());
     await waitTimeout(1800);
   }