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

package/cjs/services/swap-service/handler/hydradx-handler.js

@@ -14,12 +14,14 @@ var _constants = require("@subwallet/extension-base/constants");
 var _xcm = require("@subwallet/extension-base/services/balance-service/transfer/xcm");
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
 var _baseHandler = require("@subwallet/extension-base/services/swap-service/handler/base-handler");
+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 _swap = require("@subwallet/extension-base/types/swap");
 var _getId = require("@subwallet/extension-base/utils/getId");
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
+var _util = require("@polkadot/util");
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
@@ -195,35 +197,138 @@ class HydradxHandler {
     }
     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);
+    if (!fromChainInfo || !toChainInfo || !fromChainInfo || !toChainInfo) {
+      throw Error('Token and chain not found');
+    }
+    try {
+      const substrateApi = await this.chainService.getSubstrateApi(fromTokenInfo.originChain).isReady;
+      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: _swap.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);
+
+      // todo: increase transfer amount when XCM local token
+      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: _serviceBase.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) {
+      return Promise.resolve(undefined);
+    }
+    const txHex = params.selectedQuote.metadata;
+    if (!txHex || !(0, _util.isHex)(txHex)) {
+      return Promise.resolve(undefined);
+    }
+    const metadata = {
+      sendingValue: params.request.fromAmount.toString(),
+      originTokenInfo: this.chainService.getAssetBySlug(swapPairInfo.from),
+      destinationTokenInfo: this.chainService.getAssetBySlug(swapPairInfo.to),
+      txHex
+    };
+    const submitStep = {
+      name: 'Swap',
+      type: _swap.SwapStepType.SWAP,
+      // @ts-ignore
+      metadata
+    };
+    return Promise.resolve([submitStep, params.selectedQuote.feeInfo]); // review fee
+  }
+
   generateOptimalProcess(params) {
     return this.swapBaseHandler.generateOptimalProcess(params, [this.getXcmStep.bind(this),
     // this.getFeeOptionStep.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);
-    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,
@@ -236,14 +341,14 @@ class HydradxHandler {
       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
@@ -274,18 +379,18 @@ class HydradxHandler {
     };
   }
   async handleSubmitStep(params) {
-    const fromAsset = this.chainService.getAssetBySlug(params.quote.pair.from);
-    const toAsset = this.chainService.getAssetBySlug(params.quote.pair.to);
-    const fromAssetId = (0, _utils._getTokenOnChainAssetId)(fromAsset);
-    const toAssetId = (0, _utils._getTokenOnChainAssetId)(toAsset);
+    const metadata = params.process.steps[params.currentStep].metadata;
+    const txHex = params.quote.metadata;
+    if (!txHex || !(0, _util.isHex)(txHex)) {
+      return new _SwapError.SwapError(_swap.SwapErrorType.UNKNOWN);
+    }
+    if (!metadata || !metadata.sendingValue || !metadata.txHex || !metadata.destinationTokenInfo || !metadata.originTokenInfo) {
+      throw new Error('Swap metadata error');
+    }
+    const fromAsset = metadata.originTokenInfo;
     if (!this.isReady || !this.tradeRouter) {
       return new _SwapError.SwapError(_swap.SwapErrorType.UNKNOWN);
     }
-    const parsedFromAmount = new _bignumber.default(params.quote.fromAmount).shiftedBy(-1 * (0, _utils._getAssetDecimals)(fromAsset)).toString();
-    const quoteResponse = await this.tradeRouter.getBestSell(fromAssetId, toAssetId, parsedFromAmount);
-    const toAmount = quoteResponse.amountOut;
-    const minReceive = toAmount.times(1 - params.slippage).integerValue();
-    const txHex = quoteResponse.toTx(minReceive).hex;
     const substrateApi = this.chainService.getSubstrateApi(this.chain());
     const chainApi = await substrateApi.isReady;
     const txData = {
@@ -293,7 +398,7 @@ class HydradxHandler {
       quote: params.quote,
       address: params.address,
       slippage: params.slippage,
-      txHex,
+      txHex: txHex,
       process: params.process
     };
     let extrinsic;
@@ -321,8 +426,7 @@ class HydradxHandler {
       txChain: fromAsset.originChain,
       txData,
       extrinsic,
-      transferNativeAmount: (0, _utils._isNativeToken)(fromAsset) ? params.quote.fromAmount : '0',
-      // todo
+      transferNativeAmount: (0, _utils._isNativeToken)(fromAsset) ? metadata.sendingValue : '0',
       extrinsicType: _KoniTypes.ExtrinsicType.SWAP,
       chainType: _KoniTypes.ChainType.SUBSTRATE
     };
@@ -352,14 +456,22 @@ class HydradxHandler {
     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 === _swap.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:
             return Promise.resolve([]);
           case _serviceBase.CommonStepType.XCM:
-            return this.swapBaseHandler.validateXcmStep(params, index);
+            return this.swapBaseHandler.validateXcmStepV2(params, index);
           case _serviceBase.CommonStepType.SET_FEE_TOKEN:
             return this.swapBaseHandler.validateSetFeeTokenStep(params, index);
           default:
@@ -375,6 +487,38 @@ class HydradxHandler {
     }
     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 = JSON.stringify(process.path.map(step => step.action));
+    const swap = actionList === JSON.stringify([_interface.DynamicSwapType.SWAP]);
+    const swapXcm = actionList === JSON.stringify([_interface.DynamicSwapType.SWAP, _interface.DynamicSwapType.BRIDGE]);
+    const xcmSwap = actionList === JSON.stringify([_interface.DynamicSwapType.BRIDGE, _interface.DynamicSwapType.SWAP]);
+    const xcmSwapXcm = actionList === JSON.stringify([_interface.DynamicSwapType.BRIDGE, _interface.DynamicSwapType.SWAP, _interface.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)];
+    }
+    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)];
+  }
   get referralCode() {
     if (this.isTestnet) {
       return HYDRADX_TESTNET_SUBWALLET_REFERRAL_CODE;

package/cjs/services/swap-service/handler/simpleswap-handler.js

@@ -8,6 +8,7 @@ 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 _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _interface = require("@subwallet/extension-base/services/swap-service/interface");
 var _types = require("@subwallet/extension-base/types");
 var _utils2 = require("@subwallet/extension-base/utils");
 var _getId = require("@subwallet/extension-base/utils/getId");
@@ -114,11 +115,19 @@ class SimpleSwapHandler {
   generateOptimalProcess(params) {
     return this.swapBaseHandler.generateOptimalProcess(params, [this.getSubmitStep.bind(this)]);
   }
+  generateOptimalProcessV2(params) {
+    return this.swapBaseHandler.generateOptimalProcessV2(params, [this.getSubmitStep.bind(this)]);
+  }
   async getSubmitStep(params) {
     if (params.selectedQuote) {
       const submitStep = {
         name: 'Swap',
-        type: _types.SwapStepType.SWAP
+        type: _types.SwapStepType.SWAP,
+        metadata: {
+          sendingValue: params.request.fromAmount.toString(),
+          originTokenInfo: this.chainService.getAssetBySlug(params.selectedQuote.pair.from),
+          destinationTokenInfo: this.chainService.getAssetBySlug(params.selectedQuote.pair.to)
+        }
       };
       return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
     }
@@ -171,6 +180,9 @@ class SimpleSwapHandler {
       sender,
       toAsset
     });
+    if (!id || id.length === 0 || !addressFrom || addressFrom.length === 0) {
+      throw new _SwapError.SwapError(_types.SwapErrorType.UNKNOWN);
+    }
 
     // Validate the amount to be swapped
     const rate = (0, _bignumber.default)(amountTo).div((0, _bignumber.default)(quote.toAmount)).multipliedBy(100);
@@ -239,5 +251,42 @@ class SimpleSwapHandler {
       chainType
     };
   }
+  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.BigNumber)(selectedQuote.fromAmount).lte(0)) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')];
+    }
+    const actionList = JSON.stringify(process.path.map(step => step.action));
+    const swap = actionList === JSON.stringify([_interface.DynamicSwapType.SWAP]);
+    const swapXcm = actionList === JSON.stringify([_interface.DynamicSwapType.SWAP, _interface.DynamicSwapType.BRIDGE]);
+    const xcmSwap = actionList === JSON.stringify([_interface.DynamicSwapType.BRIDGE, _interface.DynamicSwapType.SWAP]);
+    const xcmSwapXcm = actionList === JSON.stringify([_interface.DynamicSwapType.BRIDGE, _interface.DynamicSwapType.SWAP, _interface.DynamicSwapType.BRIDGE]);
+    const swapIndex = params.process.steps.findIndex(step => step.type === _types.SwapStepType.SWAP); // todo
+
+    if (swapIndex <= -1) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (swap) {
+      return this.swapBaseHandler.validateSwapOnlyProcess(params, swapIndex); // todo: create interface for input request
+    }
+
+    if (swapXcm) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (xcmSwap) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (xcmSwapXcm) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+  }
 }
 exports.SimpleSwapHandler = SimpleSwapHandler;

