@subwallet/extension-base 1.3.22-0 → 1.3.23-0

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

@@ -5,7 +5,6 @@ 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");
@@ -23,7 +22,6 @@ var _router = require("./router");
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-const PAH_LOW_LIQUIDITY_THRESHOLD = 0.15;
 class AssetHubSwapHandler {
   isReady = false;
   constructor(chainService, balanceService, feeService, chain) {
@@ -157,57 +155,6 @@ class AssetHubSwapHandler {
   generateOptimalProcess(params) {
     return this.swapBaseHandler.generateOptimalProcess(params, [this.getXcmStep.bind(this), this.getSubmitStep.bind(this)]);
   }
-  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 (!this.isReady || !this.router) {
-      return new _SwapError.SwapError(_swap2.SwapErrorType.UNKNOWN);
-    }
-    const earlyValidation = await this.validateSwapRequest(request);
-    if (earlyValidation.error) {
-      const metadata = earlyValidation.metadata;
-      return (0, _swap._getEarlyAssetHubValidationError)(earlyValidation.error, metadata);
-    }
-    try {
-      const paths = this.router.buildPath(request.pair);
-      const amountOut = earlyValidation.metadata.toAmount;
-      const toAmount = new _bignumber.default(amountOut);
-      const minReceive = toAmount.times(1 - request.slippage).integerValue(_bignumber.default.ROUND_DOWN);
-      const extrinsic = await this.router.buildSwapExtrinsic(paths, request.address, request.fromAmount, minReceive.toString());
-      const paymentInfo = await extrinsic.paymentInfo(request.address);
-      const networkFee = {
-        tokenSlug: fromChainNativeTokenSlug,
-        amount: paymentInfo.partialFee.toString(),
-        feeType: _swap2.SwapFeeType.NETWORK_FEE
-      };
-      const feeTokenOptions = [fromChainNativeTokenSlug];
-      const selectedFeeToken = fromChainNativeTokenSlug;
-      const priceImpactPct = earlyValidation.metadata.priceImpactPct || '0';
-      return {
-        pair: request.pair,
-        fromAmount: request.fromAmount,
-        toAmount: toAmount.toString(),
-        rate: (0, _utils2.convertSwapRate)(earlyValidation.metadata.quoteRate, fromAsset, toAsset),
-        provider: this.providerInfo,
-        aliveUntil: +Date.now() + (_utils2.SWAP_QUOTE_TIMEOUT_MAP[this.slug] || _utils2.SWAP_QUOTE_TIMEOUT_MAP.default),
-        feeInfo: {
-          feeComponent: [networkFee],
-          defaultFeeToken: fromChainNativeTokenSlug,
-          feeOptions: feeTokenOptions,
-          // TODO: enable fee options
-          selectedFeeToken
-        },
-        isLowLiquidity: Math.abs(parseFloat(priceImpactPct)) >= PAH_LOW_LIQUIDITY_THRESHOLD,
-        route: {
-          path: paths.map(asset => asset.slug)
-        }
-      };
-    } catch (e) {
-      return new _SwapError.SwapError(_swap2.SwapErrorType.ERROR_FETCHING_QUOTE);
-    }
-  }
   async handleXcmStep(params) {
     const pair = params.quote.pair;
     const alternativeAssetSlug = (0, _utils2.getSwapAlternativeAsset)(pair);
@@ -369,11 +316,5 @@ class AssetHubSwapHandler {
     }
     return [];
   }
-  validateSwapRequest(request) {
-    if (!this.isReady || !this.router) {
-      throw new _SwapError.SwapError(_swap2.SwapErrorType.ERROR_FETCHING_QUOTE);
-    }
-    return this.router.earlyValidateSwapValidation(request);
-  }
 }
 exports.AssetHubSwapHandler = AssetHubSwapHandler;

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

@@ -5,12 +5,9 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.ChainflipSwapHandler = exports.CHAINFLIP_BROKER_API = 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 _swap2 = require("@subwallet/extension-base/core/logic-validation/swap");
 var _smartContract = require("@subwallet/extension-base/services/balance-service/transfer/smart-contract");
 var _token = require("@subwallet/extension-base/services/balance-service/transfer/token");
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
@@ -18,29 +15,17 @@ var _baseHandler = require("@subwallet/extension-base/services/swap-service/hand
 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 _swap3 = require("@subwallet/extension-base/types/swap");
+var _swap = require("@subwallet/extension-base/types/swap");
+var _utils3 = require("@subwallet/extension-base/utils");
 var _getId = require("@subwallet/extension-base/utils/getId");
 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["BOOST"] = "BOOST";
-  ChainflipFeeType["BROKER"] = "BROKER";
-})(ChainflipFeeType || (ChainflipFeeType = {}));
+
 const INTERMEDIARY_MAINNET_ASSET_SLUG = _chainList.COMMON_ASSETS.USDC_ETHEREUM;
 const INTERMEDIARY_TESTNET_ASSET_SLUG = _chainList.COMMON_ASSETS.USDC_SEPOLIA;
 const CHAINFLIP_BROKER_API = process.env.CHAINFLIP_BROKER_API || '';
 exports.CHAINFLIP_BROKER_API = CHAINFLIP_BROKER_API;
