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

package/cjs/services/earning-service/service.js

@@ -7,16 +7,28 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = void 0;
 var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
 var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _constants = require("@subwallet/extension-base/constants");
+var _types = require("@subwallet/extension-base/services/base/types");
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
-var _constants = require("@subwallet/extension-base/services/earning-service/constants");
+var _constants2 = require("@subwallet/extension-base/services/earning-service/constants");
 var _base = _interopRequireDefault(require("@subwallet/extension-base/services/earning-service/handlers/liquid-staking/base"));
-var _types = require("@subwallet/extension-base/types");
+var _types2 = require("@subwallet/extension-base/types");
 var _utils2 = require("@subwallet/extension-base/utils");
+var _crossFetch = _interopRequireDefault(require("cross-fetch"));
 var _rxjs = require("rxjs");
 var _handlers = require("./handlers");
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
+const POOLS_DATA_URLS = 'https://sw-static-cache.pages.dev/earning/yield-pools.json';
+const fetchPoolsData = async () => {
+  const res = await (0, _crossFetch.default)(POOLS_DATA_URLS);
+  if (res.status !== 200) {
+    return {};
+  }
+  const fetchData = await res.json();
+  return fetchData.data;
+};
 class EarningService {
   handlers = {};
   earningRewardSubject = new _rxjs.BehaviorSubject({
@@ -25,32 +37,44 @@ class EarningService {
   });
   earningRewardHistorySubject = new _rxjs.BehaviorSubject({});
   minAmountPercentSubject = new _rxjs.BehaviorSubject({});
+
+  // earning
+  yieldPoolInfoSubject = new _rxjs.BehaviorSubject({});
+  yieldPositionSubject = new _rxjs.BehaviorSubject({});
+  yieldPositionListSubject = new _rxjs.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 = [];
-      if (_constants._STAKING_CHAIN_GROUP.relay.includes(chain)) {
+      if (_constants2._STAKING_CHAIN_GROUP.relay.includes(chain)) {
         handlers.push(new _handlers.RelayNativeStakingPoolHandler(this.state, chain));
       }
-      if (_constants._STAKING_CHAIN_GROUP.para.includes(chain)) {
+      if (_constants2._STAKING_CHAIN_GROUP.para.includes(chain)) {
         handlers.push(new _handlers.ParaNativeStakingPoolHandler(this.state, chain));
       }
-      if (_constants._STAKING_CHAIN_GROUP.astar.includes(chain)) {
+      if (_constants2._STAKING_CHAIN_GROUP.astar.includes(chain)) {
         handlers.push(new _handlers.AstarNativeStakingPoolHandler(this.state, chain));
       }
-      if (_constants._STAKING_CHAIN_GROUP.amplitude.includes(chain)) {
+      if (_constants2._STAKING_CHAIN_GROUP.amplitude.includes(chain)) {
         handlers.push(new _handlers.AmplitudeNativeStakingPoolHandler(this.state, chain));
       }
-      if (_constants._STAKING_CHAIN_GROUP.nominationPool.includes(chain)) {
+      if (_constants2._STAKING_CHAIN_GROUP.nominationPool.includes(chain)) {
         handlers.push(new _handlers.NominationPoolHandler(this.state, chain));
       }
-      if (_constants._STAKING_CHAIN_GROUP.liquidStaking.includes(chain)) {
+      if (_constants2._STAKING_CHAIN_GROUP.liquidStaking.includes(chain)) {
         if (chain === 'bifrost_dot') {
           handlers.push(new _handlers.BifrostLiquidStakingPoolHandler(this.state, chain));
         }
@@ -64,7 +88,7 @@ class EarningService {
           handlers.push(new _handlers.StellaSwapLiquidStakingPoolHandler(this.state, chain));
         }
       }
-      if (_constants._STAKING_CHAIN_GROUP.lending.includes(chain)) {
+      if (_constants2._STAKING_CHAIN_GROUP.lending.includes(chain)) {
         if (chain === 'interlay') {
           handlers.push(new _handlers.InterlayLendingPoolHandler(this.state, chain));
         }
@@ -74,13 +98,132 @@ class EarningService {
       }
     }
     for (const handler of Object.values(this.handlers)) {
-      if (handler.type === _types.YieldPoolType.LIQUID_STAKING) {
+      if (handler.type === _types2.YieldPoolType.LIQUID_STAKING) {
         minAmountPercent[handler.slug] = handler.minAmountPercent;
       }
     }
     minAmountPercent.default = _base.default.defaultMinAmountPercent;
     this.minAmountPercentSubject.next(minAmountPercent);
+
+    // Emit earning ready
+    this.eventService.emit('earning.ready', true);
   }
+  startPromiseHandler = (0, _utils2.createPromiseHandler)();
+  stopPromiseHandler = (0, _utils2.createPromiseHandler)();
+  status = _types.ServiceStatus.NOT_INITIALIZED;
+  async init() {
+    this.status = _types.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 = _types.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 === _types.ServiceStatus.STOPPING) {
+      await this.waitForStopped();
+    }
+    if (this.status === _types.ServiceStatus.STARTED || this.status === _types.ServiceStatus.STARTING) {
+      return this.waitForStarted();
+    }
+    this.status = _types.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 = (0, _utils2.createPromiseHandler)();
+    this.status = _types.ServiceStatus.STARTED;
+  }
+  async stop() {
+    if (this.status === _types.ServiceStatus.STARTING) {
+      await this.waitForStarted();
+    }
+    if (this.status === _types.ServiceStatus.STOPPED || this.status === _types.ServiceStatus.STOPPING) {
+      return this.waitForStopped();
+    }
+    this.status = _types.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 = (0, _utils2.createPromiseHandler)();
+    this.status = _types.ServiceStatus.STOPPED;
+  }
+  waitForStarted() {
+    return this.startPromiseHandler.promise;
+  }
+  waitForStopped() {
+    return this.stopPromiseHandler.promise;
+  }
+
+  /* Pools' info methods */
+
   getPoolHandler(slug) {
     return this.handlers[slug];
   }
@@ -98,19 +241,20 @@ 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);
     }
@@ -121,14 +265,71 @@ 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);
+    (0, _utils2.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] = (0, _utils2.categoryAddresses)(addresses);
     const activeChains = this.state.activeChainSlugs;
     const unsubList = [];
@@ -152,8 +353,105 @@ class EarningService {
       });
     };
   }
+  async removeYieldPositions(chains, addresses) {
+    const removeKeys = [];
+    chains && chains.length > 0 && Object.entries(this.yieldPositionSubject.getValue()).forEach(_ref => {
+      let [key, value] = _ref;
+      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(_ref2 => {
+      let [key, value] = _ref2;
+      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);
+    (0, _utils2.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() {
+    let reset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 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 */
 
@@ -166,7 +464,7 @@ class EarningService {
   }
   async getPoolReward(addresses, callback) {
     let cancel = false;
-    await this.state.eventService.waitChainReady;
+    await this.eventService.waitChainReady;
     const [substrateAddresses, evmAddresses] = (0, _utils2.categoryAddresses)(addresses);
     const activeChains = this.state.activeChainSlugs;
     const unsubList = [];
@@ -196,9 +494,26 @@ 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);
+    }, _constants.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] = (0, _utils2.categoryAddresses)(addresses);
     const activeChains = this.state.activeChainSlugs;
     const unsubList = [];
@@ -224,7 +539,7 @@ 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);
   }
@@ -234,6 +549,24 @@ 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);
+    }, _constants.CRON_REFRESH_EARNING_REWARD_HISTORY_INTERVAL);
+  }
+  runUnsubscribeEarningRewardHistoryInterval() {
+    this.earningsRewardHistoryInterval && clearInterval(this.earningsRewardHistoryInterval);
+  }
 
   /* Get pools' reward */
 
@@ -246,7 +579,7 @@ 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();
@@ -262,7 +595,7 @@ class EarningService {
   /* Join */
 
   async earlyValidateJoin(request) {
-    await this.state.eventService.waitChainReady;
+    await this.eventService.waitChainReady;
     const {
       slug
     } = request;
@@ -274,7 +607,7 @@ class EarningService {
     }
   }
   async generateOptimalSteps(params) {
-    await this.state.eventService.waitChainReady;
+    await this.eventService.waitChainReady;
     const {
       slug
     } = params;
@@ -286,7 +619,7 @@ class EarningService {
     }
   }
   async validateYieldJoin(params) {
-    await this.state.eventService.waitChainReady;
+    await this.eventService.waitChainReady;
     const {
       slug
     } = params.data;
@@ -298,7 +631,7 @@ class EarningService {
     }
   }
   async handleYieldJoin(params) {
-    await this.state.eventService.waitChainReady;
+    await this.eventService.waitChainReady;
     const {
       slug
     } = params.data;
@@ -315,7 +648,7 @@ class EarningService {
   /* Leave */
 
   async validateYieldLeave(params) {
-    await this.state.eventService.waitChainReady;
+    await this.eventService.waitChainReady;
     const {
       slug
     } = params;
@@ -327,7 +660,7 @@ class EarningService {
     }
   }
   async handleYieldLeave(params) {
-    await this.state.eventService.waitChainReady;
+    await this.eventService.waitChainReady;
     const {
       slug
     } = params;
@@ -344,7 +677,7 @@ class EarningService {
   /* Other */
 
   async handleYieldWithdraw(params) {
-    await this.state.eventService.waitChainReady;
+    await this.eventService.waitChainReady;
     const {
       slug
     } = params;
@@ -356,7 +689,7 @@ class EarningService {
     }
   }
   async handleYieldCancelUnstake(params) {
-    await this.state.eventService.waitChainReady;
+    await this.eventService.waitChainReady;
     const {
       slug
     } = params;
@@ -368,7 +701,7 @@ class EarningService {
     }
   }
   async handleYieldClaimReward(params) {
-    await this.state.eventService.waitChainReady;
+    await this.eventService.waitChainReady;
     const {
       slug
     } = params;

package/cjs/services/event-service/index.js

@@ -33,6 +33,7 @@ class EventService extends _eventemitter.default {
     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/cjs/services/migration-service/scripts/index.js

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = exports.EVERYTIME = void 0;
 var _DeleteEarningData = _interopRequireDefault(require("@subwallet/extension-base/services/migration-service/scripts/DeleteEarningData"));
-var _EnableEarningChains = _interopRequireDefault(require("@subwallet/extension-base/services/migration-service/scripts/EnableEarningChains"));
 var _MigrateEarningVersion = _interopRequireDefault(require("./databases/MigrateEarningVersion"));
 var _MigrateEthProvider = _interopRequireDefault(require("./providers/MigrateEthProvider"));
 var _MigratePioneerProvider = _interopRequireDefault(require("./providers/MigratePioneerProvider"));
@@ -44,7 +43,7 @@ var _default = {
   '1.1.6-01': _MigrateWalletReference.default,
   '1.1.7': _DeleteChain.default,
   '1.1.13-01': _MigrateTokenDecimals.default,
-  '1.1.13-02': _EnableEarningChains.default,
+  // '1.1.13-02-2': EnableEarningChains,
   '1.1.13-03': _DeleteEarningData.default,
   '1.1.17-01': _MigratePioneerProvider.default,
   '1.1.17-03': _EnableVaraChain.default,

package/cjs/services/storage-service/DatabaseService.js

@@ -295,6 +295,9 @@ 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);
   }
@@ -317,9 +320,18 @@ 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);
   }
@@ -334,6 +346,9 @@ class DatabaseService {
 
   /* Campaign */
 
+  getAllCampaign() {
+    return this.stores.campaign.getAll();
+  }
   subscribeProcessingCampaign() {
     return this.stores.campaign.subscribeProcessingCampaign();
   }

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

@@ -13,7 +13,13 @@ var _dexie = require("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);
 };
 class CampaignStore extends _BaseStore.default {
   async getAll() {
@@ -23,10 +29,10 @@ class CampaignStore extends _BaseStore.default {
     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 (0, _dexie.liveQuery)(() => this.table.filter(filterProcessing).toArray());
+    return (0, _dexie.liveQuery)(async () => (await this.table.filter(filterProcessing).toArray()).sort(sortById));
   }
   upsertCampaign(campaign) {
     return this.table.put(campaign);