@subwallet/extension-base 1.3.29-1 → 1.3.31-0

package/services/swap-service/index.js

@@ -1,26 +1,28 @@
 // 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 { 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, 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 { findAllBridgeDestinations, findBridgeTransitDestination, findSwapTransitDestination, getBridgeStep, getSupportSwapChain, getSwapAltToken, getSwapStep, getTokenPairFromStep, isChainsHasSameProvider, 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 { createPromiseHandler, reformatAddress } from '@subwallet/extension-base/utils';
+import { _reformatAddressWithChain, createPromiseHandler, reformatAddress } from '@subwallet/extension-base/utils';
 import subwalletApiSdk from '@subwallet/subwallet-api-sdk';
+import BigN from 'bignumber.js';
+import { t } from 'i18next';
 import { BehaviorSubject } from 'rxjs';
 import { SimpleSwapHandler } from "./handler/simpleswap-handler.js";
 import { UniswapHandler } from "./handler/uniswap-handler.js";
-export const _isChainSupportedByProvider = (providerSlug, chain) => {
-  const supportedChains = _PROVIDER_TO_SUPPORTED_PAIR_MAP[providerSlug];
-  return supportedChains ? supportedChains.includes(chain) : false;
-};
 export class SwapService {
   swapPairSubject = new BehaviorSubject([]);
   handlers = {};
@@ -35,13 +37,6 @@ export class SwapService {
   async askProvidersForQuote(request) {
     var _subwalletApiSdk$swap;
     const availableQuotes = [];
-    await Promise.all(Object.values(this.handlers).map(async handler => {
-      // temporary solution to reduce number of requests to providers, will work as long as there's only 1 provider for 1 chain
-
-      if (handler.init && handler.isReady === false) {
-        await handler.init();
-      }
-    }));
     const quotes = await ((_subwalletApiSdk$swap = subwalletApiSdk.swapApi) === null || _subwalletApiSdk$swap === void 0 ? void 0 : _subwalletApiSdk$swap.fetchSwapQuoteData(request));
     if (Array.isArray(quotes)) {
       quotes.forEach(quoteData => {
@@ -61,32 +56,17 @@ export class SwapService {
     }
     return availableQuotes;
   }
-  getDefaultProcess(params) {
-    const result = {
-      totalFee: [MOCK_STEP_FEE],
-      steps: [DEFAULT_FIRST_STEP],
-      path: []
-    };
-    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
-    });
-    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
-
+    const swapPairInfo = params.path.find(action => action.action === DynamicSwapType.SWAP);
+    if (!swapPairInfo) {
+      console.error('Swap pair is not found');
+      return result;
+    }
     result.totalFee.push({
       feeComponent: [],
       feeOptions: [params.request.pair.from],
@@ -98,34 +78,18 @@ export class SwapService {
       type: SwapStepType.SWAP,
       metadata: {
         sendingValue: params.request.fromAmount.toString(),
-        originTokenInfo: this.chainService.getAssetBySlug(swapPairInfo.from),
-        destinationTokenInfo: this.chainService.getAssetBySlug(swapPairInfo.to)
+        originTokenInfo: this.chainService.getAssetBySlug(swapPairInfo.pair.from),
+        destinationTokenInfo: this.chainService.getAssetBySlug(swapPairInfo.pair.to)
       }
     });
     return result;
   }
-
-  // deprecated
-  async generateOptimalProcess(params) {
-    if (!params.selectedQuote) {
-      return this.getDefaultProcess(params);
-    } else {
-      var _params$request$curre;
-      const providerId = ((_params$request$curre = params.request.currentQuote) === null || _params$request$curre === void 0 ? void 0 : _params$request$curre.id) || params.selectedQuote.provider.id;
-      const handler = this.handlers[providerId];
-      if (handler) {
-        return handler.generateOptimalProcess(params);
-      } else {
-        return this.getDefaultProcess(params);
-      }
-    }
-  }
   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;
+      var _params$request$curre;
+      const providerId = ((_params$request$curre = params.request.currentQuote) === null || _params$request$curre === void 0 ? void 0 : _params$request$curre.id) || params.selectedQuote.provider.id;
       const handler = this.handlers[providerId];
       if (handler) {
         return handler.generateOptimalProcessV2(params);
@@ -134,48 +98,6 @@ export class SwapService {
       }
     }
   }
-  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
-    * */
-
-    // 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
@@ -184,14 +106,6 @@ export class SwapService {
     * 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
@@ -201,63 +115,131 @@ export class SwapService {
       selectedQuote: swapQuoteResponse.optimalQuote,
       path
     });
+    console.log('-------');
+    console.log('optimalProcess', optimalProcess);
+    console.log('-------');
+    if (optimalProcess.steps.length - 1 < optimalProcess.path.length) {
+      // minus the fill info step
+      throw new Error('Swap pair is not found');
+    }
     return {
       process: optimalProcess,
       quote: swapQuoteResponse
     };
   }
+
+  // todo: rewrite this function
   getAvailablePath(request) {
     const {
+      address,
       pair
     } = request;
     // todo: control provider tighter
-    const allSupportedChainsBySwapProvider = [...new Set(Object.values(_PROVIDER_TO_SUPPORTED_PAIR_MAP).flat())];
+    const supportSwapChains = getSupportSwapChain();
     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 = [];
+    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
-      const swapStep = getSwapStep(fromToken.slug, toToken.slug);
+      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
       }];
     }
 
