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

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

@@ -0,0 +1,331 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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 _types = require("@subwallet/extension-base/types");
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+var _utils = require("../../chain-service/utils");
+var _utils2 = require("../../fee-service/utils");
+var _baseHandler = require("./base-handler");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const API_URL = 'https://trade-api.gateway.uniswap.org/v1';
+const headers = {
+  'x-api-key': process.env.UNISWAP_API_KEY || ''
+};
+async function fetchCheckApproval(walletAddress, fromAmount, quote) {
+  const chainId = quote.chainId;
+  const response = await fetch(`${API_URL}/check_approval`, {
+    method: 'POST',
+    headers: {
+      ...headers,
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({
+      walletAddress,
+      amount: (0, _bignumber.default)(fromAmount).multipliedBy(2).toString(),
+      token: quote.input.token,
+      chainId: chainId,
+      tokenOut: quote.output.token,
+      tokenOutChainId: chainId
+    })
+  });
+  const data = await response.json();
+  return data;
+}
+class UniswapHandler {
+  constructor(chainService, balanceService, transactionService, feeService) {
+    this.swapBaseHandler = new _baseHandler.SwapBaseHandler({
+      chainService,
+      balanceService,
+      feeService,
+      providerName: 'Uniswap',
+      providerSlug: _types.SwapProviderId.UNISWAP
+    });
+    this.transactionService = transactionService;
+    this.providerSlug = _types.SwapProviderId.UNISWAP;
+  }
+  get chainService() {
+    return this.swapBaseHandler.chainService;
+  }
+  get balanceService() {
+    return this.swapBaseHandler.balanceService;
+  }
+  get feeService() {
+    return this.swapBaseHandler.feeService;
+  }
+  get providerInfo() {
+    return this.swapBaseHandler.providerInfo;
+  }
+  generateOptimalProcess(params) {
+    return this.swapBaseHandler.generateOptimalProcess(params, [this.getApprovalStep.bind(this), this.getPermitStep.bind(this), this.getSubmitStep.bind(this)]);
+  }
+  async getApprovalStep(params) {
+    if (params.selectedQuote) {
+      const walletAddress = params.request.address;
+      const fromAmount = params.selectedQuote.fromAmount;
+      const inputTokenInfo = this.chainService.getAssetBySlug(params.selectedQuote.pair.from);
+      const {
+        quote
+      } = params.selectedQuote.metadata;
+      const checkApprovalResponse = await fetchCheckApproval(walletAddress, fromAmount, quote);
+      const approval = checkApprovalResponse.approval;
+      if (approval) {
+        let spender = '';
+        try {
+          const valueLength = 40;
+          spender = approval.data.slice(-(valueLength * 2), -valueLength);
+        } catch (e) {
+          // Empty
+        }
+        const metadata = {
+          tokenApprove: inputTokenInfo.slug,
+          contractAddress: (0, _utils._getContractAddressOfToken)(inputTokenInfo),
+          spenderAddress: spender
+        };
+        const submitStep = {
+          name: 'Approve token',
+          type: _types.CommonStepType.TOKEN_APPROVAL,
+          metadata: metadata
+        };
+        return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
+      }
+    }
+    return Promise.resolve(undefined);
+  }
+  async getPermitStep(params) {
+    if (params.selectedQuote && params.selectedQuote.metadata.permitData) {
+      const submitStep = {
+        name: 'Permit Step',
+        type: _types.SwapStepType.PERMIT
+      };
+      // TODO: GET NATIVE TOKEN
+      const defaultFeeToken = params.selectedQuote.feeInfo.defaultFeeToken;
+      const feeInfo = {
+        feeComponent: [{
+          amount: '0',
+          feeType: _types.SwapFeeType.NETWORK_FEE,
+          tokenSlug: defaultFeeToken
+        }],
+        defaultFeeToken: defaultFeeToken,
+        feeOptions: [defaultFeeToken]
+      };
+      return Promise.resolve([submitStep, feeInfo]);
+    }
+    return Promise.resolve(undefined);
+  }
+  async getSubmitStep(params) {
+    if (params.selectedQuote) {
+      const submitStep = {
+        name: 'Swap',
+        type: _types.SwapStepType.SWAP
+      };
+      return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
+    }
+    return Promise.resolve(undefined);
+  }
+  async validateSwapProcess(params) {
+    const amount = params.selectedQuote.fromAmount;
+    const bnAmount = BigInt(amount);
+    if (bnAmount <= BigInt(0)) {
+      return Promise.resolve([new _TransactionError.TransactionError(_types.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 _types.CommonStepType.DEFAULT:
+            return Promise.resolve([]);
+          case _types.CommonStepType.TOKEN_APPROVAL:
+            return Promise.resolve([]);
+          default:
+            return this.swapBaseHandler.validateSwapStep(params, isXcmOk, index);
+        }
+      };
+      const errors = await getErrors();
+      if (errors.length) {
+        return errors;
+      } else if (step.type === _types.CommonStepType.XCM) {
+        isXcmOk = true;
+      }
+    }
+    return [];
+  }
+  async handleSwapProcess(params) {
+    const {
+      currentStep,
+      process
+    } = params;
+    const type = process.steps[currentStep].type;
+    switch (type) {
+      case _types.CommonStepType.DEFAULT:
+        return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED));
+      case _types.CommonStepType.TOKEN_APPROVAL:
+        return this.tokenApproveSpending(params);
+      case _types.SwapStepType.SWAP:
+        return this.handleSubmitStep(params);
+      case _types.SwapStepType.PERMIT:
+        return this.handlePermitStep(params);
+      default:
+        return this.handleSubmitStep(params);
+    }
+  }
+  async tokenApproveSpending(params) {
+    const fromAsset = this.chainService.getAssetBySlug(params.quote.pair.from);
+    const walletAddress = params.address;
+    const fromAmount = params.quote.fromAmount;
+    const {
+      quote
+    } = params.quote.metadata;
+    const checkApprovalResponse = await fetchCheckApproval(walletAddress, fromAmount, quote);
+    let transactionConfig = {};
+    const approval = checkApprovalResponse.approval;
+    if (approval) {
+      var _priority$options, _priority$options$Fee, _priority$options2;
+      const evmApi = this.chainService.getEvmApi(fromAsset.originChain);
+      const priority = await (0, _utils2.calculateGasFeeParams)(evmApi, evmApi.chainSlug);
+      transactionConfig = {
+        from: approval.from,
+        to: approval.to,
+        value: approval.value,
+        data: approval.data,
+        gasPrice: priority.gasPrice,
+        maxFeePerGas: (_priority$options = priority.options) === null || _priority$options === void 0 ? void 0 : (_priority$options$Fee = _priority$options[_types.FeeOptionKey.AVERAGE].maxFeePerGas) === null || _priority$options$Fee === void 0 ? void 0 : _priority$options$Fee.toString(),
+        maxPriorityFeePerGas: (_priority$options2 = priority.options) === null || _priority$options2 === void 0 ? void 0 : _priority$options2[_types.FeeOptionKey.AVERAGE].maxPriorityFeePerGas.toString()
+      };
+      const gasLimit = await evmApi.api.eth.estimateGas(transactionConfig).catch(() => 200000);
+      transactionConfig.gas = gasLimit.toString();
+    }
+    const chain = fromAsset.originChain;
+    const _data = {
+      spenderAddress: quote.output.token,
+      contractAddress: quote.input.token,
+      amount: params.quote.fromAmount,
+      owner: params.address,
+      chain: quote.chainId.toString()
+    };
+    return Promise.resolve({
+      txChain: chain,
+      extrinsicType: _KoniTypes.ExtrinsicType.TOKEN_SPENDING_APPROVAL,
+      extrinsic: transactionConfig,
+      txData: _data,
+      transferNativeAmount: '0',
+      chainType: _KoniTypes.ChainType.EVM
+    });
+  }
+  async handleSubmitStep(params) {
+    const fromAsset = this.chainService.getAssetBySlug(params.quote.pair.from);
+    const {
+      permitData,
+      quote,
+      routing
+    } = params.quote.metadata;
+    const processId = params.cacheProcessId;
+    let signature;
+    if (permitData) {
+      signature = this.transactionService.getCacheInfo(processId, _types.SwapStepType.PERMIT);
+    }
+    let postTransactionResponse;
+    let extrinsic;
+    if (routing === 'CLASSIC' || routing === 'WRAP' || routing === 'UNWRAP') {
+      const body = {
+        signature: signature,
+        quote: quote
+      };
+      if (permitData) {
+        body.permitData = permitData;
+      }
+      postTransactionResponse = await fetch(`${API_URL}/swap`, {
+        method: 'POST',
+        headers: {
+          ...headers,
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(body)
+      });
+      const transactionResponse = await postTransactionResponse.json();
+      extrinsic = transactionResponse.swap;
+    } else if (routing === 'DUTCH_LIMIT' || routing === 'DUTCH_V2') {
+      postTransactionResponse = await fetch(`${API_URL}/order`, {
+        method: 'POST',
+        headers: {
+          ...headers,
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+          signature: signature,
+          quote: quote
+        })
+      });
+    }
+    const txData = {
+      address: params.address,
+      provider: this.providerInfo,
+      quote: params.quote,
+      slippage: params.slippage,
+      recipient: params.recipient,
+      process: params.process
+    };
+    return {
+      txChain: fromAsset.originChain,
+      txData,
+      extrinsic: extrinsic,
+      transferNativeAmount: (0, _utils._isNativeToken)(fromAsset) ? params.quote.fromAmount : '0',
+      extrinsicType: _KoniTypes.ExtrinsicType.SWAP,
+      chainType: _KoniTypes.ChainType.EVM
+    };
+  }
+  handlePermitStep(params) {
+    const fromAsset = this.chainService.getAssetBySlug(params.quote.pair.from);
+    const {
+      permitData
+    } = params.quote.metadata;
+    const processId = params.cacheProcessId;
+    let validatePayload;
+    if (permitData) {
+      const payload = {
+        types: {
+          EIP712Domain: [{
+            name: 'name',
+            type: 'string'
+          }, {
+            name: 'chainId',
+            type: 'uint256'
+          }, {
+            name: 'verifyingContract',
+            type: 'address'
+          }],
+          ...permitData.types
+        },
+        domain: permitData.domain,
+        primaryType: 'PermitSingle',
+        message: permitData.values
+      };
+      validatePayload = (0, _logicValidation.validateTypedSignMessageDataV3V4)({
+        data: payload,
+        from: params.address
+      });
+    }
+    const txData = {
+      processId,
+      step: _types.SwapStepType.PERMIT
+    };
+    return {
+      txChain: fromAsset.originChain,
+      txData,
+      extrinsic: validatePayload,
+      extrinsicType: _KoniTypes.ExtrinsicType.TOKEN_SPENDING_APPROVAL,
+      transferNativeAmount: '0',
+      chainType: _KoniTypes.ChainType.EVM,
+      isPermit: true
+    };
+  }
+}
+exports.UniswapHandler = UniswapHandler;

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

