@subwallet/extension-base 1.1.31-beta.0 → 1.1.32-beta.0

package/services/earning-service/service.js

@@ -3,13 +3,25 @@
 
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { BasicTxErrorType } from '@subwallet/extension-base/background/KoniTypes';
+import { CRON_REFRESH_EARNING_REWARD_HISTORY_INTERVAL, CRON_REFRESH_STAKING_REWARD_FAST_INTERVAL } from '@subwallet/extension-base/constants';
+import { ServiceStatus } from '@subwallet/extension-base/services/base/types';
 import { _isChainEvmCompatible } from '@subwallet/extension-base/services/chain-service/utils';
 import { _STAKING_CHAIN_GROUP } from '@subwallet/extension-base/services/earning-service/constants';
 import BaseLiquidStakingPoolHandler from '@subwallet/extension-base/services/earning-service/handlers/liquid-staking/base';
 import { YieldPoolType } from '@subwallet/extension-base/types';
-import { categoryAddresses } from '@subwallet/extension-base/utils';
+import { addLazy, categoryAddresses, createPromiseHandler } from '@subwallet/extension-base/utils';
+import fetch from 'cross-fetch';
 import { BehaviorSubject } from 'rxjs';
 import { AcalaLiquidStakingPoolHandler, AmplitudeNativeStakingPoolHandler, AstarNativeStakingPoolHandler, BifrostLiquidStakingPoolHandler, InterlayLendingPoolHandler, NominationPoolHandler, ParallelLiquidStakingPoolHandler, ParaNativeStakingPoolHandler, RelayNativeStakingPoolHandler, StellaSwapLiquidStakingPoolHandler } from "./handlers/index.js";