-    // 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);
+    // ------------------------
+    // 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,
-        address: reformatAddress(request.address, _getChainSubstrateAddressPrefix(toChainInfo)),
         pair: swapStep.pair
       }];
     }
 
-    // todo: improve to support SWAP -> BRIDGE and BRIDGE -> SWAP -> BRIDGE
+    // ------------------------
+    // 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) {
     const [path, directSwapRequest] = this.getAvailablePath(request);
     if (!directSwapRequest) {
-      throw Error('Swap pair not found');
+      throw Error('Swap pair is not found');
     }
     const swapQuoteResponse = await this.getLatestDirectQuotes(directSwapRequest);
     return {
@@ -284,12 +266,32 @@ export class SwapService {
       quoteError = (preferredErrorResp === null || preferredErrorResp === void 0 ? void 0 : preferredErrorResp.error) || (defaultErrorResp === null || defaultErrorResp === void 0 ? void 0 : defaultErrorResp.error);
     } else {
       var _selectedQuote;
-      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]; // todo: choose best quote based on rate
+      // sort quotes by largest receivable, with priority for some providers
+      availableQuotes.sort((a, b) => {
+        const bnToAmountA = BigN(a.toAmount);
+        const bnToAmountB = BigN(b.toAmount);
+        if (bnToAmountB.eq(bnToAmountA) && [SwapProviderId.CHAIN_FLIP_MAINNET, SwapProviderId.UNISWAP].includes(a.provider.id)) {
+          return -1;
+        }
+        if (bnToAmountA.gt(bnToAmountB)) {
+          return -1;
+        } else {
+          return 1;
+        }
+      });
+      if (request.preferredProvider) {
+        selectedQuote = availableQuotes.find(quote => quote.provider.id === request.preferredProvider) || availableQuotes[0];
+      } else {
+        selectedQuote = availableQuotes[0];
+      }
       aliveUntil = ((_selectedQuote = selectedQuote) === null || _selectedQuote === void 0 ? void 0 : _selectedQuote.aliveUntil) || +Date.now() + SWAP_QUOTE_TIMEOUT_MAP.default;
     }
+    const neededProviders = availableQuotes.map(quote => quote.provider.id);
+    await Promise.all(Object.values(this.handlers).map(async handler => {
+      if (neededProviders.includes(handler.providerSlug) && handler.init && handler.isReady === false) {
+        await handler.init();
+      }
+    }));
     return {
       optimalQuote: selectedQuote,
       quotes: availableQuotes,
@@ -393,18 +395,29 @@ export class SwapService {
       };
     });
   }
