@subwallet/extension-base 1.1.54-0 → 1.1.55-0

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

@@ -0,0 +1,189 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SwapBaseHandler = void 0;
+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 _utils2 = require("@subwallet/extension-base/services/swap-service/utils");
+var _swap = 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
+
+class SwapBaseHandler {
+  constructor(_ref) {
+    let {
+      balanceService,
+      chainService,
+      providerName,
+      providerSlug
+    } = _ref;
+    this.providerName = providerName;
+    this.providerSlug = providerSlug;
+    this.chainService = chainService;
+    this.balanceService = balanceService;
+  }
+
+  // public abstract getSwapQuote(request: SwapRequest): Promise<SwapQuote | SwapError>;
+  async generateOptimalProcess(params, genStepFuncList) {
+    const result = {
+      totalFee: [_utils2.MOCK_SWAP_FEE],
+      steps: [_utils2.DEFAULT_SWAP_FIRST_STEP]
+    };
+    try {
+      for (const genStepFunc of genStepFuncList) {
+        const step = await genStepFunc.bind(this, params)();
+        if (step) {
+          result.steps.push({
+            id: result.steps.length,
+            ...step[0]
+          });
+          result.totalFee.push(step[1]);
+        }
+      }
+      return result;
+    } catch (e) {
+      return result;
+    }
+  }
+  async validateXcmStep(params, stepIndex) {
+    const bnAmount = new _bignumber.default(params.selectedQuote.fromAmount);
+    const swapPair = params.selectedQuote.pair;
+    const alternativeAssetSlug = (0, _utils2.getSwapAlternativeAsset)(swapPair);
+    if (!alternativeAssetSlug) {
+      return [new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    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 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
+    const xcmFee = new _bignumber.default(xcmFeeComponent.amount || '0');
+    let xcmAmount = bnAmount.minus(bnFromAssetBalance);
+    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);
+      const maxValue = (0, _utils3.formatNumber)(maxBn.toString(), fromAsset.decimals || 0);
+      const altInputTokenInfo = this.chainService.getAssetBySlug(alternativeAssetSlug);
+      const symbol = altInputTokenInfo.symbol;
+      const alternativeChain = this.chainService.getChainInfoByKey(altInputTokenInfo.originChain);
+      const chain = this.chainService.getChainInfoByKey(fromAsset.originChain);
+      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 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.`))];
+      }
+      return [new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.NOT_ENOUGH_BALANCE, (0, _i18next.t)('You can only enter a maximum of {{maxValue}} {{symbol}}, which is {{currentValue}} {{symbol}} ({{inputNetworkName}}) and {{maxXCMValue}} {{symbol}} ({{altNetworkName}}). Lower your amount and try again.', {
+        replace: {
+          symbol,
+          maxValue,
+          inputNetworkName,
+          altNetworkName,
+          currentValue,
+          maxXCMValue
+        }
+      }))];
+    }
+    return [];
+  }
+  async validateTokenApproveStep(params, stepIndex) {
+    return Promise.resolve([]);
+  }
+  async validateSetFeeTokenStep(params, stepIndex) {
+    if (!params.selectedQuote) {
+      return Promise.resolve([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)]);
+    }
+    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 bnFeeTokenBalance = new _bignumber.default(feeTokenBalance.value);
+    const bnFeeAmount = new _bignumber.default(feeAmount.amount);
+    if (bnFeeAmount.gte(bnFeeTokenBalance)) {
+      return Promise.resolve([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.NOT_ENOUGH_BALANCE)]);
+    }
+    return [];
+  }
+  async validateSwapStep(params, isXcmOk, stepIndex) {
+    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)]);
+    }
+    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);
+    if (!networkFee) {
+      return Promise.resolve([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)]);
+    }
+    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`)]);
+    }
+    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.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)]);
+      }
+    }
+    return Promise.resolve([]);
+  }
+  get name() {
+    return this.providerName;
+  }
+  get slug() {
+    return this.providerSlug;
+  }
+  get providerInfo() {
+    return {
+      id: this.providerSlug,
+      name: this.providerName
+    };
+  }
+}
+exports.SwapBaseHandler = SwapBaseHandler;

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