package/cjs/services/swap-service/handler/uniswap-handler.js

@@ -8,6 +8,7 @@ exports.UniswapHandler = void 0;
 var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
 var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
 var _logicValidation = require("@subwallet/extension-base/core/logic-validation");
+var _interface = require("@subwallet/extension-base/services/swap-service/interface");
 var _types = require("@subwallet/extension-base/types");
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
 var _utils = require("../../chain-service/utils");
@@ -67,6 +68,9 @@ class UniswapHandler {
   generateOptimalProcess(params) {
     return this.swapBaseHandler.generateOptimalProcess(params, [this.getApprovalStep.bind(this), this.getPermitStep.bind(this), this.getSubmitStep.bind(this)]);
   }
+  generateOptimalProcessV2(params) {
+    return this.swapBaseHandler.generateOptimalProcessV2(params, [this.getApprovalStep.bind(this), this.getPermitStep.bind(this), this.getSubmitStep.bind(this)]);
+  }
   async getApprovalStep(params) {
     if (params.selectedQuote) {
       const walletAddress = params.request.address;
@@ -125,7 +129,12 @@ class UniswapHandler {
     if (params.selectedQuote) {
       const submitStep = {
         name: 'Swap',
-        type: _types.SwapStepType.SWAP
+        type: _types.SwapStepType.SWAP,
+        metadata: {
+          sendingValue: params.request.fromAmount.toString(),
+          originTokenInfo: this.chainService.getAssetBySlug(params.selectedQuote.pair.from),
+          destinationTokenInfo: this.chainService.getAssetBySlug(params.selectedQuote.pair.to)
+        }
       };
       return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
     }
@@ -327,5 +336,42 @@ class UniswapHandler {
       isPermit: true
     };
   }
+  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 = JSON.stringify(process.path.map(step => step.action));
+    const swap = actionList === JSON.stringify([_interface.DynamicSwapType.SWAP]);
+    const swapXcm = actionList === JSON.stringify([_interface.DynamicSwapType.SWAP, _interface.DynamicSwapType.BRIDGE]);
+    const xcmSwap = actionList === JSON.stringify([_interface.DynamicSwapType.BRIDGE, _interface.DynamicSwapType.SWAP]);
+    const xcmSwapXcm = actionList === JSON.stringify([_interface.DynamicSwapType.BRIDGE, _interface.DynamicSwapType.SWAP, _interface.DynamicSwapType.BRIDGE]);
+    const swapIndex = params.process.steps.findIndex(step => step.type === _types.SwapStepType.SWAP); // todo
+
+    if (swapIndex <= -1) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (swap) {
+      return this.swapBaseHandler.validateSwapOnlyProcess(params, swapIndex); // todo: create interface for input request
+    }
+
+    if (swapXcm) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (xcmSwap) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (xcmSwapXcm) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+  }
 }
 exports.UniswapHandler = UniswapHandler;