-
-  // private getSwapPairMetadata (slug: string): Record<string, any> | undefined {
-  //   return this.getSwapPairs().find((pair) => pair.slug === slug)?.metadata;
-  // }
-
-  async validateSwapProcess(params) {
+  async validateSwapProcessV2(params) {
     const providerId = params.selectedQuote.provider.id;
     const handler = this.handlers[providerId];
-    if (params.currentStep > 1) {
-      // only validate from the first step
+    if (params.currentStep > 0) {
       return [];
     }
+    const blockedConfigObjects = await fetchBlockedConfigObjects();
+    const currentConfig = this.state.settingService.getEnvironmentSetting();
+    const passBlockedConfigId = getPassConfigId(currentConfig, blockedConfigObjects);
+    const blockedActionsFeaturesMaps = await fetchLatestBlockedActionsAndFeatures(passBlockedConfigId);
+    const originSwapPairInfo = getTokenPairFromStep(params.process.steps);
+    if (!originSwapPairInfo) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    const currentAction = `${ExtrinsicType.SWAP}___${originSwapPairInfo.slug}___${params.selectedQuote.provider.id}`;
+    for (const blockedActionsFeaturesMap of blockedActionsFeaturesMaps) {
+      const {
+        blockedActionsMap
+      } = blockedActionsFeaturesMap;
+      if (blockedActionsMap.swap.includes(currentAction)) {
+        return [new TransactionError(BasicTxErrorType.UNSUPPORTED, t('Feature under maintenance. Try again later'))];
+      }
+    }
     if (handler) {
       return handler.validateSwapProcessV2(params);
     } else {
@@ -417,7 +430,6 @@ 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/utils.d.ts

@@ -1,6 +1,5 @@
 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 { CommonStepDetail, DynamicSwapAction } 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";
@@ -9,6 +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 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;
@@ -28,6 +28,14 @@ export declare function getChainflipBroker(isTestnet: boolean): {
 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 findBridgeTransitDestination(assetRefMap: Record<string, _AssetRef>, fromToken: _ChainAsset, toToken: _ChainAsset): string | undefined;
+export declare function findSwapTransitDestination(assetRefMap: Record<string, _AssetRef>, fromToken: _ChainAsset, toToken: _ChainAsset): string | undefined;
+export declare function findAllBridgeDestinations(assetRefMap: Record<string, _AssetRef>, fromToken: _ChainAsset): string[];
+export declare function getAmountAfterSlippage(amount: string, slippage: number): string;
 export declare function isChainsHasSameProvider(fromChain: string, toChain: string): boolean;
+export declare function getLastAmountFromSteps(steps: CommonStepDetail[]): string | undefined;
+export declare function getFirstAmountFromSteps(steps: CommonStepDetail[]): string | undefined;
+export declare function getChainRouteFromSteps(steps: CommonStepDetail[]): string[];
 export declare function getTokenPairFromStep(steps: CommonStepDetail[]): SwapPair | undefined;
+export declare function getSwapChainsFromPath(path: DynamicSwapAction[]): string[];
+export declare const DEFAULT_EXCESS_AMOUNT_WEIGHT = 1.04;

package/services/swap-service/utils.js

@@ -3,10 +3,9 @@
 
 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 { _getAssetDecimals, _getAssetOriginChain, _getOriginChainOfAsset, _parseAssetRefKey } 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 { CommonStepType, DynamicSwapType, SwapStepType } 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';
@@ -21,7 +20,7 @@ export const SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING = {
 };
 export const SWAP_QUOTE_TIMEOUT_MAP = {
   // in milliseconds
-  default: 30000,
+  default: 90000,
   [SwapProviderId.CHAIN_FLIP_TESTNET]: 30000,
   [SwapProviderId.CHAIN_FLIP_MAINNET]: 30000
 };
@@ -43,6 +42,9 @@ export const FEE_RATE_MULTIPLIER = {
   medium: 1.2,
   high: 2
 };
+export function getSupportSwapChain() {
+  return [...new Set(Object.values(_PROVIDER_TO_SUPPORTED_PAIR_MAP).flat())];
+}
 export function getSwapAlternativeAsset(swapPair) {
   var _swapPair$metadata;
   return swapPair === null || swapPair === void 0 ? void 0 : (_swapPair$metadata = swapPair.metadata) === null || _swapPair$metadata === void 0 ? void 0 : _swapPair$metadata.alternativeAsset;
@@ -52,15 +54,15 @@ export function getSwapAltToken(chainAsset) {
   return (_chainAsset$metadata = chainAsset.metadata) === null || _chainAsset$metadata === void 0 ? void 0 : _chainAsset$metadata.alternativeSwapAsset;
 }
 export function calculateSwapRate(fromAmount, toAmount, fromAsset, toAsset) {
-  const bnFromAmount = new BigN(fromAmount);
-  const bnToAmount = new BigN(toAmount);
+  const bnFromAmount = BigN(fromAmount);
+  const bnToAmount = BigN(toAmount);
   const decimalDiff = _getAssetDecimals(toAsset) - _getAssetDecimals(fromAsset);
   const bnRate = bnFromAmount.div(bnToAmount);
   return 1 / bnRate.times(10 ** decimalDiff).toNumber();
 }
 export function convertSwapRate(rate, fromAsset, toAsset) {
   const decimalDiff = _getAssetDecimals(toAsset) - _getAssetDecimals(fromAsset);
-  const bnRate = new BigN(rate);
+  const bnRate = BigN(rate);
   return bnRate.times(10 ** decimalDiff).pow(-1).toNumber();
 }
 export function getChainflipOptions(isTestnet) {
@@ -101,6 +103,7 @@ export function getBridgeStep(from, to) {
     action: DynamicSwapType.BRIDGE,
     pair: {
       slug: `${from}___${to}`,
+      // todo: recheck with assetRef format from chain list
       from,
       to
     }
@@ -111,18 +114,33 @@ export function getSwapStep(from, to) {
     action: DynamicSwapType.SWAP,
     pair: {
       slug: `${from}___${to}`,
+      // todo: recheck with assetRef format from chain list
       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);
+export function findBridgeTransitDestination(assetRefMap, fromToken, toToken) {
+  const foundAssetRef = Object.values(assetRefMap).find(assetRef => assetRef.srcAsset === fromToken.slug && assetRef.destChain === _getAssetOriginChain(toToken) && assetRef.path === _AssetRefPath.XCM);
   if (foundAssetRef) {
     return foundAssetRef.destAsset;
   }
   return undefined;
 }
+export function findSwapTransitDestination(assetRefMap, fromToken, toToken) {
+  const foundAssetRef = Object.values(assetRefMap).find(assetRef => assetRef.destAsset === toToken.slug && assetRef.srcChain === _getAssetOriginChain(fromToken) && assetRef.path === _AssetRefPath.XCM);
+  if (foundAssetRef) {
+    return foundAssetRef.srcAsset;
+  }
+  return undefined;
+}
+export function findAllBridgeDestinations(assetRefMap, fromToken) {
+  const foundAssetRefs = Object.values(assetRefMap).filter(assetRef => assetRef.srcAsset === fromToken.slug && assetRef.path === _AssetRefPath.XCM);
+  return foundAssetRefs.map(assetRef => assetRef.destAsset);
+}
+export function getAmountAfterSlippage(amount, slippage) {
+  return BigN(amount).multipliedBy(BigN(1).minus(BigN(slippage))).integerValue(BigN.ROUND_DOWN).toString();
+}
 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)) {
@@ -132,27 +150,90 @@ export function isChainsHasSameProvider(fromChain, toChain) {
   }
   return false;
 }
-export function getTokenPairFromStep(steps) {
+export function getLastAmountFromSteps(steps) {
+  var _lastStep$metadata;
+  const lastStep = steps[steps.length - 1]; // last step
+  const lastAmount = lastStep === null || lastStep === void 0 ? void 0 : (_lastStep$metadata = lastStep.metadata) === null || _lastStep$metadata === void 0 ? void 0 : _lastStep$metadata.destinationValue;
+  return lastAmount !== null && lastAmount !== void 0 ? lastAmount : undefined;
+}
+export function getFirstAmountFromSteps(steps) {
+  var _firstStep$metadata;
+  const firstStep = steps[1]; // first step after default step
+  const firstAmount = firstStep === null || firstStep === void 0 ? void 0 : (_firstStep$metadata = firstStep.metadata) === null || _firstStep$metadata === void 0 ? void 0 : _firstStep$metadata.sendingValue;
+  return firstAmount !== null && firstAmount !== void 0 ? firstAmount : undefined;
+}
+export function getChainRouteFromSteps(steps) {
+  // todo: handle metadata for other providers than hydra & pah. Also add validate metadata.
   const mainSteps = steps.filter(step => step.type !== CommonStepType.DEFAULT);
+  return mainSteps.reduce((chainRoute, currentStep, currentIndex) => {
+    const metadata = currentStep.metadata;
+    if (!metadata) {
+      console.error('Step has no metadata');
+      return chainRoute;
+    }
+    if (currentIndex === 0) {
+      chainRoute.push(metadata.originTokenInfo.originChain);
+      chainRoute.push(metadata.destinationTokenInfo.originChain);
+    } else {
+      chainRoute.push(metadata.destinationTokenInfo.originChain);
+    }
+    return chainRoute;
+  }, []);
+}
+
+// note: this function may return undefined if metadata version is < 2 or does not exist
+export function getTokenPairFromStep(steps) {
+  // todo: review this
+  const mainSteps = steps.filter(step => step.type !== CommonStepType.DEFAULT && step.type !== CommonStepType.TOKEN_APPROVAL && step.type !== SwapStepType.PERMIT);
   if (!mainSteps.length) {
     return undefined;
   }
+  const isStepValidIfSwap = step => {
+    const metadata = step.metadata;
+    return step.type !== SwapStepType.SWAP || !!(metadata !== null && metadata !== void 0 && metadata.version) && (metadata === null || metadata === void 0 ? void 0 : metadata.version) >= 2;
+  };
   if (mainSteps.length === 1) {
-    const metadata = mainSteps[0].metadata; // todo: temp for round 1, the exact interface is handle in round 2
-
+    if (!isStepValidIfSwap(mainSteps[0])) {
+      return undefined;
+    }
+    const metadata = mainSteps[0].metadata;
+    if (!metadata) {
+      return undefined;
+    }
     return {
       from: metadata.originTokenInfo.slug,
       to: metadata.destinationTokenInfo.slug,
-      slug: `${metadata.originTokenInfo.slug}___${metadata.destinationTokenInfo.slug}`
+      slug: _parseAssetRefKey(metadata.originTokenInfo.slug, metadata.destinationTokenInfo.slug)
     };
   }
   const firstStep = mainSteps[0];
   const lastStep = mainSteps[mainSteps.length - 1];
+  if (!isStepValidIfSwap(firstStep) || !isStepValidIfSwap(lastStep)) {
+    return undefined;
+  }
   const firstMetadata = firstStep.metadata;
   const lastMetadata = lastStep.metadata;
+  if (!firstMetadata || !lastMetadata) {
+    return undefined;
+  }
   return {
     from: firstMetadata.originTokenInfo.slug,
     to: lastMetadata.destinationTokenInfo.slug,
-    slug: `${firstMetadata.originTokenInfo.slug}___${lastMetadata.destinationTokenInfo.slug}`
+    slug: _parseAssetRefKey(firstMetadata.originTokenInfo.slug, lastMetadata.destinationTokenInfo.slug)
   };
-}
+}
+export function getSwapChainsFromPath(path) {
+  const swapChains = [];
+  path.forEach(pathElement => {
+    const fromAssetOriginChain = _getOriginChainOfAsset(pathElement.pair.from);
+    const toAssetOriginChain = _getOriginChainOfAsset(pathElement.pair.to);
+    if (swapChains.at(-1) !== fromAssetOriginChain) {
+      swapChains.push(fromAssetOriginChain);
+    }
+    if (swapChains.at(-1) !== toAssetOriginChain) {
+      swapChains.push(toAssetOriginChain);
+    }
+  });
+  return swapChains;
+}
+export const DEFAULT_EXCESS_AMOUNT_WEIGHT = 1.04; // add 2%

package/services/transaction-service/index.js

@@ -4,7 +4,7 @@
 import { EvmProviderError } from '@subwallet/extension-base/background/errors/EvmProviderError';
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { ChainType, EvmProviderErrorType, ExtrinsicStatus, ExtrinsicType, NotificationType, TransactionDirection } from '@subwallet/extension-base/background/KoniTypes';
-import { _SUPPORT_TOKEN_PAY_FEE_GROUP, ALL_ACCOUNT_KEY, fetchBlockedConfigObjects, fetchLastestBlockedActionsAndFeatures, getPassConfigId } from '@subwallet/extension-base/constants';
+import { _SUPPORT_TOKEN_PAY_FEE_GROUP, ALL_ACCOUNT_KEY, fetchBlockedConfigObjects, fetchLatestBlockedActionsAndFeatures, getPassConfigId } from '@subwallet/extension-base/constants';
 import { checkBalanceWithTransactionFee, checkSigningAccountForTransaction, checkSupportForAction, checkSupportForFeature, checkSupportForTransaction, estimateFeeForTransaction } from '@subwallet/extension-base/core/logic-validation/transfer';
 import { cellToBase64Str, externalMessage, getTransferCellPromise } from '@subwallet/extension-base/services/balance-service/helpers/subscribe/ton/utils';
 import { _getAssetDecimals, _getAssetSymbol, _getChainNativeTokenBasicInfo, _getEvmChainId, _isChainEvmCompatible, _isNativeTokenBySlug } from '@subwallet/extension-base/services/chain-service/utils';
@@ -80,7 +80,7 @@ export default class TransactionService {
     const blockedConfigObjects = await fetchBlockedConfigObjects();
     const currentConfig = this.state.settingService.getEnvironmentSetting();
     const passBlockedConfigId = getPassConfigId(currentConfig, blockedConfigObjects);
-    const blockedActionsFeaturesMaps = await fetchLastestBlockedActionsAndFeatures(passBlockedConfigId);
+    const blockedActionsFeaturesMaps = await fetchLatestBlockedActionsAndFeatures(passBlockedConfigId);
     for (const blockedActionsFeaturesMap of blockedActionsFeaturesMaps) {
       const {
         blockedActionsMap,