-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, feeService) {
     let isTestnet = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
@@ -49,13 +34,11 @@ class ChainflipSwapHandler {
       balanceService,
       feeService,
       providerName: isTestnet ? 'Chainflip Testnet' : 'Chainflip',
-      providerSlug: isTestnet ? _swap3.SwapProviderId.CHAIN_FLIP_TESTNET : _swap3.SwapProviderId.CHAIN_FLIP_MAINNET
+      providerSlug: isTestnet ? _swap.SwapProviderId.CHAIN_FLIP_TESTNET : _swap.SwapProviderId.CHAIN_FLIP_MAINNET
     });
     this.isTestnet = isTestnet;
-    this.providerSlug = isTestnet ? _swap3.SwapProviderId.CHAIN_FLIP_TESTNET : _swap3.SwapProviderId.CHAIN_FLIP_MAINNET;
-
-    // @ts-ignore
-    this.swapSdk = new _swap.SwapSDK((0, _utils2.getChainflipOptions)(isTestnet));
+    this.providerSlug = isTestnet ? _swap.SwapProviderId.CHAIN_FLIP_TESTNET : _swap.SwapProviderId.CHAIN_FLIP_MAINNET;
+    this.baseUrl = (0, _utils2.getChainflipSwap)(isTestnet);
   }
   get chainService() {
     return this.swapBaseHandler.chainService;
@@ -72,20 +55,6 @@ class ChainflipSwapHandler {
   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;
@@ -93,224 +62,6 @@ class ChainflipSwapHandler {
       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 isSwapCrossChain = srcChain !== destChain;
-      const srcChainInfo = this.chainService.getChainInfoByKey(srcChain);
-      const srcChainId = this.chainMapping[srcChain];
-      const destChainId = this.chainMapping[destChain];
-      const fromAssetId = (0, _utils._getAssetSymbol)(fromAsset);
-      const toAssetId = (0, _utils._getAssetSymbol)(toAsset);
-      if (!srcChainId || !destChainId || !fromAssetId || !toAssetId) {
-        return {
-          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)]);
-      const supportedDestChainId = supportedDestChains.find(c => c.chain === destChainId);
-      const srcAssetData = srcAssets.find(a => {
-        if ((0, _utils._isSmartContractToken)(fromAsset)) {
-          var _a$contractAddress;
-          return (a === null || a === void 0 ? void 0 : (_a$contractAddress = a.contractAddress) === null || _a$contractAddress === void 0 ? void 0 : _a$contractAddress.toLowerCase()) === (0, _utils._getContractAddressOfToken)(fromAsset).toLowerCase() && a.asset === fromAssetId;
-        }
-        return a.asset === fromAssetId;
-      });
-      const destAssetData = destAssets.find(a => {
-        if ((0, _utils._isSmartContractToken)(toAsset)) {
-          var _a$contractAddress2;
-          return (a === null || a === void 0 ? void 0 : (_a$contractAddress2 = a.contractAddress) === null || _a$contractAddress2 === void 0 ? void 0 : _a$contractAddress2.toLowerCase()) === (0, _utils._getContractAddressOfToken)(toAsset).toLowerCase() && a.asset === toAssetId;
-        }
-        return a.asset === toAssetId;
-      });
-      if (!destAssetData || !srcAssetData || isSwapCrossChain && !supportedDestChainId) {
-        return {
-          error: _swap3.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: _swap3.SwapErrorType.UNKNOWN
-          };
-        }
-        if (bnAmount.gte(bnMaxProtocolSwap)) {
-          return {
-            error: _swap3.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: _swap3.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: _swap3.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(_swap3.SwapErrorType.UNKNOWN);
-    }
-    const earlyValidation = await this.validateSwapRequest(request);
-    const metadata = earlyValidation.metadata;
-    if (earlyValidation.error) {
-      return (0, _swap2._getChainflipEarlyValidationError)(earlyValidation.error, metadata);
-    }
-    const srcChainId = this.chainMapping[fromAsset.originChain];
-    const destChainId = this.chainMapping[toAsset.originChain];
-    const fromAssetId = (0, _utils._getAssetSymbol)(fromAsset);
-    const toAssetId = (0, _utils._getAssetSymbol)(toAsset);
-    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:
-            {
-              feeComponent.push({
-                tokenSlug: fromAsset.slug,
-                amount: fee.amount,
-                feeType: _swap3.SwapFeeType.NETWORK_FEE
-              });
-              break;
-            }
-
-          // eslint-disable-next-line no-fallthrough
-          case ChainflipFeeType.EGRESS:
-            {
-              feeComponent.push({
-                tokenSlug: toAsset.slug,
-                amount: fee.amount,
-                feeType: _swap3.SwapFeeType.NETWORK_FEE
-              });
-              break;
-            }
-          case ChainflipFeeType.NETWORK:
-
-          // eslint-disable-next-line no-fallthrough
-          case ChainflipFeeType.BOOST:
-
-          // eslint-disable-next-line no-fallthrough
-          case ChainflipFeeType.BROKER:
-            {
-              feeComponent.push({
-                tokenSlug: this.intermediaryAssetSlug,
-                amount: fee.amount,
-                feeType: _swap3.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(_swap3.SwapErrorType.NOT_ENOUGH_LIQUIDITY);
-      }
-      if (errorObj && errorObj.message && errorObj.message.includes(CHAINFLIP_QUOTE_ERROR.InsufficientLiquidity)) {
-        return new _SwapError.SwapError(_swap3.SwapErrorType.NOT_ENOUGH_LIQUIDITY);
-      }
-      return new _SwapError.SwapError(_swap3.SwapErrorType.ERROR_FETCHING_QUOTE);
-    }
-  }
   async validateSwapProcess(params) {
     const amount = params.selectedQuote.fromAmount;
     const bnAmount = new _bignumber.default(amount);
@@ -349,48 +100,49 @@ class ChainflipSwapHandler {
     const fromAsset = this.chainService.getAssetBySlug(pair.from);
     const toAsset = this.chainService.getAssetBySlug(pair.to);
     const chainInfo = this.chainService.getChainInfoByKey(fromAsset.originChain);
+    const toChainInfo = this.chainService.getChainInfoByKey(fromAsset.originChain);
     const chainType = (0, _utils._isChainSubstrateCompatible)(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 receiver = (0, _utils3._reformatAddressWithChain)(recipient !== null && recipient !== void 0 ? recipient : address, toChainInfo);
     const fromAssetId = (0, _utils._getAssetSymbol)(fromAsset);
     const toAssetId = (0, _utils._getAssetSymbol)(toAsset);
     const minReceive = new _bignumber.default(quote.rate).times(1 - slippage).toString();
-    const depositAddressResponse = await this.swapSdk.requestDepositAddress({
-      srcChain: srcChainId,
-      destChain: destChainId,
-      srcAsset: fromAssetId,
-      destAsset: toAssetId,
-      destAddress: receiver,
-      amount: quote.fromAmount,
-      fillOrKillParams: {
-        minPrice: minReceive,
-        // minimum accepted price for swaps through the channel
-        refundAddress: address,
-        // address to which assets are refunded
-        retryDurationBlocks: 100 // 100 blocks * 6 seconds = 10 minutes before deposits are refunded
-      }
+    const depositParams = {
+      destinationAddress: receiver,
+      destinationAsset: toAssetId,
+      minimumPrice: minReceive,
+      // minimum accepted price for swaps through the channel
+      refundAddress: address,
+      // address to which assets are refunded
+      retryDurationInBlocks: '100',
+      // 100 blocks * 6 seconds = 10 minutes before deposits are refunded
+      sourceAsset: fromAssetId
+    };
+    const url = `${this.baseUrl}&${new URLSearchParams(depositParams).toString()}`;
+    const response = await fetch(url, {
+      method: 'GET'
     });
-
+    const data = await response.json();
+    const depositChannelId = `${data.issuedBlock}-${data.network}-${data.channelId}`;
+    const depositAddress = data.address;
     const txData = {
       address,
       provider: this.providerInfo,
       quote: params.quote,
       slippage: params.slippage,
       recipient,
-      depositChannelId: depositAddressResponse.depositChannelId,
-      depositAddress: depositAddressResponse.depositAddress,
+      depositChannelId: depositChannelId,
+      depositAddress: 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, _token.createTransferExtrinsic)({
+      const [submittableExtrinsic] = await (0, _token.createSubstrateExtrinsic)({
         from: address,
         networkKey: chainInfo.slug,
         substrateApi,
-        to: depositAddressResponse.depositAddress,
+        to: depositAddress,
         tokenInfo: fromAsset,
         transferAll: false,
         // always false, because we do not allow swapping all the balance
@@ -405,7 +157,7 @@ class ChainflipSwapHandler {
           chain: chainInfo.slug,
           evmApi: this.chainService.getEvmApi(chainInfo.slug),
           from: address,
-          to: depositAddressResponse.depositAddress,
+          to: depositAddress,
           value: quote.fromAmount,
           feeInfo,
           transferAll: false
@@ -417,7 +169,7 @@ class ChainflipSwapHandler {
           chain: chainInfo.slug,
           evmApi: this.chainService.getEvmApi(chainInfo.slug),
           from: address,
-          to: depositAddressResponse.depositAddress,
+          to: depositAddress,
           value: quote.fromAmount,
           feeInfo,
           transferAll: false
@@ -444,7 +196,7 @@ class ChainflipSwapHandler {
     switch (type) {
       case _serviceBase.CommonStepType.DEFAULT:
         return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED));
-      case _swap3.SwapStepType.SWAP:
+      case _swap.SwapStepType.SWAP:
         return this.handleSubmitStep(params);
       default:
         return this.handleSubmitStep(params);
@@ -454,7 +206,7 @@ class ChainflipSwapHandler {
     if (params.selectedQuote) {
       const submitStep = {
         name: 'Swap',
-        type: _swap3.SwapStepType.SWAP
+        type: _swap.SwapStepType.SWAP
       };
       return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
     }