@subwallet/extension-base 1.1.33-beta.1 → 1.1.34-0

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

@@ -1,497 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-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 is a problem fetching your data. Check your Internet connection or change the network endpoint 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);
-    if (bnInputAssetBalance.add(bnAltInputAssetBalance).lt(bnMinJoinPool)) {
-      const originChain = this.state.getChainInfo(inputTokenInfo.originChain);
-      const altChain = this.state.getChainInfo(altInputTokenInfo.originChain);
-      const parsedMinJoinPool = (0, _utils3.formatNumber)(bnMinJoinPool.toString(), inputAssetInfo.decimals || 0);
-      return {
-        passed: false,
-        errorMessage: `You need at least ${parsedMinJoinPool} ${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 _callback = data => {
-      !cancel && callback(data);
-    };
-    const defaultCallback = async () => {
-      const data = {
-        ...this.baseInfo,
-        type: this.type,
-        metadata: {
-          ...this.metadataInfo,
-          description: this.getDescription()
-        }
-      };
-      const poolInfo = await this.getPoolInfo();
-      !poolInfo && _callback(data);
-    };
-    const getStatInterval = () => {
-      if (!this.isActive) {
-        defaultCallback().catch(console.error);
-      } else {
-        defaultCallback().then(() => {
-          return this.getPoolStat();
-        }).then(rs => {
-          _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 altChainInfo = this.state.getChainInfo(altInputTokenInfo.originChain);
-          const symbol = altInputTokenInfo.symbol;
-          const networkName = altChainInfo.name;
-          const step = {
-            metadata: {
-              sendingValue: bnAmount.toString(),
-              originTokenInfo: altInputTokenInfo,
-              destinationTokenInfo: inputTokenInfo
-            },
-            name: `Transfer ${symbol} from ${networkName}`,
-            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 inputTokenInfo = this.state.getAssetBySlug(this.inputAsset);
-    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;
-      const maxBn = bnInputTokenBalance.add(new _util.BN(altInputTokenBalance.value)).sub(xcmFee).sub(altInputTokenMinAmount);
-      const maxValue = (0, _utils3.formatNumber)(maxBn.toString(), inputTokenInfo.decimals || 0);
-      const altInputTokenInfo = this.state.getAssetBySlug(altInputTokenSlug);
-      const symbol = altInputTokenInfo.symbol;
-      const altNetwork = this.state.getChainInfo(altInputTokenInfo.originChain);
-      const inputNetworkName = this.chainInfo.name;
-      const altNetworkName = altNetwork.name;
-      const currentValue = (0, _utils3.formatNumber)(bnInputTokenBalance.toString(), inputTokenInfo.decimals || 0);
-      const bnMaxXCM = new _util.BN(altInputTokenBalance.value).sub(xcmFee).sub(altInputTokenMinAmount);
-      const maxXCMValue = (0, _utils3.formatNumber)(bnMaxXCM.toString(), inputTokenInfo.decimals || 0);
-      processValidation.message = (0, _i18next.t)('You can only enter a maximum of {{maxValue}} {{symbol}}, which is {{currentValue}} {{symbol}} ({{inputNetworkName}}) and {{maxXCMValue}} {{symbol}} ({{altNetworkName}}). Lower your amount and try again.', {
-        replace: {
-          symbol,
-          maxValue,
-          inputNetworkName,
-          altNetworkName,
-          currentValue,
-          maxXCMValue
-        }
-      });
-      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 inputTokenInfo = this.state.getAssetBySlug(this.inputAsset);
-    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;
-      const maxString = (0, _utils3.formatNumber)(bnInputTokenBalance.toString(), inputTokenInfo.decimals || 0);
-      if (maxString !== '0') {
-        processValidation.message = (0, _i18next.t)('Amount must be equal or less than {{number}}', {
-          replace: {
-            number: maxString
-          }
-        });
-      } else {
-        processValidation.message = (0, _i18next.t)('You need balance greater than 0 to continue');
-      }
-      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 altInputTokenSlug = this.altInputAsset || '';
-    const altInputTokenInfo = this.state.getAssetBySlug(altInputTokenSlug);
-    const originChainInfo = this.state.getChainInfo(altInputTokenInfo.originChain);
-    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(),
-      chainType: _KoniTypes.ChainType.SUBSTRATE
-    };
-  }
-  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 */
-
-  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;