@subwallet/extension-base 1.3.26-0 → 1.3.27-1

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

@@ -5,16 +5,16 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 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 _serviceBase = require("@subwallet/extension-base/types/service-base");
-var _swap2 = require("@subwallet/extension-base/types/swap");
 var _getId = require("@subwallet/extension-base/utils/getId");
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
 var _baseHandler = require("../base-handler");
@@ -29,13 +29,13 @@ class AssetHubSwapHandler {
     const providerSlug = function () {
       switch (chain) {
         case 'statemint':
-          return _swap2.SwapProviderId.POLKADOT_ASSET_HUB;
+          return _types.SwapProviderId.POLKADOT_ASSET_HUB;
         case 'statemine':
-          return _swap2.SwapProviderId.KUSAMA_ASSET_HUB;
+          return _types.SwapProviderId.KUSAMA_ASSET_HUB;
         case 'westend_assethub':
-          return _swap2.SwapProviderId.WESTEND_ASSET_HUB;
+          return _types.SwapProviderId.WESTEND_ASSET_HUB;
         default:
-          return _swap2.SwapProviderId.ROCOCO_ASSET_HUB;
+          return _types.SwapProviderId.ROCOCO_ASSET_HUB;
       }
     }();
     this.swapBaseHandler = new _baseHandler.SwapBaseHandler({
@@ -114,7 +114,7 @@ class AssetHubSwapHandler {
       const xcmFeeInfo = _xcmFeeInfo.toPrimitive();
       const fee = {
         feeComponent: [{
-          feeType: _swap2.SwapFeeType.NETWORK_FEE,
+          feeType: _types.SwapFeeType.NETWORK_FEE,
           amount: Math.round(xcmFeeInfo.partialFee * _constants.XCM_MIN_AMOUNT_RATIO).toString(),
           tokenSlug: (0, _utils._getChainNativeTokenSlug)(alternativeChainInfo)
         }],
@@ -134,7 +134,7 @@ class AssetHubSwapHandler {
           destinationTokenInfo: fromAsset
         },
         name: `Transfer ${alternativeAsset.symbol} from ${alternativeChainInfo.name}`,
-        type: _serviceBase.CommonStepType.XCM
+        type: _types.CommonStepType.XCM
       };
       return [step, fee];
     } catch (e) {
@@ -146,7 +146,96 @@ class AssetHubSwapHandler {
     if (params.selectedQuote) {
       const submitStep = {
         name: 'Swap',
-        type: _swap2.SwapStepType.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) {
+      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]);
     }
@@ -155,36 +244,39 @@ class AssetHubSwapHandler {
   generateOptimalProcess(params) {
     return this.swapBaseHandler.generateOptimalProcess(params, [this.getXcmStep.bind(this), this.getSubmitStep.bind(this)]);
   }
+  generateOptimalProcessV2(params) {
+    const stepFuncList = params.path.map(step => {
+      if (step.action === _interface.DynamicSwapType.BRIDGE) {
+        return this.getXcmStepV2.bind(this);
+      }
+      if (step.action === _interface.DynamicSwapType.SWAP) {
+        return this.getSwapStepV2.bind(this);
+      }
+      throw new Error(`Error generating optimal process: Action ${step.action} is not supported`);
+    });
+    return this.swapBaseHandler.generateOptimalProcessV2(params, stepFuncList);
+  }
   async handleXcmStep(params) {
-    const pair = params.quote.pair;
-    const alternativeAssetSlug = (0, _utils2.getSwapAlternativeAsset)(pair);
-    const originAsset = this.chainService.getAssetBySlug(alternativeAssetSlug);
-    const destinationAsset = this.chainService.getAssetBySlug(pair.from);
+    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 destinationAssetBalance = await this.balanceService.getTransferableBalance(params.address, destinationAsset.originChain, destinationAsset.slug);
-    const xcmFee = params.process.totalFee[params.currentStep];
-    const bnAmount = new _bignumber.default(params.quote.fromAmount);
-    const bnDestinationAssetBalance = new _bignumber.default(destinationAssetBalance.value);
-    const id = (0, _getId.getId)();
-    const feeInfo = await this.swapBaseHandler.feeService.subscribeChainFee(id, originChain.slug, 'substrate');
-    let bnTotalAmount = bnAmount.minus(bnDestinationAssetBalance);
-    if ((0, _utils._isNativeToken)(originAsset)) {
-      const bnXcmFee = new _bignumber.default(xcmFee.feeComponent[0].amount); // xcm fee is paid in native token but swap token is not always native token
-
-      bnTotalAmount = bnTotalAmount.plus(bnXcmFee);
-    }
+    const feeInfo = await this.swapBaseHandler.feeService.subscribeChainFee((0, _getId.getId)(), originAsset.originChain, 'substrate');
     const xcmTransfer = await (0, _xcm.createXcmExtrinsic)({
       originTokenInfo: originAsset,
       destinationTokenInfo: destinationAsset,
-      sendingValue: bnTotalAmount.toString(),
+      sendingValue: briefXcmStep.sendingValue,
       recipient: params.address,
       substrateApi: chainApi,
       sender: params.address,
-      originChain: originChain,
-      destinationChain: destinationChain,
+      destinationChain,
+      originChain,
       feeInfo
     });
     const xcmData = {
@@ -192,14 +284,14 @@ class AssetHubSwapHandler {
       destinationNetworkKey: destinationAsset.originChain,
       from: params.address,
       to: params.address,
-      value: bnTotalAmount.toString(),
+      value: briefXcmStep.sendingValue,
       tokenSlug: originAsset.slug,
       showExtraWarning: true
     };
     return {
       txChain: originAsset.originChain,
       extrinsic: xcmTransfer,
-      transferNativeAmount: (0, _utils._isNativeToken)(originAsset) ? bnTotalAmount.toString() : '0',
+      transferNativeAmount: (0, _utils._isNativeToken)(originAsset) ? briefXcmStep.sendingValue : '0',
       extrinsicType: _KoniTypes.ExtrinsicType.TRANSFER_XCM,
       chainType: _KoniTypes.ChainType.SUBSTRATE,
       txData: xcmData
@@ -207,7 +299,11 @@ class AssetHubSwapHandler {
   }
   async handleSubmitStep(params) {
     var _this$router;
-    const fromAsset = this.chainService.getAssetBySlug(params.quote.pair.from);
+    const metadata = params.process.steps[params.currentStep].metadata;
+    if (!metadata || !metadata.sendingValue || !metadata.destinationTokenInfo || !metadata.originTokenInfo) {
+      return new _SwapError.SwapError(_types.SwapErrorType.UNKNOWN);
+    }
+    const fromAsset = metadata.originTokenInfo;
     const txData = {
       provider: this.providerInfo,
       quote: params.quote,
@@ -220,7 +316,12 @@ class AssetHubSwapHandler {
       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) {
+      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()));
     return {
       txChain: fromAsset.originChain,
@@ -239,9 +340,9 @@ class AssetHubSwapHandler {
     } = params;
     const type = process.steps[currentStep].type;
     switch (type) {
-      case _serviceBase.CommonStepType.XCM:
+      case _types.CommonStepType.XCM:
         return this.handleXcmStep(params);
-      case _swap2.SwapStepType.SWAP:
+      case _types.SwapStepType.SWAP:
         return this.handleSubmitStep(params);
       default:
         return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED));
@@ -257,10 +358,10 @@ class AssetHubSwapHandler {
     const selectedQuote = params.selectedQuote;
     const currentTimestamp = +Date.now();
     if (selectedQuote.aliveUntil <= currentTimestamp) {
-      return Promise.resolve([new _TransactionError.TransactionError(_swap2.SwapErrorType.QUOTE_TIMEOUT)]);
+      return Promise.resolve([new _TransactionError.TransactionError(_types.SwapErrorType.QUOTE_TIMEOUT)]);
     }
     const stepFee = params.process.totalFee[stepIndex].feeComponent;
-    const networkFee = stepFee.find(fee => fee.feeType === _swap2.SwapFeeType.NETWORK_FEE);
+    const networkFee = stepFee.find(fee => fee.feeType === _types.SwapFeeType.NETWORK_FEE);
     if (!networkFee) {
       return Promise.resolve([new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)]);
     }
@@ -293,15 +394,23 @@ class AssetHubSwapHandler {
     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 _serviceBase.CommonStepType.DEFAULT:
+          case _types.CommonStepType.DEFAULT:
             return Promise.resolve([]);
-          case _serviceBase.CommonStepType.XCM:
-            return this.swapBaseHandler.validateXcmStep(params, index);
-          case _swap2.SwapStepType.SWAP:
+          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));
@@ -310,11 +419,44 @@ class AssetHubSwapHandler {
       const errors = await getErrors();
       if (errors.length) {
         return errors;
-      } else if (step.type === _serviceBase.CommonStepType.XCM) {
+      } else if (step.type === _types.CommonStepType.XCM) {
         isXcmOk = true;
       }
     }
     return [];
   }
+  async validateSwapProcessV2(params) {
+    // todo: recheck address and recipient format in params
+    const {
+      process,
+      selectedQuote
+    } = params; // todo: review flow, currentStep param.
+
+    // todo: validate path with optimalProcess
+    // todo: review error message in case many step swap
+    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;
+    if (swap) {
+      return this.swapBaseHandler.validateSwapOnlyProcess(params, 1); // todo: create interface for input request
+    }
+
+    if (swapXcm) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (xcmSwap) {
+      return this.swapBaseHandler.validateXcmSwapProcess(params, 2, 1);
+    }
+    if (xcmSwapXcm) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+  }
 }
 exports.AssetHubSwapHandler = AssetHubSwapHandler;

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

@@ -152,6 +152,9 @@ const buildSwapExtrinsic = function (api, paths, recipient, amountIn, amountOutM
   let keepAlive = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : true;
   const pathsInfo = paths.map(asset => {
     const multilocation = (0, _utils._getXcmAssetMultilocation)(asset);
+    if (!multilocation) {
+      throw new Error('Error getting multilocation');
+    }
     return api.createType('MultiLocation', multilocation).toU8a();
   });
   return api.tx.assetConversion.swapExactTokensForTokens(pathsInfo, amountIn, amountOutMin, recipient, keepAlive);