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

package/services/earning-service/handlers/nomination-pool/index.js

@@ -0,0 +1,492 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { APIItemState, BasicTxErrorType, ExtrinsicType, StakingTxErrorType, StakingType } from '@subwallet/extension-base/background/KoniTypes';
+import { calculateChainStakedReturn, calculateInflation, getExistUnstakeErrorMessage, getMinStakeErrorMessage, parsePoolStashAddress } from '@subwallet/extension-base/koni/api/staking/bonding/utils';
+import { _STAKING_ERA_LENGTH_MAP } from '@subwallet/extension-base/services/chain-service/constants';
+import { _getChainSubstrateAddressPrefix } from '@subwallet/extension-base/services/chain-service/utils';
+import { EarningStatus, UnstakingStatus, YieldPoolType, YieldStepType } from '@subwallet/extension-base/types';
+import { balanceFormatter, formatNumber, reformatAddress } from '@subwallet/extension-base/utils';
+import BigN from 'bignumber.js';
+import { t } from 'i18next';
+import { BN, BN_ZERO, hexToString, isHex } from '@polkadot/util';
+import BasePoolHandler from "../base.js";
+export default class NominationPoolHandler extends BasePoolHandler {
+  type = YieldPoolType.NOMINATION_POOL;
+  constructor(state, chain) {
+    super(state, chain);
+    const _chainAsset = this.nativeToken;
+    const _chainInfo = this.chainInfo;
+    const symbol = _chainAsset.symbol;
+    const tokenName = _chainAsset.name;
+    this.slug = `${symbol}___nomination_pool___${_chainInfo.slug}`;
+    this.name = `${tokenName} Nomination Pool`;
+    this.shortName = _chainInfo.name.replaceAll(' Relay Chain', '');
+    this.description = `Start staking with just {{amount}} ${symbol}`;
+  }
+
+  /* Subscribe pool info */
+
+  async subscribePoolInfo(callback) {
+    var _substrateApi$api$que;
+    let cancel = false;
+    const substrateApi = this.substrateApi;
+    const chainInfo = this.chainInfo;
+    const nativeToken = this.nativeToken;
+    const defaultData = this.defaultInfo;
+    await substrateApi.isReady;
+    const unsub = await ((_substrateApi$api$que = substrateApi.api.query.staking) === null || _substrateApi$api$que === void 0 ? void 0 : _substrateApi$api$que.currentEra(async _currentEra => {
+      var _substrateApi$api$que2, _substrateApi$api$que3, _substrateApi$api$que4;
+      if (cancel) {
+        unsub();
+        return;
+      }
+      if (!substrateApi.api.query.nominationPools) {
+        return;
+      }
+      const currentEra = _currentEra.toString();
+      const maxUnlockingChunks = substrateApi.api.consts.staking.maxUnlockingChunks.toString();
+      const unlockingEras = substrateApi.api.consts.staking.bondingDuration.toString();
+      const [_totalEraStake, _totalIssuance, _auctionCounter, _minPoolJoin] = await Promise.all([substrateApi.api.query.staking.erasTotalStake(parseInt(currentEra)), substrateApi.api.query.balances.totalIssuance(), (_substrateApi$api$que2 = substrateApi.api.query.auctions) === null || _substrateApi$api$que2 === void 0 ? void 0 : _substrateApi$api$que2.auctionCounter(), (_substrateApi$api$que3 = substrateApi.api.query) === null || _substrateApi$api$que3 === void 0 ? void 0 : (_substrateApi$api$que4 = _substrateApi$api$que3.nominationPools) === null || _substrateApi$api$que4 === void 0 ? void 0 : _substrateApi$api$que4.minJoinBond()]);
+      const rawTotalEraStake = _totalEraStake.toString();
+      const rawTotalIssuance = _totalIssuance.toString();
+      const numAuctions = _auctionCounter ? _auctionCounter.toHuman() : 0;
+      const bnTotalEraStake = new BN(rawTotalEraStake);
+      const bnTotalIssuance = new BN(rawTotalIssuance);
+      const inflation = calculateInflation(bnTotalEraStake, bnTotalIssuance, numAuctions, chainInfo.slug);
+      const minPoolJoin = (_minPoolJoin === null || _minPoolJoin === void 0 ? void 0 : _minPoolJoin.toString()) || undefined;
+      const expectedReturn = calculateChainStakedReturn(inflation, bnTotalEraStake, bnTotalIssuance, chainInfo.slug);
+      const unlockingPeriod = parseInt(unlockingEras) * (_STAKING_ERA_LENGTH_MAP[chainInfo.slug] || _STAKING_ERA_LENGTH_MAP.default); // in hours
+
+      const minToHuman = formatNumber(minPoolJoin || '0', nativeToken.decimals || 0, balanceFormatter);
+      const data = {
+        // TODO
+        ...defaultData,
+        description: this.description.replaceAll('{{amount}}', minToHuman),
+        type: this.type,
+        metadata: {
+          inputAsset: nativeToken.slug,
+          isAvailable: true,
+          maxCandidatePerFarmer: 1,
+          maxWithdrawalRequestPerFarmer: parseInt(maxUnlockingChunks),
+          // TODO recheck
+          minJoinPool: minPoolJoin || '0',
+          farmerCount: 0,
+          // TODO recheck
+          era: parseInt(currentEra),
+          tvl: bnTotalEraStake.toString(),
+          // TODO recheck
+          totalApy: expectedReturn,
+          // TODO recheck
+          unstakingPeriod: unlockingPeriod,
+          allowCancelUnstaking: false,
+          inflation: inflation
+        }
+      };
+      callback(data);
+    }));
+    return () => {
+      cancel = true;
+      unsub();
+    };
+  }
+
+  /* Subscribe pool info */
+
+  /* Subscribe pool position */
+
+  async parsePoolMemberMetadata(substrateApi, poolMemberInfo) {
+    const chainInfo = this.chainInfo;
+    const unlimitedNominatorRewarded = substrateApi.api.consts.staking.maxExposurePageSize !== undefined;
+    const _maxNominatorRewardedPerValidator = (substrateApi.api.consts.staking.maxNominatorRewardedPerValidator || 0).toString();
+    const maxNominatorRewardedPerValidator = parseInt(_maxNominatorRewardedPerValidator);
+    const poolsPalletId = substrateApi.api.consts.nominationPools.palletId.toString();
+    const poolStashAccount = parsePoolStashAddress(substrateApi.api, 0, poolMemberInfo.poolId, poolsPalletId);
+    const [_nominations, _poolMetadata, _currentEra] = await Promise.all([substrateApi.api.query.staking.nominators(poolStashAccount), substrateApi.api.query.nominationPools.metadata(poolMemberInfo.poolId), substrateApi.api.query.staking.currentEra()]);
+    const poolMetadata = _poolMetadata.toPrimitive();
+    const currentEra = _currentEra.toString();
+    const nominations = _nominations.toJSON();
+    const poolName = isHex(poolMetadata) ? hexToString(poolMetadata) : poolMetadata;
+    let stakingStatus = EarningStatus.NOT_EARNING;
+    if (nominations) {
+      const validatorList = nominations.targets;
+      await Promise.all(validatorList.map(async validatorAddress => {
+        const _eraStaker = await substrateApi.api.query.staking.erasStakers(currentEra, validatorAddress);
+        const eraStaker = _eraStaker.toPrimitive();
+        const sortedNominators = eraStaker.others.sort((a, b) => {
+          return new BigN(b.value).minus(a.value).toNumber();
+        });
+        const topNominators = sortedNominators.map(nominator => {
+          return nominator.who;
+        }).slice(0, unlimitedNominatorRewarded ? undefined : maxNominatorRewardedPerValidator);
+        if (topNominators.includes(reformatAddress(poolStashAccount, _getChainSubstrateAddressPrefix(chainInfo)))) {
+          // if address in top nominators
+          stakingStatus = EarningStatus.EARNING_REWARD;
+        }
+      }));
+    }
+    const joinedPoolInfo = {
+      activeStake: poolMemberInfo.points.toString(),
+      chain: chainInfo.slug,
+      status: stakingStatus,
+      validatorIdentity: poolName,
+      validatorAddress: poolMemberInfo.poolId.toString(),
+      // use poolId
+      hasUnstaking: poolMemberInfo.unbondingEras && Object.keys(poolMemberInfo.unbondingEras).length > 0
+    };
+    const unstakings = [];
+    let unstakingBalance = BN_ZERO;
+    Object.entries(poolMemberInfo.unbondingEras).forEach(([unlockingEra, amount]) => {
+      const remainingEra = parseInt(unlockingEra) - parseInt(currentEra);
+      const isClaimable = remainingEra < 0;
+      const waitingTime = remainingEra * _STAKING_ERA_LENGTH_MAP[chainInfo.slug];
+      unstakingBalance = unstakingBalance.add(new BN(amount));
+      unstakings.push({
+        chain: chainInfo.slug,
+        status: isClaimable ? UnstakingStatus.CLAIMABLE : UnstakingStatus.UNLOCKING,
+        claimable: amount.toString(),
+        waitingTime: waitingTime
+      });
+    });
+    const bnActiveStake = new BN(poolMemberInfo.points.toString());
+    const bnTotalStake = bnActiveStake.add(unstakingBalance);
+    if (!bnActiveStake.gt(BN_ZERO)) {
+      stakingStatus = EarningStatus.NOT_EARNING;
+    }
+    return {
+      status: stakingStatus,
+      balanceToken: this.nativeToken.slug,
+      totalStake: bnTotalStake.toString(),
+      activeStake: bnActiveStake.toString(),
+      unstakeBalance: unstakingBalance.toString(),
+      isBondedBefore: bnTotalStake.gt(BN_ZERO),
+      nominations: [joinedPoolInfo],
+      // can only join 1 pool at a time
+      unstakings
+    };
+  }
+  async subscribePoolPosition(useAddresses, resultCallback) {
+    var _substrateApi$api$que5, _substrateApi$api$que6;
+    let cancel = false;
+    const substrateApi = this.substrateApi;
+    const defaultInfo = this.defaultInfo;
+    await substrateApi.isReady;
+    const unsub = await ((_substrateApi$api$que5 = substrateApi.api.query) === null || _substrateApi$api$que5 === void 0 ? void 0 : (_substrateApi$api$que6 = _substrateApi$api$que5.nominationPools) === null || _substrateApi$api$que6 === void 0 ? void 0 : _substrateApi$api$que6.poolMembers.multi(useAddresses, async ledgers => {
+      if (cancel) {
+        unsub();
+        return;
+      }
+      if (ledgers) {
+        await Promise.all(ledgers.map(async (_poolMemberInfo, i) => {
+          const poolMemberInfo = _poolMemberInfo.toPrimitive();
+          const owner = reformatAddress(useAddresses[i], 42);
+          if (poolMemberInfo) {
+            const nominatorMetadata = await this.parsePoolMemberMetadata(substrateApi, poolMemberInfo);
+            resultCallback({
+              ...defaultInfo,
+              ...nominatorMetadata,
+              address: owner,
+              type: this.type
+            });
+          } else {
+            resultCallback({
+              ...defaultInfo,
+              type: this.type,
+              address: owner,
+              balanceToken: this.nativeToken.slug,
+              totalStake: '0',
+              activeStake: '0',
+              unstakeBalance: '0',
+              isBondedBefore: false,
+              status: EarningStatus.NOT_STAKING,
+              nominations: [],
+              // can only join 1 pool at a time
+              unstakings: []
+            });
+          }
+        }));
+      }
+    }));
+    return () => {
+      cancel = true;
+      unsub();
+    };
+  }
+
+  /* Subscribe pool position */
+
+  /* Get pool reward */
+
+  async getPoolReward(useAddresses, callBack) {
+    let cancel = false;
+    const substrateApi = this.substrateApi;
+    await substrateApi.isReady;
+    if (substrateApi.api.call.nominationPoolsApi) {
+      for (const address of useAddresses) {
+        if (!cancel) {
+          var _substrateApi$api$cal, _substrateApi$api$cal2;
+          const _unclaimedReward = await ((_substrateApi$api$cal = substrateApi.api.call) === null || _substrateApi$api$cal === void 0 ? void 0 : (_substrateApi$api$cal2 = _substrateApi$api$cal.nominationPoolsApi) === null || _substrateApi$api$cal2 === void 0 ? void 0 : _substrateApi$api$cal2.pendingRewards(address));
+          if (_unclaimedReward) {
+            callBack({
+              ...this.defaultInfo,
+              address: address,
+              type: this.type,
+              unclaimedReward: _unclaimedReward.toString(),
+              state: APIItemState.READY
+            });
+          }
+        }
+      }
+    }
+    return () => {
+      cancel = false;
+    };
+  }
+
+  /* Get pool reward */
+
+  /* Get pool targets */
+
+  async getPoolTargets() {
+    const substrateApi = await this.substrateApi.isReady;
+    const nominationPools = [];
+    const _allPoolsInfo = await substrateApi.api.query.nominationPools.reversePoolIdLookup.entries();
+    await Promise.all(_allPoolsInfo.map(async _poolInfo => {
+      var _bondedPool$points;
+      const poolAddressList = _poolInfo[0].toHuman();
+      const poolAddress = poolAddressList[0];
+      const poolId = _poolInfo[1].toPrimitive();
+      const poolsPalletId = substrateApi.api.consts.nominationPools.palletId.toString();
+      const poolStashAccount = parsePoolStashAddress(substrateApi.api, 0, poolId, poolsPalletId);
+      const [_nominations, _bondedPool, _metadata, _minimumActiveStake] = await Promise.all([substrateApi.api.query.staking.nominators(poolStashAccount), substrateApi.api.query.nominationPools.bondedPools(poolId), substrateApi.api.query.nominationPools.metadata(poolId), substrateApi.api.query.staking.minimumActiveStake()]);
+      const minimumActiveStake = _minimumActiveStake.toPrimitive();
+      const nominations = _nominations.toJSON();
+      const poolMetadata = _metadata.toPrimitive();
+      const bondedPool = _bondedPool.toPrimitive();
+      const poolName = isHex(poolMetadata) ? hexToString(poolMetadata) : poolMetadata;
+      const isPoolOpen = bondedPool.state === 'Open';
+      const isPoolNominating = !!nominations && nominations.targets.length > 0;
+      const isPoolEarningReward = bondedPool.points > minimumActiveStake;
+      nominationPools.push({
+        id: poolId,
+        address: poolAddress,
+        name: poolName,
+        bondedAmount: ((_bondedPool$points = bondedPool.points) === null || _bondedPool$points === void 0 ? void 0 : _bondedPool$points.toString()) || '0',
+        roles: bondedPool.roles,
+        memberCounter: bondedPool.memberCounter,
+        state: bondedPool.state,
+        isProfitable: isPoolOpen && isPoolNominating && isPoolEarningReward
+      });
+    }));
+    return nominationPools;
+  }
+
+  /* Get pool targets */
+
+  /* Join pool action */
+
+  get defaultSubmitStep() {
+    return [{
+      name: 'Join nomination pool',
+      type: YieldStepType.JOIN_NOMINATION_POOL
+    }, {
+      slug: this.nativeToken.slug,
+      amount: '0'
+    }];
+  }
+  async getSubmitStep(params) {
+    const {
+      address,
+      amount,
+      slug,
+      targets
+    } = params;
+    if (!targets || !targets.length) {
+      return Promise.reject(new TransactionError(BasicTxErrorType.INVALID_PARAMS));
+    }
+    const data = {
+      amount,
+      address,
+      slug,
+      selectedPool: targets[0]
+    };
+    const positionInfo = await this.getPoolPosition(address);
+    const [, fee] = await this.createJoinExtrinsic(data, positionInfo);
+    return [{
+      name: 'Join nomination pool',
+      type: YieldStepType.JOIN_NOMINATION_POOL,
+      metadata: {
+        amount: amount
+      }
+    }, fee];
+  }
+  async validateYieldJoin(data, path) {
+    const {
+      address,
+      amount,
+      selectedPool
+    } = data;
+    const _poolInfo = await this.getPoolInfo();
+    if (!_poolInfo) {
+      return Promise.resolve([new TransactionError(BasicTxErrorType.INTERNAL_ERROR)]);
+    }
+    const poolInfo = _poolInfo;
+    const chainInfo = this.chainInfo;
+    const positionInfo = await this.getPoolPosition(address);
+
+    // cannot stake when unstake all
+    // amount >= min stake
+    const errors = [];
+    let bnTotalStake = new BN(amount);
+    const bnMinStake = new BN(poolInfo.metadata.minJoinPool || '0');
+    const minStakeErrorMessage = getMinStakeErrorMessage(chainInfo, bnMinStake);
+    const existUnstakeErrorMessage = getExistUnstakeErrorMessage(chainInfo.slug, StakingType.POOLED, true);
+    if (selectedPool.state !== 'Open') {
+      errors.push(new TransactionError(StakingTxErrorType.INACTIVE_NOMINATION_POOL));
+    }
+    if (positionInfo) {
+      const bnCurrentActiveStake = new BN(positionInfo.activeStake);
+      bnTotalStake = bnTotalStake.add(bnCurrentActiveStake);
+      if (positionInfo.unstakings.length > 0 && bnCurrentActiveStake.isZero()) {
+        errors.push(new TransactionError(StakingTxErrorType.EXIST_UNSTAKING_REQUEST, existUnstakeErrorMessage));
+      }
+    }
+    if (!bnTotalStake.gte(bnMinStake)) {
+      errors.push(new TransactionError(StakingTxErrorType.NOT_ENOUGH_MIN_STAKE, minStakeErrorMessage));
+    }
+    return errors;
+  }
+  async createJoinExtrinsic(data, positionInfo) {
+    const {
+      address,
+      amount,
+      selectedPool: {
+        id: selectedPoolId
+      }
+    } = data;
+    const chainApi = await this.substrateApi.isReady;
+    const bnActiveStake = new BN((positionInfo === null || positionInfo === void 0 ? void 0 : positionInfo.activeStake) || '0');
+    const compoundResult = async extrinsic => {
+      const tokenSlug = this.nativeToken.slug;
+      const feeInfo = await extrinsic.paymentInfo(address);
+      const fee = feeInfo.toPrimitive();
+      return [extrinsic, {
+        slug: tokenSlug,
+        amount: fee.partialFee.toString()
+      }];
+    };
+    if (bnActiveStake.gt(BN_ZERO)) {
+      // already joined a pool
+      const extrinsic = chainApi.api.tx.nominationPools.bondExtra({
+        FreeBalance: amount
+      });
+      return compoundResult(extrinsic);
+    }
+    const extrinsic = chainApi.api.tx.nominationPools.join(amount, selectedPoolId);
+    return compoundResult(extrinsic);
+  }
+  async handleYieldJoin(_data, path, currentStep) {
+    const data = _data;
+    const {
+      address,
+      amount,
+      selectedPool
+    } = data;
+    const positionInfo = await this.getPoolPosition(address);
+    const [extrinsic] = await this.createJoinExtrinsic(data);
+    const joinPoolData = {
+      poolPosition: positionInfo,
+      slug: this.slug,
+      selectedPool,
+      amount,
+      address
+    };
+    return {
+      txChain: this.chain,
+      extrinsicType: ExtrinsicType.STAKING_JOIN_POOL,
+      extrinsic,
+      txData: joinPoolData,
+      transferNativeAmount: amount
+    };
+  }
+
+  /* Join pool action */
+
+  /* Leave pool action */
+
+  /**
+   * @todo Recheck
+   * */
+  async validateYieldLeave(amount, address, fastLeave, selectedTarget) {
+    const errors = [];
+    const poolInfo = await this.getPoolInfo();
+    const poolPosition = await this.getPoolPosition(address);
+    if (!poolInfo || !poolPosition || fastLeave) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (fastLeave) {
+      return [new TransactionError(BasicTxErrorType.INVALID_PARAMS)];
+    }
+    const bnActiveStake = new BN(poolPosition.activeStake);
+    const bnRemainingStake = bnActiveStake.sub(new BN(amount));
+    const minStake = new BN(poolInfo.metadata.minJoinPool || '0');
+    const maxUnstake = poolInfo.metadata.maxWithdrawalRequestPerFarmer;
+    if (!(bnRemainingStake.isZero() || bnRemainingStake.gte(minStake))) {
+      errors.push(new TransactionError(StakingTxErrorType.INVALID_ACTIVE_STAKE));
+    }
+    if (poolPosition.unstakings.length > maxUnstake) {
+      errors.push(new TransactionError(StakingTxErrorType.EXCEED_MAX_UNSTAKING, t('You cannot unstake more than {{number}} times', {
+        replace: {
+          number: maxUnstake
+        }
+      })));
+    }
+    return Promise.resolve(errors);
+  }
+  async handleYieldRedeem(amount, address, selectedTarget) {
+    return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
+  }
+  async handleYieldUnstake(amount, address, selectedTarget) {
+    const chainApi = await this.substrateApi.isReady;
+    const poolPosition = await this.getPoolPosition(address);
+    if (!poolPosition) {
+      return Promise.reject(new TransactionError(BasicTxErrorType.INTERNAL_ERROR));
+    }
+    const extrinsic = chainApi.api.tx.nominationPools.unbond({
+      Id: poolPosition.address
+    }, amount);
+    return [ExtrinsicType.STAKING_LEAVE_POOL, extrinsic];
+  }
+
+  /* Leave pool action */
+
+  /* Other action */
+
+  handleYieldCancelUnstake(params) {
+    return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
+  }
+  async handleYieldClaimReward(address, bondReward) {
+    const chainApi = await this.substrateApi.isReady;
+    if (bondReward) {
+      return chainApi.api.tx.nominationPools.bondExtra('Rewards');
+    }
+    return chainApi.api.tx.nominationPools.claimPayout();
+  }
+  async handleYieldWithdraw(address, unstakingInfo) {
+    const chainApi = await this.substrateApi.isReady;
+    if (chainApi.api.tx.nominationPools.withdrawUnbonded.meta.args.length === 2) {
+      const _slashingSpans = (await chainApi.api.query.staking.slashingSpans(address)).toHuman();
+      const slashingSpanCount = _slashingSpans !== null ? _slashingSpans.spanIndex : '0';
+      return chainApi.api.tx.nominationPools.withdrawUnbonded({
+        Id: address
+      }, slashingSpanCount);
+    } else {
+      return chainApi.api.tx.nominationPools.withdrawUnbonded({
+        Id: address
+      });
+    }
+  }
+
+  /* Other actions */
+}

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

@@ -0,0 +1,56 @@
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { BaseYieldStepDetail, HandleYieldStepData, OptimalYieldPath, OptimalYieldPathParams, SpecialYieldPoolInfo, SpecialYieldPoolMetadata, SubmitYieldJoinData, TransactionData, UnstakingInfo, YieldPoolInfo, YieldPoolTarget, YieldStepBaseInfo, YieldTokenBaseInfo } from '@subwallet/extension-base/types';
+import BN from 'bn.js';
+import BasePoolHandler from './base';
+export default abstract class BaseSpecialStakingPoolHandler extends BasePoolHandler {
+    protected abstract altInputAsset: string;
+    protected abstract derivativeAssets: string[];
+    protected abstract inputAsset: string;
+    protected abstract rewardAssets: string[];
+    protected abstract feeAssets: string[];
+    /** Allow to create default unstake transaction */
+    protected readonly allowDefaultUnstake: boolean;
+    /** Allow to create fast unstake transaction */
+    protected readonly allowFastUnstake: boolean;
+    protected get baseMetadata(): Pick<SpecialYieldPoolMetadata, 'altInputAssets' | 'derivativeAssets' | 'inputAsset' | 'rewardAssets' | 'feeAssets'>;
+    get isPoolSupportAlternativeFee(): boolean;
+    get group(): string;
+    abstract getPoolStat(): Promise<SpecialYieldPoolInfo>;
+    subscribePoolInfo(callback: (data: YieldPoolInfo) => void): Promise<VoidFunction>;
+    getPoolReward(): Promise<VoidFunction>;
+    getPoolTargets(): Promise<YieldPoolTarget[]>;
+    /**
+     * @async
+     * @function getXcmStep
+     * */
+    getXcmStep(params: OptimalYieldPathParams): Promise<[BaseYieldStepDetail, YieldTokenBaseInfo] | undefined>;
+    protected get defaultSubmitStep(): YieldStepBaseInfo;
+    /**
+     * @function submitJoinStepInfo
+     * @description Base info of submit step
+     * @return Fee of the submitting step
+     * */
+    abstract get submitJoinStepInfo(): BaseYieldStepDetail;
+    /**
+     * @async
+     * @function getSubmitStepFee
+     * @description Get submit step fee
+     * @return {Promise<YieldTokenBaseInfo>} Fee of the submitting step
+     * */
+    abstract getSubmitStepFee(params: OptimalYieldPathParams): Promise<YieldTokenBaseInfo>;
+    protected getSubmitStep(params: OptimalYieldPathParams): Promise<YieldStepBaseInfo>;
+    protected validateTokenApproveStep(params: OptimalYieldPathParams, path: OptimalYieldPath): Promise<TransactionError[]>;
+    protected validateXcmStep(params: OptimalYieldPathParams, path: OptimalYieldPath, bnInputTokenBalance: BN): Promise<TransactionError[]>;
+    protected validateJoinStep(id: number, params: OptimalYieldPathParams, path: OptimalYieldPath, bnInputTokenBalance: BN, isXcmOk: boolean): Promise<TransactionError[]>;
+    validateYieldJoin(params: SubmitYieldJoinData, path: OptimalYieldPath): Promise<TransactionError[]>;
+    protected handleTokenApproveStep(data: SubmitYieldJoinData, path: OptimalYieldPath): Promise<HandleYieldStepData>;
+    handleXcmStep(data: SubmitYieldJoinData, path: OptimalYieldPath, xcmFee: string): Promise<HandleYieldStepData>;
+    abstract handleSubmitStep(data: SubmitYieldJoinData, path: OptimalYieldPath): Promise<HandleYieldStepData>;
+    handleYieldJoin(data: SubmitYieldJoinData, path: OptimalYieldPath, currentStep: number): Promise<HandleYieldStepData>;
+    validateYieldLeave(amount: string, address: string, fastLeave: boolean, selectedTarget?: string): Promise<TransactionError[]>;
+    handleYieldUnstake(amount: string, address: string, selectedTarget?: string): Promise<[ExtrinsicType, TransactionData]>;
+    handleYieldCancelUnstake(): Promise<TransactionData>;
+    handleYieldClaimReward(address: string, bondReward?: boolean): Promise<TransactionData>;
+    handleYieldWithdraw(address: string, unstakingInfo: UnstakingInfo): Promise<TransactionData>;
+}