@@ -0,0 +1,407 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ChainflipSwapHandler = void 0;
+var _swap = require("@chainflip/sdk/swap");
+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 _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 _bignumber = _interopRequireDefault(require("bignumber.js"));
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+var ChainflipFeeType;
+(function (ChainflipFeeType) {
+  ChainflipFeeType["INGRESS"] = "INGRESS";
+  ChainflipFeeType["NETWORK"] = "NETWORK";
+  ChainflipFeeType["EGRESS"] = "EGRESS";
+  ChainflipFeeType["LIQUIDITY"] = "LIQUIDITY";
+})(ChainflipFeeType || (ChainflipFeeType = {}));
+const INTERMEDIARY_MAINNET_ASSET_SLUG = _chainList.COMMON_ASSETS.USDC_ETHEREUM;
+const INTERMEDIARY_TESTNET_ASSET_SLUG = _chainList.COMMON_ASSETS.USDC_SEPOLIA;
+var CHAINFLIP_QUOTE_ERROR;
+(function (CHAINFLIP_QUOTE_ERROR) {
+  CHAINFLIP_QUOTE_ERROR["InsufficientLiquidity"] = "InsufficientLiquidity";
+  CHAINFLIP_QUOTE_ERROR["InsufficientEgress"] = "is lower than minimum egress amount";
+  CHAINFLIP_QUOTE_ERROR["InsufficientIngress"] = "amount is lower than estimated ingress fee";
+})(CHAINFLIP_QUOTE_ERROR || (CHAINFLIP_QUOTE_ERROR = {}));
+class ChainflipSwapHandler {
+  constructor(chainService, balanceService) {
+    let isTestnet = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+    this.swapBaseHandler = new _baseHandler.SwapBaseHandler({
+      chainService,
+      balanceService,
+      providerName: isTestnet ? 'Chainflip Testnet' : 'Chainflip',
+      providerSlug: isTestnet ? _swap2.SwapProviderId.CHAIN_FLIP_TESTNET : _swap2.SwapProviderId.CHAIN_FLIP_MAINNET
+    });
+    this.isTestnet = isTestnet;
+    this.swapSdk = new _swap.SwapSDK({
+      network: isTestnet ? 'perseverance' : 'mainnet'
+    });
+  }
+  get chainService() {
+    return this.swapBaseHandler.chainService;
+  }
+  get balanceService() {
+    return this.swapBaseHandler.balanceService;
+  }
+  get providerInfo() {
+    return this.swapBaseHandler.providerInfo;
+  }
+  get name() {
+    return this.swapBaseHandler.name;
+  }
+  get slug() {
+    return this.swapBaseHandler.slug;
+  }
+  get assetMapping() {
+    if (this.isTestnet) {
+      return _utils2.CHAIN_FLIP_SUPPORTED_TESTNET_ASSET_MAPPING;
+    } else {
+      return _utils2.CHAIN_FLIP_SUPPORTED_MAINNET_ASSET_MAPPING;
+    }
+  }
+  get chainMapping() {
+    if (this.isTestnet) {
+      return _utils2.CHAIN_FLIP_SUPPORTED_TESTNET_MAPPING;
+    } else {
+      return _utils2.CHAIN_FLIP_SUPPORTED_MAINNET_MAPPING;
+    }
+  }
+  get intermediaryAssetSlug() {
+    if (this.isTestnet) {
+      return INTERMEDIARY_TESTNET_ASSET_SLUG;
+    } else {
+      return INTERMEDIARY_MAINNET_ASSET_SLUG;
+    }
+  }
+  async validateSwapRequest(request) {
+    try {
+      // todo: risk of matching wrong chain, asset can lead to loss of funds
+
+      const fromAsset = this.chainService.getAssetBySlug(request.pair.from);
+      const toAsset = this.chainService.getAssetBySlug(request.pair.to);
+      const srcChain = fromAsset.originChain;
+      const destChain = toAsset.originChain;
+      const srcChainInfo = this.chainService.getChainInfoByKey(srcChain);
+      const srcChainId = this.chainMapping[srcChain];
+      const destChainId = this.chainMapping[destChain];
+      const fromAssetId = this.assetMapping[fromAsset.slug];
+      const toAssetId = this.assetMapping[toAsset.slug];
+      if (!srcChainId || !destChainId || !fromAssetId || !toAssetId) {
+        return {
+          error: _swap2.SwapErrorType.ASSET_NOT_SUPPORTED
+        };
+      }
+      const [supportedDestChains, srcAssets, destAssets] = await Promise.all([this.swapSdk.getChains(srcChainId), this.swapSdk.getAssets(srcChainId), this.swapSdk.getAssets(destChainId)]);
+      const supportedDestChainId = supportedDestChains.find(c => c.chain === destChainId);
+      const srcAssetData = srcAssets.find(a => a.asset === fromAssetId);
+      const destAssetData = destAssets.find(a => a.asset === toAssetId);
+      if (!destAssetData || !srcAssetData || !supportedDestChainId) {
+        return {
+          error: _swap2.SwapErrorType.UNKNOWN
+        };
+      }
+      const bnAmount = new _bignumber.default(request.fromAmount);
+      const bnMinSwap = new _bignumber.default(srcAssetData.minimumSwapAmount);
+      if (srcAssetData.maximumSwapAmount) {
+        const bnMaxProtocolSwap = new _bignumber.default(srcAssetData.maximumSwapAmount);
+        if (bnMinSwap.gte(bnMaxProtocolSwap)) {
+          return {
+            error: _swap2.SwapErrorType.UNKNOWN
+          };
+        }
+        if (bnAmount.gte(bnMaxProtocolSwap)) {
+          return {
+            error: _swap2.SwapErrorType.SWAP_EXCEED_ALLOWANCE,
+            metadata: {
+              minSwap: {
+                value: srcAssetData.minimumSwapAmount,
+                decimals: (0, _utils._getAssetDecimals)(fromAsset),
+                symbol: fromAsset.symbol
+              },
+              maxSwap: {
+                value: bnMaxProtocolSwap.toString(),
+                decimals: (0, _utils._getAssetDecimals)(fromAsset),
+                symbol: fromAsset.symbol
+              },
+              chain: srcChainInfo
+            }
+          };
+        }
+      }
+      if (bnAmount.lt(bnMinSwap)) {
+        // might miss case when minSwap is 0
+        return {
+          error: _swap2.SwapErrorType.NOT_MEET_MIN_SWAP,
+          metadata: {
+            minSwap: {
+              value: srcAssetData.minimumSwapAmount,
+              decimals: (0, _utils._getAssetDecimals)(fromAsset),
+              symbol: fromAsset.symbol
+            },
+            maxSwap: {
+              value: srcAssetData.maximumSwapAmount,
+              decimals: (0, _utils._getAssetDecimals)(fromAsset),
+              symbol: fromAsset.symbol
+            },
+            chain: srcChainInfo
+          }
+        };
+      }
+      return {
+        metadata: {
+          minSwap: {
+            value: srcAssetData.minimumSwapAmount,
+            decimals: (0, _utils._getAssetDecimals)(fromAsset),
+            symbol: fromAsset.symbol
+          },
+          maxSwap: {
+            value: srcAssetData.maximumSwapAmount,
+            decimals: (0, _utils._getAssetDecimals)(fromAsset),
+            symbol: fromAsset.symbol
+          },
+          chain: srcChainInfo
+        }
+      };
+    } catch (e) {
+      return {
+        error: _swap2.SwapErrorType.UNKNOWN
+      };
+    }
+  }
+  parseSwapPath(fromAsset, toAsset) {
+    if (toAsset.slug !== this.intermediaryAssetSlug && fromAsset.slug !== this.intermediaryAssetSlug) {
+      // Chainflip always use USDC as intermediary
+      return [fromAsset.slug, this.intermediaryAssetSlug, toAsset.slug]; // todo: generalize this
+    }
+
+    return [fromAsset.slug, toAsset.slug];
+  }
+  async getSwapQuote(request) {
+    const fromAsset = this.chainService.getAssetBySlug(request.pair.from);
+    const toAsset = this.chainService.getAssetBySlug(request.pair.to);
+    const fromChain = this.chainService.getChainInfoByKey(fromAsset.originChain);
+    const fromChainNativeTokenSlug = (0, _utils._getChainNativeTokenSlug)(fromChain);
+    if (!fromAsset || !toAsset) {
+      return new _SwapError.SwapError(_swap2.SwapErrorType.UNKNOWN);
+    }
+    const earlyValidation = await this.validateSwapRequest(request);
+    const metadata = earlyValidation.metadata;
+    if (earlyValidation.error) {
+      return (0, _utils2.getChainflipEarlyValidationError)(earlyValidation.error, metadata);
+    }
+    const srcChainId = this.chainMapping[fromAsset.originChain];
+    const destChainId = this.chainMapping[toAsset.originChain];
+    const fromAssetId = this.assetMapping[fromAsset.slug];
+    const toAssetId = this.assetMapping[toAsset.slug];
+    try {
+      var _metadata$maxSwap;
+      const quoteResponse = await this.swapSdk.getQuote({
+        srcChain: srcChainId,
+        destChain: destChainId,
+        srcAsset: fromAssetId,
+        destAsset: toAssetId,
+        amount: request.fromAmount
+      });
+      const feeComponent = [];
+      quoteResponse.quote.includedFees.forEach(fee => {
+        switch (fee.type) {
+          case ChainflipFeeType.INGRESS:
+
+          // eslint-disable-next-line no-fallthrough
+          case ChainflipFeeType.EGRESS:
+            {
+              const tokenSlug = Object.keys(this.assetMapping).find(assetSlug => this.assetMapping[assetSlug] === fee.asset);
+              feeComponent.push({
+                tokenSlug,
+                amount: fee.amount,
+                feeType: _swap2.SwapFeeType.NETWORK_FEE
+              });
+              break;
+            }
+          case ChainflipFeeType.NETWORK:
+
+          // eslint-disable-next-line no-fallthrough
+          case ChainflipFeeType.LIQUIDITY:
+            {
+              const tokenSlug = Object.keys(this.assetMapping).find(assetSlug => this.assetMapping[assetSlug] === fee.asset);
+              feeComponent.push({
+                tokenSlug,
+                amount: fee.amount,
+                feeType: _swap2.SwapFeeType.PLATFORM_FEE
+              });
+              break;
+            }
+        }
+      });
+      const defaultFeeToken = (0, _utils._isNativeToken)(fromAsset) ? fromAsset.slug : fromChainNativeTokenSlug;
+      return {
+        pair: request.pair,
+        fromAmount: request.fromAmount,
+        toAmount: quoteResponse.quote.egressAmount.toString(),
+        rate: (0, _utils2.calculateSwapRate)(request.fromAmount, quoteResponse.quote.egressAmount.toString(), fromAsset, toAsset),
+        provider: this.providerInfo,
+        aliveUntil: +Date.now() + (_utils2.SWAP_QUOTE_TIMEOUT_MAP[this.slug] || _utils2.SWAP_QUOTE_TIMEOUT_MAP.default),
+        minSwap: metadata.minSwap.value,
+        maxSwap: (_metadata$maxSwap = metadata.maxSwap) === null || _metadata$maxSwap === void 0 ? void 0 : _metadata$maxSwap.value,
+        estimatedArrivalTime: quoteResponse.quote.estimatedDurationSeconds,
+        // in seconds
+        isLowLiquidity: quoteResponse.quote.lowLiquidityWarning,
+        feeInfo: {
+          feeComponent: feeComponent,
+          defaultFeeToken,
+          feeOptions: [defaultFeeToken]
+        },
+        route: {
+          path: this.parseSwapPath(fromAsset, toAsset)
+        }
+      };
+    } catch (e) {
+      var _error$response;
+      const error = e;
+      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);
+      }
+      if (errorObj && errorObj.message && errorObj.message.includes(CHAINFLIP_QUOTE_ERROR.InsufficientLiquidity)) {
+        return new _SwapError.SwapError(_swap2.SwapErrorType.NOT_ENOUGH_LIQUIDITY);
+      }
+      return new _SwapError.SwapError(_swap2.SwapErrorType.ERROR_FETCHING_QUOTE);
+    }
+  }
+  async validateSwapProcess(params) {
+    const amount = params.selectedQuote.fromAmount;
+    const bnAmount = new _bignumber.default(amount);
+    if (bnAmount.lte(0)) {
+      return [new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')];
+    }
+    let isXcmOk = false;
+    for (const [index, step] of params.process.steps.entries()) {
+      const getErrors = async () => {
+        switch (step.type) {
+          case _swap2.SwapStepType.DEFAULT:
+            return Promise.resolve([]);
+          case _swap2.SwapStepType.TOKEN_APPROVAL:
+            return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNSUPPORTED));
+          default:
+            return this.swapBaseHandler.validateSwapStep(params, isXcmOk, index);
+        }
+      };
+      const errors = await getErrors();
+      if (errors.length) {
+        return errors;
+      } else if (step.type === _swap2.SwapStepType.XCM) {
+        isXcmOk = true;
+      }
+    }
+    return [];
+  }
+  async handleSubmitStep(params) {
+    const {
+      address,
+      quote,
+      recipient
+    } = params;
+    const pair = quote.pair;
+    const fromAsset = this.chainService.getAssetBySlug(pair.from);
+    const toAsset = this.chainService.getAssetBySlug(pair.to);
+    const chainInfo = this.chainService.getChainInfoByKey(fromAsset.originChain);
+    const chainType = (0, _utils._isSubstrateChain)(chainInfo) ? _KoniTypes.ChainType.SUBSTRATE : _KoniTypes.ChainType.EVM;
+    const receiver = recipient !== null && recipient !== void 0 ? recipient : address;
+    const srcChainId = this.chainMapping[fromAsset.originChain];
+    const destChainId = this.chainMapping[toAsset.originChain];
+    const fromAssetId = this.assetMapping[fromAsset.slug];
+    const toAssetId = this.assetMapping[toAsset.slug];
+    const depositAddressResponse = await this.swapSdk.requestDepositAddress({
+      srcChain: srcChainId,
+      destChain: destChainId,
+      srcAsset: fromAssetId,
+      destAsset: toAssetId,
+      destAddress: receiver,
+      amount: quote.fromAmount
+    });
+    const txData = {
+      address,
+      provider: this.providerInfo,
+      quote: params.quote,
+      slippage: params.slippage,
+      recipient,
+      depositChannelId: depositAddressResponse.depositChannelId,
+      depositAddress: depositAddressResponse.depositAddress,
+      process: params.process
+    };
+    let extrinsic;
+    if (chainType === _KoniTypes.ChainType.SUBSTRATE) {
+      const chainApi = this.chainService.getSubstrateApi(chainInfo.slug);
+      const substrateApi = await chainApi.isReady;
+      const [submittableExtrinsic] = await (0, _transfer.createTransferExtrinsic)({
+        from: address,
+        networkKey: chainInfo.slug,
+        substrateApi,
+        to: depositAddressResponse.depositAddress,
+        tokenInfo: fromAsset,
+        transferAll: false,
+        // always false, because we do not allow swapping all the balance
+        value: quote.fromAmount
+      });
+      extrinsic = submittableExtrinsic;
+    } else {
+      if ((0, _utils._isNativeToken)(fromAsset)) {
+        const [transactionConfig] = await (0, _transfer2.getEVMTransactionObject)(chainInfo, address, depositAddressResponse.depositAddress, quote.fromAmount, false, this.chainService.getEvmApi(chainInfo.slug));
+        extrinsic = transactionConfig;
+      } else {
+        const [transactionConfig] = await (0, _transfer2.getERC20TransactionObject)((0, _utils._getContractAddressOfToken)(fromAsset), chainInfo, address, depositAddressResponse.depositAddress, quote.fromAmount, false, this.chainService.getEvmApi(chainInfo.slug));
+        extrinsic = transactionConfig;
+      }
+    }
+    return {
+      txChain: fromAsset.originChain,
+      txData,
+      extrinsic,
+      transferNativeAmount: (0, _utils._isNativeToken)(fromAsset) ? quote.fromAmount : '0',
+      // todo
+      extrinsicType: _KoniTypes.ExtrinsicType.SWAP,
+      chainType
+    };
+  }
+  async handleSwapProcess(params) {
+    const {
+      currentStep,
+      process
+    } = params;
+    const type = process.steps[currentStep].type;
+    switch (type) {
+      case _swap2.SwapStepType.DEFAULT:
+        return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNSUPPORTED));
+      case _swap2.SwapStepType.SWAP:
+        return this.handleSubmitStep(params);
+      default:
+        return this.handleSubmitStep(params);
+    }
+  }
+  async getSubmitStep(params) {
+    if (params.selectedQuote) {
+      const submitStep = {
+        name: 'Swap',
+        type: _swap2.SwapStepType.SWAP
+      };
+      return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
+    }
+    return Promise.resolve(undefined);
+  }
+  generateOptimalProcess(params) {
+    return this.swapBaseHandler.generateOptimalProcess(params, [this.getSubmitStep]);
+  }
+}
+exports.ChainflipSwapHandler = ChainflipSwapHandler;