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

package/services/earning-service/handlers/special.js

@@ -0,0 +1,495 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { COMMON_CHAIN_SLUGS } from '@subwallet/chain-list';
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { BasicTxErrorType, ExtrinsicType, StakingTxErrorType } from '@subwallet/extension-base/background/KoniTypes';
+import { ALL_ACCOUNT_KEY } from '@subwallet/extension-base/constants';
+import { createXcmExtrinsic } from '@subwallet/extension-base/koni/api/xcm';
+import { YIELD_POOL_STAT_REFRESH_INTERVAL } from '@subwallet/extension-base/koni/api/yield/helper/utils';
+import { _getChainNativeTokenSlug } from '@subwallet/extension-base/services/chain-service/utils';
+import { YieldStepType, YieldValidationStatus } from '@subwallet/extension-base/types';
+import { createPromiseHandler, formatNumber } from '@subwallet/extension-base/utils';
+import { t } from 'i18next';
+import { BN, BN_TEN, BN_ZERO, noop } from '@polkadot/util';
+import BasePoolHandler from "./base.js";
+export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
+  /** Pool's type */
+
+  /** Exchange rate before divine with decimals */
+  rate = 0;
+  constructor(state, chain) {
+    super(state, chain);
+    this.exchangeRatePromise = createPromiseHandler();
+  }
+  get metadataInfo() {
+    return {
+      altInputAssets: this.altInputAsset,
+      derivativeAssets: this.derivativeAssets,
+      inputAsset: this.inputAsset,
+      rewardAssets: this.rewardAssets,
+      feeAssets: this.feeAssets,
+      logo: this.logo,
+      shortName: this.shortName,
+      name: this.name,
+      isAvailable: true,
+      maintainAsset: this.nativeToken.slug,
+      maintainBalance: this.maintainBalance,
+      availableMethod: this.availableMethod
+    };
+  }
+  updateExchangeRate(rate) {
+    this.rate = rate;
+    this.exchangeRatePromise.resolve(true);
+  }
+  async getExchangeRate() {
+    await this.exchangeRatePromise.promise;
+    return this.rate;
+  }
+  get isPoolSupportAlternativeFee() {
+    return this.feeAssets.length > 1;
+  }
+  async earlyValidate(request) {
+    var _poolInfo$statistic;
+    const poolInfo = await this.getPoolInfo();
+    if (!poolInfo || !((_poolInfo$statistic = poolInfo.statistic) !== null && _poolInfo$statistic !== void 0 && _poolInfo$statistic.earningThreshold.join)) {
+      return {
+        passed: false,
+        errorMessage: 'There\'s a trouble fetching data, please check your internet connection and try again'
+      };
+    }
+    if (request.address === ALL_ACCOUNT_KEY) {
+      return {
+        passed: true
+      };
+    }
+    const feeAssetInfo = this.state.chainService.getAssetBySlug(this.feeAssets[0]);
+    const altInputAssetInfo = this.state.chainService.getAssetBySlug(this.altInputAsset);
+    const inputAssetInfo = this.state.chainService.getAssetBySlug(this.inputAsset);
+    const [inputAssetBalance, altInputAssetBalance, feeAssetBalance] = await Promise.all([this.state.balanceService.getTokenFreeBalance(request.address, inputAssetInfo.originChain, inputAssetInfo.slug), altInputAssetInfo ? this.state.balanceService.getTokenFreeBalance(request.address, altInputAssetInfo.originChain, altInputAssetInfo.slug) : Promise.resolve({
+      symbol: '',
+      decimals: 0,
+      value: '0'
+    }), this.state.balanceService.getTokenFreeBalance(request.address, feeAssetInfo.originChain, feeAssetInfo.slug)]);
+    const bnInputAssetBalance = new BN(inputAssetBalance.value);
+    const bnAltInputAssetBalance = new BN(altInputAssetBalance.value);
+    const bnMinJoinPool = new BN(poolInfo.statistic.earningThreshold.join);
+    const inputTokenInfo = this.state.chainService.getAssetBySlug(this.inputAsset);
+    const altInputTokenInfo = this.state.chainService.getAssetBySlug(this.altInputAsset);
+    const minJoinDiv = BN_TEN.pow(new BN(inputAssetInfo.decimals || 0));
+    const parsedMinJoinPool = bnMinJoinPool.div(minJoinDiv);
+    if (bnInputAssetBalance.add(bnAltInputAssetBalance).lt(bnMinJoinPool)) {
+      const originChain = this.state.getChainInfo(inputTokenInfo.originChain);
+      const altChain = this.state.getChainInfo(altInputTokenInfo.originChain);
+      return {
+        passed: false,
+        errorMessage: `You need at least ${parsedMinJoinPool.toString()} ${inputTokenInfo.symbol} (${originChain.name}) or ${altInputTokenInfo.symbol} (${altChain.name}) to start earning`
+      };
+    }
+    if (this.feeAssets.length === 1) {
+      const bnFeeAssetBalance = new BN(feeAssetBalance.value);
+      const minFeeAssetBalance = new BN(this.maintainBalance || '0');
+      const feeAssetDiv = BN_TEN.pow(new BN(feeAssetInfo.decimals || 0));
+      const parsedMinFeeAssetBalance = minFeeAssetBalance.div(feeAssetDiv).mul(new BN(12)).div(BN_TEN);
+      if (bnFeeAssetBalance.lte(BN_ZERO)) {
+        const feeChain = this.state.getChainInfo(feeAssetInfo.originChain);
+        return {
+          passed: false,
+          errorMessage: `You need at least ${parsedMinFeeAssetBalance.toString()} ${feeAssetInfo.symbol} (${feeChain.name}) to start earning`
+        };
+      }
+    }
+    return {
+      passed: true
+    };
+  }
+  get group() {
+    const inputAsset = this.state.getAssetBySlug(this.inputAsset);
+    const groupSlug = inputAsset.multiChainAsset;
+    return groupSlug || this.inputAsset;
+  }
+
+  /* Subscribe pool info */
+
+  async subscribePoolInfo(callback) {
+    let cancel = false;
+    const getStatInterval = () => {
+      if (!this.isActive) {
+        if (!cancel) {
+          const rs = {
+            ...this.baseInfo,
+            type: this.type,
+            metadata: {
+              ...this.metadataInfo,
+              description: this.getDescription()
+            }
+          };
+          callback(rs);
+        }
+      } else {
+        this.getPoolStat().then(rs => {
+          if (!cancel) {
+            callback(rs);
+          }
+        }).catch(console.error);
+      }
+    };
+    getStatInterval();
+    const interval = setInterval(() => {
+      if (cancel) {
+        clearInterval(interval);
+      } else {
+        getStatInterval();
+      }
+    }, YIELD_POOL_STAT_REFRESH_INTERVAL);
+    return new Promise(resolve => {
+      const rs = () => {
+        cancel = true;
+        clearInterval(interval);
+      };
+      resolve(rs);
+    });
+  }
+
+  /* Subscribe pool info */
+
+  /* Get pool reward */
+
+  async getPoolReward() {
+    return new Promise(resolve => resolve(noop));
+  }
+  async getPoolRewardHistory() {
+    return new Promise(resolve => resolve(noop));
+  }
+
+  /* Get pool reward */
+
+  /* Get pool targets */
+
+  async getPoolTargets() {
+    return new Promise(resolve => resolve([]));
+  }
+
+  /* Get pool targets */
+
+  /* Join pool action */
+
+  /* Generate steps */
+
+  /**
+   * @async
+   * @function getXcmStep
+   * */
+  async getXcmStep(params) {
+    const {
+      address,
+      amount
+    } = params;
+    const bnAmount = new BN(amount);
+    const inputTokenSlug = this.inputAsset; // assume that the pool only has 1 input token, will update later
+    const inputTokenInfo = this.state.getAssetBySlug(inputTokenSlug);
+    const inputTokenBalance = await this.state.balanceService.getTokenFreeBalance(address, inputTokenInfo.originChain, inputTokenSlug);
+    const bnInputTokenBalance = new BN(inputTokenBalance.value);
+    if (!bnInputTokenBalance.gte(bnAmount)) {
+      if (this.altInputAsset) {
+        const altInputTokenSlug = this.altInputAsset;
+        const altInputTokenInfo = this.state.getAssetBySlug(altInputTokenSlug);
+        const altInputTokenBalance = await this.state.balanceService.getTokenFreeBalance(address, altInputTokenInfo.originChain, altInputTokenSlug);
+        const bnAltInputTokenBalance = new BN(altInputTokenBalance.value || '0');
+        if (bnAltInputTokenBalance.gt(BN_ZERO)) {
+          const step = {
+            metadata: {
+              sendingValue: bnAmount.toString(),
+              originTokenInfo: altInputTokenInfo,
+              destinationTokenInfo: inputTokenInfo
+            },
+            name: 'Transfer DOT from Polkadot',
+            type: YieldStepType.XCM
+          };
+          const xcmOriginSubstrateApi = await this.state.getSubstrateApi(altInputTokenInfo.originChain).isReady;
+          const xcmTransfer = await createXcmExtrinsic({
+            originTokenInfo: altInputTokenInfo,
+            destinationTokenInfo: inputTokenInfo,
+            sendingValue: bnAmount.toString(),
+            recipient: address,
+            chainInfoMap: this.state.getChainInfoMap(),
+            substrateApi: xcmOriginSubstrateApi
+          });
+          const _xcmFeeInfo = await xcmTransfer.paymentInfo(address);
+          const xcmFeeInfo = _xcmFeeInfo.toPrimitive();
+          // TODO: calculate fee for destination chain
+
+          const fee = {
+            slug: altInputTokenSlug,
+            amount: Math.round(xcmFeeInfo.partialFee * 1.2).toString() // TODO
+          };
+
+          return [step, fee];
+        }
+      }
+    }
+    return undefined;
+  }
+  get defaultSubmitStep() {
+    return [this.submitJoinStepInfo, {
+      slug: this.feeAssets[0],
+      amount: '0'
+    }];
+  }
+
+  /**
+   * @function submitJoinStepInfo
+   * @description Base info of submit step
+   * @return Fee of the submitting step
+   * */
+
+  async getSubmitStep(params) {
+    const fee = await this.getSubmitStepFee(params);
+    return [this.submitJoinStepInfo, fee];
+  }
+
+  /* Generate steps */
+
+  /* Validate join action */
+
+  async validateTokenApproveStep(params, path) {
+    return Promise.resolve([new TransactionError(BasicTxErrorType.UNSUPPORTED)]);
+  }
+  async validateXcmStep(params, path, bnInputTokenBalance) {
+    const processValidation = {
+      ok: true,
+      status: YieldValidationStatus.OK
+    };
+    const bnAmount = new BN(params.amount);
+    const altInputTokenSlug = this.altInputAsset || '';
+    const altInputTokenInfo = this.state.getAssetBySlug(altInputTokenSlug);
+    const altInputTokenBalance = await this.state.balanceService.getTokenFreeBalance(params.address, altInputTokenInfo.originChain, altInputTokenSlug);
+    const missingAmount = bnAmount.sub(bnInputTokenBalance); // TODO: what if input token is not LOCAL ??
+    const xcmFee = new BN(path.totalFee[1].amount || '0');
+    const xcmAmount = missingAmount.add(xcmFee);
+    const bnAltInputTokenBalance = new BN(altInputTokenBalance.value || '0');
+    const altInputTokenMinAmount = new BN(altInputTokenInfo.minAmount || '0');
+    if (!bnAltInputTokenBalance.sub(xcmAmount).gte(altInputTokenMinAmount)) {
+      processValidation.failedStep = path.steps[1];
+      processValidation.ok = false;
+      processValidation.status = YieldValidationStatus.NOT_ENOUGH_BALANCE;
+      return [new TransactionError(YieldValidationStatus.NOT_ENOUGH_BALANCE, processValidation.message, processValidation)];
+    }
+    return [];
+  }
+  async validateJoinStep(id, params, path, bnInputTokenBalance, isXcmOk) {
+    const _poolInfo = await this.getPoolInfo();
+    if (!_poolInfo) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    const poolInfo = _poolInfo;
+    if (!poolInfo.statistic) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    const processValidation = {
+      ok: true,
+      status: YieldValidationStatus.OK
+    };
+    const feeTokenSlug = path.totalFee[id].slug;
+    const feeTokenInfo = this.state.getAssetBySlug(feeTokenSlug);
+    const defaultFeeTokenSlug = this.feeAssets[0];
+    const bnAmount = new BN(params.amount);
+    if (this.feeAssets.length === 1 && feeTokenSlug === defaultFeeTokenSlug) {
+      var _path$totalFee$id;
+      const bnFeeAmount = new BN(((_path$totalFee$id = path.totalFee[id]) === null || _path$totalFee$id === void 0 ? void 0 : _path$totalFee$id.amount) || '0');
+      const feeTokenBalance = await this.state.balanceService.getTokenFreeBalance(params.address, feeTokenInfo.originChain, feeTokenSlug);
+      const bnFeeTokenBalance = new BN(feeTokenBalance.value || '0');
+      const bnFeeTokenMinAmount = new BN((feeTokenInfo === null || feeTokenInfo === void 0 ? void 0 : feeTokenInfo.minAmount) || '0');
+      if (!bnFeeTokenBalance.sub(bnFeeAmount).gte(bnFeeTokenMinAmount)) {
+        processValidation.failedStep = path.steps[id];
+        processValidation.ok = false;
+        processValidation.status = YieldValidationStatus.NOT_ENOUGH_FEE;
+        return [new TransactionError(YieldValidationStatus.NOT_ENOUGH_FEE, processValidation.message, processValidation)];
+      }
+    }
+    if (!bnAmount.gte(new BN(poolInfo.statistic.earningThreshold.join || '0'))) {
+      processValidation.failedStep = path.steps[id];
+      processValidation.ok = false;
+      processValidation.status = YieldValidationStatus.NOT_ENOUGH_MIN_JOIN_POOL;
+      return [new TransactionError(YieldValidationStatus.NOT_ENOUGH_MIN_JOIN_POOL, processValidation.message, processValidation)];
+    }
+    if (!isXcmOk && bnAmount.gt(bnInputTokenBalance)) {
+      processValidation.failedStep = path.steps[id];
+      processValidation.ok = false;
+      processValidation.status = YieldValidationStatus.NOT_ENOUGH_BALANCE;
+      return [new TransactionError(YieldValidationStatus.NOT_ENOUGH_BALANCE, processValidation.message, processValidation)];
+    }
+    return [];
+  }
+  async validateYieldJoin(params, path) {
+    const inputTokenSlug = this.inputAsset;
+    const inputTokenInfo = this.state.getAssetBySlug(inputTokenSlug);
+    const balanceService = this.state.balanceService;
+    const inputTokenBalance = await balanceService.getTokenFreeBalance(params.address, inputTokenInfo.originChain, inputTokenSlug);
+    const bnInputTokenBalance = new BN(inputTokenBalance.value || '0');
+    const bnAmount = new BN(params.amount);
+    if (bnAmount.lte(BN_ZERO)) {
+      return [new TransactionError(BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')];
+    }
+    let isXcmOk = false;
+    for (const step of path.steps) {
+      const getErrors = async () => {
+        switch (step.type) {
+          case YieldStepType.DEFAULT:
+            return Promise.resolve([]);
+          case YieldStepType.XCM:
+            return this.validateXcmStep(params, path, bnInputTokenBalance);
+          case YieldStepType.TOKEN_APPROVAL:
+            return this.validateTokenApproveStep(params, path);
+          default:
+            return this.validateJoinStep(step.id, params, path, bnInputTokenBalance, isXcmOk);
+        }
+      };
+      const errors = await getErrors();
+      if (errors.length) {
+        return errors;
+      } else if (step.type === YieldStepType.XCM) {
+        isXcmOk = true;
+      }
+    }
+    return [];
+  }
+
+  /* Validate join action */
+
+  /* Submit join action */
+
+  async handleTokenApproveStep(data, path) {
+    return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
+  }
+  async handleXcmStep(data, path, xcmFee) {
+    const {
+      address,
+      amount
+    } = data;
+    const destinationTokenSlug = this.inputAsset;
+    const originChainInfo = this.state.getChainInfo(COMMON_CHAIN_SLUGS.POLKADOT);
+    const originTokenSlug = _getChainNativeTokenSlug(originChainInfo);
+    const originTokenInfo = this.state.getAssetBySlug(originTokenSlug);
+    const destinationTokenInfo = this.state.getAssetBySlug(destinationTokenSlug);
+    const substrateApi = this.state.getSubstrateApi(originChainInfo.slug);
+    const inputTokenBalance = await this.state.balanceService.getTokenFreeBalance(address, destinationTokenInfo.originChain, destinationTokenSlug);
+    const bnInputTokenBalance = new BN(inputTokenBalance.value);
+    const bnXcmFee = new BN(xcmFee);
+    const bnAmount = new BN(amount);
+    const bnTotalAmount = bnAmount.sub(bnInputTokenBalance).add(bnXcmFee);
+    const extrinsic = await createXcmExtrinsic({
+      chainInfoMap: this.state.getChainInfoMap(),
+      destinationTokenInfo,
+      originTokenInfo,
+      recipient: address,
+      sendingValue: bnTotalAmount.toString(),
+      substrateApi
+    });
+    const xcmData = {
+      originNetworkKey: originChainInfo.slug,
+      destinationNetworkKey: destinationTokenInfo.originChain,
+      from: address,
+      to: address,
+      value: bnTotalAmount.toString(),
+      tokenSlug: originTokenSlug,
+      showExtraWarning: true
+    };
+    return {
+      txChain: originChainInfo.slug,
+      extrinsicType: ExtrinsicType.TRANSFER_XCM,
+      extrinsic,
+      txData: xcmData,
+      transferNativeAmount: bnTotalAmount.toString()
+    };
+  }
+  handleYieldJoin(data, path, currentStep) {
+    const type = path.steps[currentStep].type;
+    switch (type) {
+      case YieldStepType.DEFAULT:
+        return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
+      case YieldStepType.TOKEN_APPROVAL:
+        return this.handleTokenApproveStep(data, path);
+      case YieldStepType.XCM:
+        {
+          const xcmFee = path.totalFee[currentStep].amount || '0';
+          return this.handleXcmStep(data, path, xcmFee);
+        }
+      default:
+        return this.handleSubmitStep(data, path);
+    }
+  }
+
+  /* Submit join action */
+
+  /* Join pool action */
+
+  /* Leave pool action */
+
+  async validateYieldLeave(amount, address, fastLeave, selectedTarget) {
+    const poolInfo = await this.getPoolInfo();
+    const poolPosition = await this.getPoolPosition(address);
+    if (!poolInfo || !poolInfo.statistic || !poolPosition) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (!this.availableMethod.defaultUnstake && !fastLeave) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (!this.availableMethod.fastUnstake && fastLeave) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    const errors = [];
+    const bnActiveStake = new BN(poolPosition.activeStake);
+    const bnAmount = new BN(amount);
+    const bnRemainingStake = bnActiveStake.sub(bnAmount);
+    const minStake = new BN(poolInfo.statistic.earningThreshold.join || '0');
+    const minUnstake = new BN((fastLeave ? poolInfo.statistic.earningThreshold.fastUnstake : poolInfo.statistic.earningThreshold.defaultUnstake) || '0');
+    const maxUnstakeRequest = poolInfo.statistic.maxWithdrawalRequestPerFarmer;
+    const derivativeTokenInfo = this.state.getAssetBySlug(this.derivativeAssets[0]);
+    if (bnAmount.lte(BN_ZERO)) {
+      return [new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('Amount must be greater than 0'))];
+    }
+    if (bnAmount.lt(minUnstake)) {
+      const minUnstakeStr = formatNumber(minUnstake.toString(), derivativeTokenInfo.decimals || 0);
+      errors.push(new TransactionError(StakingTxErrorType.NOT_ENOUGH_MIN_UNSTAKE, t('You need to unstake at least {{amount}} {{token}}', {
+        replace: {
+          amount: minUnstakeStr,
+          token: derivativeTokenInfo.symbol
+        }
+      })));
+    }
+    if (!fastLeave) {
+      if (!(bnRemainingStake.isZero() || bnRemainingStake.gte(minStake))) {
+        errors.push(new TransactionError(StakingTxErrorType.INVALID_ACTIVE_STAKE)); // TODO
+      }
+
+      if (poolPosition.unstakings.length > maxUnstakeRequest) {
+        errors.push(new TransactionError(StakingTxErrorType.EXCEED_MAX_UNSTAKING, t('You cannot unstake more than {{number}} times', {
+          replace: {
+            number: maxUnstakeRequest
+          }
+        })));
+      }
+    }
+    return Promise.resolve(errors);
+  }
+  handleYieldUnstake(amount, address, selectedTarget) {
+    return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
+  }
+
+  /* Leave pool action */
+
+  /* Other action */
+
+  handleYieldCancelUnstake() {
+    return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
+  }
+  handleYieldClaimReward(address, bondReward) {
+    return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
+  }
+  handleYieldWithdraw(address, unstakingInfo) {
+    return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
+  }
+
+  /* Other actions */
+}

