@subwallet/extension-base 1.3.25-0 → 1.3.27-0

package/services/swap-service/index.js

@@ -4,14 +4,15 @@
 import { SwapError } from '@subwallet/extension-base/background/errors/SwapError';
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { ServiceStatus } from '@subwallet/extension-base/services/base/types';
+import { _getAssetOriginChain, _getChainSubstrateAddressPrefix } 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 { _PROVIDER_TO_SUPPORTED_PAIR_MAP, getSwapAltToken, SWAP_QUOTE_TIMEOUT_MAP } from '@subwallet/extension-base/services/swap-service/utils';
+import { _PROVIDER_TO_SUPPORTED_PAIR_MAP, findXcmDestination, getBridgeStep, getSwapAltToken, getSwapStep, isChainsHasSameProvider, SWAP_QUOTE_TIMEOUT_MAP } from '@subwallet/extension-base/services/swap-service/utils';
 import { BasicTxErrorType } 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 { createPromiseHandler } from '@subwallet/extension-base/utils';
+import { createPromiseHandler, reformatAddress } from '@subwallet/extension-base/utils';
 import subwalletApiSdk from '@subwallet/subwallet-api-sdk';
 import { BehaviorSubject } from 'rxjs';
 import { SimpleSwapHandler } from "./handler/simpleswap-handler.js";
