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

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

@@ -0,0 +1,503 @@
+"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;