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

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

@@ -1,13 +1,12 @@
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-import { COMMON_ASSETS } from '@subwallet/chain-list';
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 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 { createSubstrateExtrinsic } from '@subwallet/extension-base/services/balance-service/transfer/token';
-import { _getContractAddressOfToken, _isChainSubstrateCompatible, _isNativeToken, _isPureBitcoinChain } from '@subwallet/extension-base/services/chain-service/utils';
+import { _chainInfoToChainType, _getContractAddressOfToken, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
 import { SwapBaseHandler } from '@subwallet/extension-base/services/swap-service/handler/base-handler';
 import { BasicTxErrorType, CommonStepType, DynamicSwapType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types';
 import { ProxyServiceRoute } from '@subwallet/extension-base/types/environment';
@@ -15,12 +14,7 @@ import { _reformatAddressWithChain, fetchFromProxyService } from '@subwallet/ext
 import { getId } from '@subwallet/extension-base/utils/getId';
 import BigNumber from 'bignumber.js';
 import * as bitcoin from 'bitcoinjs-lib';
-const INTERMEDIARY_MAINNET_ASSET_SLUG = COMMON_ASSETS.USDC_ETHEREUM;
-const INTERMEDIARY_TESTNET_ASSET_SLUG = COMMON_ASSETS.USDC_SEPOLIA;
 export class ChainflipSwapHandler {
-  // private baseUrl: string;
-  // private assetsUrl: string;
-
   constructor(chainService, balanceService, feeService, isTestnet = true) {
     this.swapBaseHandler = new SwapBaseHandler({
       chainService,
@@ -31,10 +25,7 @@ export class ChainflipSwapHandler {
     });
     this.isTestnet = isTestnet;
     this.providerSlug = isTestnet ? SwapProviderId.CHAIN_FLIP_TESTNET : SwapProviderId.CHAIN_FLIP_MAINNET;
-    // this.baseUrl = getChainflipSwap(isTestnet);
-    // this.assetsUrl = getAssetsUrl(isTestnet);
   }
-
   get chainService() {
     return this.swapBaseHandler.chainService;
   }
@@ -50,13 +41,6 @@ export class ChainflipSwapHandler {
   get slug() {
     return this.swapBaseHandler.slug;
   }
-  get intermediaryAssetSlug() {
-    if (this.isTestnet) {
-      return INTERMEDIARY_TESTNET_ASSET_SLUG;
-    } else {
-      return INTERMEDIARY_MAINNET_ASSET_SLUG;
-    }
-  }
   async handleSubmitStep(params) {
     const {
       address,
@@ -70,7 +54,7 @@ export class ChainflipSwapHandler {
     const fromAsset = this.chainService.getAssetBySlug(pair.from);
     const chainInfo = this.chainService.getChainInfoByKey(fromAsset.originChain);
     const toChainInfo = this.chainService.getChainInfoByKey(fromAsset.originChain);
-    const chainType = _isChainSubstrateCompatible(chainInfo) ? ChainType.SUBSTRATE : _isPureBitcoinChain(chainInfo) ? ChainType.BITCOIN : ChainType.EVM; // todo: improve throw error for unknown chain
+    const chainType = _chainInfoToChainType(chainInfo);
     const receiver = _reformatAddressWithChain(recipient !== null && recipient !== void 0 ? recipient : address, toChainInfo);
     const minReceive = new BigNumber(quote.rate).times(1 - slippage).toString();
     const processMetadata = process.steps[currentStep].metadata;

package/services/swap-service/handler/optimex-handler.d.ts

@@ -0,0 +1,43 @@
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { BalanceService } from '@subwallet/extension-base/services/balance-service';
+import { ChainService } from '@subwallet/extension-base/services/chain-service';
+import FeeService from '@subwallet/extension-base/services/fee-service/service';
+import { SwapBaseInterface } from '@subwallet/extension-base/services/swap-service/handler/base-handler';
+import { BaseStepDetail, CommonOptimalSwapPath, CommonStepFeeInfo, OptimalSwapPathParamsV2, SwapProviderId, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types';
+interface OptimexTradeMetadata {
+    trade_id: string;
+    deposit_address: string;
+    payload: string;
+    need_approve: boolean;
+    approve_address: string;
+    approve_payload: string;
+}
+export declare class OptimexHandler implements SwapBaseInterface {
+    private readonly baseUrl;
+    private currentTradeMetadata;
+    private swapBaseHandler;
+    private isTestnet;
+    providerSlug: SwapProviderId;
+    constructor(chainService: ChainService, balanceService: BalanceService, feeService: FeeService, isTestnet?: boolean);
+    get chainService(): ChainService;
+    get providerInfo(): import("@subwallet/extension-base/types").SwapProvider;
+    get name(): string;
+    get slug(): string;
+    generateOptimalProcessV2(params: OptimalSwapPathParamsV2): Promise<CommonOptimalSwapPath>;
+    initTrade(request: OptimalSwapPathParamsV2): Promise<OptimexTradeMetadata | undefined>;
+    getApprovalStep(params: OptimalSwapPathParamsV2): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
+    getSubmitStep(params: OptimalSwapPathParamsV2, stepIndex: number): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
+    validateSwapProcessV2(params: ValidateSwapProcessParams): Promise<TransactionError[]>;
+    handleSwapProcess(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
+    handleApproveStep(params: SwapSubmitParams): {
+        txChain: string;
+        txData: string;
+        extrinsic: {};
+        extrinsicType: ExtrinsicType;
+        transferNativeAmount: string;
+        chainType: ChainType;
+    };
+    handleSubmitStep(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
+}
+export {};

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;