@subwallet/extension-base 1.3.62-0 → 1.3.63-0

package/services/swap-service/handler/optimex-handler.js

@@ -0,0 +1,410 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { estimateTxFee } from '@subwallet/extension-base/koni/api/contract-handler/evm/web3';
+import { createBitcoinTransaction } from '@subwallet/extension-base/services/balance-service/transfer/bitcoin-transfer';
+import { getERC20TransactionObject, getEVMTransactionObject } from '@subwallet/extension-base/services/balance-service/transfer/smart-contract';
+import { _chainInfoToChainType, _getChainNativeTokenSlug, _getContractAddressOfToken, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
+import { SwapBaseHandler } from '@subwallet/extension-base/services/swap-service/handler/base-handler';
+import { getAmountAfterSlippage } from '@subwallet/extension-base/services/swap-service/utils';
+import { BasicTxErrorType, CommonStepType, DynamicSwapType, SwapFeeType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types';
+import { _reformatAddressWithChain, combineBitcoinFee, getSizeInfo } from '@subwallet/extension-base/utils';
+import { getId } from '@subwallet/extension-base/utils/getId';
+import keyring from '@subwallet/ui-keyring';
+import BigNumber from 'bignumber.js';
+import * as bitcoin from 'bitcoinjs-lib';
+import { hexStripPrefix, u8aToHex } from '@polkadot/util';
+const OptimexBaseUrl = {
+  mainnet: 'https://subwallet-provider.optimex.xyz',
+  testnet: 'https://provider-stg.bitdex.xyz'
+};
+export class OptimexHandler {
+  constructor(chainService, balanceService, feeService, isTestnet = true) {
+    this.swapBaseHandler = new SwapBaseHandler({
+      chainService,
+      balanceService,
+      feeService,
+      providerName: isTestnet ? 'Optimex Testnet' : 'Optimex',
+      providerSlug: isTestnet ? SwapProviderId.OPTIMEX_TESTNET : SwapProviderId.OPTIMEX
+    });
+    this.providerSlug = isTestnet ? SwapProviderId.OPTIMEX_TESTNET : SwapProviderId.OPTIMEX;
+    this.baseUrl = isTestnet ? OptimexBaseUrl.testnet : OptimexBaseUrl.mainnet;
+    this.isTestnet = isTestnet;
+  }
+  get chainService() {
+    return this.swapBaseHandler.chainService;
+  }
+  get providerInfo() {
+    return this.swapBaseHandler.providerInfo;
+  }
+  get name() {
+    return this.swapBaseHandler.name;
+  }
+  get slug() {
+    return this.swapBaseHandler.slug;
+  }
+  async generateOptimalProcessV2(params) {
+    const tradeMetadata = await this.initTrade(params);
+    if (!tradeMetadata) {
+      throw new Error('Error generating optimal process: Cannot init Optimex trade');
+    }
+    const isNeedApprove = tradeMetadata.need_approve;
+    this.currentTradeMetadata = tradeMetadata;
+    if (!isNeedApprove) {
+      return this.swapBaseHandler.generateOptimalProcessV2(params, [this.getSubmitStep.bind(this)]);
+    }
+    if (!tradeMetadata.approve_address || !tradeMetadata.approve_payload) {
+      throw new Error('Error generating optimal process: Lack of approve info');
+    }
+    return this.swapBaseHandler.generateOptimalProcessV2(params, [this.getApprovalStep.bind(this), this.getSubmitStep.bind(this)]);
+  }
+  async initTrade(request) {
+    var _request$selectedQuot, _request$selectedQuot2;
+    const pair = request.request.pair;
+    const fromAsset = this.chainService.getAssetBySlug(pair.from);
+    const fromChain = this.chainService.getChainInfoByKey(fromAsset.originChain);
+    const fromChainType = _chainInfoToChainType(fromChain);
+    const sender = request.request.address;
+    const receiver = request.request.recipient;
+    const sendingValue = request.request.fromAmount;
+    const slippage = request.request.slippage;
+    const metadata = (_request$selectedQuot = request.selectedQuote) === null || _request$selectedQuot === void 0 ? void 0 : _request$selectedQuot.metadata;
+    const walletFeeInfo = (_request$selectedQuot2 = request.selectedQuote) === null || _request$selectedQuot2 === void 0 ? void 0 : _request$selectedQuot2.feeInfo.feeComponent.find(fee => fee.feeType === SwapFeeType.WALLET_FEE);
+    if (!metadata || !walletFeeInfo) {
+      return undefined;
+    }
+    let initTradeRequest;
+    const swAffiliate = walletFeeInfo.metadata;
+    if (fromChainType === ChainType.EVM) {
+      initTradeRequest = {
+        session_id: metadata.session_id,
+        amount_in: sendingValue,
+        from_user_address: sender,
+        // compressPublicKey for BTC and SOLANA, address for EVM
+        to_user_address: receiver || '',
+        // Receiving address
+        user_refund_address: sender,
+        // Refund address if trade fails
+        user_refund_pubkey: sender,
+        // Refund pubkey if trade fails, in btc is pubkey and in evm is address
+        creator_public_key: sender,
+        // Compressed public key, in btc is pubkey and in evm is address
+        from_wallet_address: sender,
+        // Creator address
+        min_amount_out: getAmountAfterSlippage(metadata.best_quote_after_fees, slippage),
+        affiliate_info: [swAffiliate]
+      };
+    } else if (fromChainType === ChainType.BITCOIN) {
+      const fromPublicKey = hexStripPrefix(u8aToHex(keyring.getPair(sender).publicKey));
+      initTradeRequest = {
+        session_id: metadata.session_id,
+        amount_in: sendingValue,
+        from_user_address: fromPublicKey,
+        to_user_address: receiver || '',
+        user_refund_address: sender,
+        user_refund_pubkey: fromPublicKey,
+        creator_public_key: fromPublicKey,
+        from_wallet_address: sender,
+        min_amount_out: getAmountAfterSlippage(metadata.best_quote_after_fees, slippage),
+        affiliate_info: [swAffiliate]
+      };
+    } else {
+      return undefined;
+    }
+    let tradeInfo;
+    try {
+      const rawResponse = await fetch(`${this.baseUrl}/v1/trades/initiate`, {
+        method: 'POST',
+        body: JSON.stringify(initTradeRequest),
+        headers: {
+          'Content-Type': 'application/json'
+        }
+      });
+      if (!rawResponse.ok) {
+        console.log('Error bad request while init quote');
+        return undefined;
+      }
+      const response = await rawResponse.json();
+      tradeInfo = response.data;
+    } catch (e) {
+      console.log('Error while init quote');
+      return undefined;
+    }
+    return tradeInfo;
+  }
+  async getApprovalStep(params) {
+    // todo: handle this when support route has approve step
+    // const selectedQuote = params.selectedQuote;
+    //
+    // if (selectedQuote) {
+    //   const metadata = selectedQuote.metadata as OptimexMetadata;
+    // }
+
+    return Promise.resolve(undefined);
+  }
+  async getSubmitStep(params, stepIndex) {
+    var _this$currentTradeMet;
+    if (!params.selectedQuote) {
+      return Promise.resolve(undefined);
+    }
+    const originTokenInfo = this.chainService.getAssetBySlug(params.selectedQuote.pair.from);
+    const originChain = this.chainService.getChainInfoByKey(originTokenInfo.originChain);
+    const destinationTokenInfo = this.chainService.getAssetBySlug(params.selectedQuote.pair.to);
+    const destinationChain = this.chainService.getChainInfoByKey(destinationTokenInfo.originChain);
+    const originChainType = _chainInfoToChainType(originChain);
+    const originChainNativeTokenSlug = _getChainNativeTokenSlug(originChain);
+
+    // Optimex do not return fee in quote. Need calculate network fee manually from client side
+    let networkFeeAmount;
+    const depositAddress = (_this$currentTradeMet = this.currentTradeMetadata) === null || _this$currentTradeMet === void 0 ? void 0 : _this$currentTradeMet.deposit_address;
+    if (!depositAddress) {
+      console.log('Optimex Trade metadata is undefined, request for new quote');
+      return Promise.resolve(undefined);
+    }
+    try {
+      if (originChainType === ChainType.EVM) {
+        const evmApi = this.chainService.getEvmApi(originChain.slug);
+        const feeInfo = await this.swapBaseHandler.feeService.subscribeChainFee(getId(), originChain.slug, 'evm');
+        let transactionConfig;
+        if (_isNativeToken(originTokenInfo)) {
+          var _this$currentTradeMet2;
+          [transactionConfig] = await getEVMTransactionObject({
+            chain: originChain.slug,
+            evmApi,
+            from: params.request.address,
+            to: depositAddress,
+            value: params.request.fromAmount,
+            feeInfo,
+            transferAll: false,
+            fallbackFee: true,
+            data: (_this$currentTradeMet2 = this.currentTradeMetadata) === null || _this$currentTradeMet2 === void 0 ? void 0 : _this$currentTradeMet2.payload
+          });
+        } else {
+          [transactionConfig] = await getERC20TransactionObject({
+            assetAddress: _getContractAddressOfToken(originTokenInfo),
+            chain: originChain.slug,
+            evmApi: this.chainService.getEvmApi(originChain.slug),
+            from: params.request.address,
+            to: depositAddress,
+            value: params.request.fromAmount,
+            feeInfo,
+            transferAll: false
+          });
+        }
+        networkFeeAmount = await estimateTxFee(transactionConfig, evmApi, feeInfo);
+      } else if (originChainType === ChainType.BITCOIN) {
+        const bitcoinApi = this.chainService.getBitcoinApi(originChain.slug);
+        const feeInfo = await this.swapBaseHandler.feeService.subscribeChainFee(getId(), originChain.slug, 'bitcoin');
+        const network = originChain.isTestnet ? bitcoin.networks.testnet : bitcoin.networks.bitcoin;
+        const [transaction] = await createBitcoinTransaction({
+          bitcoinApi,
+          chain: originChain.slug,
+          from: params.request.address,
+          feeInfo,
+          to: depositAddress,
+          transferAll: false,
+          value: params.request.fromAmount,
+          network
+        });
+        const feeCombine = combineBitcoinFee(feeInfo, undefined, undefined); // todo: recheck when implement custom fee
+
+        const recipients = [];
+        for (const txOutput of transaction.txOutputs) {
+          txOutput.address && recipients.push(txOutput.address);
+        }
+        const sizeInfo = getSizeInfo({
+          inputLength: transaction.inputCount,
+          recipients: recipients,
+          sender: params.request.address
+        });
+        networkFeeAmount = Math.ceil(feeCombine.feeRate * sizeInfo.txVBytes).toString();
+      } else {
+        console.log('Unsupported swap from this chain type', originChainType);
+        return Promise.resolve(undefined);
+      }
+    } catch (e) {
+      throw new Error(e.message);
+    }
+    const networkFee = {
+      amount: networkFeeAmount || '0',
+      feeType: SwapFeeType.NETWORK_FEE,
+      tokenSlug: originChainNativeTokenSlug
+    };
+    const submitStep = {
+      name: 'Swap',
+      type: SwapStepType.SWAP,
+      // @ts-ignore
+      metadata: {
+        sendingValue: params.request.fromAmount.toString(),
+        expectedReceive: params.selectedQuote.toAmount,
+        originTokenInfo,
+        destinationTokenInfo,
+        sender: _reformatAddressWithChain(params.request.address, originChain),
+        receiver: _reformatAddressWithChain(params.request.recipient || params.request.address, destinationChain),
+        version: 2
+      }
+    };
+    const feeInfo = {
+      defaultFeeToken: params.selectedQuote.feeInfo.defaultFeeToken,
+      feeComponent: [...params.selectedQuote.feeInfo.feeComponent, networkFee],
+      feeOptions: params.selectedQuote.feeInfo.feeOptions
+    };
+    return Promise.resolve([submitStep, feeInfo]);
+  }
+  async validateSwapProcessV2(params) {
+    const {
+      process,
+      selectedQuote
+    } = params;
+    if (BigNumber(selectedQuote.fromAmount).lte(0)) {
+      return [new TransactionError(BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')];
+    }
+    const actionList = JSON.stringify(process.path.map(step => step.action));
+    const swap = actionList === JSON.stringify([DynamicSwapType.SWAP]);
+    const swapXcm = actionList === JSON.stringify([DynamicSwapType.SWAP, DynamicSwapType.BRIDGE]);
+    const xcmSwap = actionList === JSON.stringify([DynamicSwapType.BRIDGE, DynamicSwapType.SWAP]);
+    const xcmSwapXcm = actionList === JSON.stringify([DynamicSwapType.BRIDGE, DynamicSwapType.SWAP, DynamicSwapType.BRIDGE]);
+    const swapIndex = params.process.steps.findIndex(step => step.type === SwapStepType.SWAP);
+    if (swapIndex <= -1) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (swap) {
+      return this.swapBaseHandler.validateSwapOnlyProcess(params, swapIndex);
+    }
+    if (swapXcm) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (xcmSwap) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (xcmSwapXcm) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+  }
+  async handleSwapProcess(params) {
+    const {
+      currentStep,
+      process
+    } = params;
+    const type = process.steps[currentStep].type;
+    switch (type) {
+      case CommonStepType.DEFAULT:
+        return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
+      case CommonStepType.TOKEN_APPROVAL:
+        return this.handleApproveStep(params);
+      case SwapStepType.SWAP:
+        return this.handleSubmitStep(params);
+      default:
+        return this.handleSubmitStep(params);
+    }
+  }
+  handleApproveStep(params) {
+    // todo: handle this when support route has approve step
+    const fromAsset = this.chainService.getAssetBySlug(params.quote.pair.from);
+    return {
+      txChain: fromAsset.originChain,
+      txData: '',
+      extrinsic: {},
+      extrinsicType: ExtrinsicType.TOKEN_SPENDING_APPROVAL,
+      transferNativeAmount: '0',
+      chainType: ChainType.EVM
+    };
+  }
+  async handleSubmitStep(params) {
+    var _this$currentTradeMet3, _this$currentTradeMet4, _this$currentTradeMet5;
+    const {
+      address,
+      process,
+      quote,
+      recipient,
+      slippage
+    } = params;
+    const pair = quote.pair;
+    const fromAsset = this.chainService.getAssetBySlug(pair.from);
+    const chainInfo = this.chainService.getChainInfoByKey(fromAsset.originChain);
+    const chainType = _chainInfoToChainType(chainInfo);
+    const depositAddress = (_this$currentTradeMet3 = this.currentTradeMetadata) === null || _this$currentTradeMet3 === void 0 ? void 0 : _this$currentTradeMet3.deposit_address;
+    const tradeId = (_this$currentTradeMet4 = this.currentTradeMetadata) === null || _this$currentTradeMet4 === void 0 ? void 0 : _this$currentTradeMet4.trade_id;
+    const payload = (_this$currentTradeMet5 = this.currentTradeMetadata) === null || _this$currentTradeMet5 === void 0 ? void 0 : _this$currentTradeMet5.payload; // undefined in case swap from btc
+
+    if (!depositAddress || !tradeId) {
+      throw new Error('Optimex Trade metadata is undefined, request for new quote');
+    }
+    const txData = {
+      address,
+      provider: this.providerInfo,
+      quote,
+      slippage,
+      recipient,
+      process
+    };
+    let extrinsic;
+
+    // dont remove this log
+    console.log('Optimex Trade metadata:', this.currentTradeMetadata);
+    console.log('Optimex Trade channel:', this.isTestnet ? `https://provider-api-docs.vercel.app/swap/${tradeId}` : `https://provider-api-docs.vercel.app/swap/${tradeId}?env=sub_wallet`);
+    if (chainType === ChainType.BITCOIN) {
+      const bitcoinApi = this.chainService.getBitcoinApi(chainInfo.slug);
+      const feeInfo = await this.swapBaseHandler.feeService.subscribeChainFee(getId(), chainInfo.slug, 'bitcoin');
+      const network = chainInfo.isTestnet ? bitcoin.networks.testnet : bitcoin.networks.bitcoin;
+      const [transaction] = await createBitcoinTransaction({
+        bitcoinApi,
+        chain: chainInfo.slug,
+        from: address,
+        feeInfo,
+        to: depositAddress,
+        transferAll: false,
+        value: quote.fromAmount,
+        network
+      });
+      extrinsic = transaction;
+    } else if (chainType === ChainType.EVM) {
+      const feeInfo = await this.swapBaseHandler.feeService.subscribeChainFee(getId(), chainInfo.slug, 'evm');
+      if (_isNativeToken(fromAsset)) {
+        const [transactionConfig] = await getEVMTransactionObject({
+          chain: chainInfo.slug,
+          evmApi: this.chainService.getEvmApi(chainInfo.slug),
+          from: address,
+          to: depositAddress,
+          value: quote.fromAmount,
+          feeInfo,
+          transferAll: false,
+          data: payload
+        });
+        extrinsic = {
+          ...transactionConfig,
+          data: payload
+        };
+      } else {
+        const [transactionConfig] = await getERC20TransactionObject({
+          assetAddress: _getContractAddressOfToken(fromAsset),
+          chain: chainInfo.slug,
+          evmApi: this.chainService.getEvmApi(chainInfo.slug),
+          from: address,
+          to: depositAddress,
+          value: quote.fromAmount,
+          feeInfo,
+          transferAll: false
+        });
+        extrinsic = transactionConfig;
+      }
+    } else {
+      throw new Error('Unknown swap chain type');
+    }
+
+    // reset tradeMetadata after use // todo: review to check if need this clear
+    // this.currentTradeMetadata = undefined;
+
+    return {
+      txChain: fromAsset.originChain,
+      txData,
+      extrinsic,
+      transferNativeAmount: _isNativeToken(fromAsset) ? quote.fromAmount : '0',
+      extrinsicType: ExtrinsicType.SWAP,
+      chainType
+    };
+  }
+}

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

@@ -4,7 +4,7 @@
 import { SwapError } from '@subwallet/extension-base/background/errors/SwapError';
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
-import { _getAssetDecimals, _getAssetSymbol, _getContractAddressOfToken, _isChainSubstrateCompatible, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
+import { _chainInfoToChainType, _getAssetDecimals, _getAssetSymbol, _getContractAddressOfToken, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
 import { BasicTxErrorType, CommonStepType, DynamicSwapType, SwapErrorType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types';
 import { ProxyServiceRoute } from '@subwallet/extension-base/types/environment';
 import { _reformatAddressWithChain, fetchFromProxyService, formatNumber } from '@subwallet/extension-base/utils';
@@ -159,7 +159,7 @@ export class SimpleSwapHandler {
     const toAsset = this.chainService.getAssetBySlug(pair.to);
     const chainInfo = this.chainService.getChainInfoByKey(fromAsset.originChain);
     const toChainInfo = this.chainService.getChainInfoByKey(toAsset.originChain);
-    const chainType = _isChainSubstrateCompatible(chainInfo) ? ChainType.SUBSTRATE : ChainType.EVM;
+    const chainType = _chainInfoToChainType(chainInfo);
     const sender = _reformatAddressWithChain(address, chainInfo);
     const receiver = _reformatAddressWithChain(recipient !== null && recipient !== void 0 ? recipient : sender, toChainInfo);
     const fromSymbol = _getAssetSymbol(fromAsset).toLowerCase();
@@ -222,7 +222,7 @@ export class SimpleSwapHandler {
         value: quote.fromAmount
       });
       extrinsic = submittableExtrinsic;
-    } else {
+    } else if (chainType === ChainType.EVM) {
       const feeInfo = await this.swapBaseHandler.feeService.subscribeChainFee(getId(), chainInfo.slug, 'evm');
       if (_isNativeToken(fromAsset)) {
         const [transactionConfig] = await getEVMTransactionObject({
@@ -248,6 +248,8 @@ export class SimpleSwapHandler {
         });
         extrinsic = transactionConfig;
       }
+    } else {
+      throw new Error('Unknown swap chain type');
     }
     return {
       txChain: fromAsset.originChain,

package/services/swap-service/index.d.ts

@@ -19,7 +19,6 @@ export declare class SwapService implements StoppableServiceInterface {
     private getDefaultProcessV2;
     generateOptimalProcessV2(params: OptimalSwapPathParamsV2): Promise<CommonOptimalSwapPath>;
     handleSwapRequestV2(request: SwapRequestV2): Promise<SwapRequestResult>;
-    getAvailablePath(request: SwapRequestV2): [DynamicSwapAction[], SwapRequestV2 | undefined];
     getLatestQuoteFromSwapRequest(request: SwapRequestV2): Promise<{
         path: DynamicSwapAction[];
         swapQuoteResponse: SwapQuoteResponse;

package/services/swap-service/index.js

@@ -1,22 +1,21 @@
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-import { COMMON_CHAIN_SLUGS } from '@subwallet/chain-list';
-import { _AssetRefPath } from '@subwallet/chain-list/types';
 import { SwapError } from '@subwallet/extension-base/background/errors/SwapError';
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 import { fetchBlockedConfigObjects, fetchLatestBlockedActionsAndFeatures, getPassConfigId } from '@subwallet/extension-base/constants';
 import { ServiceStatus } from '@subwallet/extension-base/services/base/types';
-import { _getAssetOriginChain, _getChainSubstrateAddressPrefix } from '@subwallet/extension-base/services/chain-service/utils';
+import { _getAssetOriginChain } from '@subwallet/extension-base/services/chain-service/utils';
 import { AssetHubSwapHandler } from '@subwallet/extension-base/services/swap-service/handler/asset-hub';
 import { ChainflipSwapHandler } from '@subwallet/extension-base/services/swap-service/handler/chainflip-handler';
 import { HydradxHandler } from '@subwallet/extension-base/services/swap-service/handler/hydradx-handler';
-import { findAllBridgeDestinations, findBridgeTransitDestination, findSwapTransitDestination, getBridgeStep, getSupportedSwapChains, getSwapAltToken, getSwapStep, getTokenPairFromStep, isChainsHasSameProvider, processStepsToPathActions, SWAP_QUOTE_TIMEOUT_MAP } from '@subwallet/extension-base/services/swap-service/utils';
+import { OptimexHandler } from '@subwallet/extension-base/services/swap-service/handler/optimex-handler';
+import { getSwapAltToken, getTokenPairFromStep, processStepsToPathActions, SWAP_QUOTE_TIMEOUT_MAP } from '@subwallet/extension-base/services/swap-service/utils';
 import { BasicTxErrorType, DynamicSwapType } from '@subwallet/extension-base/types';
 import { DEFAULT_FIRST_STEP, MOCK_STEP_FEE } from '@subwallet/extension-base/types/service-base';
 import { _SUPPORTED_SWAP_PROVIDERS, SwapErrorType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types/swap';
-import { _reformatAddressWithChain, createPromiseHandler, reformatAddress } from '@subwallet/extension-base/utils';
+import { _reformatAddressWithChain, createPromiseHandler } from '@subwallet/extension-base/utils';
 import subwalletApiSdk from '@subwallet-monorepos/subwallet-services-sdk';
 import BigN from 'bignumber.js';
 import { t } from 'i18next';
@@ -107,6 +106,7 @@ export class SwapService {
       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) {
+        // todo: handle error response from generateOptimalProcess
         return handler.generateOptimalProcessV2(params);
       } else {
         return this.getDefaultProcessV2(params);
@@ -144,6 +144,12 @@ export class SwapService {
     } catch (e) {
       throw new Error(e.message);
     }
+
+    // override fee for quote because some cases need estimate network fee on Extension (i.e. Optimex)
+    if (swapQuoteResponse.optimalQuote) {
+      const swapIndex = optimalProcess.steps.findIndex(step => step.type === SwapStepType.SWAP);
+      swapQuoteResponse.optimalQuote.feeInfo.feeComponent = optimalProcess.totalFee[swapIndex].feeComponent;
+    }
     if (swapQuoteResponse.error) {
       return {
         process: optimalProcess,
@@ -160,115 +166,6 @@ export class SwapService {
       quote: swapQuoteResponse
     };
   }
-
-  // todo: rewrite this function
-  getAvailablePath(request) {
-    const {
-      address,
-      pair
-    } = request;
-    // todo: control provider tighter
-    const supportSwapChains = getSupportedSwapChains();
-    const fromToken = this.chainService.getAssetBySlug(pair.from);
-    const toToken = this.chainService.getAssetBySlug(pair.to);
-    const fromChain = _getAssetOriginChain(fromToken);
-    const toChain = _getAssetOriginChain(toToken);
-    const toChainInfo = this.chainService.getChainInfoByKey(toChain);
-    const assetRefMap = this.chainService.getAssetRefMap();
-    let process = [];
-    if (!fromToken || !toToken) {
-      throw Error('Token not found');
-    }
-    if (!fromChain || !toChain) {
-      throw Error('Token metadata error');
-    }
-    const directXcmRef = Object.values(assetRefMap).find(assetRef => assetRef.path === _AssetRefPath.XCM && assetRef.srcAsset === fromToken.slug && assetRef.destAsset === toToken.slug);
-    if (directXcmRef) {
-      return [[], undefined];
-    }
-
-    // SWAP: 2 tokens in the same chain and chain has dex
-    if (isChainsHasSameProvider(fromChain, toChain)) {
-      // there's a dex that can support direct swapping
-      process.push(getSwapStep(fromToken.slug, toToken.slug));
-      return [process, request];
-    }
-
-    // ------------------------
-    // BRIDGE -> SWAP: Try to find a token in dest chain that can bridge from fromToken
-    const bridgeTransit = findBridgeTransitDestination(assetRefMap, fromToken, toToken);
-    if (bridgeTransit && supportSwapChains.includes(toChain)) {
-      const swapStep = getSwapStep(bridgeTransit, toToken.slug);
-      process.push(getBridgeStep(fromToken.slug, bridgeTransit));
-      process.push(swapStep);
-      return [process, {
-        ...request,
-        address: reformatAddress(address, _getChainSubstrateAddressPrefix(toChainInfo)),
-        pair: swapStep.pair
-      }];
-    }
-
-    // ------------------------
-    // SWAP -> BRIDGE: Try to find a token in from chain that can bridge to toToken
-    const swapTransit = findSwapTransitDestination(assetRefMap, fromToken, toToken);
-    if (swapTransit && supportSwapChains.includes(fromChain)) {
-      const swapStep = getSwapStep(fromToken.slug, swapTransit);
-      process.push(swapStep);
-      process.push(getBridgeStep(swapTransit, toToken.slug));
-      return [process, {
-        ...request,
-        pair: swapStep.pair
-      }];
-    }
-
-    // ------------------------
-    // BRIDGE -> SWAP -> BRIDGE: Try to find a tri-step path to swap
-    const processList = [];
-    const swapPairList = [];
-    const allBridgeDestinations = findAllBridgeDestinations(assetRefMap, fromToken);
-
-    // currently find first path. Todo: return all paths or best path.
-    for (const bridgeTransit of allBridgeDestinations) {
-      process = [];
-      const bridgeDestinationInfo = this.chainService.getAssetBySlug(bridgeTransit);
-      const swapTransit = findSwapTransitDestination(assetRefMap, bridgeDestinationInfo, toToken);
-      if (bridgeTransit === swapTransit) {
-        continue;
-      }
-      if (swapTransit && supportSwapChains.includes(bridgeDestinationInfo.originChain)) {
-        const swapStep = getSwapStep(bridgeTransit, swapTransit);
-        process.push(getBridgeStep(fromToken.slug, bridgeTransit));
-        process.push(swapStep);
-        process.push(getBridgeStep(swapTransit, toToken.slug));
-
-        // set the highest priority to hydration provider
-        if (bridgeDestinationInfo.originChain === COMMON_CHAIN_SLUGS.HYDRADX) {
-          return [process, {
-            ...request,
-            address: _reformatAddressWithChain(address, this.chainService.getChainInfoByKey(COMMON_CHAIN_SLUGS.HYDRADX)),
-            pair: swapStep.pair
-          }];
-        }
-        processList.push(process);
-        swapPairList.push(swapStep.pair);
-      }
-    }
-
-    // get first process
-    if (processList.length && swapPairList.length) {
-      const [firstProcess, firstSwapPair] = [processList[0], swapPairList[0]];
-      const chainSwap = this.chainService.getAssetBySlug(firstSwapPair.from).originChain;
-      return [firstProcess, {
-        ...request,
-        address: _reformatAddressWithChain(address, this.chainService.getChainInfoByKey(chainSwap)),
-        pair: firstSwapPair
-      }];
-    }
-
-    // todo: encapsulate each route type to function
-
-    return [[], undefined];
-  }
   async getLatestQuoteFromSwapRequest(request) {
     let availablePath;
     try {
@@ -368,9 +265,6 @@ export class SwapService {
         case SwapProviderId.CHAIN_FLIP_MAINNET:
           this.handlers[providerId] = new ChainflipSwapHandler(this.chainService, this.state.balanceService, this.state.feeService, false);
           break;
-        case SwapProviderId.HYDRADX_TESTNET:
-          this.handlers[providerId] = new HydradxHandler(this.chainService, this.state.balanceService, this.state.feeService);
-          break;
         case SwapProviderId.HYDRADX_MAINNET:
           this.handlers[providerId] = new HydradxHandler(this.chainService, this.state.balanceService, this.state.feeService, false);
           break;
@@ -380,12 +274,6 @@ export class SwapService {
         case SwapProviderId.KUSAMA_ASSET_HUB:
           this.handlers[providerId] = new AssetHubSwapHandler(this.chainService, this.state.balanceService, this.state.feeService, 'statemine');
           break;
-        // case SwapProviderId.ROCOCO_ASSET_HUB:
-        //   this.handlers[providerId] = new AssetHubSwapHandler(this.chainService, this.state.balanceService, this.state.feeService, 'rococo_assethub');
-        //   break;
-        case SwapProviderId.WESTEND_ASSET_HUB:
-          this.handlers[providerId] = new AssetHubSwapHandler(this.chainService, this.state.balanceService, this.state.feeService, 'westend_assethub');
-          break;
         case SwapProviderId.SIMPLE_SWAP:
           this.handlers[providerId] = new SimpleSwapHandler(this.chainService, this.state.balanceService, this.state.feeService);
           break;
@@ -395,6 +283,12 @@ export class SwapService {
         case SwapProviderId.KYBER:
           this.handlers[providerId] = new KyberHandler(this.chainService, this.state.balanceService, this.state.transactionService, this.state.feeService);
           break;
+        case SwapProviderId.OPTIMEX:
+          this.handlers[providerId] = new OptimexHandler(this.chainService, this.state.balanceService, this.state.feeService, false);
+          break;
+        case SwapProviderId.OPTIMEX_TESTNET:
+          this.handlers[providerId] = new OptimexHandler(this.chainService, this.state.balanceService, this.state.feeService, true);
+          break;
         default:
           throw new Error('Unsupported provider');
       }
@@ -445,6 +339,8 @@ export class SwapService {
   waitForStopped() {
     return this.stopPromiseHandler.promise;
   }
+
+  // todo: deprecated
   getSwapPairs() {
     return Object.entries(this.chainService.swapRefMap).map(([slug, assetRef]) => {
       const fromAsset = this.chainService.getAssetBySlug(assetRef.srcAsset);
@@ -499,6 +395,8 @@ export class SwapService {
       return Promise.reject(new TransactionError(BasicTxErrorType.INTERNAL_ERROR));
     }
   }
+
+  // todo: deprecated
   subscribeSwapPairs(callback) {
     return this.chainService.subscribeSwapRefMap().subscribe(refMap => {
       const latestData = Object.entries(refMap).map(([slug, assetRef]) => {