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

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

@@ -1,503 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _chainList = require("@subwallet/chain-list");
-var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
-var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
-var _constants = require("@subwallet/extension-base/constants");
-var _xcm = require("@subwallet/extension-base/koni/api/xcm");
-var _utils = require("@subwallet/extension-base/koni/api/yield/helper/utils");
-var _utils2 = require("@subwallet/extension-base/services/chain-service/utils");
-var _types = require("@subwallet/extension-base/types");
-var _utils3 = require("@subwallet/extension-base/utils");
-var _i18next = require("i18next");
-var _util = require("@polkadot/util");
-var _base = _interopRequireDefault(require("./base"));
-// Copyright 2019-2022 @subwallet/extension-base
-// SPDX-License-Identifier: Apache-2.0
-
-class BaseSpecialStakingPoolHandler extends _base.default {
-  /** Pool's type */
-
-  /** Exchange rate before divine with decimals */
-  rate = 0;
-  constructor(state, chain) {
-    super(state, chain);
-    this.exchangeRatePromise = (0, _utils3.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 === _constants.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 _util.BN(inputAssetBalance.value);
-    const bnAltInputAssetBalance = new _util.BN(altInputAssetBalance.value);
-    const bnMinJoinPool = new _util.BN(poolInfo.statistic.earningThreshold.join);
-    const inputTokenInfo = this.state.chainService.getAssetBySlug(this.inputAsset);
-    const altInputTokenInfo = this.state.chainService.getAssetBySlug(this.altInputAsset);
-    const minJoinDiv = _util.BN_TEN.pow(new _util.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 _util.BN(feeAssetBalance.value);
-      const minFeeAssetBalance = new _util.BN(this.maintainBalance || '0');
-      const feeAssetDiv = _util.BN_TEN.pow(new _util.BN(feeAssetInfo.decimals || 0));
-      const parsedMinFeeAssetBalance = minFeeAssetBalance.div(feeAssetDiv).mul(new _util.BN(12)).div(_util.BN_TEN);
-      if (bnFeeAssetBalance.lte(_util.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();
-      }
-    }, _utils.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(_util.noop));
-  }
-  async getPoolRewardHistory() {
-    return new Promise(resolve => resolve(_util.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 _util.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 _util.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 _util.BN(altInputTokenBalance.value || '0');
-        if (bnAltInputTokenBalance.gt(_util.BN_ZERO)) {
-          const step = {
-            metadata: {
-              sendingValue: bnAmount.toString(),
-              originTokenInfo: altInputTokenInfo,
-              destinationTokenInfo: inputTokenInfo
-            },
-            name: 'Transfer DOT from Polkadot',
-            type: _types.YieldStepType.XCM
-          };
-          const xcmOriginSubstrateApi = await this.state.getSubstrateApi(altInputTokenInfo.originChain).isReady;
-          const xcmTransfer = await (0, _xcm.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.TransactionError(_KoniTypes.BasicTxErrorType.UNSUPPORTED)]);
-  }
-  async validateXcmStep(params, path, bnInputTokenBalance) {
-    const processValidation = {
-      ok: true,
-      status: _types.YieldValidationStatus.OK
-    };
-    const bnAmount = new _util.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 _util.BN(path.totalFee[1].amount || '0');
-    const xcmAmount = missingAmount.add(xcmFee);
-    const bnAltInputTokenBalance = new _util.BN(altInputTokenBalance.value || '0');
-    const altInputTokenMinAmount = new _util.BN(altInputTokenInfo.minAmount || '0');
-    if (!bnAltInputTokenBalance.sub(xcmAmount).gte(altInputTokenMinAmount)) {
-      processValidation.failedStep = path.steps[1];
-      processValidation.ok = false;
-      processValidation.status = _types.YieldValidationStatus.NOT_ENOUGH_BALANCE;
-      return [new _TransactionError.TransactionError(_types.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.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)];
-    }
-    const poolInfo = _poolInfo;
-    if (!poolInfo.statistic) {
-      return [new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)];
-    }
-    const processValidation = {
-      ok: true,
-      status: _types.YieldValidationStatus.OK
-    };
-    const feeTokenSlug = path.totalFee[id].slug;
-    const feeTokenInfo = this.state.getAssetBySlug(feeTokenSlug);
-    const defaultFeeTokenSlug = this.feeAssets[0];
-    const bnAmount = new _util.BN(params.amount);
-    if (this.feeAssets.length === 1 && feeTokenSlug === defaultFeeTokenSlug) {
-      var _path$totalFee$id;
-      const bnFeeAmount = new _util.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 _util.BN(feeTokenBalance.value || '0');
-      const bnFeeTokenMinAmount = new _util.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 = _types.YieldValidationStatus.NOT_ENOUGH_FEE;
-        return [new _TransactionError.TransactionError(_types.YieldValidationStatus.NOT_ENOUGH_FEE, processValidation.message, processValidation)];
-      }
-    }
-    if (!bnAmount.gte(new _util.BN(poolInfo.statistic.earningThreshold.join || '0'))) {
-      processValidation.failedStep = path.steps[id];
-      processValidation.ok = false;
-      processValidation.status = _types.YieldValidationStatus.NOT_ENOUGH_MIN_JOIN_POOL;
-      return [new _TransactionError.TransactionError(_types.YieldValidationStatus.NOT_ENOUGH_MIN_JOIN_POOL, processValidation.message, processValidation)];
-    }
-    if (!isXcmOk && bnAmount.gt(bnInputTokenBalance)) {
-      processValidation.failedStep = path.steps[id];
-      processValidation.ok = false;
-      processValidation.status = _types.YieldValidationStatus.NOT_ENOUGH_BALANCE;
-      return [new _TransactionError.TransactionError(_types.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 _util.BN(inputTokenBalance.value || '0');
-    const bnAmount = new _util.BN(params.amount);
-    if (bnAmount.lte(_util.BN_ZERO)) {
-      return [new _TransactionError.TransactionError(_KoniTypes.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 _types.YieldStepType.DEFAULT:
-            return Promise.resolve([]);
-          case _types.YieldStepType.XCM:
-            return this.validateXcmStep(params, path, bnInputTokenBalance);
-          case _types.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 === _types.YieldStepType.XCM) {
-        isXcmOk = true;
-      }
-    }
-    return [];
-  }
-
-  /* Validate join action */
-
-  /* Submit join action */
-
-  async handleTokenApproveStep(data, path) {
-    return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNSUPPORTED));
-  }
-  async handleXcmStep(data, path, xcmFee) {
-    const {
-      address,
-      amount
-    } = data;
-    const destinationTokenSlug = this.inputAsset;
-    const originChainInfo = this.state.getChainInfo(_chainList.COMMON_CHAIN_SLUGS.POLKADOT);
-    const originTokenSlug = (0, _utils2._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 _util.BN(inputTokenBalance.value);
-    const bnXcmFee = new _util.BN(xcmFee);
-    const bnAmount = new _util.BN(amount);
-    const bnTotalAmount = bnAmount.sub(bnInputTokenBalance).add(bnXcmFee);
-    const extrinsic = await (0, _xcm.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: _KoniTypes.ExtrinsicType.TRANSFER_XCM,
-      extrinsic,
-      txData: xcmData,
-      transferNativeAmount: bnTotalAmount.toString()
-    };
-  }
-  handleYieldJoin(data, path, currentStep) {
-    const type = path.steps[currentStep].type;
-    switch (type) {
-      case _types.YieldStepType.DEFAULT:
-        return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNSUPPORTED));
-      case _types.YieldStepType.TOKEN_APPROVAL:
-        return this.handleTokenApproveStep(data, path);
-      case _types.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.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)];
-    }
-    if (!this.availableMethod.defaultUnstake && !fastLeave) {
-      return [new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)];
-    }
-    if (!this.availableMethod.fastUnstake && fastLeave) {
-      return [new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)];
-    }
-    const errors = [];
-    const bnActiveStake = new _util.BN(poolPosition.activeStake);
-    const bnAmount = new _util.BN(amount);
-    const bnRemainingStake = bnActiveStake.sub(bnAmount);
-    const minStake = new _util.BN(poolInfo.statistic.earningThreshold.join || '0');
-    const minUnstake = new _util.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(_util.BN_ZERO)) {
-      return [new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS, (0, _i18next.t)('Amount must be greater than 0'))];
-    }
-    if (bnAmount.lt(minUnstake)) {
-      const minUnstakeStr = (0, _utils3.formatNumber)(minUnstake.toString(), derivativeTokenInfo.decimals || 0);
-      errors.push(new _TransactionError.TransactionError(_KoniTypes.StakingTxErrorType.NOT_ENOUGH_MIN_UNSTAKE, (0, _i18next.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.TransactionError(_KoniTypes.StakingTxErrorType.INVALID_ACTIVE_STAKE)); // TODO
-      }
-
-      if (poolPosition.unstakings.length > maxUnstakeRequest) {
-        errors.push(new _TransactionError.TransactionError(_KoniTypes.StakingTxErrorType.EXCEED_MAX_UNSTAKING, (0, _i18next.t)('You cannot unstake more than {{number}} times', {
-          replace: {
-            number: maxUnstakeRequest
-          }
-        })));
-      }
-    }
-    return Promise.resolve(errors);
-  }
-  handleYieldUnstake(amount, address, selectedTarget) {
-    return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNSUPPORTED));
-  }
-
-  /* Leave pool action */
-
-  /* Other action */
-
-  handleYieldCancelUnstake() {
-    return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNSUPPORTED));
-  }
-  handleYieldClaimReward(address, bondReward) {
-    return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNSUPPORTED));
-  }
-  handleYieldWithdraw(address, unstakingInfo) {
-    return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNSUPPORTED));
-  }
-
-  /* Other actions */
-}
-exports.default = BaseSpecialStakingPoolHandler;