@@ -1,5 +1,6 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -15,8 +16,10 @@ var _types2 = require("@subwallet/extension-base/types");
 var _serviceBase = require("@subwallet/extension-base/types/service-base");
 var _swap = require("@subwallet/extension-base/types/swap");
 var _utils2 = require("@subwallet/extension-base/utils");
+var _subwalletApiSdk = _interopRequireDefault(require("@subwallet/subwallet-api-sdk"));
 var _rxjs = require("rxjs");
 var _simpleswapHandler = require("./handler/simpleswap-handler");
+var _uniswapHandler = require("./handler/uniswap-handler");
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
@@ -37,31 +40,34 @@ class SwapService {
     this.chainService = state.chainService;
   }
   async askProvidersForQuote(request) {
+    var _subwalletApiSdk$swap;
     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 (!_isChainSupportedByProvider(handler.providerSlug, 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
-        });
-      } else {
-        availableQuotes.push({
-          error: quote
-        });
-      }
     }));
-    return availableQuotes; // todo: need to propagate error for further handling
+    const quotes = await ((_subwalletApiSdk$swap = _subwalletApiSdk.default.swapApi) === null || _subwalletApiSdk$swap === void 0 ? void 0 : _subwalletApiSdk$swap.fetchSwapQuoteData(request));
+    if (Array.isArray(quotes)) {
+      quotes.forEach(quoteData => {
+        if (!quoteData.quote || Object.keys(quoteData.quote).length === 0) {
+          return;
+        }
+        if (!('errorClass' in quoteData.quote)) {
+          availableQuotes.push({
+            quote: quoteData.quote
+          });
+        } else {
+          availableQuotes.push({
+            error: new _SwapError.SwapError(quoteData.quote.errorType, quoteData.quote.message)
+          });
+        }
+      });
+    }
+    return availableQuotes;
   }
