@subwallet/extension-base 1.3.31-0 → 1.3.32-0

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

@@ -4,10 +4,14 @@
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 import { validateTypedSignMessageDataV3V4 } from '@subwallet/extension-base/core/logic-validation';
+import { estimateTxFee, getERC20Allowance, getERC20SpendingApprovalTx } from '@subwallet/extension-base/koni/api/contract-handler/evm/web3';
+import { createAcrossBridgeExtrinsic } from '@subwallet/extension-base/services/balance-service/transfer/xcm';
+import { SpokePoolMapping } from '@subwallet/extension-base/services/balance-service/transfer/xcm/acrossBridge';
 import { BasicTxErrorType, CommonStepType, DynamicSwapType, FeeOptionKey, SwapFeeType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types';
 import { _reformatAddressWithChain } from '@subwallet/extension-base/utils';
+import { getId } from '@subwallet/extension-base/utils/getId';
 import BigNumber from 'bignumber.js';
-import { _getContractAddressOfToken, _isNativeToken } from "../../chain-service/utils/index.js";
+import { _getAssetOriginChain, _getChainNativeTokenSlug, _getContractAddressOfToken, _getEvmChainId, _isNativeToken } from "../../chain-service/utils/index.js";
 import { calculateGasFeeParams } from "../../fee-service/utils/index.js";
 import { SwapBaseHandler } from "./base-handler.js";
 const API_URL = 'https://trade-api.gateway.uniswap.org/v1';
@@ -59,41 +63,121 @@ export class UniswapHandler {
     return this.swapBaseHandler.providerInfo;
   }
   generateOptimalProcessV2(params) {
-    return this.swapBaseHandler.generateOptimalProcessV2(params, [this.getApprovalStep.bind(this), this.getPermitStep.bind(this), this.getSubmitStep.bind(this)]);
+    const stepFuncList = [];
+    /**
+     * approve - permit - swap or
+     * approve - permit - swap - approve - bridge
+     */
+
+    params.path.forEach(step => {
+      if (step.action === DynamicSwapType.SWAP) {
+        stepFuncList.push(...[this.getApprovalStep.bind(this), this.getPermitStep.bind(this), this.getSubmitStep.bind(this)]);
+        return;
+      }
+      if (step.action === DynamicSwapType.BRIDGE) {
+        stepFuncList.push(...[this.getApprovalStep.bind(this), this.getBridgeStep.bind(this)]);
+        return;
+      }
+      throw new Error(`Error generating optimal process: Action ${step.action} is not supported`);
+    });
+    return this.swapBaseHandler.generateOptimalProcessV2(params, stepFuncList);
   }
   async getApprovalStep(params, stepIndex) {
-    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: _getContractAddressOfToken(inputTokenInfo),
-          spenderAddress: spender
-        };
-        const submitStep = {
-          name: 'Approve token',
-          type: CommonStepType.TOKEN_APPROVAL,
-          metadata: metadata
-        };
-        return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
-      }
+    if (stepIndex === 0) {
+      return this.getApproveSwap(params);
+    }
+    if (stepIndex === 3) {
+      return this.getApproveBridge(params);
     }
     return Promise.resolve(undefined);
   }
