@subwallet/extension-base 1.1.35-0 → 1.1.35-beta.0

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

@@ -0,0 +1,733 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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 _constants2 = require("@subwallet/extension-base/services/earning-service/constants");
+var _base = _interopRequireDefault(require("@subwallet/extension-base/services/earning-service/handlers/liquid-staking/base"));
+var _types2 = require("@subwallet/extension-base/types");
+var _utils2 = require("@subwallet/extension-base/utils");
+var _fetchStaticCache = require("@subwallet/extension-base/utils/fetchStaticCache");
+var _rxjs = require("rxjs");
+var _handlers = require("./handlers");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const fetchPoolsData = async () => {
+  const fetchData = await (0, _fetchStaticCache.fetchStaticCache)('earning/yield-pools.json', {
+    data: {}
+  });
+  return fetchData.data;
+};
+class EarningService {
+  handlers = {};
+  earningRewardSubject = new _rxjs.BehaviorSubject({
+    ready: false,
+    data: {}
+  });
+  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.dbService = state.dbService;
+    this.eventService = state.eventService;
+  }
+  async initHandlers() {
+    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 (_constants2._STAKING_CHAIN_GROUP.relay.includes(chain)) {
+        handlers.push(new _handlers.RelayNativeStakingPoolHandler(this.state, chain));
+      }
+      if (_constants2._STAKING_CHAIN_GROUP.para.includes(chain)) {
+        handlers.push(new _handlers.ParaNativeStakingPoolHandler(this.state, chain));
+      }
+      if (_constants2._STAKING_CHAIN_GROUP.astar.includes(chain)) {
+        handlers.push(new _handlers.AstarNativeStakingPoolHandler(this.state, chain));
+      }
+      if (_constants2._STAKING_CHAIN_GROUP.amplitude.includes(chain)) {
+        handlers.push(new _handlers.AmplitudeNativeStakingPoolHandler(this.state, chain));
+      }
+      if (_constants2._STAKING_CHAIN_GROUP.nominationPool.includes(chain)) {
+        handlers.push(new _handlers.NominationPoolHandler(this.state, chain));
+      }
+      if (_constants2._STAKING_CHAIN_GROUP.liquidStaking.includes(chain)) {
+        if (chain === 'bifrost_dot') {
+          handlers.push(new _handlers.BifrostLiquidStakingPoolHandler(this.state, chain));
+        }
+        if (chain === 'acala') {
+          handlers.push(new _handlers.AcalaLiquidStakingPoolHandler(this.state, chain));
+        }
+        if (chain === 'parallel') {
+          handlers.push(new _handlers.ParallelLiquidStakingPoolHandler(this.state, chain));
+        }
+        if (chain === 'moonbeam') {
+          handlers.push(new _handlers.StellaSwapLiquidStakingPoolHandler(this.state, chain));
+        }
+      }
+      if (_constants2._STAKING_CHAIN_GROUP.lending.includes(chain)) {
+        if (chain === 'interlay') {
+          handlers.push(new _handlers.InterlayLendingPoolHandler(this.state, chain));
+        }
+      }
+      for (const handler of handlers) {
+        this.handlers[handler.slug] = handler;
+      }
+    }
+    for (const handler of Object.values(this.handlers)) {
+      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.getYieldPoolInfoFromDB();
+    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];
+  }
+  isPoolSupportAlternativeFee(slug) {
+    const handler = this.getPoolHandler(slug);
+    if (handler) {
+      return handler.isPoolSupportAlternativeFee;
+    } else {
+      throw new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR);
+    }
+  }
+  subscribeMinAmountPercent() {
+    return this.minAmountPercentSubject;
+  }
+  getMinAmountPercent() {
+    return this.minAmountPercentSubject.getValue();
+  }
+  async getYieldPool(slug) {
+    await this.eventService.waitEarningReady;
+    return this.yieldPoolInfoSubject.getValue()[slug];
+  }
+  async subscribePoolsInfo(callback) {
+    let cancel = false;
+    await this.eventService.waitChainReady;
+    const unsubList = [];
+    for (const handler of Object.values(this.handlers)) {
+      handler.subscribePoolInfo(callback).then(unsub => {
+        if (!cancel) {
+          unsubList.push(unsub);
+        } else {
+          unsub();
+        }
+      }).catch(console.error);
+    }
+    return () => {
+      cancel = true;
+      unsubList.forEach(unsub => {
+        unsub === null || unsub === void 0 ? void 0 : unsub();
+      });
+    };
+  }
+  async getYieldPoolInfoFromDB() {
+    // Get online pool data
+    const yieldPoolInfo = {};
+    const existedYieldPoolInfo = await this.dbService.getYieldPools();
+    existedYieldPoolInfo.forEach(info => {
+      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 => {
+        const existed = yieldPoolInfo[item.slug];
+        if (item.statistic && (!(existed !== null && existed !== void 0 && existed.lastUpdated) || existed.lastUpdated < ((item === null || item === void 0 ? void 0 : item.lastUpdated) || 0))) {
+          // Only update item has statistic information
+          yieldPoolInfo[item.slug] = item;
+        }
+      });
+      this.yieldPoolInfoSubject.next(yieldPoolInfo);
+
+      // Persist data
+      this.dbService.updateYieldPoolsStore(queue).catch(console.warn);
+    }, 300, 900);
+  }
+  async fetchingPoolsInfoOnline() {
+    const onlineData = await fetchPoolsData();
+    Object.values(onlineData).forEach(item => {
+      this.updateYieldPoolInfo(item);
+    });
+  }
+  async runSubscribePoolsInfo() {
+    await this.eventService.waitChainReady;
+    this.runUnsubscribePoolsInfo();
+
+    // Fetching online data
+    this.fetchingPoolsInfoOnline().catch(console.error);
+    const interval = setInterval(() => {
+      this.fetchingPoolsInfoOnline().catch(console.error);
+    }, _constants.CRON_REFRESH_CHAIN_STAKING_METADATA);
+
+    // Fetching from chains
+    this.subscribePoolsInfo(data => {
+      data.lastUpdated = Date.now();
+      this.updateYieldPoolInfo(data);
+    }).then(rs => {
+      this.yieldPoolsInfoUnsub = () => {
+        rs();
+        clearInterval(interval);
+      };
+    }).catch(console.error);
+  }
+  runUnsubscribePoolsInfo() {
+    var _this$yieldPoolsInfoU;
+    (_this$yieldPoolsInfoU = this.yieldPoolsInfoUnsub) === null || _this$yieldPoolsInfoU === void 0 ? void 0 : _this$yieldPoolsInfoU.call(this);
+  }
+
+  /* Pools' info methods */
+
+  /* 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.eventService.waitChainReady;
+    const [substrateAddresses, evmAddresses] = (0, _utils2.categoryAddresses)(addresses);
+    const activeChains = this.state.activeChainSlugs;
+    const unsubList = [];
+    for (const handler of Object.values(this.handlers)) {
+      if (activeChains.includes(handler.chain)) {
+        const chainInfo = handler.chainInfo;
+        const useAddresses = (0, _utils._isChainEvmCompatible)(chainInfo) ? evmAddresses : substrateAddresses;
+        handler.subscribePoolPosition(useAddresses, callback).then(unsub => {
+          if (cancel) {
+            unsub();
+          } else {
+            unsubList.push(unsub);
+          }
+        }).catch(console.error);
+      }
+    }
+    return () => {
+      cancel = true;
+      unsubList.forEach(unsub => {
+        unsub === null || unsub === void 0 ? void 0 : unsub();
+      });
+    };
+  }
+  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 = [];
+  }
+
+  /* Pools' position methods */
+
+  /* Get pools' reward */
+
+  updateEarningReward(stakingRewardData) {
+    const stakingRewardState = this.earningRewardSubject.getValue();
+    stakingRewardState.ready = true;
+    const key = `${stakingRewardData.slug}---${stakingRewardData.address}`;
+    stakingRewardState.data[key] = stakingRewardData;
+    this.earningRewardSubject.next(stakingRewardState);
+  }
+  async getPoolReward(addresses, callback) {
+    let cancel = false;
+    await this.eventService.waitChainReady;
+    const [substrateAddresses, evmAddresses] = (0, _utils2.categoryAddresses)(addresses);
+    const activeChains = this.state.activeChainSlugs;
+    const unsubList = [];
+    for (const handler of Object.values(this.handlers)) {
+      if (activeChains.includes(handler.chain)) {
+        const chainInfo = handler.chainInfo;
+        const useAddresses = (0, _utils._isChainEvmCompatible)(chainInfo) ? evmAddresses : substrateAddresses;
+        handler.getPoolReward(useAddresses, callback).then(unsub => {
+          if (cancel) {
+            unsub();
+          } else {
+            unsubList.push(unsub);
+          }
+        }).catch(console.error);
+      }
+    }
+    return () => {
+      cancel = true;
+      unsubList.forEach(unsub => {
+        unsub === null || unsub === void 0 ? void 0 : unsub();
+      });
+    };
+  }
+  subscribeEarningReward() {
+    return this.earningRewardSubject;
+  }
+  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.eventService.waitChainReady;
+    const [substrateAddresses, evmAddresses] = (0, _utils2.categoryAddresses)(addresses);
+    const activeChains = this.state.activeChainSlugs;
+    const unsubList = [];
+    for (const handler of Object.values(this.handlers)) {
+      if (activeChains.includes(handler.chain)) {
+        const chainInfo = handler.chainInfo;
+        const useAddresses = (0, _utils._isChainEvmCompatible)(chainInfo) ? evmAddresses : substrateAddresses;
+        handler.getPoolRewardHistory(useAddresses, callback).then(unsub => {
+          if (cancel) {
+            unsub();
+          } else {
+            unsubList.push(unsub);
+          }
+        }).catch(console.error);
+      }
+    }
+    return () => {
+      cancel = true;
+      unsubList.forEach(unsub => {
+        unsub === null || unsub === void 0 ? void 0 : unsub();
+      });
+    };
+  }
+  updateEarningRewardHistory(earningRewardHistory) {
+    const earningRewardHistoryState = this.earningRewardHistorySubject.getValue();
+    const key = `${earningRewardHistory.slug}---${earningRewardHistory.address}---${earningRewardHistory.eventIndex}`;
+    earningRewardHistoryState[key] = earningRewardHistory;
+    this.earningRewardHistorySubject.next(earningRewardHistoryState);
+  }
+  subscribeEarningRewardHistory() {
+    return this.earningRewardHistorySubject;
+  }
+  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 */
+
+  /* Get pool's targets */
+
+  /**
+   * @async
+   * @function getPoolTargets
+   * @param {string} slug - Pool's slug
+   * @return {Promise<YieldPoolTarget[]>} List of pool's target
+   * */
+  async getPoolTargets(slug) {
+    await this.eventService.waitChainReady;
+    const handler = this.getPoolHandler(slug);
+    if (handler) {
+      return await handler.getPoolTargets();
+    } else {
+      return [];
+    }
+  }
+
+  /* Get pool's targets */
+
+  /* Handle actions */
+
+  /* Join */
+
+  async earlyValidateJoin(request) {
+    await this.eventService.waitChainReady;
+    const {
+      slug
+    } = request;
+    const handler = this.getPoolHandler(slug);
+    if (handler) {
+      return handler.earlyValidate(request);
+    } else {
+      throw new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR);
+    }
+  }
+  async generateOptimalSteps(params) {
+    await this.eventService.waitChainReady;
+    const {
+      slug
+    } = params;
+    const handler = this.getPoolHandler(slug);
+    if (handler) {
+      return handler.generateOptimalPath(params);
+    } else {
+      throw new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR);
+    }
+  }
+  async validateYieldJoin(params) {
+    await this.eventService.waitChainReady;
+    const {
+      slug
+    } = params.data;
+    const handler = this.getPoolHandler(slug);
+    if (handler) {
+      return handler.validateYieldJoin(params.data, params.path);
+    } else {
+      return [new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+  }
+  async handleYieldJoin(params) {
+    await this.eventService.waitChainReady;
+    const {
+      slug
+    } = params.data;
+    const handler = this.getPoolHandler(slug);
+    if (handler) {
+      return handler.handleYieldJoin(params.data, params.path, params.currentStep);
+    } else {
+      return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR));
+    }
+  }
+
+  /* Join */
+
+  /* Leave */
+
+  async validateYieldLeave(params) {
+    await this.eventService.waitChainReady;
+    const {
+      slug
+    } = params;
+    const handler = this.getPoolHandler(slug);
+    if (handler) {
+      return handler.validateYieldLeave(params.amount, params.address, params.fastLeave, params.selectedTarget);
+    } else {
+      return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR));
+    }
+  }
+  async handleYieldLeave(params) {
+    await this.eventService.waitChainReady;
+    const {
+      slug
+    } = params;
+    const handler = this.getPoolHandler(slug);
+    if (handler) {
+      return handler.handleYieldLeave(params.fastLeave, params.amount, params.address, params.selectedTarget);
+    } else {
+      return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR));
+    }
+  }
+
+  /* Leave */
+
+  /* Other */
+
+  async handleYieldWithdraw(params) {
+    await this.eventService.waitChainReady;
+    const {
+      slug
+    } = params;
+    const handler = this.getPoolHandler(slug);
+    if (handler) {
+      return handler.handleYieldWithdraw(params.address, params.unstakingInfo);
+    } else {
+      return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR));
+    }
+  }
+  async handleYieldCancelUnstake(params) {
+    await this.eventService.waitChainReady;
+    const {
+      slug
+    } = params;
+    const handler = this.getPoolHandler(slug);
+    if (handler) {
+      return handler.handleYieldCancelUnstake(params);
+    } else {
+      return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR));
+    }
+  }
+  async handleYieldClaimReward(params) {
+    await this.eventService.waitChainReady;
+    const {
+      slug
+    } = params;
+    const handler = this.getPoolHandler(slug);
+    if (handler) {
+      return handler.handleYieldClaimReward(params.address, params.bondReward);
+    } else {
+      return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR));
+    }
+  }
+
+  /* Other */
+
+  /* Handle actions */
+}
+exports.default = EarningService;