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

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

@@ -0,0 +1,411 @@
+"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 _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 _bn = _interopRequireDefault(require("bn.js"));
+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 */
+
+  /** Allow to create default unstake transaction */
+  allowDefaultUnstake = false;
+  /** Allow to create fast unstake transaction */
+  allowFastUnstake = true;
+  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,
+      allowCancelUnstaking: false
+    };
+  }
+  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 = () => {
+      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));
+  }
+
+  /* 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.default(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.default(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.default(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 _bn.default(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.default(path.totalFee[1].amount || '0');
+    const xcmAmount = missingAmount.add(xcmFee);
+    const bnAltInputTokenBalance = new _bn.default(altInputTokenBalance.value || '0');
+    const altInputTokenMinAmount = new _bn.default(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 _bn.default(params.amount);
+    if (this.feeAssets.length === 1 && feeTokenSlug === defaultFeeTokenSlug) {
+      var _path$totalFee$id;
+      const bnFeeAmount = new _bn.default(((_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.default(feeTokenBalance.value || '0');
+      const bnFeeTokenMinAmount = new _bn.default((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 _bn.default(poolInfo.statistic.minJoinPool || '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 _bn.default(inputTokenBalance.value || '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 _bn.default(inputTokenBalance.value);
+    const bnXcmFee = new _bn.default(xcmFee);
+    const bnAmount = new _bn.default(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.allowDefaultUnstake && !fastLeave) {
+      return [new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (!this.allowFastUnstake && fastLeave) {
+      return [new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    const errors = [];
+    const bnActiveStake = new _bn.default(poolPosition.activeStake);
+    const bnRemainingStake = bnActiveStake.sub(new _bn.default(amount));
+    const minStake = new _bn.default(poolInfo.statistic.minJoinPool || '0');
+    const maxUnstake = poolInfo.statistic.maxWithdrawalRequestPerFarmer;
+    if (!(bnRemainingStake.isZero() || bnRemainingStake.gte(minStake))) {
+      errors.push(new _TransactionError.TransactionError(_KoniTypes.StakingTxErrorType.INVALID_ACTIVE_STAKE));
+    }
+    if (poolPosition.unstakings.length > maxUnstake) {
+      errors.push(new _TransactionError.TransactionError(_KoniTypes.StakingTxErrorType.EXCEED_MAX_UNSTAKING, (0, _i18next.t)('You cannot unstake more than {{number}} times', {
+        replace: {
+          number: maxUnstake
+        }
+      })));
+    }
+    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;