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

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

@@ -0,0 +1,379 @@
+// 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 { 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 BN from 'bn.js';
+import { t } from 'i18next';
+import { BN_ZERO, noop } from '@polkadot/util';
+import BasePoolHandler from "./base.js";
+export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
+  /** Allow to create default unstake transaction */
+  allowDefaultUnstake = false;
+  /** Allow to create fast unstake transaction */
+  allowFastUnstake = true;
+  get baseMetadata() {
+    return {
+      altInputAssets: this.altInputAsset,
+      derivativeAssets: this.derivativeAssets,
+      inputAsset: this.inputAsset,
+      rewardAssets: this.rewardAssets,
+      feeAssets: this.feeAssets
+    };
+  }
+  get isPoolSupportAlternativeFee() {
+    return this.feeAssets.length > 1;
+  }
+  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 = () => {
+      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));
+  }
+
+  /* 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;
+    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.metadata.minJoinPool || '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');
+    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 || !poolPosition) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (!this.allowDefaultUnstake && !fastLeave) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (!this.allowFastUnstake && fastLeave) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    const errors = [];
+    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);
+  }
+  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,36 @@
+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 { EarningRewardItem, EarningRewardJson, HandleYieldStepData, HandleYieldStepParams, OptimalYieldPath, OptimalYieldPathParams, RequestStakeCancelWithdrawal, RequestStakeClaimReward, RequestYieldLeave, RequestYieldWithdrawal, 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;
+    constructor(state: KoniState);
+    initHandlers(): void;
+    getPoolHandler(slug: string): BasePoolHandler | undefined;
+    isPoolSupportAlternativeFee(slug: string): boolean;
+    subscribePoolsInfo(callback: (rs: YieldPoolInfo) => void): Promise<VoidFunction>;
+    subscribePoolPositions(addresses: string[], callback: (rs: YieldPositionInfo) => void): Promise<VoidFunction>;
+    updateEarningReward(stakingRewardData: EarningRewardItem, callback?: (earningRewardData: EarningRewardJson) => void): void;
+    getPoolReward(addresses: string[], callback: (result: EarningRewardItem) => void): Promise<VoidFunction>;
+    subscribeEarningReward(): BehaviorSubject<EarningRewardJson>;
+    getEarningRewards(): EarningRewardJson;
+    /**
+     * @async
+     * @function getPoolTargets
+     * @param {string} slug - Pool's slug
+     * @return {Promise<YieldPoolTarget[]>} List of pool's target
+     * */
+    getPoolTargets(slug: string): Promise<YieldPoolTarget[]>;
+    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>;
+}