package/services/earning-service/service.d.ts

@@ -0,0 +1,45 @@
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
+import { EarningRewardHistoryItem, EarningRewardItem, EarningRewardJson, HandleYieldStepData, HandleYieldStepParams, OptimalYieldPath, OptimalYieldPathParams, RequestEarlyValidateYield, RequestStakeCancelWithdrawal, RequestStakeClaimReward, RequestYieldLeave, RequestYieldWithdrawal, ResponseEarlyValidateYield, TransactionData, ValidateYieldProcessParams, YieldPoolInfo, YieldPoolTarget, YieldPositionInfo } from '@subwallet/extension-base/types';
+import { BehaviorSubject } from 'rxjs';
+import { BasePoolHandler } from './handlers';
+export default class EarningService {
+    protected readonly state: KoniState;
+    protected handlers: Record<string, BasePoolHandler>;
+    private earningRewardSubject;
+    private earningRewardHistorySubject;
+    private minAmountPercentSubject;
+    constructor(state: KoniState);
+    private initHandlers;
+    getPoolHandler(slug: string): BasePoolHandler | undefined;
+    isPoolSupportAlternativeFee(slug: string): boolean;
+    subscribeMinAmountPercent(): BehaviorSubject<Record<string, number>>;
+    getMinAmountPercent(): Record<string, number>;
+    subscribePoolsInfo(callback: (rs: YieldPoolInfo) => void): Promise<VoidFunction>;
+    subscribePoolPositions(addresses: string[], callback: (rs: YieldPositionInfo) => void): Promise<VoidFunction>;
+    updateEarningReward(stakingRewardData: EarningRewardItem): void;
+    getPoolReward(addresses: string[], callback: (result: EarningRewardItem) => void): Promise<VoidFunction>;
+    subscribeEarningReward(): BehaviorSubject<EarningRewardJson>;
+    getEarningRewards(): EarningRewardJson;
+    fetchPoolRewardHistory(addresses: string[], callback: (result: EarningRewardHistoryItem) => void): Promise<VoidFunction>;
+    updateEarningRewardHistory(earningRewardHistory: EarningRewardHistoryItem): void;
+    subscribeEarningRewardHistory(): BehaviorSubject<Record<string, EarningRewardHistoryItem>>;
+    getEarningRewardHistory(): Record<string, EarningRewardHistoryItem>;
+    /**
+     * @async
+     * @function getPoolTargets
+     * @param {string} slug - Pool's slug
+     * @return {Promise<YieldPoolTarget[]>} List of pool's target
+     * */
+    getPoolTargets(slug: string): Promise<YieldPoolTarget[]>;
+    earlyValidateJoin(request: RequestEarlyValidateYield): Promise<ResponseEarlyValidateYield>;
+    generateOptimalSteps(params: OptimalYieldPathParams): Promise<OptimalYieldPath>;
+    validateYieldJoin(params: ValidateYieldProcessParams): Promise<TransactionError[]>;
+    handleYieldJoin(params: HandleYieldStepParams): Promise<HandleYieldStepData>;
+    validateYieldLeave(params: RequestYieldLeave): Promise<TransactionError[]>;
+    handleYieldLeave(params: RequestYieldLeave): Promise<[ExtrinsicType, TransactionData]>;
+    handleYieldWithdraw(params: RequestYieldWithdrawal): Promise<TransactionData>;
+    handleYieldCancelUnstake(params: RequestStakeCancelWithdrawal): Promise<TransactionData>;
+    handleYieldClaimReward(params: RequestStakeClaimReward): Promise<TransactionData>;
+}