+const POOLS_DATA_URLS = 'https://sw-static-cache.pages.dev/earning/yield-pools.json';
+const fetchPoolsData = async () => {
+  const res = await fetch(POOLS_DATA_URLS);
+  if (res.status !== 200) {
+    return {};
+  }
+  const fetchData = await res.json();
+  return fetchData.data;
+};
 export default class EarningService {
   handlers = {};
   earningRewardSubject = new BehaviorSubject({
@@ -18,13 +30,25 @@ export default class EarningService {
   });
   earningRewardHistorySubject = new BehaviorSubject({});
   minAmountPercentSubject = new BehaviorSubject({});
+
+  // earning
+  yieldPoolInfoSubject = new BehaviorSubject({});
+  yieldPositionSubject = new BehaviorSubject({});
+  yieldPositionListSubject = new BehaviorSubject([]); // virtual list of yieldPositionSubject with filter values
+
   constructor(state) {
     this.state = state;
-    this.initHandlers().catch(console.error);
+    this.dbService = state.dbService;
+    this.eventService = state.eventService;
   }
   async initHandlers() {
-    await this.state.eventService.waitChainReady;
-    const chains = Object.keys(this.state.getChainInfoMap());
+    await this.eventService.waitChainReady;
+    const chains = [];
+    for (const chain of Object.values(this.state.getChainInfoMap())) {
+      if (chain.chainStatus === 'ACTIVE') {
+        chains.push(chain.slug);
+      }
+    }
     const minAmountPercent = {};
     for (const chain of chains) {
       const handlers = [];
@@ -73,7 +97,126 @@ export default class EarningService {
     }
     minAmountPercent.default = BaseLiquidStakingPoolHandler.defaultMinAmountPercent;
     this.minAmountPercentSubject.next(minAmountPercent);
+
+    // Emit earning ready
+    this.eventService.emit('earning.ready', true);
   }
+  startPromiseHandler = createPromiseHandler();
+  stopPromiseHandler = createPromiseHandler();
+  status = ServiceStatus.NOT_INITIALIZED;
+  async init() {
+    this.status = ServiceStatus.INITIALIZING;
+    await this.initHandlers();
+
+    // Load data from db
+    await this.loadData();
+
+    // Pin list with value from map
+    this.yieldPositionSubject.subscribe({
+      next: data => {
+        const activeMap = this.state.getActiveChainInfoMap();
+        const activePositions = Object.values(data).filter(item => {
+          return !!activeMap[item.chain];
+        });
+        this.yieldPositionListSubject.next(Object.values(activePositions));
+      }
+    });
+    this.status = ServiceStatus.INITIALIZED;
+    await this.start();
+    this.handleActions();
+  }
+  handleActions() {
+    this.eventService.onLazy((events, eventTypes) => {
+      (async () => {
+        const removedAddresses = [];
+        events.forEach(event => {
+          if (event.type === 'account.remove') {
+            removedAddresses.push(event.data[0]);
+          }
+        });
+        if (removedAddresses.length > 0) {
+          await this.removeYieldPositions(undefined, removedAddresses);
+        }
+
+        // Account changed or chain changed (active or inactive)
+        // Chain changed (active or inactive)
+        // Todo: Optimize performance of chain active or inactive in the future
+        if (eventTypes.includes('account.updateCurrent') || eventTypes.includes('account.remove') || eventTypes.includes('chain.updateState')) {
+          await this.reloadEarning();
+        }
+      })().catch(console.error);
+    });
+  }
+  async loadData() {
+    await this.getYieldPoolInfoFromDBAndOnline();
+    await this.getYieldPositionFromDB();
+  }
+  persistData() {
+    // Data is auto persisted with lazy queue
+    return Promise.resolve(undefined);
+  }
+  async start() {
+    if (this.status === ServiceStatus.STOPPING) {
+      await this.waitForStopped();
+    }
+    if (this.status === ServiceStatus.STARTED || this.status === ServiceStatus.STARTING) {
+      return this.waitForStarted();
+    }
+    this.status = ServiceStatus.STARTING;
+
+    // Start subscribe pools' info
+    await this.runSubscribePoolsInfo();
+
+    // Start subscribe pools' position
+    await this.runSubscribePoolsPosition();
+
+    // Start subscribe pools' reward
+    this.runSubscribeStakingRewardInterval();
+
+    // Start subscribe pools' reward history
+    this.runSubscribeEarningRewardHistoryInterval();
+
+    // Update promise handler
+    this.startPromiseHandler.resolve();
+    this.stopPromiseHandler = createPromiseHandler();
+    this.status = ServiceStatus.STARTED;
+  }
+  async stop() {
+    if (this.status === ServiceStatus.STARTING) {
+      await this.waitForStarted();
+    }
+    if (this.status === ServiceStatus.STOPPED || this.status === ServiceStatus.STOPPING) {
+      return this.waitForStopped();
+    }
+    this.status = ServiceStatus.STOPPING;
+    await this.persistData();
+
+    // Stop subscribe pools' info
+    this.runUnsubscribePoolsInfo();
+
+    // Stop subscribe pools' position
+    this.runUnsubscribePoolsPosition();
+
+    // Stop subscribe pools' reward
+    this.runUnsubscribeStakingRewardInterval();
+
+    // Stop subscribe pools' reward history
+    this.runUnsubscribeEarningRewardHistoryInterval();
+
+    // Update promise handler
+    this.stopPromiseHandler.resolve();
+    this.startPromiseHandler = createPromiseHandler();
+    this.status = ServiceStatus.STOPPED;
+  }
+  waitForStarted() {
+    return this.startPromiseHandler.promise;
+  }
+  waitForStopped() {
+    return this.stopPromiseHandler.promise;
+  }
+
+  /* Pools' info methods */
+
   getPoolHandler(slug) {
     return this.handlers[slug];
   }
@@ -91,19 +234,20 @@ export default class EarningService {
   getMinAmountPercent() {
     return this.minAmountPercentSubject.getValue();
   }
-
-  /* Subscribe pools' info */
-
+  async getYieldPool(slug) {
+    await this.eventService.waitEarningReady;
+    return this.yieldPoolInfoSubject.getValue()[slug];
+  }
   async subscribePoolsInfo(callback) {
     let cancel = false;
-    await this.state.eventService.waitChainReady;
+    await this.eventService.waitChainReady;
     const unsubList = [];
     for (const handler of Object.values(this.handlers)) {
       handler.subscribePoolInfo(callback).then(unsub => {
-        if (cancel) {
-          unsub();
-        } else {
+        if (!cancel) {
           unsubList.push(unsub);
+        } else {
+          unsub();
         }
       }).catch(console.error);
     }
@@ -114,14 +258,71 @@ export default class EarningService {
       });
     };
   }
+  async getYieldPoolInfoFromDBAndOnline() {
+    // Get online pool data
+    const yieldPoolInfo = await Promise.race([fetchPoolsData(), new Promise(resolve => {
+      setTimeout(() => {
+        resolve({});
+      }, 1200);
+    })]);
+    const existedYieldPoolInfo = await this.dbService.getYieldPools();
+    existedYieldPoolInfo.forEach(info => {
+      if (!yieldPoolInfo[info.slug]) {
+        yieldPoolInfo[info.slug] = info;
+      }
+    });
+    this.yieldPoolInfoSubject.next(yieldPoolInfo);
+  }
+  subscribeYieldPoolInfo() {
+    return this.yieldPoolInfoSubject;
+  }
+  async getYieldPoolInfo() {
+    await this.eventService.waitEarningReady;
+    return Object.values(this.yieldPoolInfoSubject.getValue());
+  }
+  yieldPoolPersistQueue = [];
+  updateYieldPoolInfo(data) {
+    this.yieldPoolPersistQueue.push(data);
+    addLazy('persistYieldPoolInfo', () => {
+      const yieldPoolInfo = this.yieldPoolInfoSubject.getValue();
+      const queue = [...this.yieldPoolPersistQueue];
+      this.yieldPoolPersistQueue = [];
+
+      // Update yield pool info
+      queue.forEach(item => {
+        yieldPoolInfo[item.slug] = item;
+      });
+      this.yieldPoolInfoSubject.next(yieldPoolInfo);
+
+      // Persist data
+      this.dbService.updateYieldPoolsStore(queue).catch(console.warn);
+    }, 300, 900);
+  }
+  async runSubscribePoolsInfo() {
+    await this.eventService.waitChainReady;
+    this.runUnsubscribePoolsInfo();
+    this.subscribePoolsInfo(data => {
+      this.updateYieldPoolInfo(data);
+    }).then(rs => {
+      this.yieldPoolsInfoUnsub = rs;
+    }).catch(console.error);
+  }
+  runUnsubscribePoolsInfo() {
+    var _this$yieldPoolsInfoU;
+    (_this$yieldPoolsInfoU = this.yieldPoolsInfoUnsub) === null || _this$yieldPoolsInfoU === void 0 ? void 0 : _this$yieldPoolsInfoU.call(this);
+  }
 
-  /* Subscribe pools' info */
+  /* Pools' info methods */
 
-  /* Subscribe pools' position */
+  /* Pools' position methods */
 
+  async getYieldPosition(address, slug) {
+    await this.eventService.waitEarningReady;
+    return this.yieldPositionSubject.getValue()[`${slug}---${address}`];
+  }
   async subscribePoolPositions(addresses, callback) {
     let cancel = false;
-    await this.state.eventService.waitChainReady;
+    await this.eventService.waitChainReady;
     const [substrateAddresses, evmAddresses] = categoryAddresses(addresses);
     const activeChains = this.state.activeChainSlugs;
     const unsubList = [];
@@ -145,8 +346,102 @@ export default class EarningService {
       });
     };
   }
+  async removeYieldPositions(chains, addresses) {
+    const removeKeys = [];
+    chains && chains.length > 0 && Object.entries(this.yieldPositionSubject.getValue()).forEach(([key, value]) => {
+      console.log('removeYieldPositions', key, value.chain, chains.indexOf(value.chain) > -1);
+      if (chains.indexOf(value.chain) > -1 && !removeKeys.includes(key)) {
+        removeKeys.push(key);
+      }
+    });
+    addresses && addresses.length > 0 && Object.entries(this.yieldPositionSubject.getValue()).forEach(([key, value]) => {
+      if (addresses.indexOf(value.address) > -1 && !removeKeys.includes(key)) {
+        removeKeys.push(key);
+      }
+    });
+
+    // Remove by keys
+    const yieldPositionInfo = this.yieldPositionSubject.getValue();
+    for (const key of removeKeys) {
+      delete yieldPositionInfo[key];
+    }
+    this.yieldPositionSubject.next(yieldPositionInfo);
+    addresses && addresses.length > 0 && (await this.dbService.removeYieldPositionByAddresses(addresses));
+    chains && chains.length > 0 && (await this.dbService.removeYieldPositionByChains(chains));
+  }
+  async getYieldPositionFromDB() {
+    await this.eventService.waitChainReady;
+    await this.eventService.waitKeyringReady;
+    const addresses = this.state.getDecodedAddresses();
+    const existedYieldPosition = await this.dbService.getYieldNominationPoolPosition(addresses, this.state.activeChainSlugs);
+    const yieldPositionInfo = this.yieldPositionSubject.getValue();
+    existedYieldPosition.forEach(item => {
+      yieldPositionInfo[this._getYieldPositionKey(item.slug, item.address)] = item;
+    });
+    this.yieldPositionSubject.next(yieldPositionInfo);
+  }
+  subscribeYieldPosition() {
+    return this.yieldPositionListSubject;
+  }
+  async getYieldPositionInfo() {
+    await this.eventService.waitEarningReady;
+    return Promise.resolve(this.yieldPositionListSubject.getValue());
+  }
+  yieldPositionPersistQueue = [];
+  resetYieldPositionQueue() {
+    this.yieldPositionPersistQueue = [];
+  }
+  resetYieldPosition() {
+    this.yieldPositionSubject.next({});
+    this.yieldPositionPersistQueue = [];
+  }
+  _getYieldPositionKey(slug, address) {
+    return `${slug}---${address}`;
+  }
+  updateYieldPosition(data) {
+    this.yieldPositionPersistQueue.push(data);
+    addLazy('persistYieldPositionInfo', () => {
+      const yieldPositionInfo = this.yieldPositionSubject.getValue();
+      const queue = [...this.yieldPositionPersistQueue];
+      this.yieldPositionPersistQueue = [];
+
+      // Update yield position info
+      queue.forEach(item => {
+        yieldPositionInfo[this._getYieldPositionKey(item.slug, item.address)] = item;
+      });
+      this.yieldPositionSubject.next(yieldPositionInfo);
+
+      // Persist data
+      this.dbService.updateYieldPositions(queue).catch(console.warn);
+    }, 300, 900);
+  }
+  async reloadEarning(reset = false) {
+    await this.waitForStarted();
+    this.runUnsubscribePoolsPosition();
+    this.runUnsubscribeStakingRewardInterval();
+    this.runUnsubscribeEarningRewardHistoryInterval();
+    reset && this.resetYieldPosition();
+    await this.runSubscribePoolsPosition();
+    this.runSubscribeStakingRewardInterval();
+    this.runSubscribeEarningRewardHistoryInterval();
+  }
+  async runSubscribePoolsPosition() {
+    await this.eventService.waitKeyringReady;
+    this.runUnsubscribePoolsPosition();
+    const addresses = this.state.getDecodedAddresses();
+    this.subscribePoolPositions(addresses, data => {
+      this.updateYieldPosition(data);
+    }).then(rs => {
+      this.yieldPositionUnsub = rs;
+    }).catch(console.error);
+  }
+  runUnsubscribePoolsPosition() {
+    var _this$yieldPositionUn;
+    (_this$yieldPositionUn = this.yieldPositionUnsub) === null || _this$yieldPositionUn === void 0 ? void 0 : _this$yieldPositionUn.call(this);
+    this.yieldPositionPersistQueue = [];
+  }
 
-  /* Subscribe pools' position */
+  /* Pools' position methods */
 
   /* Get pools' reward */
 
@@ -159,7 +454,7 @@ export default class EarningService {
   }
   async getPoolReward(addresses, callback) {
     let cancel = false;
-    await this.state.eventService.waitChainReady;
+    await this.eventService.waitChainReady;
     const [substrateAddresses, evmAddresses] = categoryAddresses(addresses);
     const activeChains = this.state.activeChainSlugs;
     const unsubList = [];
@@ -189,9 +484,26 @@ export default class EarningService {
   getEarningRewards() {
     return this.earningRewardSubject.getValue();
   }
+  runSubscribeStakingRewardInterval() {
+    const addresses = this.state.getDecodedAddresses();
+    if (!addresses.length) {
+      return;
+    }
+    this.getPoolReward(addresses, result => {
+      this.updateEarningReward(result);
+    }).catch(console.error);
+    this.earningsRewardInterval = setInterval(() => {
+      this.getPoolReward(addresses, result => {
+        this.updateEarningReward(result);
+      }).catch(console.error);
+    }, CRON_REFRESH_STAKING_REWARD_FAST_INTERVAL);
+  }
+  runUnsubscribeStakingRewardInterval() {
+    this.earningsRewardInterval && clearInterval(this.earningsRewardInterval);
+  }
   async fetchPoolRewardHistory(addresses, callback) {
     let cancel = false;
-    await this.state.eventService.waitChainReady;
+    await this.eventService.waitChainReady;
     const [substrateAddresses, evmAddresses] = categoryAddresses(addresses);
     const activeChains = this.state.activeChainSlugs;
     const unsubList = [];
@@ -217,7 +529,7 @@ export default class EarningService {
   }
   updateEarningRewardHistory(earningRewardHistory) {
     const earningRewardHistoryState = this.earningRewardHistorySubject.getValue();
-    const key = `${earningRewardHistory.slug}---${earningRewardHistory.address}---${earningRewardHistory.blockTimestamp}`;
+    const key = `${earningRewardHistory.slug}---${earningRewardHistory.address}---${earningRewardHistory.eventIndex}`;
     earningRewardHistoryState[key] = earningRewardHistory;
     this.earningRewardHistorySubject.next(earningRewardHistoryState);
   }
@@ -227,6 +539,24 @@ export default class EarningService {
   getEarningRewardHistory() {
     return this.earningRewardHistorySubject.getValue();
   }
+  runSubscribeEarningRewardHistoryInterval() {
+    this.runUnsubscribeEarningRewardHistoryInterval();
+    const addresses = this.state.getDecodedAddresses();
+    if (!addresses.length) {
+      return;
+    }
+    this.fetchPoolRewardHistory(addresses, result => {
+      this.updateEarningRewardHistory(result);
+    }).catch(console.error);
+    this.earningsRewardHistoryInterval = setInterval(() => {
+      this.fetchPoolRewardHistory(addresses, result => {
+        this.updateEarningRewardHistory(result);
+      }).catch(console.error);
+    }, CRON_REFRESH_EARNING_REWARD_HISTORY_INTERVAL);
+  }
+  runUnsubscribeEarningRewardHistoryInterval() {
+    this.earningsRewardHistoryInterval && clearInterval(this.earningsRewardHistoryInterval);
+  }
 
   /* Get pools' reward */
 
@@ -239,7 +569,7 @@ export default class EarningService {
    * @return {Promise<YieldPoolTarget[]>} List of pool's target
    * */
   async getPoolTargets(slug) {
-    await this.state.eventService.waitChainReady;
+    await this.eventService.waitChainReady;
     const handler = this.getPoolHandler(slug);
     if (handler) {
       return await handler.getPoolTargets();
@@ -255,7 +585,7 @@ export default class EarningService {
   /* Join */
 
   async earlyValidateJoin(request) {
-    await this.state.eventService.waitChainReady;
+    await this.eventService.waitChainReady;
     const {
       slug
     } = request;
@@ -267,7 +597,7 @@ export default class EarningService {
     }
   }
   async generateOptimalSteps(params) {
-    await this.state.eventService.waitChainReady;
+    await this.eventService.waitChainReady;
     const {
       slug
     } = params;
@@ -279,7 +609,7 @@ export default class EarningService {
     }
   }
   async validateYieldJoin(params) {
-    await this.state.eventService.waitChainReady;
+    await this.eventService.waitChainReady;
     const {
       slug
     } = params.data;
@@ -291,7 +621,7 @@ export default class EarningService {
     }
   }
   async handleYieldJoin(params) {
-    await this.state.eventService.waitChainReady;
+    await this.eventService.waitChainReady;
     const {
       slug
     } = params.data;
@@ -308,7 +638,7 @@ export default class EarningService {
   /* Leave */
 
   async validateYieldLeave(params) {
-    await this.state.eventService.waitChainReady;
+    await this.eventService.waitChainReady;
     const {
       slug
     } = params;
@@ -320,7 +650,7 @@ export default class EarningService {
     }
   }
   async handleYieldLeave(params) {
-    await this.state.eventService.waitChainReady;
+    await this.eventService.waitChainReady;
     const {
       slug
     } = params;
@@ -337,7 +667,7 @@ export default class EarningService {
   /* Other */
 
   async handleYieldWithdraw(params) {
-    await this.state.eventService.waitChainReady;
+    await this.eventService.waitChainReady;
     const {
       slug
     } = params;
@@ -349,7 +679,7 @@ export default class EarningService {
     }
   }
   async handleYieldCancelUnstake(params) {
-    await this.state.eventService.waitChainReady;
+    await this.eventService.waitChainReady;
     const {
       slug
     } = params;
@@ -361,7 +691,7 @@ export default class EarningService {
     }
   }
   async handleYieldClaimReward(params) {
-    await this.state.eventService.waitChainReady;
+    await this.eventService.waitChainReady;
     const {
       slug
     } = params;

package/services/event-service/index.d.ts

@@ -15,6 +15,7 @@ export declare class EventService extends EventEmitter<EventRegistry> {
     readonly waitCampaignReady: Promise<boolean>;
     readonly waitBuyTokenReady: Promise<boolean>;
     readonly waitBuyServiceReady: Promise<boolean>;
+    readonly waitEarningReady: Promise<boolean>;
     constructor();
     private generateWaitPromise;
     private setLazyTimeout;

package/services/event-service/index.js

@@ -26,6 +26,7 @@ export class EventService extends EventEmitter {
     this.waitCampaignReady = this.generateWaitPromise('campaign.ready');
     this.waitBuyTokenReady = this.generateWaitPromise('buy.tokens.ready');
     this.waitBuyServiceReady = this.generateWaitPromise('buy.services.ready');
+    this.waitEarningReady = this.generateWaitPromise('earning.ready');
   }
   generateWaitPromise(eventType) {
     return new Promise(resolve => {

package/services/event-service/types.d.ts

@@ -35,6 +35,7 @@ export interface EventRegistry {
     'campaign.ready': [boolean];
     'buy.tokens.ready': [boolean];
     'buy.services.ready': [boolean];
+    'earning.ready': [boolean];
 }
 export declare type EventType = keyof EventRegistry;
 export declare const COMMON_RELOAD_EVENTS: EventType[];

package/services/migration-service/scripts/index.js

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import DeleteEarningData from '@subwallet/extension-base/services/migration-service/scripts/DeleteEarningData';
-import EnableEarningChains from '@subwallet/extension-base/services/migration-service/scripts/EnableEarningChains';
 import MigrateEarningVersion from "./databases/MigrateEarningVersion.js";
 import MigrateEthProvider from "./providers/MigrateEthProvider.js";
 import MigratePioneerProvider from "./providers/MigratePioneerProvider.js";
@@ -36,7 +35,7 @@ export default {
   '1.1.6-01': MigrateWalletReference,
   '1.1.7': DeleteChain,
   '1.1.13-01': MigrateTokenDecimals,
-  '1.1.13-02': EnableEarningChains,
+  // '1.1.13-02-2': EnableEarningChains,
   '1.1.13-03': DeleteEarningData,
   '1.1.17-01': MigratePioneerProvider,
   '1.1.17-03': EnableVaraChain,

package/services/storage-service/DatabaseService.d.ts

@@ -90,16 +90,21 @@ export default class DatabaseService {
     getMantaPayFirstConfig(chain: string): Promise<any>;
     removeOldEarningData(): Promise<void>;
     updateYieldPoolStore(data: YieldPoolInfo): Promise<void>;
+    updateYieldPoolsStore(data: YieldPoolInfo[]): Promise<void>;
     deleteYieldPoolInfo(slugs: string[]): Promise<void>;
     getYieldPools(): Promise<YieldPoolInfo[]>;
     getYieldPoolStakingInfo(chain: string, poolType: YieldPoolType): Promise<YieldPoolInfo | undefined>;
     getYieldPool(slug: string): Promise<YieldPoolInfo | undefined>;
     getYieldPositionByAddressAndSlug(address: string, slug: string): Promise<YieldPositionInfo | undefined>;
     subscribeYieldPoolInfo(chains: string[], callback: (data: YieldPoolInfo[]) => void): Subscription;
+    removeYieldPositionByAddresses(addresses: string[]): import("dexie").PromiseExtended<number>;
+    removeYieldPositionByChains(chains: string[]): import("dexie").PromiseExtended<number>;
     updateYieldPosition(data: YieldPositionInfo): Promise<void>;
+    updateYieldPositions(data: YieldPositionInfo[]): Promise<void>;
     getYieldPositionByAddress(addresses: string[]): Promise<YieldPositionInfo[]>;
     subscribeYieldPosition(addresses: string[], callback: (data: YieldPositionInfo[]) => void): Subscription;
     getYieldNominationPoolPosition(addresses: string[], chains: string[]): Promise<YieldPositionInfo[]>;
+    getAllCampaign(): Promise<import("@subwallet/extension-base/background/KoniTypes").CampaignData[]>;
     subscribeProcessingCampaign(): import("dexie").Observable<import("@subwallet/extension-base/background/KoniTypes").CampaignData[]>;
     getProcessingCampaign(): Promise<import("@subwallet/extension-base/background/KoniTypes").CampaignData[]>;
     getCampaign(slug: string): Promise<import("@subwallet/extension-base/background/KoniTypes").CampaignData | undefined>;

package/services/storage-service/DatabaseService.js

@@ -286,6 +286,9 @@ export default class DatabaseService {
   async updateYieldPoolStore(data) {
     await this.stores.yieldPoolInfo.upsert(data);
   }
+  async updateYieldPoolsStore(data) {
+    await this.stores.yieldPoolInfo.bulkUpsert(data);
+  }
   async deleteYieldPoolInfo(slugs) {
     await this.stores.yieldPoolInfo.bulkDelete(slugs);
   }
@@ -308,9 +311,18 @@ export default class DatabaseService {
     });
     return this.yieldInfoSubscription;
   }
+  removeYieldPositionByAddresses(addresses) {
+    return this.stores.yieldPosition.removeByAddresses(addresses);
+  }
+  removeYieldPositionByChains(chains) {
+    return this.stores.yieldPosition.removeByChains(chains);
+  }
   async updateYieldPosition(data) {
     await this.stores.yieldPosition.upsert(data);
   }
+  async updateYieldPositions(data) {
+    await this.stores.yieldPosition.bulkUpsert(data);
+  }
   async getYieldPositionByAddress(addresses) {
     return this.stores.yieldPosition.getByAddress(addresses);
   }
@@ -325,6 +337,9 @@ export default class DatabaseService {
 
   /* Campaign */
 
+  getAllCampaign() {
+    return this.stores.campaign.getAll();
+  }
   subscribeProcessingCampaign() {
     return this.stores.campaign.subscribeProcessingCampaign();
   }

package/services/storage-service/db-stores/Campaign.js

@@ -6,7 +6,13 @@ import { liveQuery } from 'dexie';
 const filterProcessing = campaign => {
   const now = new Date().getTime();
   const isExpired = now <= campaign.startTime || now >= campaign.endTime;
-  return !(campaign.isDone || isExpired);
+  return !(campaign.isArchive || campaign.isDone || isExpired);
+};
+const getId = campaign => {
+  return campaign.campaignId;
+};
+const sortById = (a, b) => {
+  return getId(a) - getId(b);
 };
 export default class CampaignStore extends BaseStore {
   async getAll() {
@@ -16,10 +22,10 @@ export default class CampaignStore extends BaseStore {
     return this.table.get(slug);
   }
   async getProcessingCampaign() {
-    return (await this.table.toArray()).filter(filterProcessing);
+    return (await this.table.toArray()).filter(filterProcessing).sort(sortById);
   }
   subscribeProcessingCampaign() {
-    return liveQuery(() => this.table.filter(filterProcessing).toArray());
+    return liveQuery(async () => (await this.table.filter(filterProcessing).toArray()).sort(sortById));
   }
   upsertCampaign(campaign) {
     return this.table.put(campaign);

package/services/storage-service/db-stores/YieldPositionStore.d.ts

@@ -3,6 +3,8 @@ import { YieldPositionInfo } from '@subwallet/extension-base/types';
 export default class YieldPositionStore extends BaseStore<YieldPositionInfo> {
     getAll(): Promise<YieldPositionInfo[]>;
     getByAddress(addresses: string[]): Promise<YieldPositionInfo[]>;
+    removeByAddresses(addresses: string[]): import("dexie").PromiseExtended<number>;
+    removeByChains(chains: string[]): import("dexie").PromiseExtended<number>;
     getByAddressAndChains(addresses: string[], chains: string[]): Promise<YieldPositionInfo[]>;
     getByAddressAndSlug(address: string, slug: string): import("dexie").PromiseExtended<YieldPositionInfo | undefined>;
     subscribeYieldPositions(addresses: string[]): import("dexie").Observable<YieldPositionInfo[]>;