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

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

@@ -1,495 +0,0 @@
-// 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

@@ -1,45 +0,0 @@
-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>;
-}