+  async getApproveSwap(params) {
+    const selectedQuote = params.selectedQuote;
+    if (!selectedQuote) {
+      return Promise.resolve(undefined);
+    }
+    const quoteMetadata = selectedQuote.metadata.quote;
+    const sender = quoteMetadata.swapper;
+    const sendingValue = quoteMetadata.input.amount;
+    const fromTokenInfo = this.chainService.getAssetBySlug(selectedQuote.pair.from);
+    const checkApprovalResponse = await fetchCheckApproval(sender, sendingValue, quoteMetadata);
+    const approval = checkApprovalResponse.approval;
+    if (!approval) {
+      return Promise.resolve(undefined);
+    }
+    let spender = '';
+    try {
+      const valueLength = 40;
+      spender = approval.data.slice(-(valueLength * 2), -valueLength);
+    } catch (e) {
+      // Empty
+    }
+    const submitStep = {
+      name: 'Approve token for swap',
+      type: CommonStepType.TOKEN_APPROVAL,
+      // @ts-ignore
+      metadata: {
+        tokenApprove: fromTokenInfo.slug,
+        contractAddress: _getContractAddressOfToken(fromTokenInfo),
+        spenderAddress: spender,
+        owner: sender,
+        amount: sendingValue,
+        isUniswapApprove: true
+      }
+    };
+    return Promise.resolve([submitStep, selectedQuote.feeInfo]); // todo: wrong feeInfo, please check
+  }
+
+  async getApproveBridge(params) {
+    const quote = params.selectedQuote;
+    if (!quote) {
+      return Promise.resolve(undefined);
+    }
+    const sendingAmount = quote.toAmount;
+    const senderAddress = params.request.address;
+    const fromTokenInfo = this.chainService.getAssetBySlug(quote.pair.to);
+    const fromChainInfo = this.chainService.getChainInfoByKey(_getAssetOriginChain(fromTokenInfo));
+    const fromChainId = _getEvmChainId(fromChainInfo);
+    const evmApi = this.chainService.getEvmApi(fromChainInfo.slug);
+    const tokenContract = _getContractAddressOfToken(fromTokenInfo);
+    if (_isNativeToken(fromTokenInfo)) {
+      return Promise.resolve(undefined);
+    }
+    if (!fromChainId) {
+      throw Error('Error getting Evm chain Id');
+    }
+    const spokePoolAddress = SpokePoolMapping[fromChainId].SpokePool.address;
+    const allowance = await getERC20Allowance(spokePoolAddress, senderAddress, tokenContract, evmApi);
+    if (allowance && BigNumber(allowance).gt(sendingAmount)) {
+      return Promise.resolve(undefined);
+    }
+    const tx = await getERC20SpendingApprovalTx(spokePoolAddress, senderAddress, tokenContract, evmApi);
+    const evmFeeInfo = await this.feeService.subscribeChainFee(getId(), fromTokenInfo.originChain, 'evm');
+    const estimatedFee = await estimateTxFee(tx, evmApi, evmFeeInfo);
+    const nativeTokenSlug = _getChainNativeTokenSlug(fromChainInfo);
+    const feeInfo = {
+      feeComponent: [{
+        feeType: SwapFeeType.NETWORK_FEE,
+        amount: estimatedFee,
+        tokenSlug: nativeTokenSlug
+      }],
+      defaultFeeToken: nativeTokenSlug,
+      feeOptions: [nativeTokenSlug]
+    };
+    const submitStep = {
+      name: 'Approve token for bridge',
+      type: CommonStepType.TOKEN_APPROVAL,
+      // @ts-ignore
+      metadata: {
+        tokenApprove: fromTokenInfo.slug,
+        contractAddress: tokenContract,
+        spenderAddress: spokePoolAddress,
+        amount: sendingAmount,
+        owner: senderAddress
+      }
+    };
+    return Promise.resolve([submitStep, feeInfo]);
+  }
   async getPermitStep(params, stepIndex) {
     if (params.selectedQuote && params.selectedQuote.metadata.permitData) {
       const submitStep = {
@@ -116,11 +200,22 @@ export class UniswapHandler {
     return Promise.resolve(undefined);
   }
   async getSubmitStep(params, stepIndex) {
-    if (!params.selectedQuote) {
+    const {
+      path,
+      request,
+      selectedQuote
+    } = params;
+
+    // stepIndex is not corresponding index in path, because uniswap include approval and permit step
+    const stepData = path.find(action => action.action === DynamicSwapType.SWAP);
+    if (!stepData || !stepData.pair) {
+      return Promise.resolve(undefined);
+    }
+    if (!selectedQuote) {
       return Promise.resolve(undefined);
     }
-    const originTokenInfo = this.chainService.getAssetBySlug(params.selectedQuote.pair.from);
-    const destinationTokenInfo = this.chainService.getAssetBySlug(params.selectedQuote.pair.to);
+    const originTokenInfo = this.chainService.getAssetBySlug(selectedQuote.pair.from);
+    const destinationTokenInfo = this.chainService.getAssetBySlug(selectedQuote.pair.to);
     const originChain = this.chainService.getChainInfoByKey(originTokenInfo.originChain);
     const destinationChain = this.chainService.getChainInfoByKey(destinationTokenInfo.originChain);
     const submitStep = {
@@ -128,16 +223,99 @@ export class UniswapHandler {
       type: SwapStepType.SWAP,
       // @ts-ignore
       metadata: {
-        sendingValue: params.request.fromAmount.toString(),
-        expectedReceive: params.selectedQuote.toAmount,
+        sendingValue: request.fromAmount.toString(),
+        expectedReceive: selectedQuote.toAmount,
         originTokenInfo,
         destinationTokenInfo,
-        sender: _reformatAddressWithChain(params.request.address, originChain),
-        receiver: _reformatAddressWithChain(params.request.recipient || params.request.address, destinationChain),
+        sender: _reformatAddressWithChain(request.address, originChain),
+        receiver: _reformatAddressWithChain(request.recipient || request.address, destinationChain),
         version: 2
       }
     };
-    return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
+    return Promise.resolve([submitStep, selectedQuote.feeInfo]);
+  }
+  async getBridgeStep(params, stepIndex) {
+    const {
+      path,
+      request,
+      selectedQuote
+    } = params;
+
+    // stepIndex is not corresponding index in path, because uniswap include approval and permit step
+    const bridgePairInfo = path.find(action => action.action === DynamicSwapType.BRIDGE);
+    if (!bridgePairInfo || !bridgePairInfo.pair) {
+      return Promise.resolve(undefined);
+    }
+    if (!selectedQuote) {
+      return Promise.resolve(undefined);
+    }
+    const fromTokenInfo = this.chainService.getAssetBySlug(bridgePairInfo.pair.from);
+    const toTokenInfo = this.chainService.getAssetBySlug(bridgePairInfo.pair.to);
+    const fromChainInfo = this.chainService.getChainInfoByKey(fromTokenInfo.originChain);
+    const toChainInfo = this.chainService.getChainInfoByKey(toTokenInfo.originChain);
+    if (!fromChainInfo || !toChainInfo || !fromChainInfo || !toChainInfo) {
+      throw Error('Token or chain not found');
+    }
+    const senderAddress = _reformatAddressWithChain(request.address, fromChainInfo);
+    const receiverAddress = _reformatAddressWithChain(request.recipient || request.address, toChainInfo);
+    const sendingValue = BigNumber(selectedQuote.toAmount).div(1.02).toFixed(0, 1);
+    try {
+      const evmApi = await this.chainService.getEvmApi(fromChainInfo.slug).isReady;
+      const feeInfo = await this.feeService.subscribeChainFee(getId(), fromTokenInfo.originChain, 'evm');
+      const tx = await createAcrossBridgeExtrinsic({
+        originTokenInfo: fromTokenInfo,
+        destinationTokenInfo: toTokenInfo,
+        originChain: fromChainInfo,
+        destinationChain: toChainInfo,
+        evmApi,
+        feeInfo,
+        // Mock sending value to get payment info
+        sendingValue,
+        sender: senderAddress,
+        recipient: receiverAddress
+      });
+
+      // // todo: wait until this ready to get destination fee. the real receiveAmount is deduce by this fee
+      // const acrossQuote = await getAcrossQuote({
+      //   destinationChain: toChainInfo,
+      //   destinationTokenInfo: toTokenInfo,
+      //   originChain: fromChainInfo,
+      //   originTokenInfo: fromTokenInfo,
+      //   recipient: receiverAddress,
+      //   sender: senderAddress,
+      //   sendingValue,
+      //   feeInfo
+      // });
+
+      const estimatedBridgeFee = await estimateTxFee(tx, evmApi, feeInfo);
+      const expectedReceive = BigNumber(sendingValue).minus(estimatedBridgeFee).toFixed(0, 1);
+      const fee = {
+        feeComponent: [{
+          feeType: SwapFeeType.NETWORK_FEE,
+          amount: estimatedBridgeFee,
+          tokenSlug: _getChainNativeTokenSlug(fromChainInfo)
+        }],
+        defaultFeeToken: _getChainNativeTokenSlug(fromChainInfo),
+        feeOptions: [_getChainNativeTokenSlug(fromChainInfo)]
+      };
+      const step = {
+        // @ts-ignore
+        metadata: {
+          sendingValue: sendingValue,
+          expectedReceive,
+          originTokenInfo: fromTokenInfo,
+          destinationTokenInfo: toTokenInfo,
+          receiver: receiverAddress,
+          sender: senderAddress
+        },
+        name: `Transfer ${fromTokenInfo.symbol} from ${fromChainInfo.name}`,
+        type: CommonStepType.XCM
+      };
+      return [step, fee];
+    } catch (e) {
+      console.error('Error creating bridge step', e);
+      throw new Error(e.message);
+    }
   }
   async handleSwapProcess(params) {
     const {
@@ -150,6 +328,8 @@ export class UniswapHandler {
         return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
       case CommonStepType.TOKEN_APPROVAL:
         return this.tokenApproveSpending(params);
+      case CommonStepType.XCM:
+        return this.swapBaseHandler.handleBridgeStep(params, 'across');
       case SwapStepType.SWAP:
         return this.handleSubmitStep(params);
       case SwapStepType.PERMIT:
@@ -159,13 +339,29 @@ export class UniswapHandler {
     }
   }
   async tokenApproveSpending(params) {
-    const fromAsset = this.chainService.getAssetBySlug(params.quote.pair.from);
-    const walletAddress = params.address;
-    const fromAmount = params.quote.fromAmount;
+    const approveStep = params.process.steps[params.currentStep].metadata;
+    if (!approveStep || !approveStep.tokenApprove || !approveStep.contractAddress || !approveStep.spenderAddress) {
+      throw new Error('Approval spending metadata error');
+    }
+    if (approveStep.isUniswapApprove) {
+      return this.approveSpendingSwap(params, approveStep);
+    }
+    return this.approveSpendingBridge(approveStep);
+  }
+  async approveSpendingSwap(params, approveStep) {
+    const fromAsset = this.chainService.getAssetBySlug(approveStep.tokenApprove);
+    const sender = approveStep.owner;
+    const sendingValue = approveStep.amount;
+    if (!sender || !sendingValue) {
+      throw new Error('Sender or value is not found');
+    }
+
+    // todo: move quote param to metadata;
+
     const {
       quote
     } = params.quote.metadata;
-    const checkApprovalResponse = await fetchCheckApproval(walletAddress, fromAmount, quote);
+    const checkApprovalResponse = await fetchCheckApproval(sender, sendingValue, quote);
     let transactionConfig = {};
     const approval = checkApprovalResponse.approval;
     if (approval) {
@@ -201,6 +397,34 @@ export class UniswapHandler {
       chainType: ChainType.EVM
     });
   }
+  async approveSpendingBridge(approveStep) {
+    const fromAsset = this.chainService.getAssetBySlug(approveStep.tokenApprove);
+    const fromChain = _getAssetOriginChain(fromAsset);
+    const evmApi = this.chainService.getEvmApi(fromAsset.originChain);
+    const sender = approveStep.owner;
+    const sendingValue = approveStep.amount;
+    if (!sender) {
+      throw new Error('Sender or value is not found');
+    }
+    const spenderAddress = approveStep.spenderAddress;
+    const contractAddress = approveStep.contractAddress;
+    const transactionConfig = await getERC20SpendingApprovalTx(spenderAddress, sender, contractAddress, evmApi);
+    const _data = {
+      spenderAddress: approveStep.spenderAddress,
+      contractAddress: approveStep.contractAddress,
+      amount: sendingValue,
+      owner: sender,
+      chain: fromChain
+    };
+    return Promise.resolve({
+      txChain: fromChain,
+      extrinsicType: ExtrinsicType.TOKEN_SPENDING_APPROVAL,
+      extrinsic: transactionConfig,
+      txData: _data,
+      transferNativeAmount: '0',
+      chainType: ChainType.EVM
+    });
+  }
   async handleSubmitStep(params) {
     const fromAsset = this.chainService.getAssetBySlug(params.quote.pair.from);
     const {
@@ -234,6 +458,8 @@ export class UniswapHandler {
       const transactionResponse = await postTransactionResponse.json();
       extrinsic = transactionResponse.swap;
     } else if (routing === 'DUTCH_LIMIT' || routing === 'DUTCH_V2') {
+      // todo: update condition and add handle exception
+      // UniswapX, UniswapX_V2, and UniswapX_V3 are alternately referred to as DutchQuote, DutchQuoteV2, and DutchQuoteV3
       postTransactionResponse = await fetch(`${API_URL}/order`, {
         method: 'POST',
         headers: {
@@ -325,17 +551,20 @@ export class UniswapHandler {
     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); // todo
-
+    const swapIndex = params.process.steps.findIndex(step => step.type === SwapStepType.SWAP);
+    const bridgeIndex = params.process.steps.findIndex(step => step.type === CommonStepType.XCM);
     if (swapIndex <= -1) {
       return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
     }
+    if (swapXcm && bridgeIndex <= -1) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
     if (swap) {
       return this.swapBaseHandler.validateSwapOnlyProcess(params, swapIndex); // todo: create interface for input request
     }
 
     if (swapXcm) {
-      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+      return this.swapBaseHandler.validateSwapXcmProcess(params, swapIndex, bridgeIndex);
     }
     if (xcmSwap) {
       return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];

package/services/swap-service/index.js

@@ -12,7 +12,7 @@ import { _getAssetOriginChain, _getChainSubstrateAddressPrefix } from '@subwalle
 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, getSupportSwapChain, getSwapAltToken, getSwapStep, getTokenPairFromStep, isChainsHasSameProvider, SWAP_QUOTE_TIMEOUT_MAP } from '@subwallet/extension-base/services/swap-service/utils';
+import { findAllBridgeDestinations, findBridgeTransitDestination, findSwapTransitDestination, getBridgeStep, getSupportedSwapChains, getSwapAltToken, getSwapStep, getTokenPairFromStep, isChainsHasSameProvider, 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';
@@ -110,16 +110,22 @@ export class SwapService {
       path,
       swapQuoteResponse
     } = await this.getLatestQuoteFromSwapRequest(request);
-    const optimalProcess = await this.generateOptimalProcessV2({
-      request,
-      selectedQuote: swapQuoteResponse.optimalQuote,
-      path
-    });
-    console.log('-------');
+    console.group('Swap Logger');
+    console.log('path', path);
+    console.log('swapQuoteResponse', swapQuoteResponse);
+    let optimalProcess;
+    try {
+      optimalProcess = await this.generateOptimalProcessV2({
+        request,
+        selectedQuote: swapQuoteResponse.optimalQuote,
+        path
+      });
+    } catch (e) {
+      throw new Error(e.message);
+    }
     console.log('optimalProcess', optimalProcess);
-    console.log('-------');
-    if (optimalProcess.steps.length - 1 < optimalProcess.path.length) {
-      // minus the fill info step
+    console.groupEnd();
+    if (JSON.stringify(processStepsToPathActions(optimalProcess.steps)) !== JSON.stringify(optimalProcess.path.map(e => e.action))) {
       throw new Error('Swap pair is not found');
     }
     return {
@@ -135,7 +141,7 @@ export class SwapService {
       pair
     } = request;
     // todo: control provider tighter
-    const supportSwapChains = getSupportSwapChain();
+    const supportSwapChains = getSupportedSwapChains();
     const fromToken = this.chainService.getAssetBySlug(pair.from);
     const toToken = this.chainService.getAssetBySlug(pair.to);
     const fromChain = _getAssetOriginChain(fromToken);
@@ -237,10 +243,26 @@ export class SwapService {
     return [[], undefined];
   }
   async getLatestQuoteFromSwapRequest(request) {
-    const [path, directSwapRequest] = this.getAvailablePath(request);
+    var _subwalletApiSdk$swap2;
+    const availablePath = await ((_subwalletApiSdk$swap2 = subwalletApiSdk.swapApi) === null || _subwalletApiSdk$swap2 === void 0 ? void 0 : _subwalletApiSdk$swap2.findAvailablePath(request));
+    if (!availablePath) {
+      throw Error('No available path');
+    }
+    const {
+      path
+    } = availablePath;
+    const swapAction = path.find(step => step.action === DynamicSwapType.SWAP);
+    const directSwapRequest = swapAction ? {
+      ...request,
+      address: _reformatAddressWithChain(request.address, this.chainService.getChainInfoByKey(_getAssetOriginChain(this.chainService.getAssetBySlug(swapAction.pair.from)))),
+      pair: swapAction.pair
+    } : undefined;
     if (!directSwapRequest) {
       throw Error('Swap pair is not found');
     }
+    if (path.length > 1 && path.map(action => action.action).includes(DynamicSwapType.BRIDGE)) {
+      directSwapRequest.isCrossChain = true;
+    }
     const swapQuoteResponse = await this.getLatestDirectQuotes(directSwapRequest);
     return {
       path,

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

@@ -1,5 +1,5 @@
 import { _AssetRef, _ChainAsset } from '@subwallet/chain-list/types';
-import { CommonStepDetail, DynamicSwapAction } from '@subwallet/extension-base/types';
+import { CommonStepDetail, DynamicSwapAction, DynamicSwapType } from '@subwallet/extension-base/types';
 import { SwapPair } from '@subwallet/extension-base/types/swap';
 export declare const CHAIN_FLIP_TESTNET_EXPLORER = "https://blocks-perseverance.chainflip.io";
 export declare const CHAIN_FLIP_MAINNET_EXPLORER = "https://scan.chainflip.io";
@@ -8,7 +8,7 @@ export declare const SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING: Record<string,
 export declare const SWAP_QUOTE_TIMEOUT_MAP: Record<string, number>;
 export declare const _PROVIDER_TO_SUPPORTED_PAIR_MAP: Record<string, string[]>;
 export declare const FEE_RATE_MULTIPLIER: Record<string, number>;
-export declare function getSupportSwapChain(): string[];
+export declare function getSupportedSwapChains(): string[];
 export declare function getSwapAlternativeAsset(swapPair: SwapPair): string | undefined;
 export declare function getSwapAltToken(chainAsset: _ChainAsset): string | undefined;
 export declare function calculateSwapRate(fromAmount: string, toAmount: string, fromAsset: _ChainAsset, toAsset: _ChainAsset): number;
@@ -38,4 +38,5 @@ export declare function getFirstAmountFromSteps(steps: CommonStepDetail[]): stri
 export declare function getChainRouteFromSteps(steps: CommonStepDetail[]): string[];
 export declare function getTokenPairFromStep(steps: CommonStepDetail[]): SwapPair | undefined;
 export declare function getSwapChainsFromPath(path: DynamicSwapAction[]): string[];
+export declare function processStepsToPathActions(steps: CommonStepDetail[]): DynamicSwapType[];
 export declare const DEFAULT_EXCESS_AMOUNT_WEIGHT = 1.04;

package/services/swap-service/utils.js

@@ -42,7 +42,7 @@ export const FEE_RATE_MULTIPLIER = {
   medium: 1.2,
   high: 2
 };
-export function getSupportSwapChain() {
+export function getSupportedSwapChains() {
   return [...new Set(Object.values(_PROVIDER_TO_SUPPORTED_PAIR_MAP).flat())];
 }
 export function getSwapAlternativeAsset(swapPair) {
@@ -236,4 +236,16 @@ export function getSwapChainsFromPath(path) {
   });
   return swapChains;
 }
+export function processStepsToPathActions(steps) {
+  const path = [];
+  for (const step of steps) {
+    if (step.type === CommonStepType.XCM) {
+      path.push(DynamicSwapType.BRIDGE);
+    }
+    if (step.type === SwapStepType.SWAP) {
+      path.push(DynamicSwapType.SWAP);
+    }
+  }
+  return path;
+}
 export const DEFAULT_EXCESS_AMOUNT_WEIGHT = 1.04; // add 2%

package/types/swap/index.d.ts

@@ -137,6 +137,7 @@ export interface SwapRequestV2 {
     recipient?: string;
     feeToken?: string;
     preferredProvider?: SwapProviderId;
+    isCrossChain?: boolean;
 }
 export interface SwapRequestResult {
     process: CommonOptimalSwapPath;

package/types/transaction/process.d.ts

@@ -84,6 +84,8 @@ export interface ApproveStepMetadata {
     contractAddress: string;
     spenderAddress: string;
     amount?: string;
+    owner?: string;
+    isUniswapApprove?: boolean;
 }
 export interface RequestSubscribeProcessById {
     processId: string;

package/utils/auth.js

@@ -2,13 +2,14 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { getKeypairTypeByAddress } from '@subwallet/keyring';
-import { EthereumKeypairTypes, SubstrateKeypairTypes, TonKeypairTypes } from '@subwallet/keyring/types';
+import { CardanoKeypairTypes, EthereumKeypairTypes, SubstrateKeypairTypes, TonKeypairTypes } from '@subwallet/keyring/types';
 export const isAddressValidWithAuthType = (address, accountAuthTypes) => {
   const keypairType = getKeypairTypeByAddress(address);
   const validTypes = {
     evm: EthereumKeypairTypes,
     substrate: SubstrateKeypairTypes,
-    ton: TonKeypairTypes
+    ton: TonKeypairTypes,
+    cardano: CardanoKeypairTypes
   };
   return !!(accountAuthTypes !== null && accountAuthTypes !== void 0 && accountAuthTypes.some(authType => {
     var _validTypes$authType;

package/utils/cardano.d.ts

@@ -0,0 +1,2 @@
+export declare const convertCardanoAddressToHex: (bech32Address: string) => string;
+export declare const convertCardanoHexToBech32: (hexAddress: string) => string;

package/utils/cardano.js

@@ -0,0 +1,12 @@
+// Copyright 2019-2022 @polkadot/extension authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { Address } from '@emurgo/cardano-serialization-lib-nodejs';
+export const convertCardanoAddressToHex = bech32Address => {
+  const addr = Address.from_bech32(bech32Address);
+  return addr.to_hex();
+};
+export const convertCardanoHexToBech32 = hexAddress => {
+  const addr = Address.from_hex(hexAddress);
+  return addr.to_bech32();
+};

package/utils/index.d.ts

@@ -4,9 +4,9 @@ import { CrowdloanParaState, NetworkJson } from '@subwallet/extension-base/backg
 import { AccountAuthType } from '@subwallet/extension-base/background/types';
 import { AccountJson } from '@subwallet/extension-base/types';
 import { BN } from '@polkadot/util';
-export { canDerive } from './canDerive';
 export * from './mv3';
 export * from './fetch';
+export { convertCardanoAddressToHex } from './cardano';
 export declare const notDef: (x: any) => boolean;
 export declare const isDef: (x: any) => boolean;
 export declare const nonEmptyArr: (x: any) => boolean;

package/utils/index.js

@@ -9,9 +9,9 @@ import { decodeAddress, encodeAddress, isCardanoAddress, isTonAddress } from '@s
 import { t } from 'i18next';
 import { assert, BN, hexToU8a, isHex } from '@polkadot/util';
 import { ethereumEncode, isEthereumAddress } from '@polkadot/util-crypto';
-export { canDerive } from "./canDerive.js";
 export * from "./mv3.js";
 export * from "./fetch.js";
+export { convertCardanoAddressToHex } from "./cardano.js";
 export const notDef = x => x === null || typeof x === 'undefined';
 export const isDef = x => !notDef(x);
 export const nonEmptyArr = x => Array.isArray(x) && x.length > 0;

package/cjs/utils/canDerive.js

@@ -1,12 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.canDerive = canDerive;
-// Copyright 2019-2022 @polkadot/extension authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-function canDerive(type) {
-  return !!type && ['ed25519', 'sr25519', 'ecdsa', 'ethereum'].includes(type);
-}

package/utils/canDerive.d.ts

@@ -1,2 +0,0 @@
-import type { KeypairType } from '@subwallet/keyring/types';
-export declare function canDerive(type?: KeypairType): boolean;

package/utils/canDerive.js

@@ -1,6 +0,0 @@
-// Copyright 2019-2022 @polkadot/extension authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-export function canDerive(type) {
-  return !!type && ['ed25519', 'sr25519', 'ecdsa', 'ethereum'].includes(type);
-}