-
   getDefaultProcess(params) {
     const result = {
       totalFee: [_serviceBase.MOCK_STEP_FEE],
@@ -83,7 +89,8 @@ class SwapService {
     if (!params.selectedQuote) {
       return this.getDefaultProcess(params);
     } else {
-      const providerId = params.selectedQuote.provider.id;
+      var _params$request$curre;
+      const providerId = ((_params$request$curre = params.request.currentQuote) === null || _params$request$curre === void 0 ? void 0 : _params$request$curre.id) || params.selectedQuote.provider.id;
       const handler = this.handlers[providerId];
       if (handler) {
         return handler.generateOptimalProcess(params);
@@ -98,7 +105,6 @@ class SwapService {
     * 2. Select the best quote
     * 3. Generate optimal process for that quote
     * */
-
     const swapQuoteResponse = await this.getLatestQuotes(request);
     const optimalProcess = await this.generateOptimalProcess({
       request,
@@ -162,15 +168,18 @@ class SwapService {
         case _swap.SwapProviderId.KUSAMA_ASSET_HUB:
           this.handlers[providerId] = new _assetHub.AssetHubSwapHandler(this.chainService, this.state.balanceService, this.state.feeService, 'statemine');
           break;
-        case _swap.SwapProviderId.ROCOCO_ASSET_HUB:
-          this.handlers[providerId] = new _assetHub.AssetHubSwapHandler(this.chainService, this.state.balanceService, this.state.feeService, 'rococo_assethub');
-          break;
+        // case SwapProviderId.ROCOCO_ASSET_HUB:
+        //   this.handlers[providerId] = new AssetHubSwapHandler(this.chainService, this.state.balanceService, this.state.feeService, 'rococo_assethub');
+        //   break;
         case _swap.SwapProviderId.WESTEND_ASSET_HUB:
           this.handlers[providerId] = new _assetHub.AssetHubSwapHandler(this.chainService, this.state.balanceService, this.state.feeService, 'westend_assethub');
           break;
         case _swap.SwapProviderId.SIMPLE_SWAP:
           this.handlers[providerId] = new _simpleswapHandler.SimpleSwapHandler(this.chainService, this.state.balanceService, this.state.feeService);
           break;
+        case _swap.SwapProviderId.UNISWAP:
+          this.handlers[providerId] = new _uniswapHandler.UniswapHandler(this.chainService, this.state.balanceService, this.state.transactionService, this.state.feeService);
+          break;
         default:
           throw new Error('Unsupported provider');
       }

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

@@ -4,18 +4,18 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports._PROVIDER_TO_SUPPORTED_PAIR_MAP = exports.SWAP_QUOTE_TIMEOUT_MAP = exports.SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING = exports.SIMPLE_SWAP_EXPLORER = exports.CHAIN_FLIP_TESTNET_EXPLORER = exports.CHAIN_FLIP_SUPPORTED_TESTNET_MAPPING = exports.CHAIN_FLIP_SUPPORTED_TESTNET_ASSET_MAPPING = exports.CHAIN_FLIP_SUPPORTED_MAINNET_MAPPING = exports.CHAIN_FLIP_SUPPORTED_MAINNET_ASSET_MAPPING = exports.CHAIN_FLIP_MAINNET_EXPLORER = void 0;
+exports._PROVIDER_TO_SUPPORTED_PAIR_MAP = exports.SWAP_QUOTE_TIMEOUT_MAP = exports.SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING = exports.SIMPLE_SWAP_EXPLORER = exports.CHAIN_FLIP_TESTNET_EXPLORER = exports.CHAIN_FLIP_MAINNET_EXPLORER = void 0;
 exports.calculateSwapRate = calculateSwapRate;
 exports.convertSwapRate = convertSwapRate;
 exports.getChainflipBroker = getChainflipBroker;
 exports.getChainflipOptions = getChainflipOptions;
+exports.getChainflipSwap = getChainflipSwap;
 exports.getSwapAltToken = getSwapAltToken;
 exports.getSwapAlternativeAsset = getSwapAlternativeAsset;
-var _swap = require("@chainflip/sdk/swap");
 var _chainList = require("@subwallet/chain-list");
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
 var _chainflipHandler = require("@subwallet/extension-base/services/swap-service/handler/chainflip-handler");
-var _swap2 = require("@subwallet/extension-base/types/swap");
+var _swap = require("@subwallet/extension-base/types/swap");
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
@@ -26,30 +26,6 @@ const CHAIN_FLIP_MAINNET_EXPLORER = 'https://scan.chainflip.io';
 exports.CHAIN_FLIP_MAINNET_EXPLORER = CHAIN_FLIP_MAINNET_EXPLORER;
 const SIMPLE_SWAP_EXPLORER = 'https://simpleswap.io';
 exports.SIMPLE_SWAP_EXPLORER = SIMPLE_SWAP_EXPLORER;
-const CHAIN_FLIP_SUPPORTED_MAINNET_MAPPING = {
-  [_chainList.COMMON_CHAIN_SLUGS.POLKADOT]: _swap.Chains.Polkadot,
-  [_chainList.COMMON_CHAIN_SLUGS.ETHEREUM]: _swap.Chains.Ethereum,
-  [_chainList.COMMON_CHAIN_SLUGS.ARBITRUM]: _swap.Chains.Arbitrum
-};
-exports.CHAIN_FLIP_SUPPORTED_MAINNET_MAPPING = CHAIN_FLIP_SUPPORTED_MAINNET_MAPPING;
-const CHAIN_FLIP_SUPPORTED_TESTNET_MAPPING = {
-  [_chainList.COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA]: _swap.Chains.Ethereum,
-  [_chainList.COMMON_CHAIN_SLUGS.CHAINFLIP_POLKADOT]: _swap.Chains.Polkadot
-};
-exports.CHAIN_FLIP_SUPPORTED_TESTNET_MAPPING = CHAIN_FLIP_SUPPORTED_TESTNET_MAPPING;
-const CHAIN_FLIP_SUPPORTED_MAINNET_ASSET_MAPPING = {
-  [_chainList.COMMON_ASSETS.DOT]: _swap.Assets.DOT,
-  [_chainList.COMMON_ASSETS.ETH]: _swap.Assets.ETH,
-  [_chainList.COMMON_ASSETS.USDC_ETHEREUM]: _swap.Assets.USDC,
-  [_chainList.COMMON_ASSETS.USDT_ETHEREUM]: _swap.Assets.USDT
-};
-exports.CHAIN_FLIP_SUPPORTED_MAINNET_ASSET_MAPPING = CHAIN_FLIP_SUPPORTED_MAINNET_ASSET_MAPPING;
-const CHAIN_FLIP_SUPPORTED_TESTNET_ASSET_MAPPING = {
-  [_chainList.COMMON_ASSETS.PDOT]: _swap.Assets.DOT,
-  [_chainList.COMMON_ASSETS.ETH_SEPOLIA]: _swap.Assets.ETH,
-  [_chainList.COMMON_ASSETS.USDC_SEPOLIA]: _swap.Assets.USDC
-};
-exports.CHAIN_FLIP_SUPPORTED_TESTNET_ASSET_MAPPING = CHAIN_FLIP_SUPPORTED_TESTNET_ASSET_MAPPING;
 const SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING = {
   'bittensor-NATIVE-TAO': 'tao',
   [_chainList.COMMON_ASSETS.ETH]: 'eth',
@@ -61,20 +37,20 @@ exports.SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING = SIMPLE_SWAP_SUPPORTED_TEST
 const SWAP_QUOTE_TIMEOUT_MAP = {
   // in milliseconds
   default: 30000,
-  [_swap2.SwapProviderId.CHAIN_FLIP_TESTNET]: 30000,
-  [_swap2.SwapProviderId.CHAIN_FLIP_MAINNET]: 30000
+  [_swap.SwapProviderId.CHAIN_FLIP_TESTNET]: 30000,
+  [_swap.SwapProviderId.CHAIN_FLIP_MAINNET]: 30000
 };
 exports.SWAP_QUOTE_TIMEOUT_MAP = SWAP_QUOTE_TIMEOUT_MAP;
 const _PROVIDER_TO_SUPPORTED_PAIR_MAP = {
-  [_swap2.SwapProviderId.HYDRADX_MAINNET]: [_chainList.COMMON_CHAIN_SLUGS.HYDRADX],
-  [_swap2.SwapProviderId.HYDRADX_TESTNET]: [_chainList.COMMON_CHAIN_SLUGS.HYDRADX_TESTNET],
-  [_swap2.SwapProviderId.CHAIN_FLIP_MAINNET]: [_chainList.COMMON_CHAIN_SLUGS.POLKADOT, _chainList.COMMON_CHAIN_SLUGS.ETHEREUM, _chainList.COMMON_CHAIN_SLUGS.ARBITRUM],
-  [_swap2.SwapProviderId.CHAIN_FLIP_TESTNET]: [_chainList.COMMON_CHAIN_SLUGS.CHAINFLIP_POLKADOT, _chainList.COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA],
-  [_swap2.SwapProviderId.POLKADOT_ASSET_HUB]: [_chainList.COMMON_CHAIN_SLUGS.POLKADOT_ASSET_HUB],
-  [_swap2.SwapProviderId.KUSAMA_ASSET_HUB]: [_chainList.COMMON_CHAIN_SLUGS.KUSAMA_ASSET_HUB],
-  [_swap2.SwapProviderId.ROCOCO_ASSET_HUB]: [_chainList.COMMON_CHAIN_SLUGS.ROCOCO_ASSET_HUB],
-  [_swap2.SwapProviderId.WESTEND_ASSET_HUB]: ['westend_assethub'],
-  [_swap2.SwapProviderId.SIMPLE_SWAP]: ['bittensor', _chainList.COMMON_CHAIN_SLUGS.ETHEREUM, _chainList.COMMON_CHAIN_SLUGS.POLKADOT]
+  [_swap.SwapProviderId.HYDRADX_MAINNET]: [_chainList.COMMON_CHAIN_SLUGS.HYDRADX],
+  [_swap.SwapProviderId.HYDRADX_TESTNET]: [_chainList.COMMON_CHAIN_SLUGS.HYDRADX_TESTNET],
+  [_swap.SwapProviderId.CHAIN_FLIP_MAINNET]: [_chainList.COMMON_CHAIN_SLUGS.POLKADOT, _chainList.COMMON_CHAIN_SLUGS.ETHEREUM, _chainList.COMMON_CHAIN_SLUGS.ARBITRUM],
+  [_swap.SwapProviderId.CHAIN_FLIP_TESTNET]: [_chainList.COMMON_CHAIN_SLUGS.CHAINFLIP_POLKADOT, _chainList.COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA],
+  [_swap.SwapProviderId.POLKADOT_ASSET_HUB]: [_chainList.COMMON_CHAIN_SLUGS.POLKADOT_ASSET_HUB],
+  [_swap.SwapProviderId.KUSAMA_ASSET_HUB]: [_chainList.COMMON_CHAIN_SLUGS.KUSAMA_ASSET_HUB],
+  [_swap.SwapProviderId.ROCOCO_ASSET_HUB]: [_chainList.COMMON_CHAIN_SLUGS.ROCOCO_ASSET_HUB],
+  [_swap.SwapProviderId.WESTEND_ASSET_HUB]: ['westend_assethub'],
+  [_swap.SwapProviderId.SIMPLE_SWAP]: ['bittensor', _chainList.COMMON_CHAIN_SLUGS.ETHEREUM, _chainList.COMMON_CHAIN_SLUGS.POLKADOT]
 };
 exports._PROVIDER_TO_SUPPORTED_PAIR_MAP = _PROVIDER_TO_SUPPORTED_PAIR_MAP;
 function getSwapAlternativeAsset(swapPair) {
@@ -122,4 +98,11 @@ function getChainflipBroker(isTestnet) {
       url: `https://chainflip-broker.io/rpc/${_chainflipHandler.CHAINFLIP_BROKER_API}`
     };
   }
+}
+function getChainflipSwap(isTestnet) {
+  if (isTestnet) {
+    return `https://perseverance.chainflip-broker.io/swap?apikey=${_chainflipHandler.CHAINFLIP_BROKER_API}`;
+  } else {
+    return `https://chainflip-broker.io/swap?apikey=${_chainflipHandler.CHAINFLIP_BROKER_API}`;
+  }
 }

package/cjs/services/transaction-service/helpers/index.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.isTonTransaction = exports.isSubstrateTransaction = exports.getValidationId = exports.getTransactionId = exports.getBaseTransactionInfo = void 0;
+exports.isTonTransaction = exports.isSubstrateTransaction = exports.isCardanoTransaction = exports.getValidationId = exports.getTransactionId = exports.getBaseTransactionInfo = void 0;
 var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
@@ -28,6 +28,11 @@ const isTonTransaction = tx => {
   return Boolean(tonTransactionConfig.messagePayload) && tonTransactionConfig.seqno >= 0;
 };
 exports.isTonTransaction = isTonTransaction;
+const isCardanoTransaction = tx => {
+  const cardanoTransactionConfig = tx;
+  return cardanoTransactionConfig.cardanoPayload !== null && cardanoTransactionConfig.cardanoPayload !== undefined;
+};
+exports.isCardanoTransaction = isCardanoTransaction;
 const typeName = type => {
   switch (type) {
     case _KoniTypes.ExtrinsicType.TRANSFER_BALANCE: