@subwallet/extension-base 1.2.3-0 → 1.2.3-1

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

@@ -7,13 +7,13 @@ Object.defineProperty(exports, "__esModule", {
 exports.SwapBaseHandler = void 0;
 var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
 var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _swap = require("@subwallet/extension-base/core/logic-validation/swap");
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
 var _utils2 = require("@subwallet/extension-base/services/swap-service/utils");
-var _swap = require("@subwallet/extension-base/types/swap");
+var _swap2 = require("@subwallet/extension-base/types/swap");
 var _utils3 = require("@subwallet/extension-base/utils");
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
 var _i18next = require("i18next");
-var _utilCrypto = require("@polkadot/util-crypto");
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
@@ -62,7 +62,7 @@ class SwapBaseHandler {
     }
     const alternativeAsset = this.chainService.getAssetBySlug(alternativeAssetSlug);
     const fromAsset = this.chainService.getAssetBySlug(swapPair.from);
-    const [alternativeAssetBalance, fromAssetBalance] = await Promise.all([this.balanceService.getTokenFreeBalance(params.address, alternativeAsset.originChain, alternativeAssetSlug), this.balanceService.getTokenFreeBalance(params.address, fromAsset.originChain, fromAsset.slug)]);
+    const [alternativeAssetBalance, fromAssetBalance] = await Promise.all([this.balanceService.getTransferableBalance(params.address, alternativeAsset.originChain, alternativeAssetSlug), this.balanceService.getTransferableBalance(params.address, fromAsset.originChain, fromAsset.slug)]);
     const bnAlternativeAssetBalance = new _bignumber.default(alternativeAssetBalance.value);
     const bnFromAssetBalance = new _bignumber.default(fromAssetBalance.value);
     const xcmFeeComponent = params.process.totalFee[stepIndex].feeComponent[0]; // todo: can do better than indexing
@@ -71,9 +71,8 @@ class SwapBaseHandler {
     if ((0, _utils._isNativeToken)(alternativeAsset)) {
       xcmAmount = xcmAmount.plus(xcmFee);
     }
-    const alternativeTokenMinAmount = new _bignumber.default(alternativeAsset.minAmount || '0');
-    if (!bnAlternativeAssetBalance.minus(xcmAmount).gte(alternativeTokenMinAmount)) {
-      const maxBn = bnFromAssetBalance.plus(new _bignumber.default(alternativeAssetBalance.value)).minus(xcmFee).minus(alternativeTokenMinAmount);
+    if (!bnAlternativeAssetBalance.minus(xcmAmount).gt(0)) {
+      const maxBn = bnFromAssetBalance.plus(new _bignumber.default(alternativeAssetBalance.value)).minus(xcmFee);
       const maxValue = (0, _utils3.formatNumber)(maxBn.toString(), fromAsset.decimals || 0);
       const altInputTokenInfo = this.chainService.getAssetBySlug(alternativeAssetSlug);
       const symbol = altInputTokenInfo.symbol;
@@ -82,7 +81,7 @@ class SwapBaseHandler {
       const inputNetworkName = chain.name;
       const altNetworkName = alternativeChain.name;
       const currentValue = (0, _utils3.formatNumber)(bnFromAssetBalance.toString(), fromAsset.decimals || 0);
-      const bnMaxXCM = new _bignumber.default(alternativeAssetBalance.value).minus(xcmFee).minus(alternativeTokenMinAmount);
+      const bnMaxXCM = new _bignumber.default(alternativeAssetBalance.value).minus(xcmFee);
       const maxXCMValue = (0, _utils3.formatNumber)(bnMaxXCM.toString(), fromAsset.decimals || 0);
       if (maxBn.lte(0) || bnFromAssetBalance.lte(0) || bnMaxXCM.lte(0)) {
         return [new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.NOT_ENOUGH_BALANCE, (0, _i18next.t)(`Insufficient balance. Deposit ${fromAsset.symbol} and try again.`))];
@@ -110,7 +109,7 @@ class SwapBaseHandler {
     const feeInfo = params.process.totalFee[stepIndex];
     const feeAmount = feeInfo.feeComponent[0];
     const feeTokenInfo = this.chainService.getAssetBySlug(feeInfo.defaultFeeToken);
-    const feeTokenBalance = await this.balanceService.getTokenFreeBalance(params.address, feeTokenInfo.originChain, feeTokenInfo.slug);
+    const feeTokenBalance = await this.balanceService.getTransferableBalance(params.address, feeTokenInfo.originChain, feeTokenInfo.slug);
     const bnFeeTokenBalance = new _bignumber.default(feeTokenBalance.value);
     const bnFeeAmount = new _bignumber.default(feeAmount.amount);
     if (bnFeeAmount.gte(bnFeeTokenBalance)) {
@@ -119,57 +118,42 @@ class SwapBaseHandler {
     return [];
   }
   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(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)]);
     }
     const selectedQuote = params.selectedQuote;
     const currentTimestamp = +Date.now();
     if (selectedQuote.aliveUntil <= currentTimestamp) {
-      return Promise.resolve([new _TransactionError.TransactionError(_swap.SwapErrorType.QUOTE_TIMEOUT)]);
+      return Promise.resolve([new _TransactionError.TransactionError(_swap2.SwapErrorType.QUOTE_TIMEOUT)]);
     }
-    const bnAmount = new _bignumber.default(params.selectedQuote.fromAmount);
-    const fromAsset = this.chainService.getAssetBySlug(params.selectedQuote.pair.from);
     const stepFee = params.process.totalFee[stepIndex].feeComponent;
-    const networkFee = stepFee.find(fee => fee.feeType === _swap.SwapFeeType.NETWORK_FEE);
+    const networkFee = stepFee.find(fee => fee.feeType === _swap2.SwapFeeType.NETWORK_FEE);
     if (!networkFee) {
       return Promise.resolve([new _TransactionError.TransactionError(_KoniTypes.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 [feeTokenBalance, fromAssetBalance] = await Promise.all([this.balanceService.getTokenFreeBalance(params.address, feeTokenInfo.originChain, feeTokenInfo.slug), this.balanceService.getTokenFreeBalance(params.address, fromAsset.originChain, fromAsset.slug)]);
-    const bnFeeTokenBalance = new _bignumber.default(feeTokenBalance.value);
-    const bnFromAssetBalance = new _bignumber.default(fromAssetBalance.value);
-    const bnFeeAmount = new _bignumber.default(networkFee.amount);
-    if (bnFeeTokenBalance.lte(bnFeeAmount)) {
-      return Promise.resolve([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.NOT_ENOUGH_BALANCE, `You don't have enough ${feeTokenInfo.symbol} (${feeTokenChain.name}) to pay transaction fee`)]);
+    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._validateBalanceToSwap)(fromAsset, feeTokenInfo, feeTokenChain, networkFee.amount, fromAssetBalance.value, feeTokenBalance.value, fromAmount, isXcmOk, minSwap);
+    if (balanceError) {
+      return Promise.resolve([balanceError]);
     }
-    if (fromAsset.slug === feeTokenInfo.slug) {
-      if (bnFromAssetBalance.lte(bnFeeAmount.plus(bnAmount))) {
-        return Promise.resolve([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.NOT_ENOUGH_BALANCE, `Insufficient balance. Deposit ${fromAsset.symbol} and try again.`)]);
-      }
+    if (!params.recipient) {
+      return Promise.resolve([]);
     }
-    if (params.selectedQuote.minSwap) {
-      const minProtocolSwap = new _bignumber.default(params.selectedQuote.minSwap);
-      if (!isXcmOk && bnFromAssetBalance.lte(minProtocolSwap)) {
-        const parsedMinSwapValue = (0, _utils3.formatNumber)(minProtocolSwap, (0, _utils._getAssetDecimals)(fromAsset));
-        return Promise.resolve([new _TransactionError.TransactionError(_swap.SwapErrorType.SWAP_NOT_ENOUGH_BALANCE, `Insufficient balance. You need more than ${parsedMinSwapValue} ${fromAsset.symbol} to start swapping. Deposit ${fromAsset.symbol} and try again.`)]); // todo: min swap or amount?
-      }
-    }
-
-    const bnSrcAssetMinAmount = new _bignumber.default((0, _utils._getTokenMinAmount)(fromAsset));
-    const bnMaxBalanceSwap = bnFromAssetBalance.minus(bnSrcAssetMinAmount);
-    if (!isXcmOk && bnAmount.gte(bnMaxBalanceSwap)) {
-      const parsedMaxBalanceSwap = (0, _utils3.formatNumber)(bnMaxBalanceSwap, (0, _utils._getAssetDecimals)(fromAsset));
-      return Promise.resolve([new _TransactionError.TransactionError(_swap.SwapErrorType.SWAP_EXCEED_ALLOWANCE, `Amount too high. Lower your amount ${bnMaxBalanceSwap.gt(0) ? `below ${parsedMaxBalanceSwap} ${fromAsset.symbol}` : ''} and try again`)]);
-    }
-    if (params.recipient) {
-      const toAsset = this.chainService.getAssetBySlug(params.selectedQuote.pair.to);
-      const destChainInfo = this.chainService.getChainInfoByKey(toAsset.originChain);
-      const isEvmAddress = (0, _utilCrypto.isEthereumAddress)(params.recipient);
-      const isEvmDestChain = (0, _utils._isChainEvmCompatible)(destChainInfo);
-      if (isEvmAddress && !isEvmDestChain || !isEvmAddress && isEvmDestChain) {
-        return Promise.resolve([new _TransactionError.TransactionError(_swap.SwapErrorType.INVALID_RECIPIENT)]);
-      }
+    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([]);
   }

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

@@ -10,12 +10,13 @@ var _chainList = require("@subwallet/chain-list");
 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 _swap2 = require("@subwallet/extension-base/core/logic-validation/swap");
 var _transfer = require("@subwallet/extension-base/koni/api/dotsama/transfer");
 var _transfer2 = require("@subwallet/extension-base/koni/api/tokens/evm/transfer");
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
 var _baseHandler = require("@subwallet/extension-base/services/swap-service/handler/base-handler");
 var _utils2 = require("@subwallet/extension-base/services/swap-service/utils");
-var _swap2 = require("@subwallet/extension-base/types/swap");
+var _swap3 = require("@subwallet/extension-base/types/swap");
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
@@ -41,9 +42,10 @@ class ChainflipSwapHandler {
       chainService,
       balanceService,
       providerName: isTestnet ? 'Chainflip Testnet' : 'Chainflip',
-      providerSlug: isTestnet ? _swap2.SwapProviderId.CHAIN_FLIP_TESTNET : _swap2.SwapProviderId.CHAIN_FLIP_MAINNET
+      providerSlug: isTestnet ? _swap3.SwapProviderId.CHAIN_FLIP_TESTNET : _swap3.SwapProviderId.CHAIN_FLIP_MAINNET
     });
     this.isTestnet = isTestnet;
+    this.providerSlug = isTestnet ? _swap3.SwapProviderId.CHAIN_FLIP_TESTNET : _swap3.SwapProviderId.CHAIN_FLIP_MAINNET;
     this.swapSdk = new _swap.SwapSDK({
       network: isTestnet ? 'perseverance' : 'mainnet'
     });
@@ -99,7 +101,7 @@ class ChainflipSwapHandler {
       const toAssetId = this.assetMapping[toAsset.slug];
       if (!srcChainId || !destChainId || !fromAssetId || !toAssetId) {
         return {
-          error: _swap2.SwapErrorType.ASSET_NOT_SUPPORTED
+          error: _swap3.SwapErrorType.ASSET_NOT_SUPPORTED
         };
       }
       const [supportedDestChains, srcAssets, destAssets] = await Promise.all([this.swapSdk.getChains(srcChainId), this.swapSdk.getAssets(srcChainId), this.swapSdk.getAssets(destChainId)]);
@@ -108,7 +110,7 @@ class ChainflipSwapHandler {
       const destAssetData = destAssets.find(a => a.asset === toAssetId);
       if (!destAssetData || !srcAssetData || !supportedDestChainId) {
         return {
-          error: _swap2.SwapErrorType.UNKNOWN
+          error: _swap3.SwapErrorType.UNKNOWN
         };
       }
       const bnAmount = new _bignumber.default(request.fromAmount);
@@ -117,12 +119,12 @@ class ChainflipSwapHandler {
         const bnMaxProtocolSwap = new _bignumber.default(srcAssetData.maximumSwapAmount);
         if (bnMinSwap.gte(bnMaxProtocolSwap)) {
           return {
-            error: _swap2.SwapErrorType.UNKNOWN
+            error: _swap3.SwapErrorType.UNKNOWN
           };
         }
         if (bnAmount.gte(bnMaxProtocolSwap)) {
           return {
-            error: _swap2.SwapErrorType.SWAP_EXCEED_ALLOWANCE,
+            error: _swap3.SwapErrorType.SWAP_EXCEED_ALLOWANCE,
             metadata: {
               minSwap: {
                 value: srcAssetData.minimumSwapAmount,
@@ -142,7 +144,7 @@ class ChainflipSwapHandler {
       if (bnAmount.lt(bnMinSwap)) {
         // might miss case when minSwap is 0
         return {
-          error: _swap2.SwapErrorType.NOT_MEET_MIN_SWAP,
+          error: _swap3.SwapErrorType.NOT_MEET_MIN_SWAP,
           metadata: {
             minSwap: {
               value: srcAssetData.minimumSwapAmount,
@@ -175,7 +177,7 @@ class ChainflipSwapHandler {
       };
     } catch (e) {
       return {
-        error: _swap2.SwapErrorType.UNKNOWN
+        error: _swap3.SwapErrorType.UNKNOWN
       };
     }
   }
@@ -193,12 +195,12 @@ class ChainflipSwapHandler {
     const fromChain = this.chainService.getChainInfoByKey(fromAsset.originChain);
     const fromChainNativeTokenSlug = (0, _utils._getChainNativeTokenSlug)(fromChain);
     if (!fromAsset || !toAsset) {
-      return new _SwapError.SwapError(_swap2.SwapErrorType.UNKNOWN);
+      return new _SwapError.SwapError(_swap3.SwapErrorType.UNKNOWN);
     }
     const earlyValidation = await this.validateSwapRequest(request);
     const metadata = earlyValidation.metadata;
     if (earlyValidation.error) {
-      return (0, _utils2.getChainflipEarlyValidationError)(earlyValidation.error, metadata);
+      return (0, _swap2._getChainflipEarlyValidationError)(earlyValidation.error, metadata);
     }
     const srcChainId = this.chainMapping[fromAsset.originChain];
     const destChainId = this.chainMapping[toAsset.originChain];
@@ -225,7 +227,7 @@ class ChainflipSwapHandler {
               feeComponent.push({
                 tokenSlug,
                 amount: fee.amount,
-                feeType: _swap2.SwapFeeType.NETWORK_FEE
+                feeType: _swap3.SwapFeeType.NETWORK_FEE
               });
               break;
             }
@@ -238,7 +240,7 @@ class ChainflipSwapHandler {
               feeComponent.push({
                 tokenSlug,
                 amount: fee.amount,
-                feeType: _swap2.SwapFeeType.PLATFORM_FEE
+                feeType: _swap3.SwapFeeType.PLATFORM_FEE
               });
               break;
             }
@@ -272,12 +274,12 @@ class ChainflipSwapHandler {
       const errorObj = error === null || error === void 0 ? void 0 : (_error$response = error.response) === null || _error$response === void 0 ? void 0 : _error$response.data;
       if (errorObj && errorObj.error && errorObj.error.includes(CHAINFLIP_QUOTE_ERROR.InsufficientLiquidity)) {
         // todo: Chainflip will improve this
-        return new _SwapError.SwapError(_swap2.SwapErrorType.NOT_ENOUGH_LIQUIDITY);
+        return new _SwapError.SwapError(_swap3.SwapErrorType.NOT_ENOUGH_LIQUIDITY);
       }
       if (errorObj && errorObj.message && errorObj.message.includes(CHAINFLIP_QUOTE_ERROR.InsufficientLiquidity)) {
-        return new _SwapError.SwapError(_swap2.SwapErrorType.NOT_ENOUGH_LIQUIDITY);
+        return new _SwapError.SwapError(_swap3.SwapErrorType.NOT_ENOUGH_LIQUIDITY);
       }
-      return new _SwapError.SwapError(_swap2.SwapErrorType.ERROR_FETCHING_QUOTE);
+      return new _SwapError.SwapError(_swap3.SwapErrorType.ERROR_FETCHING_QUOTE);
     }
   }
   async validateSwapProcess(params) {
@@ -290,9 +292,9 @@ class ChainflipSwapHandler {
     for (const [index, step] of params.process.steps.entries()) {
       const getErrors = async () => {
         switch (step.type) {
-          case _swap2.SwapStepType.DEFAULT:
+          case _swap3.SwapStepType.DEFAULT:
             return Promise.resolve([]);
-          case _swap2.SwapStepType.TOKEN_APPROVAL:
+          case _swap3.SwapStepType.TOKEN_APPROVAL:
             return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNSUPPORTED));
           default:
             return this.swapBaseHandler.validateSwapStep(params, isXcmOk, index);
@@ -301,7 +303,7 @@ class ChainflipSwapHandler {
       const errors = await getErrors();
       if (errors.length) {
         return errors;
-      } else if (step.type === _swap2.SwapStepType.XCM) {
+      } else if (step.type === _swap3.SwapStepType.XCM) {
         isXcmOk = true;
       }
     }
@@ -382,9 +384,9 @@ class ChainflipSwapHandler {
     } = params;
     const type = process.steps[currentStep].type;
     switch (type) {
-      case _swap2.SwapStepType.DEFAULT:
+      case _swap3.SwapStepType.DEFAULT:
         return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNSUPPORTED));
-      case _swap2.SwapStepType.SWAP:
+      case _swap3.SwapStepType.SWAP:
         return this.handleSubmitStep(params);
       default:
         return this.handleSubmitStep(params);
@@ -394,7 +396,7 @@ class ChainflipSwapHandler {
     if (params.selectedQuote) {
       const submitStep = {
         name: 'Swap',
-        type: _swap2.SwapStepType.SWAP
+        type: _swap3.SwapStepType.SWAP
       };
       return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
     }

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

@@ -11,11 +11,12 @@ var _types = require("@subwallet/chain-list/types");
 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 _swap = require("@subwallet/extension-base/core/logic-validation/swap");
 var _xcm = require("@subwallet/extension-base/koni/api/xcm");
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
 var _baseHandler = require("@subwallet/extension-base/services/swap-service/handler/base-handler");
 var _utils2 = require("@subwallet/extension-base/services/swap-service/utils");
-var _swap = require("@subwallet/extension-base/types/swap");
+var _swap2 = require("@subwallet/extension-base/types/swap");
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
@@ -34,8 +35,9 @@ class HydradxHandler {
       balanceService,
       chainService,
       providerName: isTestnet ? 'HydraDX Testnet' : 'HydraDX',
-      providerSlug: isTestnet ? _swap.SwapProviderId.HYDRADX_TESTNET : _swap.SwapProviderId.HYDRADX_MAINNET
+      providerSlug: isTestnet ? _swap2.SwapProviderId.HYDRADX_TESTNET : _swap2.SwapProviderId.HYDRADX_MAINNET
     });
+    this.providerSlug = isTestnet ? _swap2.SwapProviderId.HYDRADX_TESTNET : _swap2.SwapProviderId.HYDRADX_MAINNET;
     this.isTestnet = isTestnet;
   }
   async init() {
@@ -75,7 +77,7 @@ class HydradxHandler {
   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.getTokenFreeBalance(params.request.address, fromAsset.originChain, fromAsset.slug);
+    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
@@ -86,7 +88,7 @@ class HydradxHandler {
       return undefined;
     }
     const alternativeAsset = this.chainService.getAssetBySlug(alternativeAssetSlug);
-    const alternativeAssetBalance = await this.balanceService.getTokenFreeBalance(params.request.address, alternativeAsset.originChain, alternativeAsset.slug);
+    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;
@@ -100,7 +102,7 @@ class HydradxHandler {
           destinationTokenInfo: fromAsset
         },
         name: `Transfer ${alternativeAsset.symbol} from ${alternativeChainInfo.name}`,
-        type: _swap.SwapStepType.XCM
+        type: _swap2.SwapStepType.XCM
       };
       const xcmOriginSubstrateApi = await this.chainService.getSubstrateApi(alternativeAsset.originChain).isReady;
       const xcmTransfer = await (0, _xcm.createXcmExtrinsic)({
@@ -115,7 +117,7 @@ class HydradxHandler {
       const xcmFeeInfo = _xcmFeeInfo.toPrimitive();
       const fee = {
         feeComponent: [{
-          feeType: _swap.SwapFeeType.NETWORK_FEE,
+          feeType: _swap2.SwapFeeType.NETWORK_FEE,
           amount: Math.round(xcmFeeInfo.partialFee * 1.2).toString(),
           tokenSlug: (0, _utils._getChainNativeTokenSlug)(alternativeChainInfo)
         }],
@@ -137,7 +139,7 @@ class HydradxHandler {
     }
     const feeStep = {
       name: 'Set fee token',
-      type: _swap.SwapStepType.SET_FEE_TOKEN
+      type: _swap2.SwapStepType.SET_FEE_TOKEN
     };
     try {
       const substrateApi = this.chainService.getSubstrateApi(this.chain());
@@ -154,7 +156,7 @@ class HydradxHandler {
       const txFee = _txFee.toPrimitive();
       const fee = {
         feeComponent: [{
-          feeType: _swap.SwapFeeType.NETWORK_FEE,
+          feeType: _swap2.SwapFeeType.NETWORK_FEE,
           amount: Math.round(txFee.partialFee).toString(),
           tokenSlug: selectedFeeAsset.slug
         }],
@@ -171,7 +173,7 @@ class HydradxHandler {
     if (params.selectedQuote) {
       const submitStep = {
         name: 'Swap',
-        type: _swap.SwapStepType.SWAP
+        type: _swap2.SwapStepType.SWAP
       };
       return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
     }
@@ -217,12 +219,12 @@ class HydradxHandler {
     const fromChain = this.chainService.getChainInfoByKey(fromAsset.originChain);
     const fromChainNativeTokenSlug = (0, _utils._getChainNativeTokenSlug)(fromChain);
     if (!this.isReady || !this.tradeRouter) {
-      return new _SwapError.SwapError(_swap.SwapErrorType.UNKNOWN);
+      return new _SwapError.SwapError(_swap2.SwapErrorType.UNKNOWN);
     }
     const earlyValidation = await this.validateSwapRequest(request);
     if (earlyValidation.error) {
       const metadata = earlyValidation.metadata;
-      return (0, _utils2.getEarlyHydradxValidationError)(earlyValidation.error, metadata);
+      return (0, _swap._getEarlyHydradxValidationError)(earlyValidation.error, metadata);
     }
     try {
       const fromAssetId = (0, _utils._getTokenOnChainAssetId)(fromAsset);
@@ -238,13 +240,13 @@ class HydradxHandler {
       const networkFee = {
         tokenSlug: fromChainNativeTokenSlug,
         amount: paymentInfo.partialFee.toString(),
-        feeType: _swap.SwapFeeType.NETWORK_FEE
+        feeType: _swap2.SwapFeeType.NETWORK_FEE
       };
       const tradeFee = {
         tokenSlug: toAsset.slug,
         // fee is subtracted from receiving amount
         amount: quoteResponse.tradeFee.toString(),
-        feeType: _swap.SwapFeeType.PLATFORM_FEE
+        feeType: _swap2.SwapFeeType.PLATFORM_FEE
       };
       const swapRoute = this.parseSwapPath(quoteResponse.swaps);
       const swapPathErrors = this.getSwapPathErrors(quoteResponse.swaps);
@@ -253,15 +255,15 @@ class HydradxHandler {
 
         switch (defaultError) {
           case _sdk.PoolError.InsufficientTradingAmount:
-            return new _SwapError.SwapError(_swap.SwapErrorType.SWAP_NOT_ENOUGH_BALANCE);
+            return new _SwapError.SwapError(_swap2.SwapErrorType.SWAP_NOT_ENOUGH_BALANCE);
           case _sdk.PoolError.TradeNotAllowed:
-            return new _SwapError.SwapError(_swap.SwapErrorType.ERROR_FETCHING_QUOTE);
+            return new _SwapError.SwapError(_swap2.SwapErrorType.ERROR_FETCHING_QUOTE);
           case _sdk.PoolError.MaxInRatioExceeded:
-            return new _SwapError.SwapError(_swap.SwapErrorType.NOT_ENOUGH_LIQUIDITY);
+            return new _SwapError.SwapError(_swap2.SwapErrorType.NOT_ENOUGH_LIQUIDITY);
           case _sdk.PoolError.UnknownError:
-            return new _SwapError.SwapError(_swap.SwapErrorType.ERROR_FETCHING_QUOTE);
+            return new _SwapError.SwapError(_swap2.SwapErrorType.ERROR_FETCHING_QUOTE);
           case _sdk.PoolError.MaxOutRatioExceeded:
-            return new _SwapError.SwapError(_swap.SwapErrorType.NOT_ENOUGH_LIQUIDITY);
+            return new _SwapError.SwapError(_swap2.SwapErrorType.NOT_ENOUGH_LIQUIDITY);
         }
       }
 
@@ -293,7 +295,7 @@ class HydradxHandler {
         metadata: txHex
       };
     } catch (e) {
-      return new _SwapError.SwapError(_swap.SwapErrorType.ERROR_FETCHING_QUOTE);
+      return new _SwapError.SwapError(_swap2.SwapErrorType.ERROR_FETCHING_QUOTE);
     }
   }
   async handleXcmStep(params) {
@@ -303,7 +305,7 @@ class HydradxHandler {
     const destinationAsset = this.chainService.getAssetBySlug(pair.from);
     const substrateApi = this.chainService.getSubstrateApi(originAsset.originChain);
     const chainApi = await substrateApi.isReady;
-    const destinationAssetBalance = await this.balanceService.getTokenFreeBalance(params.address, destinationAsset.originChain, destinationAsset.slug);
+    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);
@@ -343,7 +345,7 @@ class HydradxHandler {
     var _swapFeeInfo$selected;
     const substrateApi = this.chainService.getSubstrateApi(this.chain());
     const chainApi = await substrateApi.isReady;
-    const swapStepIndex = params.process.steps.findIndex(step => step.type === _swap.SwapStepType.SWAP);
+    const swapStepIndex = params.process.steps.findIndex(step => step.type === _swap2.SwapStepType.SWAP);
     if (swapStepIndex <= -1) {
       return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR));
     }
@@ -383,7 +385,7 @@ class HydradxHandler {
     const referral = _referral === null || _referral === void 0 ? void 0 : _referral.toString();
     const needSetReferral = !referral || referral === '';
     const steps = params.process.steps.map(step => step.type);
-    const needSetFeeToken = steps.includes(_swap.SwapStepType.SET_FEE_TOKEN);
+    const needSetFeeToken = steps.includes(_swap2.SwapStepType.SET_FEE_TOKEN);
     if (!needSetReferral && !needSetFeeToken) {
       extrinsic = swapTx;
     } else {
@@ -414,13 +416,13 @@ class HydradxHandler {
     } = params;
     const type = process.steps[currentStep].type;
     switch (type) {
-      case _swap.SwapStepType.DEFAULT:
+      case _swap2.SwapStepType.DEFAULT:
         return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNSUPPORTED));
-      case _swap.SwapStepType.XCM:
+      case _swap2.SwapStepType.XCM:
         return this.handleXcmStep(params);
-      case _swap.SwapStepType.SET_FEE_TOKEN:
+      case _swap2.SwapStepType.SET_FEE_TOKEN:
         return this.handleSetFeeStep(params);
-      case _swap.SwapStepType.SWAP:
+      case _swap2.SwapStepType.SWAP:
         return this.handleSubmitStep(params);
       default:
         return this.handleSubmitStep(params);
@@ -436,11 +438,11 @@ class HydradxHandler {
     for (const [index, step] of params.process.steps.entries()) {
       const getErrors = async () => {
         switch (step.type) {
-          case _swap.SwapStepType.DEFAULT:
+          case _swap2.SwapStepType.DEFAULT:
             return Promise.resolve([]);
-          case _swap.SwapStepType.XCM:
+          case _swap2.SwapStepType.XCM:
             return this.swapBaseHandler.validateXcmStep(params, index);
-          case _swap.SwapStepType.SET_FEE_TOKEN:
+          case _swap2.SwapStepType.SET_FEE_TOKEN:
             return this.swapBaseHandler.validateSetFeeTokenStep(params, index);
           default:
             return this.swapBaseHandler.validateSwapStep(params, isXcmOk, index);
@@ -449,7 +451,7 @@ class HydradxHandler {
       const errors = await getErrors();
       if (errors.length) {
         return errors;
-      } else if (step.type === _swap.SwapStepType.XCM) {
+      } else if (step.type === _swap2.SwapStepType.XCM) {
         isXcmOk = true;
       }
     }
@@ -466,42 +468,42 @@ class HydradxHandler {
       const allAssets = await ((_this$tradeRouter = this.tradeRouter) === null || _this$tradeRouter === void 0 ? void 0 : _this$tradeRouter.getAllAssets());
       if (!allAssets) {
         return {
-          error: _swap.SwapErrorType.UNKNOWN
+          error: _swap2.SwapErrorType.UNKNOWN
         };
       }
       const supportedFromAsset = allAssets.find(asset => asset.id === fromAssetId && asset.symbol === fromAsset.symbol);
       const supportedToAsset = allAssets.find(asset => asset.id === toAssetId && asset.symbol === toAsset.symbol);
       if (!supportedFromAsset || !supportedToAsset) {
         return {
-          error: _swap.SwapErrorType.ASSET_NOT_SUPPORTED
+          error: _swap2.SwapErrorType.ASSET_NOT_SUPPORTED
         };
       }
       const assetPairs = await ((_this$tradeRouter2 = this.tradeRouter) === null || _this$tradeRouter2 === void 0 ? void 0 : _this$tradeRouter2.getAssetPairs(fromAssetId));
       if (!assetPairs) {
         return {
-          error: _swap.SwapErrorType.UNKNOWN
+          error: _swap2.SwapErrorType.UNKNOWN
         };
       }
       const pairedToAsset = assetPairs.find(supportedToAsset => supportedToAsset.id === toAssetId && supportedToAsset.symbol === toAsset.symbol);
       if (!pairedToAsset) {
         return {
-          error: _swap.SwapErrorType.ASSET_NOT_SUPPORTED
+          error: _swap2.SwapErrorType.ASSET_NOT_SUPPORTED
         };
       }
       if (!(fromAsset.originChain === this.chain() && toAsset.originChain === this.chain())) {
         return {
-          error: _swap.SwapErrorType.ASSET_NOT_SUPPORTED
+          error: _swap2.SwapErrorType.ASSET_NOT_SUPPORTED
         };
       }
       if (!fromAssetId || !toAssetId) {
         return {
-          error: _swap.SwapErrorType.UNKNOWN
+          error: _swap2.SwapErrorType.UNKNOWN
         };
       }
       const bnAmount = new _bignumber.default(request.fromAmount);
       if (bnAmount.lte(0)) {
         return {
-          error: _swap.SwapErrorType.AMOUNT_CANNOT_BE_ZERO
+          error: _swap2.SwapErrorType.AMOUNT_CANNOT_BE_ZERO
         };
       }
       return {
@@ -511,7 +513,7 @@ class HydradxHandler {
       };
     } catch (e) {
       return {
-        error: _swap.SwapErrorType.UNKNOWN
+        error: _swap2.SwapErrorType.UNKNOWN
       };
     }
   }

package/cjs/services/swap-service/index.js

@@ -30,12 +30,18 @@ class SwapService {
   }
   async askProvidersForQuote(request) {
     const availableQuotes = [];
+    const swappingSrcChain = this.chainService.getAssetBySlug(request.pair.from).originChain;
     await Promise.all(Object.values(this.handlers).map(async handler => {
+      // temporary solution to reduce number of requests to providers, will work as long as there's only 1 provider for 1 chain
+      if (!_utils._PROVIDER_TO_SUPPORTED_PAIR_MAP[handler.providerSlug].includes(swappingSrcChain)) {
+        return;
+      }
       if (handler.init && handler.isReady === false) {
         await handler.init();
       }
       const quote = await handler.getSwapQuote(request);
       if (!(quote instanceof _SwapError.SwapError)) {
+        // todo: can do better
         availableQuotes.push({
           quote
         });