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

package/services/earning-service/service.js

@@ -0,0 +1,709 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+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 { 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({
+    ready: false,
+    data: {}
+  });
+  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.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 (_STAKING_CHAIN_GROUP.relay.includes(chain)) {
+        handlers.push(new RelayNativeStakingPoolHandler(this.state, chain));
+      }
+      if (_STAKING_CHAIN_GROUP.para.includes(chain)) {
+        handlers.push(new ParaNativeStakingPoolHandler(this.state, chain));
+      }
+      if (_STAKING_CHAIN_GROUP.astar.includes(chain)) {
+        handlers.push(new AstarNativeStakingPoolHandler(this.state, chain));
+      }
+      if (_STAKING_CHAIN_GROUP.amplitude.includes(chain)) {
+        handlers.push(new AmplitudeNativeStakingPoolHandler(this.state, chain));
+      }
+      if (_STAKING_CHAIN_GROUP.nominationPool.includes(chain)) {
+        handlers.push(new NominationPoolHandler(this.state, chain));
+      }
+      if (_STAKING_CHAIN_GROUP.liquidStaking.includes(chain)) {
+        if (chain === 'bifrost_dot') {
+          handlers.push(new BifrostLiquidStakingPoolHandler(this.state, chain));
+        }
+        if (chain === 'acala') {
+          handlers.push(new AcalaLiquidStakingPoolHandler(this.state, chain));
+        }
+        if (chain === 'parallel') {
+          handlers.push(new ParallelLiquidStakingPoolHandler(this.state, chain));
+        }
+        if (chain === 'moonbeam') {
+          handlers.push(new StellaSwapLiquidStakingPoolHandler(this.state, chain));
+        }
+      }
+      if (_STAKING_CHAIN_GROUP.lending.includes(chain)) {
+        if (chain === 'interlay') {
+          handlers.push(new 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 === YieldPoolType.LIQUID_STAKING) {
+        minAmountPercent[handler.slug] = handler.minAmountPercent;
+      }
+    }
+    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];
+  }
+  isPoolSupportAlternativeFee(slug) {
+    const handler = this.getPoolHandler(slug);
+    if (handler) {
+      return handler.isPoolSupportAlternativeFee;
+    } else {
+      throw new TransactionError(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 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);
+  }
+
+  /* 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] = 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 = _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(([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 = [];
+  }
+
+  /* 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] = 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 = _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);
+    }, 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] = 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 = _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);
+    }, 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(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(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(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(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(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(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(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(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(BasicTxErrorType.INTERNAL_ERROR));
+    }
+  }
+
+  /* Other */
+
+  /* Handle actions */
+}