@subwallet/extension-base 1.3.29-0 → 1.3.30-0

package/cjs/services/swap-service/handler/asset-hub/handler.js

@@ -8,14 +8,10 @@ exports.AssetHubSwapHandler = void 0;
 var _SwapError = require("@subwallet/extension-base/background/errors/SwapError");
 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 _swap = require("@subwallet/extension-base/core/logic-validation/swap");
-var _xcm = require("@subwallet/extension-base/services/balance-service/transfer/xcm");
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
-var _interface = require("@subwallet/extension-base/services/swap-service/interface");
 var _utils2 = require("@subwallet/extension-base/services/swap-service/utils");
 var _types = require("@subwallet/extension-base/types");
-var _getId = require("@subwallet/extension-base/utils/getId");
+var _utils3 = require("@subwallet/extension-base/utils");
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
 var _baseHandler = require("../base-handler");
 var _router = require("./router");
@@ -68,235 +64,70 @@ class AssetHubSwapHandler {
     if (!chainState.active) {
       await this.chainService.enableChain(this.chain);
     }
-    const substrateApi = this.chainService.getSubstrateApi(this.chain);
-    await substrateApi.api.isReady;
     this.router = new _router.AssetHubRouter(this.chain, this.chainService);
     this.isReady = true;
   }