@@ -63,7 +64,8 @@ export class SwapService {
   getDefaultProcess(params) {
     const result = {
       totalFee: [MOCK_STEP_FEE],
-      steps: [DEFAULT_FIRST_STEP]
+      steps: [DEFAULT_FIRST_STEP],
+      path: []
     };
     result.totalFee.push({
       feeComponent: [],
@@ -77,6 +79,33 @@ export class SwapService {
     });
     return result;
   }
+  getDefaultProcessV2(params) {
+    const result = {
+      totalFee: [MOCK_STEP_FEE],
+      steps: [DEFAULT_FIRST_STEP],
+      path: []
+    };
+    const swapPairInfo = params.path[0].pair; // todo: improve for Round 2
+
+    result.totalFee.push({
+      feeComponent: [],
+      feeOptions: [params.request.pair.from],
+      defaultFeeToken: params.request.pair.from
+    });
+    result.steps.push({
+      id: result.steps.length,
+      name: 'Swap',
+      type: SwapStepType.SWAP,
+      metadata: {
+        sendingValue: params.request.fromAmount.toString(),
+        originTokenInfo: this.chainService.getAssetBySlug(swapPairInfo.from),
+        destinationTokenInfo: this.chainService.getAssetBySlug(swapPairInfo.to)
+      }
+    });
+    return result;
+  }
+
+  // deprecated
   async generateOptimalProcess(params) {
     if (!params.selectedQuote) {
       return this.getDefaultProcess(params);
@@ -91,24 +120,153 @@ export class SwapService {
       }
     }
   }
+  async generateOptimalProcessV2(params) {
+    if (!params.selectedQuote) {
+      return this.getDefaultProcessV2(params);
+    } else {
+      var _params$request$curre2;
+      const providerId = ((_params$request$curre2 = params.request.currentQuote) === null || _params$request$curre2 === void 0 ? void 0 : _params$request$curre2.id) || params.selectedQuote.provider.id;
+      const handler = this.handlers[providerId];
+      if (handler) {
+        return handler.generateOptimalProcessV2(params);
+      } else {
+        return this.getDefaultProcessV2(params);
+      }
+    }
+  }
+  async generateOptimalProcessWithoutPath(params) {
+    var _params$request$curre3;
+    if (!params.selectedQuote || params.path.length > 0) {
+      return this.getDefaultProcessV2(params);
+    }
+    const [path, directSwapRequest] = this.getAvailablePath(params.request);
+    if (!directSwapRequest) {
+      return this.getDefaultProcessV2(params);
+    }
+    params.path = path;
+    const providerId = ((_params$request$curre3 = params.request.currentQuote) === null || _params$request$curre3 === void 0 ? void 0 : _params$request$curre3.id) || params.selectedQuote.provider.id;
+    const handler = this.handlers[providerId];
+    if (handler) {
+      return handler.generateOptimalProcessV2(params);
+    } else {
+      return this.getDefaultProcessV2(params);
+    }
+  }
+
+  // deprecated
+  // eslint-disable-next-line @typescript-eslint/require-await
   async handleSwapRequest(request) {
-    /*
-    * 1. Ask swap quotes from providers
-    * 2. Select the best quote
-    * 3. Generate optimal process for that quote
+    /*
+    * 1. Ask swap quotes from providers
+    * 2. Select the best quote
+    * 3. Generate optimal process for that quote
     * */
-    const swapQuoteResponse = await this.getLatestQuotes(request);
-    const optimalProcess = await this.generateOptimalProcess({
+
+    // const swapQuoteResponse = await this.getLatestDirectQuotes(request);
+
+    // const optimalProcess = await this.generateOptimalProcess({
+    //   request,
+    //   selectedQuote: swapQuoteResponse.optimalQuote
+    // });
+
+    return {
+      // @ts-ignore
+      process: null,
+      // @ts-ignore
+      quote: null
+    };
+  }
+  async handleSwapRequestV2(request) {
+    /*
+    * 1. Find available path
+    * 2. Ask swap quotes from providers
+    * 3. Select the best quote
+    * 4. Generate optimal process for that quote
+    * */
+
+    // todo: path will become a list of path in Round 2
+    // const [path, directSwapRequest] = this.getAvailablePath(request);
+    //
+    // if (!directSwapRequest) {
+    //   throw Error('Swap pair not found');
+    // }
+
+    // const swapQuoteResponse = await this.getLatestDirectQuotes(directSwapRequest);
+    const {
+      path,
+      swapQuoteResponse
+    } = await this.getLatestQuoteFromSwapRequest(request);
+    const optimalProcess = await this.generateOptimalProcessV2({
       request,
-      selectedQuote: swapQuoteResponse.optimalQuote
+      selectedQuote: swapQuoteResponse.optimalQuote,
+      path
     });
     return {
       process: optimalProcess,
       quote: swapQuoteResponse
     };
   }
-  async getLatestQuotes(request) {
-    request.pair.metadata = this.getSwapPairMetadata(request.pair.slug); // todo: improve this
+  getAvailablePath(request) {
+    const {
+      pair
+    } = request;
+    // todo: control provider tighter
+    const allSupportedChainsBySwapProvider = [...new Set(Object.values(_PROVIDER_TO_SUPPORTED_PAIR_MAP).flat())];
+    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 process = [];
+    if (!fromToken || !toToken) {
+      throw Error('Token not found');
+    }
+    if (!fromChain || !toChain) {
+      throw Error('Token metadata error');
+    }
+
+    // SWAP: 2 tokens in the same chain and chain has dex
+    if (isChainsHasSameProvider(fromChain, toChain)) {
+      // there's a dex that can support direct swapping
+      const swapStep = getSwapStep(fromToken.slug, toToken.slug);
+      process.push(swapStep);
+      return [process, {
+        ...request,
+        pair: swapStep.pair
+      }];
+    }
+
+    // BRIDGE -> SWAP: Try to find a token in dest chain that can bridge from fromToken
+    const bridgeDestination = findXcmDestination(this.chainService.getAssetRefMap(), fromToken, toChain);
+    if (bridgeDestination && allSupportedChainsBySwapProvider.includes(toChain)) {
+      const bridgeStep = getBridgeStep(fromToken.slug, bridgeDestination);
+      const swapStep = getSwapStep(bridgeDestination, toToken.slug);
+      process.push(bridgeStep);
+      process.push(swapStep);
+      return [process, {
+        ...request,
+        address: reformatAddress(request.address, _getChainSubstrateAddressPrefix(toChainInfo)),
+        pair: swapStep.pair
+      }];
+    }
+
+    // todo: improve to support SWAP -> BRIDGE and BRIDGE -> SWAP -> BRIDGE
+
+    return [[], undefined];
+  }
+  async getLatestQuoteFromSwapRequest(request) {
+    const [path, directSwapRequest] = this.getAvailablePath(request);
+    if (!directSwapRequest) {
+      throw Error('Swap pair not found');
+    }
+    const swapQuoteResponse = await this.getLatestDirectQuotes(directSwapRequest);
+    return {
+      path,
+      swapQuoteResponse
+    };
+  }
+  async getLatestDirectQuotes(request) {
+    // request.pair.metadata = this.getSwapPairMetadata(request.pair.slug); // deprecated
     const quoteAskResponses = await this.askProvidersForQuote(request);
 
     // todo: handle error to return back to UI
@@ -129,7 +287,7 @@ export class SwapService {
       selectedQuote = availableQuotes.find(quote => {
         var _request$currentQuote;
         return quote.provider.id === ((_request$currentQuote = request.currentQuote) === null || _request$currentQuote === void 0 ? void 0 : _request$currentQuote.id);
-      }) || availableQuotes[0];
+      }) || availableQuotes[0]; // todo: choose best quote based on rate
       aliveUntil = ((_selectedQuote = selectedQuote) === null || _selectedQuote === void 0 ? void 0 : _selectedQuote.aliveUntil) || +Date.now() + SWAP_QUOTE_TIMEOUT_MAP.default;
     }
     return {
@@ -235,15 +393,20 @@ export class SwapService {
       };
     });
   }
-  getSwapPairMetadata(slug) {
-    var _this$getSwapPairs$fi;
-    return (_this$getSwapPairs$fi = this.getSwapPairs().find(pair => pair.slug === slug)) === null || _this$getSwapPairs$fi === void 0 ? void 0 : _this$getSwapPairs$fi.metadata;
-  }
+
+  // private getSwapPairMetadata (slug: string): Record<string, any> | undefined {
+  //   return this.getSwapPairs().find((pair) => pair.slug === slug)?.metadata;
+  // }
+
   async validateSwapProcess(params) {
     const providerId = params.selectedQuote.provider.id;
     const handler = this.handlers[providerId];
+    if (params.currentStep > 1) {
+      // only validate from the first step
+      return [];
+    }
     if (handler) {
-      return handler.validateSwapProcess(params);
+      return handler.validateSwapProcessV2(params);
     } else {
       return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
     }
@@ -254,6 +417,7 @@ export class SwapService {
       // todo: do better to handle error generating steps
       return Promise.reject(new TransactionError(BasicTxErrorType.INTERNAL_ERROR, 'Please check your network and try again'));
     }
+    console.log('handling swap process: ', params.process);
     if (handler) {
       return handler.handleSwapProcess(params);
     } else {

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

@@ -0,0 +1,9 @@
+import { ActionPair } from '@subwallet/extension-base/types';
+export declare enum DynamicSwapType {
+    SWAP = "SWAP",
+    BRIDGE = "BRIDGE"
+}
+export interface DynamicSwapAction {
+    action: DynamicSwapType;
+    pair: ActionPair;
+}

package/services/swap-service/interface.js

@@ -0,0 +1,8 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+export let DynamicSwapType;
+(function (DynamicSwapType) {
+  DynamicSwapType["SWAP"] = "SWAP";
+  DynamicSwapType["BRIDGE"] = "BRIDGE";
+})(DynamicSwapType || (DynamicSwapType = {}));

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

@@ -1,4 +1,6 @@
-import { _ChainAsset } from '@subwallet/chain-list/types';
+import { _AssetRef, _ChainAsset } from '@subwallet/chain-list/types';
+import { DynamicSwapAction } from '@subwallet/extension-base/services/swap-service/interface';
+import { CommonStepDetail } 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";
@@ -6,6 +8,7 @@ export declare const SIMPLE_SWAP_EXPLORER = "https://simpleswap.io";
 export declare const SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING: Record<string, 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 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;
@@ -23,3 +26,8 @@ export declare function getChainflipBroker(isTestnet: boolean): {
     url: string;
 };
 export declare function getChainflipSwap(isTestnet: boolean): string;
+export declare function getBridgeStep(from: string, to: string): DynamicSwapAction;
+export declare function getSwapStep(from: string, to: string): DynamicSwapAction;
+export declare function findXcmDestination(assetRefMap: Record<string, _AssetRef>, chainAsset: _ChainAsset, destChain: string): string | undefined;
+export declare function isChainsHasSameProvider(fromChain: string, toChain: string): boolean;
+export declare function getTokenPairFromStep(steps: CommonStepDetail[]): SwapPair | undefined;

package/services/swap-service/utils.js

@@ -2,8 +2,11 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { COMMON_ASSETS, COMMON_CHAIN_SLUGS } from '@subwallet/chain-list';
+import { _AssetRefPath } from '@subwallet/chain-list/types';
 import { _getAssetDecimals } from '@subwallet/extension-base/services/chain-service/utils';
 import { CHAINFLIP_BROKER_API } from '@subwallet/extension-base/services/swap-service/handler/chainflip-handler';
+import { DynamicSwapType } from '@subwallet/extension-base/services/swap-service/interface';
+import { CommonStepType } from '@subwallet/extension-base/types';
 import { SwapProviderId } from '@subwallet/extension-base/types/swap';
 import BigN from 'bignumber.js';
 export const CHAIN_FLIP_TESTNET_EXPLORER = 'https://blocks-perseverance.chainflip.io';
@@ -24,14 +27,21 @@ export const SWAP_QUOTE_TIMEOUT_MAP = {
 };
 export const _PROVIDER_TO_SUPPORTED_PAIR_MAP = {
   [SwapProviderId.HYDRADX_MAINNET]: [COMMON_CHAIN_SLUGS.HYDRADX],
-  [SwapProviderId.HYDRADX_TESTNET]: [COMMON_CHAIN_SLUGS.HYDRADX_TESTNET],
   [SwapProviderId.CHAIN_FLIP_MAINNET]: [COMMON_CHAIN_SLUGS.POLKADOT, COMMON_CHAIN_SLUGS.ETHEREUM, COMMON_CHAIN_SLUGS.ARBITRUM],
-  [SwapProviderId.CHAIN_FLIP_TESTNET]: [COMMON_CHAIN_SLUGS.CHAINFLIP_POLKADOT, COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA],
   [SwapProviderId.POLKADOT_ASSET_HUB]: [COMMON_CHAIN_SLUGS.POLKADOT_ASSET_HUB],
   [SwapProviderId.KUSAMA_ASSET_HUB]: [COMMON_CHAIN_SLUGS.KUSAMA_ASSET_HUB],
+  [SwapProviderId.SIMPLE_SWAP]: ['bittensor', COMMON_CHAIN_SLUGS.ETHEREUM, COMMON_CHAIN_SLUGS.POLKADOT],
+  [SwapProviderId.UNISWAP]: [COMMON_CHAIN_SLUGS.ETHEREUM, COMMON_CHAIN_SLUGS.ARBITRUM],
+  // testnet
+  [SwapProviderId.CHAIN_FLIP_TESTNET]: [COMMON_CHAIN_SLUGS.CHAINFLIP_POLKADOT, COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA],
+  [SwapProviderId.HYDRADX_TESTNET]: [COMMON_CHAIN_SLUGS.HYDRADX_TESTNET],
   [SwapProviderId.ROCOCO_ASSET_HUB]: [COMMON_CHAIN_SLUGS.ROCOCO_ASSET_HUB],
-  [SwapProviderId.WESTEND_ASSET_HUB]: ['westend_assethub'],
-  [SwapProviderId.SIMPLE_SWAP]: ['bittensor', COMMON_CHAIN_SLUGS.ETHEREUM, COMMON_CHAIN_SLUGS.POLKADOT]
+  [SwapProviderId.WESTEND_ASSET_HUB]: ['westend_assethub']
+};
+export const FEE_RATE_MULTIPLIER = {
+  default: 1,
+  medium: 1.2,
+  high: 2
 };
 export function getSwapAlternativeAsset(swapPair) {
   var _swapPair$metadata;
@@ -85,4 +95,64 @@ export function getChainflipSwap(isTestnet) {
   } else {
     return `https://chainflip-broker.io/swap?apikey=${CHAINFLIP_BROKER_API}`;
   }
+}
+export function getBridgeStep(from, to) {
+  return {
+    action: DynamicSwapType.BRIDGE,
+    pair: {
+      slug: `${from}___${to}`,
+      from,
+      to
+    }
+  };
+}
+export function getSwapStep(from, to) {
+  return {
+    action: DynamicSwapType.SWAP,
+    pair: {
+      slug: `${from}___${to}`,
+      from,
+      to
+    }
+  };
+}
+export function findXcmDestination(assetRefMap, chainAsset, destChain) {
+  const foundAssetRef = Object.values(assetRefMap).find(assetRef => assetRef.srcAsset === chainAsset.slug && assetRef.destChain === destChain && assetRef.path === _AssetRefPath.XCM);
+  if (foundAssetRef) {
+    return foundAssetRef.destAsset;
+  }
+  return undefined;
+}
+export function isChainsHasSameProvider(fromChain, toChain) {
+  // todo: a provider may support multiple chains but not cross-chain swaps
+  for (const group of Object.values(_PROVIDER_TO_SUPPORTED_PAIR_MAP)) {
+    if (group.includes(fromChain) && group.includes(toChain)) {
+      return true;
+    }
+  }
+  return false;
+}
+export function getTokenPairFromStep(steps) {
+  const mainSteps = steps.filter(step => step.type !== CommonStepType.DEFAULT);
+  if (!mainSteps.length) {
+    return undefined;
+  }
+  if (mainSteps.length === 1) {
+    const metadata = mainSteps[0].metadata; // todo: temp for round 1, the exact interface is handle in round 2
+
+    return {
+      from: metadata.originTokenInfo.slug,
+      to: metadata.destinationTokenInfo.slug,
+      slug: `${metadata.originTokenInfo.slug}___${metadata.destinationTokenInfo.slug}`
+    };
+  }
+  const firstStep = mainSteps[0];
+  const lastStep = mainSteps[mainSteps.length - 1];
+  const firstMetadata = firstStep.metadata;
+  const lastMetadata = lastStep.metadata;
+  return {
+    from: firstMetadata.originTokenInfo.slug,
+    to: lastMetadata.destinationTokenInfo.slug,
+    slug: `${firstMetadata.originTokenInfo.slug}___${lastMetadata.destinationTokenInfo.slug}`
+  };
 }

package/services/transaction-service/utils.js

@@ -42,6 +42,9 @@ function getBlockExplorerAccountRoute(explorerLink) {
   if (explorerLink.includes('astral.autonomys')) {
     return 'accounts';
   }
+  if (explorerLink.includes('taostats.io')) {
+    return 'account';
+  }
   return 'address';
 }
 function getBlockExplorerTxRoute(chainInfo) {
@@ -66,9 +69,6 @@ export function getExplorerLink(chainInfo, value, type) {
     return `${explorerLink}${explorerLink.endsWith('/') ? '' : '/'}${route}/${value}`;
   }
   if (explorerLink && isHex(hexAddPrefix(value))) {
-    if (chainInfo.slug === 'bittensor') {
-      return undefined;
-    }
     const route = getBlockExplorerTxRoute(chainInfo);
     if (chainInfo.slug === 'tangle') {
       return `${explorerLink}${explorerLink.endsWith('/') ? '' : '/'}extrinsic/${value}${route}/${value}`;

package/types/service-base.d.ts

@@ -1,7 +1,8 @@
+import { DynamicSwapAction } from '@subwallet/extension-base/services/swap-service/interface';
 import { OptimalSwapPathParams, SwapFeeType, SwapStepType } from '@subwallet/extension-base/types/swap';
 import { OptimalYieldPath, OptimalYieldPathParams, YieldStepType } from '@subwallet/extension-base/types/yield';
 export declare type OptimalProcessParams = OptimalYieldPathParams | OptimalSwapPathParams;
-export declare type OptimalProcessResult = OptimalYieldPath | CommonOptimalPath;
+export declare type OptimalProcessResult = OptimalYieldPath | CommonOptimalSwapPath;
 export declare enum CommonStepType {
     DEFAULT = "DEFAULT",
     XCM = "XCM",
@@ -30,7 +31,10 @@ export interface CommonStepFeeInfo {
 export interface CommonStepDetail extends BaseStepDetail {
     id: number;
 }
-export interface CommonOptimalPath {
+export interface CommonOptimalSwapPath extends CommonOptimalTransferPath {
+    path: DynamicSwapAction[];
+}
+export interface CommonOptimalTransferPath {
     totalFee: CommonStepFeeInfo[];
     steps: CommonStepDetail[];
 }

package/types/swap/index.d.ts

@@ -1,7 +1,8 @@
-import { _ChainInfo } from '@subwallet/chain-list/types';
+import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
 import { SwapError } from '@subwallet/extension-base/background/errors/SwapError';
 import { AmountData, ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
-import { BaseStepDetail, BaseStepType, CommonOptimalPath, CommonStepFeeInfo } from '@subwallet/extension-base/types/service-base';
+import { DynamicSwapAction } from '@subwallet/extension-base/services/swap-service/interface';
+import { BaseStepDetail, BaseStepType, CommonOptimalSwapPath, CommonStepFeeInfo } from '@subwallet/extension-base/types/service-base';
 import BigN from 'bignumber.js';
 import { BaseProcessRequestSign, TransactionData } from '../transaction';
 export declare type SwapRate = number;
@@ -11,6 +12,11 @@ export interface SwapPair {
     to: string;
     metadata?: Record<string, any>;
 }
+export interface ActionPair {
+    slug: string;
+    from: string;
+    to: string;
+}
 export interface SwapQuote {
     pair: SwapPair;
     fromAmount: string;
@@ -77,7 +83,7 @@ export interface SwapBaseTxData {
     address: string;
     slippage: number;
     recipient?: string;
-    process: CommonOptimalPath;
+    process: CommonOptimalSwapPath;
 }
 export interface ChainflipSwapTxData extends SwapBaseTxData {
     depositChannelId: string;
@@ -91,6 +97,7 @@ export interface HydradxSwapTxData extends SwapBaseTxData {
     txHex: string;
 }
 export declare type GenSwapStepFunc = (params: OptimalSwapPathParams) => Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
+export declare type GenSwapStepFuncV2 = (params: OptimalSwapPathParamsV2) => Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
 export interface ChainflipPreValidationMetadata {
     minSwap: AmountData;
     maxSwap?: AmountData;
@@ -125,7 +132,7 @@ export interface SwapRequest {
     currentQuote?: SwapProvider;
 }
 export interface SwapRequestResult {
-    process: CommonOptimalPath;
+    process: CommonOptimalSwapPath;
     quote: SwapQuoteResponse;
 }
 export interface SwapQuoteResponse {
@@ -135,7 +142,7 @@ export interface SwapQuoteResponse {
     error?: SwapError;
 }
 export interface SwapSubmitParams extends BaseProcessRequestSign {
-    process: CommonOptimalPath;
+    process: CommonOptimalSwapPath;
     currentStep: number;
     quote: SwapQuote;
     address: string;
@@ -156,6 +163,11 @@ export interface OptimalSwapPathParams {
     request: SwapRequest;
     selectedQuote?: SwapQuote;
 }
+export interface OptimalSwapPathParamsV2 {
+    request: SwapRequest;
+    selectedQuote?: SwapQuote;
+    path: DynamicSwapAction[];
+}
 export interface SwapEarlyValidation {
     error?: SwapErrorType;
     metadata?: ChainflipPreValidationMetadata | HydradxPreValidationMetadata | AssetHubPreValidationMetadata;
@@ -165,9 +177,10 @@ export interface AssetHubSwapEarlyValidation extends SwapEarlyValidation {
 }
 export interface ValidateSwapProcessParams {
     address: string;
-    process: CommonOptimalPath;
+    process: CommonOptimalSwapPath;
     selectedQuote: SwapQuote;
     recipient?: string;
+    currentStep: number;
 }
 export interface SlippageType {
     slippage: BigN;
@@ -179,3 +192,18 @@ export interface PermitSwapData {
 }
 export declare const CHAINFLIP_SLIPPAGE = 0.02;
 export declare const SIMPLE_SWAP_SLIPPAGE = 0.05;
+export interface BaseSwapStepMetadata {
+    sendingValue: string;
+    originTokenInfo: _ChainAsset;
+    destinationTokenInfo: _ChainAsset;
+}
+export interface BriefXCMStep extends BaseSwapStepMetadata {
+    expectedReceive?: string;
+}
+export interface HydrationSwapStepMetadata extends BaseSwapStepMetadata {
+    txHex: `0x${string}`;
+}
+export interface ChainFlipSwapStepMetadata extends BaseSwapStepMetadata {
+    srcChain: string;
+    destChain: string;
+}

package/types/transaction/process.d.ts

@@ -1,4 +1,3 @@
-import { _ChainAsset } from '@subwallet/chain-list/types';
 import { TransactionEventResponse } from '@subwallet/extension-base/services/transaction-service/types';
 import { CommonStepDetail, CommonStepFeeInfo } from '../service-base';
 import { SwapPair, SwapProvider, SwapRate, SwapRoute, SwapSubmitParams } from '../swap';
@@ -52,11 +51,6 @@ export interface BriefProcessStep {
     processId: string;
     stepId: number;
 }
-export interface BriefXCMStep {
-    sendingValue: string;
-    originTokenInfo: _ChainAsset;
-    destinationTokenInfo: _ChainAsset;
-}
 export interface BriefSwapStep {
     pair: SwapPair;
     fromAmount: string;