-  async getXcmStep(params) {
-    const bnAmount = new _bignumber.default(params.request.fromAmount);
-    const fromAsset = this.chainService.getAssetBySlug(params.request.pair.from);
-    const fromAssetBalance = await this.balanceService.getTransferableBalance(params.request.address, fromAsset.originChain, fromAsset.slug);
-    const bnFromAssetBalance = new _bignumber.default(fromAssetBalance.value);
-    if (bnFromAssetBalance.gte(bnAmount)) {
-      return undefined; // enough balance, no need to xcm
-    }
-
-    const alternativeAssetSlug = (0, _utils2.getSwapAlternativeAsset)(params.request.pair);
-    if (!alternativeAssetSlug) {
-      return undefined;
-    }
-    const alternativeAsset = this.chainService.getAssetBySlug(alternativeAssetSlug);
-    const alternativeAssetBalance = await this.balanceService.getTransferableBalance(params.request.address, alternativeAsset.originChain, alternativeAsset.slug);
-    const bnAlternativeAssetBalance = new _bignumber.default(alternativeAssetBalance.value);
-    if (bnAlternativeAssetBalance.lte(0)) {
-      return undefined;
-    }
-    try {
-      const alternativeChainInfo = this.chainService.getChainInfoByKey(alternativeAsset.originChain);
-      const originalChainInfo = this.chainService.getChainInfoByKey(this.chain);
-      const xcmOriginSubstrateApi = await this.chainService.getSubstrateApi(alternativeAsset.originChain).isReady;
-      const id = (0, _getId.getId)();
-      const feeInfo = await this.swapBaseHandler.feeService.subscribeChainFee(id, alternativeChainInfo.slug, 'substrate');
-      const xcmTransfer = await (0, _xcm.createXcmExtrinsic)({
-        originTokenInfo: alternativeAsset,
-        destinationTokenInfo: fromAsset,
-        // Mock sending value to get payment info
-        sendingValue: bnAmount.toString(),
-        recipient: params.request.address,
-        sender: params.request.address,
-        feeInfo: feeInfo,
-        substrateApi: xcmOriginSubstrateApi,
-        destinationChain: originalChainInfo,
-        originChain: alternativeChainInfo
-      });
-      const _xcmFeeInfo = await xcmTransfer.paymentInfo(params.request.address);
-      const xcmFeeInfo = _xcmFeeInfo.toPrimitive();
-      const fee = {
-        feeComponent: [{
-          feeType: _types.SwapFeeType.NETWORK_FEE,
-          amount: Math.round(xcmFeeInfo.partialFee * _constants.XCM_MIN_AMOUNT_RATIO).toString(),
-          tokenSlug: (0, _utils._getChainNativeTokenSlug)(alternativeChainInfo)
-        }],
-        defaultFeeToken: (0, _utils._getChainNativeTokenSlug)(alternativeChainInfo),
-        feeOptions: [(0, _utils._getChainNativeTokenSlug)(alternativeChainInfo)]
-      };
-      let bnTransferAmount = bnAmount.minus(bnFromAssetBalance);
-      if ((0, _utils._isNativeToken)(alternativeAsset)) {
-        const bnXcmFee = new _bignumber.default(fee.feeComponent[0].amount); // xcm fee is paid in native token but swap token is not always native token
-
-        bnTransferAmount = bnTransferAmount.plus(bnXcmFee);
-      }
-      const step = {
-        metadata: {
-          sendingValue: bnTransferAmount.toString(),
-          originTokenInfo: alternativeAsset,
-          destinationTokenInfo: fromAsset
-        },
-        name: `Transfer ${alternativeAsset.symbol} from ${alternativeChainInfo.name}`,
-        type: _types.CommonStepType.XCM
-      };
-      return [step, fee];
-    } catch (e) {
-      console.error('Error creating xcm step', e);
-      return undefined;
-    }
-  }
-  async getSubmitStep(params) {
-    if (params.selectedQuote) {
-      const submitStep = {
-        name: 'Swap',
-        type: _types.SwapStepType.SWAP
-      };
-      return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
-    }
-    return Promise.resolve(undefined);
-  }
-  async getXcmStepV2(params) {
-    var _params$path$find;
-    // todo: improve this function for Round 2
-
-    const xcmPairInfo = (_params$path$find = params.path.find((step, i) => i === 0 && step.action === _interface.DynamicSwapType.BRIDGE)) === null || _params$path$find === void 0 ? void 0 : _params$path$find.pair;
-    if (!xcmPairInfo) {
-      return undefined;
-    }
-    const fromTokenInfo = this.chainService.getAssetBySlug(xcmPairInfo.from);
-    const toTokenInfo = this.chainService.getAssetBySlug(xcmPairInfo.to);
-    const fromChainInfo = this.chainService.getChainInfoByKey(fromTokenInfo.originChain);
-    const toChainInfo = this.chainService.getChainInfoByKey(toTokenInfo.originChain);
-    const substrateApi = await this.chainService.getSubstrateApi(fromTokenInfo.originChain).isReady;
-    if (!fromChainInfo || !toChainInfo || !fromChainInfo || !toChainInfo) {
-      throw Error('Token and chain not found');
-    }
-    try {
-      const id = (0, _getId.getId)();
-      const [feeInfo, toTokenBalance] = await Promise.all([this.swapBaseHandler.feeService.subscribeChainFee(id, fromTokenInfo.originChain, 'substrate'), this.balanceService.getTotalBalance(params.request.address, toTokenInfo.originChain, toTokenInfo.slug, _KoniTypes.ExtrinsicType.TRANSFER_BALANCE)]);
-      const xcmTransfer = await (0, _xcm.createXcmExtrinsic)({
-        originTokenInfo: fromTokenInfo,
-        destinationTokenInfo: toTokenInfo,
-        // Mock sending value to get payment info
-        sendingValue: params.request.fromAmount,
-        recipient: params.request.address,
-        substrateApi: substrateApi,
-        sender: params.request.address,
-        originChain: fromChainInfo,
-        destinationChain: toChainInfo,
-        feeInfo
-      });
-      const _xcmFeeInfo = await xcmTransfer.paymentInfo(params.request.address);
-      const xcmFeeInfo = _xcmFeeInfo.toPrimitive();
-      const fee = {
-        feeComponent: [{
-          feeType: _types.SwapFeeType.NETWORK_FEE,
-          amount: Math.ceil(xcmFeeInfo.partialFee * _utils2.FEE_RATE_MULTIPLIER.high).toString(),
-          tokenSlug: (0, _utils._getChainNativeTokenSlug)(fromChainInfo)
-        }],
-        defaultFeeToken: (0, _utils._getChainNativeTokenSlug)(fromChainInfo),
-        feeOptions: [(0, _utils._getChainNativeTokenSlug)(fromChainInfo)]
-      };
-      let bnTransferAmount = new _bignumber.default(params.request.fromAmount);
-      if ((0, _utils._isNativeToken)(fromTokenInfo)) {
-        // xcm fee is paid in native token but swap token is not always native token
-        // add amount of fee into sending value to ensure has enough token to swap
-        const bnXcmFee = new _bignumber.default(fee.feeComponent[0].amount);
-        bnTransferAmount = bnTransferAmount.plus(bnXcmFee);
-      } else {
-        bnTransferAmount = bnTransferAmount.plus((0, _bignumber.default)((0, _utils._getTokenMinAmount)(toTokenInfo)).multipliedBy(_utils2.FEE_RATE_MULTIPLIER.medium));
-      }
-      if ((0, _bignumber.default)(toTokenBalance.value).lte(0)) {
-        bnTransferAmount = bnTransferAmount.plus((0, _utils._getTokenMinAmount)(toTokenInfo));
-      }
-      const step = {
-        metadata: {
-          sendingValue: bnTransferAmount.toString(),
-          originTokenInfo: fromTokenInfo,
-          destinationTokenInfo: toTokenInfo
-        },
-        name: `Transfer ${fromTokenInfo.symbol} from ${fromChainInfo.name}`,
-        type: _types.CommonStepType.XCM
-      };
-      return [step, fee];
-    } catch (e) {
-      console.error('Error creating xcm step', e);
-      return undefined;
-    }
-  }
-  async getSwapStepV2(params) {
-    var _params$path$find2;
-    const swapPairInfo = (_params$path$find2 = params.path.find(step => step.action === _interface.DynamicSwapType.SWAP)) === null || _params$path$find2 === void 0 ? void 0 : _params$path$find2.pair;
-    if (!swapPairInfo) {
+  async getSubmitStep(params, stepIndex) {
+    const {
+      path,
+      request: {
+        fromAmount
+      },
+      selectedQuote
+    } = params;
+    const stepData = path[stepIndex];
+    if (stepData.action !== _types.DynamicSwapType.SWAP) {
       return Promise.resolve(undefined);
     }
-    if (params.selectedQuote) {
-      const submitStep = {
-        name: 'Swap',
-        type: _types.SwapStepType.SWAP,
-        metadata: {
-          sendingValue: params.request.fromAmount.toString(),
-          originTokenInfo: this.chainService.getAssetBySlug(swapPairInfo.from),
-          destinationTokenInfo: this.chainService.getAssetBySlug(swapPairInfo.to)
-        }
-      };
-      return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
+    const swapPairInfo = stepData.pair;
+    if (!swapPairInfo || !selectedQuote) {
+      return Promise.resolve(undefined);
     }
-    return Promise.resolve(undefined);
-  }
-  generateOptimalProcess(params) {
-    return this.swapBaseHandler.generateOptimalProcess(params, [this.getXcmStep.bind(this), this.getSubmitStep.bind(this)]);
+    const originTokenInfo = this.chainService.getAssetBySlug(swapPairInfo.from);
+    const destinationTokenInfo = this.chainService.getAssetBySlug(swapPairInfo.to);
+    const originChain = this.chainService.getChainInfoByKey(originTokenInfo.originChain);
+    const destinationChain = this.chainService.getChainInfoByKey(destinationTokenInfo.originChain);
+    const actionList = JSON.stringify(path.map(step => step.action));
+    const xcmSwapXcm = actionList === JSON.stringify([_types.DynamicSwapType.BRIDGE, _types.DynamicSwapType.SWAP, _types.DynamicSwapType.BRIDGE]);
+    const swapXcm = actionList === JSON.stringify([_types.DynamicSwapType.SWAP, _types.DynamicSwapType.BRIDGE]);
+    const needModifyData = swapXcm || xcmSwapXcm;
+    let bnSendingValue = (0, _bignumber.default)(fromAmount);
+    let bnExpectedReceive = (0, _bignumber.default)(selectedQuote.toAmount);
+    const sender = (0, _utils3._reformatAddressWithChain)(params.request.address, originChain);
+    let receiver = (0, _utils3._reformatAddressWithChain)(params.request.recipient || params.request.address, destinationChain);
+    if (needModifyData) {
+      bnSendingValue = bnSendingValue.multipliedBy(_utils2.DEFAULT_EXCESS_AMOUNT_WEIGHT);
+      bnExpectedReceive = bnExpectedReceive.multipliedBy(_utils2.DEFAULT_EXCESS_AMOUNT_WEIGHT);
+      receiver = (0, _utils3._reformatAddressWithChain)(params.request.address, destinationChain);
+    }
+    const submitStep = {
+      name: 'Swap',
+      type: _types.SwapStepType.SWAP,
+      // @ts-ignore
+      metadata: {
+        sendingValue: bnSendingValue.toFixed(0, 1),
+        expectedReceive: bnExpectedReceive.toFixed(0, 1),
+        originTokenInfo,
+        destinationTokenInfo,
+        sender,
+        receiver,
+        version: 2
+      }
+    };
+    return Promise.resolve([submitStep, selectedQuote.feeInfo]);
   }
   generateOptimalProcessV2(params) {
     const stepFuncList = params.path.map(step => {
-      if (step.action === _interface.DynamicSwapType.BRIDGE) {
-        return this.getXcmStepV2.bind(this);
+      if (step.action === _types.DynamicSwapType.SWAP) {
+        return this.getSubmitStep.bind(this);
       }
-      if (step.action === _interface.DynamicSwapType.SWAP) {
-        return this.getSwapStepV2.bind(this);
+      if (step.action === _types.DynamicSwapType.BRIDGE) {
+        return this.swapBaseHandler.getBridgeStep.bind(this.swapBaseHandler);
       }
       throw new Error(`Error generating optimal process: Action ${step.action} is not supported`);
     });
     return this.swapBaseHandler.generateOptimalProcessV2(params, stepFuncList);
   }
-  async handleXcmStep(params) {
-    const briefXcmStep = params.process.steps[params.currentStep].metadata;
-    if (!briefXcmStep || !briefXcmStep.originTokenInfo || !briefXcmStep.destinationTokenInfo || !briefXcmStep.sendingValue) {
-      throw new Error('XCM metadata error');
-    }
-    const originAsset = briefXcmStep.originTokenInfo;
-    const destinationAsset = briefXcmStep.destinationTokenInfo;
-    const originChain = this.chainService.getChainInfoByKey(originAsset.originChain);
-    const destinationChain = this.chainService.getChainInfoByKey(destinationAsset.originChain);
-    const substrateApi = this.chainService.getSubstrateApi(originAsset.originChain);
-    const chainApi = await substrateApi.isReady;
-    const feeInfo = await this.swapBaseHandler.feeService.subscribeChainFee((0, _getId.getId)(), originAsset.originChain, 'substrate');
-    const xcmTransfer = await (0, _xcm.createXcmExtrinsic)({
-      originTokenInfo: originAsset,
-      destinationTokenInfo: destinationAsset,
-      sendingValue: briefXcmStep.sendingValue,
-      recipient: params.address,
-      substrateApi: chainApi,
-      sender: params.address,
-      destinationChain,
-      originChain,
-      feeInfo
-    });
-    const xcmData = {
-      originNetworkKey: originAsset.originChain,
-      destinationNetworkKey: destinationAsset.originChain,
-      from: params.address,
-      to: params.address,
-      value: briefXcmStep.sendingValue,
-      tokenSlug: originAsset.slug,
-      showExtraWarning: true
-    };
-    return {
-      txChain: originAsset.originChain,
-      extrinsic: xcmTransfer,
-      transferNativeAmount: (0, _utils._isNativeToken)(originAsset) ? briefXcmStep.sendingValue : '0',
-      extrinsicType: _KoniTypes.ExtrinsicType.TRANSFER_XCM,
-      chainType: _KoniTypes.ChainType.SUBSTRATE,
-      txData: xcmData
-    };
-  }
   async handleSubmitStep(params) {
     var _this$router;
     const metadata = params.process.steps[params.currentStep].metadata;
@@ -312,17 +143,11 @@ class AssetHubSwapHandler {
       process: params.process
     };
     const paths = params.quote.route.path.map(slug => this.chainService.getAssetBySlug(slug));
-    const {
-      fromAmount,
-      toAmount
-    } = params.quote;
-
-    // todo: move to gen process
-    const minReceive = new _bignumber.default(1 - params.slippage).times(toAmount).integerValue(_bignumber.default.ROUND_DOWN);
-    if (!params.address || !paths || !fromAmount || !minReceive) {
+    const minReceive = (0, _bignumber.default)((0, _utils2.getAmountAfterSlippage)(metadata.expectedReceive, params.slippage));
+    if (!params.address || !paths || !minReceive) {
       throw new _SwapError.SwapError(_types.SwapErrorType.UNKNOWN);
     }
-    const extrinsic = await ((_this$router = this.router) === null || _this$router === void 0 ? void 0 : _this$router.buildSwapExtrinsic(paths, params.address, fromAmount, minReceive.toString()));
+    const extrinsic = await ((_this$router = this.router) === null || _this$router === void 0 ? void 0 : _this$router.buildSwapExtrinsic(paths, params.address, metadata.sendingValue, minReceive.toString()));
     return {
       txChain: fromAsset.originChain,
       txData,
@@ -341,90 +166,13 @@ class AssetHubSwapHandler {
     const type = process.steps[currentStep].type;
     switch (type) {
       case _types.CommonStepType.XCM:
-        return this.handleXcmStep(params);
+        return this.swapBaseHandler.handleBridgeStep(params);
       case _types.SwapStepType.SWAP:
         return this.handleSubmitStep(params);
       default:
         return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED));
     }
   }
-  async validateSwapStep(params, isXcmOk, stepIndex) {
-    // check swap quote timestamp
-    // check balance to pay transaction fee
-    // check balance against spending amount
-    if (!params.selectedQuote) {
-      return Promise.resolve([new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)]);
-    }
-    const selectedQuote = params.selectedQuote;
-    const currentTimestamp = +Date.now();
-    if (selectedQuote.aliveUntil <= currentTimestamp) {
-      return Promise.resolve([new _TransactionError.TransactionError(_types.SwapErrorType.QUOTE_TIMEOUT)]);
-    }
-    const stepFee = params.process.totalFee[stepIndex].feeComponent;
-    const networkFee = stepFee.find(fee => fee.feeType === _types.SwapFeeType.NETWORK_FEE);
-    if (!networkFee) {
-      return Promise.resolve([new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)]);
-    }
-    const fromAsset = this.chainService.getAssetBySlug(params.selectedQuote.pair.from);
-    const feeTokenInfo = this.chainService.getAssetBySlug(networkFee.tokenSlug);
-    const feeTokenChain = this.chainService.getChainInfoByKey(feeTokenInfo.originChain);
-    const {
-      fromAmount,
-      minSwap
-    } = params.selectedQuote;
-    const [feeTokenBalance, fromAssetBalance] = await Promise.all([this.balanceService.getTransferableBalance(params.address, feeTokenInfo.originChain, feeTokenInfo.slug), this.balanceService.getTransferableBalance(params.address, fromAsset.originChain, fromAsset.slug)]);
-    const balanceError = (0, _swap._validateBalanceToSwapOnAssetHub)(fromAsset, feeTokenInfo, feeTokenChain, networkFee.amount, fromAssetBalance.value, feeTokenBalance.value, fromAmount, isXcmOk, minSwap);
-    if (balanceError) {
-      return Promise.resolve([balanceError]);
-    }
-    if (!params.recipient) {
-      return Promise.resolve([]);
-    }
-    const toAsset = this.chainService.getAssetBySlug(params.selectedQuote.pair.to);
-    const toAssetChain = this.chainService.getChainInfoByKey(toAsset.originChain);
-    const recipientError = (0, _swap._validateSwapRecipient)(toAssetChain, params.recipient);
-    if (recipientError) {
-      return Promise.resolve([recipientError]);
-    }
-    return Promise.resolve([]);
-  }
-  async validateSwapProcess(params) {
-    const amount = params.selectedQuote.fromAmount;
-    const bnAmount = new _bignumber.default(amount);
-    if (bnAmount.lte(0)) {
-      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')];
-    }
-    const swapStep = params.process.steps.find(item => item.type === _types.SwapStepType.SWAP);
-    if (!swapStep) {
-      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR, 'Swap step not found')];
-    }
-    let isXcmOk = false;
-    const currentStep = params.currentStep;
-    for (const [index, step] of params.process.steps.entries()) {
-      if (currentStep > index) {
-        continue;
-      }
-      const getErrors = async () => {
-        switch (step.type) {
-          case _types.CommonStepType.DEFAULT:
-            return Promise.resolve([]);
-          case _types.CommonStepType.XCM:
-            return this.swapBaseHandler.validateXcmStepV2(params, index);
-          case _types.SwapStepType.SWAP:
-            return this.validateSwapStep(params, isXcmOk, index);
-          default:
-            return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED));
-        }
-      };
-      const errors = await getErrors();
-      if (errors.length) {
-        return errors;
-      } else if (step.type === _types.CommonStepType.XCM) {
-        isXcmOk = true;
-      }
-    }
-    return [];
-  }
   async validateSwapProcessV2(params) {
     // todo: recheck address and recipient format in params
     const {
@@ -437,24 +185,23 @@ class AssetHubSwapHandler {
     if ((0, _bignumber.default)(selectedQuote.fromAmount).lte(0)) {
       return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')];
     }
-    const actionList = process.steps.map(step => step.type);
-    const [firstStep, secondStep, thirdStep, fourthStep, fifthStep] = actionList;
-    const swap = firstStep === _types.CommonStepType.DEFAULT && secondStep === _types.SwapStepType.SWAP && !thirdStep;
-    const swapXcm = firstStep === _types.CommonStepType.DEFAULT && secondStep === _types.SwapStepType.SWAP && thirdStep === _types.CommonStepType.XCM && !fourthStep;
-    const xcmSwap = firstStep === _types.CommonStepType.DEFAULT && secondStep === _types.CommonStepType.XCM && thirdStep === _types.SwapStepType.SWAP && !fourthStep;
-    const xcmSwapXcm = firstStep === _types.CommonStepType.DEFAULT && secondStep === _types.CommonStepType.XCM && thirdStep === _types.SwapStepType.SWAP && fourthStep === _types.CommonStepType.XCM && !fifthStep;
+    const actionList = JSON.stringify(process.path.map(step => step.action));
+    const swap = actionList === JSON.stringify([_types.DynamicSwapType.SWAP]);
+    const swapXcm = actionList === JSON.stringify([_types.DynamicSwapType.SWAP, _types.DynamicSwapType.BRIDGE]);
+    const xcmSwap = actionList === JSON.stringify([_types.DynamicSwapType.BRIDGE, _types.DynamicSwapType.SWAP]);
+    const xcmSwapXcm = actionList === JSON.stringify([_types.DynamicSwapType.BRIDGE, _types.DynamicSwapType.SWAP, _types.DynamicSwapType.BRIDGE]);
     if (swap) {
       return this.swapBaseHandler.validateSwapOnlyProcess(params, 1); // todo: create interface for input request
     }
 
     if (swapXcm) {
-      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+      return this.swapBaseHandler.validateSwapXcmProcess(params, 1, 2);
     }
     if (xcmSwap) {
       return this.swapBaseHandler.validateXcmSwapProcess(params, 2, 1);
     }
     if (xcmSwapXcm) {
-      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+      return this.swapBaseHandler.validateXcmSwapXcmProcess(params, 2, 1, 3);
     }
     return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
   }