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

package/koni/background/handlers/Extension.js

@@ -11,6 +11,7 @@ import { CampaignDataType, ChainType, ExternalRequestPromiseStatus, ExtrinsicTyp
 import { _SUPPORT_TOKEN_PAY_FEE_GROUP, ALL_ACCOUNT_KEY, LATEST_SESSION } from '@subwallet/extension-base/constants';
 import { additionalValidateTransferForRecipient, additionalValidateXcmTransfer, validateTransferRequest, validateXcmTransferRequest } from '@subwallet/extension-base/core/logic-validation/transfer';
 import { _isSnowBridgeXcm } from '@subwallet/extension-base/core/substrate/xcm-parser';
+import { _isSufficientToken } from '@subwallet/extension-base/core/utils';
 import { ALLOWED_PATH } from '@subwallet/extension-base/defaults';
 import { getERC20SpendingApprovalTx } from '@subwallet/extension-base/koni/api/contract-handler/evm/web3';
 import { _ERC721_ABI, isAvailBridgeGatewayContract, isSnowBridgeGatewayContract } from '@subwallet/extension-base/koni/api/contract-handler/utils';
@@ -32,9 +33,9 @@ import { createAvailBridgeExtrinsicFromAvail, createAvailBridgeTxFromEth, create
 import { getClaimTxOnAvail, getClaimTxOnEthereum, isAvailChainBridge } from '@subwallet/extension-base/services/balance-service/transfer/xcm/availBridge';
 import { _isPolygonChainBridge, getClaimPolygonBridge, isClaimedPolygonBridge } from '@subwallet/extension-base/services/balance-service/transfer/xcm/polygonBridge';
 import { _isPosChainBridge, getClaimPosBridge } from '@subwallet/extension-base/services/balance-service/transfer/xcm/posBridge';
-import { _DEFAULT_MANTA_ZK_CHAIN, _MANTA_ZK_CHAIN_GROUP, _ZK_ASSET_PREFIX, SUFFICIENT_CHAIN } from '@subwallet/extension-base/services/chain-service/constants';
+import { _DEFAULT_MANTA_ZK_CHAIN, _MANTA_ZK_CHAIN_GROUP, _ZK_ASSET_PREFIX } from '@subwallet/extension-base/services/chain-service/constants';
 import { _ChainConnectionStatus } from '@subwallet/extension-base/services/chain-service/types';
-import { _getAssetDecimals, _getAssetSymbol, _getChainNativeTokenBasicInfo, _getContractAddressOfToken, _getEvmChainId, _getTokenOnChainAssetId, _getXcmAssetMultilocation, _isAssetSmartContractNft, _isBridgedToken, _isChainEvmCompatible, _isChainSubstrateCompatible, _isCustomAsset, _isLocalToken, _isMantaZkAsset, _isNativeToken, _isNativeTokenBySlug, _isPureEvmChain, _isTokenEvmSmartContract, _isTokenTransferredByCardano, _isTokenTransferredByEvm, _isTokenTransferredByTon } from '@subwallet/extension-base/services/chain-service/utils';
+import { _getAssetDecimals, _getAssetSymbol, _getChainNativeTokenBasicInfo, _getContractAddressOfToken, _getEvmChainId, _isAssetSmartContractNft, _isChainEvmCompatible, _isChainSubstrateCompatible, _isCustomAsset, _isLocalToken, _isMantaZkAsset, _isNativeToken, _isNativeTokenBySlug, _isPureEvmChain, _isTokenEvmSmartContract, _isTokenTransferredByCardano, _isTokenTransferredByEvm, _isTokenTransferredByTon } from '@subwallet/extension-base/services/chain-service/utils';
 import { calculateToAmountByReservePool } from '@subwallet/extension-base/services/fee-service/utils';
 import { batchExtrinsicSetFeeHydration, getAssetHubTokensCanPayFee, getHydrationTokensCanPayFee } from '@subwallet/extension-base/services/fee-service/utils/tokenPayFee';
 import { EXTENSION_REQUEST_URL } from '@subwallet/extension-base/services/request-service/constants';
@@ -1299,7 +1300,7 @@ export default class KoniExtension {
       const receiverSendingTokenKeepAliveBalance = BigInt(_receiverSendingTokenKeepAliveBalance);
       const amount = BigInt(transferAmount.value);
       const substrateApi = this.#koniState.getSubstrateApi(chain);
-      const isSendingTokenSufficient = await this.isSufficientToken(transferTokenInfo, substrateApi);
+      const isSendingTokenSufficient = await _isSufficientToken(transferTokenInfo, substrateApi);
       const [warnings, errors] = additionalValidateTransferForRecipient(transferTokenInfo, nativeTokenInfo, extrinsicType, receiverSendingTokenKeepAliveBalance, amount, senderSendingTokenTransferable, receiverSystemAccountInfo, isSendingTokenSufficient);
       warnings.length && inputTransaction.warnings.push(...warnings);
       errors.length && inputTransaction.errors.push(...errors);
@@ -1663,25 +1664,6 @@ export default class KoniExtension {
       };
     }
   }
-  async isSufficientToken(tokenInfo, substrateApi) {
-    let metadata;
-    if (SUFFICIENT_CHAIN.includes(tokenInfo.originChain) && tokenInfo.assetType !== _AssetType.NATIVE) {
-      const assetId = _isBridgedToken(tokenInfo) ? _getXcmAssetMultilocation(tokenInfo) : _getTokenOnChainAssetId(tokenInfo);
-      const queryParams = {
-        section: 'query',
-        module: 'foreignAssets',
-        method: 'asset',
-        args: [assetId]
-      };
-      if (!_isBridgedToken(tokenInfo)) {
-        queryParams.module = 'assets';
-      }
-      metadata = await substrateApi.makeRpcQuery(queryParams);
-    } else {
-      return false;
-    }
-    return metadata.isSufficient;
-  }
   async deleteCustomAsset(assetSlug) {
     const assetInfo = this.#koniState.getAssetBySlug(assetSlug);
     if (assetInfo && _isCustomAsset(assetSlug)) {
@@ -3603,14 +3585,20 @@ export default class KoniExtension {
     ready = true;
     return this.#koniState.swapService.getSwapPairs();
   }
-  async generateOptimalProcess(request) {
-    return this.#koniState.swapService.generateOptimalProcess(request);
+  async getOptimalSwapProcessOnSelectQuote(request) {
+    return this.#koniState.swapService.generateOptimalProcessWithoutPath(request);
   }
   async handleSwapRequest(request) {
     return this.#koniState.swapService.handleSwapRequest(request);
   }
+  async handleSwapRequestV2(request) {
+    return this.#koniState.swapService.handleSwapRequestV2(request);
+  }
   async getLatestSwapQuote(swapRequest) {
-    return this.#koniState.swapService.getLatestQuotes(swapRequest);
+    const {
+      swapQuoteResponse
+    } = await this.#koniState.swapService.getLatestQuoteFromSwapRequest(swapRequest);
+    return swapQuoteResponse;
   }
   async validateSwapProcess(params) {
     return this.#koniState.swapService.validateSwapProcess(params);
@@ -3647,7 +3635,8 @@ export default class KoniExtension {
       address,
       process,
       selectedQuote: quote,
-      recipient
+      recipient,
+      currentStep: inputData.currentStep
     });
     if (swapValidations.length > 0) {
       if (step) {
@@ -3668,6 +3657,7 @@ export default class KoniExtension {
       }
       throw e;
     }
+    console.log('swap data', submitData);
 
     // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     const {
@@ -4716,10 +4706,12 @@ export default class KoniExtension {
       /* Swap service */
       case 'pri(swapService.subscribePairs)':
         return this.subscribeSwapPairs(id, port);
-      case 'pri(swapService.generateOptimalProcess)':
-        return this.generateOptimalProcess(request);
+      case 'pri(swapService.getOptimalProcessOnSelectQuote)':
+        return this.getOptimalSwapProcessOnSelectQuote(request);
       case 'pri(swapService.handleSwapRequest)':
         return this.handleSwapRequest(request);
+      case 'pri(swapService.handleSwapRequestV2)':
+        return this.handleSwapRequestV2(request);
       case 'pri(swapService.getLatestQuote)':
         return this.getLatestSwapQuote(request);
       case 'pri(swapService.validateSwapProcess)':

package/package.json

@@ -17,7 +17,7 @@
     "./cjs/detectPackage.js"
   ],
   "type": "module",
-  "version": "1.3.26-0",
+  "version": "1.3.27-0",
   "main": "./cjs/index.js",
   "module": "./index.js",
   "types": "./index.d.ts",
@@ -1886,6 +1886,11 @@
       "require": "./cjs/services/swap-service/handler/uniswap-handler.js",
       "default": "./services/swap-service/handler/uniswap-handler.js"
     },
+    "./services/swap-service/interface": {
+      "types": "./services/swap-service/interface.d.ts",
+      "require": "./cjs/services/swap-service/interface.js",
+      "default": "./services/swap-service/interface.js"
+    },
     "./services/swap-service/utils": {
       "types": "./services/swap-service/utils.d.ts",
       "require": "./cjs/services/swap-service/utils.js",
@@ -2664,13 +2669,13 @@
     "@reduxjs/toolkit": "^1.9.1",
     "@sora-substrate/type-definitions": "^1.17.7",
     "@substrate/connect": "^0.8.9",
-    "@subwallet/chain-list": "0.2.101",
-    "@subwallet/extension-base": "^1.3.26-0",
-    "@subwallet/extension-chains": "^1.3.26-0",
-    "@subwallet/extension-dapp": "^1.3.26-0",
-    "@subwallet/extension-inject": "^1.3.26-0",
+    "@subwallet/chain-list": "0.2.102",
+    "@subwallet/extension-base": "^1.3.27-0",
+    "@subwallet/extension-chains": "^1.3.27-0",
+    "@subwallet/extension-dapp": "^1.3.27-0",
+    "@subwallet/extension-inject": "^1.3.27-0",
     "@subwallet/keyring": "^0.1.9",
-    "@subwallet/subwallet-api-sdk": "^1.3.26-0",
+    "@subwallet/subwallet-api-sdk": "^1.3.27-0",
     "@subwallet/ui-keyring": "^0.1.9",
     "@ton/core": "^0.56.3",
     "@ton/crypto": "^3.2.0",

package/packageInfo.js

@@ -7,5 +7,5 @@ export const packageInfo = {
   name: '@subwallet/extension-base',
   path: (import.meta && import.meta.url) ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf('/') + 1) : 'auto',
   type: 'esm',
-  version: '1.3.26-0'
+  version: '1.3.27-0'
 };

package/services/balance-service/helpers/process.d.ts

@@ -1,7 +1,7 @@
 import { _ChainAsset } from '@subwallet/chain-list/types';
 import { _Address } from '@subwallet/extension-base/background/KoniTypes';
 import { _EvmApi } from '@subwallet/extension-base/services/chain-service/types';
-import { CommonOptimalPath } from '@subwallet/extension-base/types/service-base';
+import { CommonOptimalTransferPath } from '@subwallet/extension-base/types/service-base';
 export interface RequestOptimalTransferProcess {
     originChain: string;
     destChain?: string;
@@ -9,5 +9,5 @@ export interface RequestOptimalTransferProcess {
     address: _Address;
     amount: string;
 }
-export declare function getDefaultTransferProcess(): CommonOptimalPath;
-export declare function getSnowbridgeTransferProcessFromEvm(address: string, evmApi: _EvmApi, tokenInfo: _ChainAsset, amount: string): Promise<CommonOptimalPath>;
+export declare function getDefaultTransferProcess(): CommonOptimalTransferPath;
+export declare function getSnowbridgeTransferProcessFromEvm(address: string, evmApi: _EvmApi, tokenInfo: _ChainAsset, amount: string): Promise<CommonOptimalTransferPath>;

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

@@ -3,8 +3,7 @@ import KoniState from '@subwallet/extension-base/koni/background/handlers/State'
 import { RequestOptimalTransferProcess } from '@subwallet/extension-base/services/balance-service/helpers/process';
 import { ServiceStatus, StoppableServiceInterface } from '@subwallet/extension-base/services/base/types';
 import { EventItem, EventType } from '@subwallet/extension-base/services/event-service/types';
-import { BalanceItem, BalanceJson } from '@subwallet/extension-base/types';
-import { CommonOptimalPath } from '@subwallet/extension-base/types/service-base';
+import { BalanceItem, BalanceJson, CommonOptimalTransferPath } from '@subwallet/extension-base/types';
 import { PromiseHandler } from '@subwallet/extension-base/utils';
 import { BehaviorSubject } from 'rxjs';
 /**
@@ -99,5 +98,5 @@ export declare class BalanceService implements StoppableServiceInterface {
     private startBalanceDetectCache;
     private startScanBalance;
     private stopScanBalance;
-    getOptimalTransferProcess(params: RequestOptimalTransferProcess): Promise<CommonOptimalPath>;
+    getOptimalTransferProcess(params: RequestOptimalTransferProcess): Promise<CommonOptimalTransferPath>;
 }

package/services/swap-service/handler/asset-hub/handler.d.ts

@@ -2,8 +2,7 @@ import { TransactionError } from '@subwallet/extension-base/background/errors/Tr
 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 { BaseStepDetail, CommonOptimalPath, CommonStepFeeInfo } from '@subwallet/extension-base/types/service-base';
-import { OptimalSwapPathParams, SwapProviderId, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types/swap';
+import { BaseStepDetail, CommonOptimalSwapPath, CommonStepFeeInfo, OptimalSwapPathParams, OptimalSwapPathParamsV2, SwapProviderId, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types';
 import { SwapBaseInterface } from '../base-handler';
 export declare class AssetHubSwapHandler implements SwapBaseInterface {
     private swapBaseHandler;
@@ -20,10 +19,14 @@ export declare class AssetHubSwapHandler implements SwapBaseInterface {
     init(): Promise<void>;
     getXcmStep(params: OptimalSwapPathParams): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
     getSubmitStep(params: OptimalSwapPathParams): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
-    generateOptimalProcess(params: OptimalSwapPathParams): Promise<CommonOptimalPath>;
+    getXcmStepV2(params: OptimalSwapPathParamsV2): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
+    getSwapStepV2(params: OptimalSwapPathParamsV2): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
+    generateOptimalProcess(params: OptimalSwapPathParams): Promise<CommonOptimalSwapPath>;
+    generateOptimalProcessV2(params: OptimalSwapPathParamsV2): Promise<CommonOptimalSwapPath>;
     handleXcmStep(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
     handleSubmitStep(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
     handleSwapProcess(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
     validateSwapStep(params: ValidateSwapProcessParams, isXcmOk: boolean, stepIndex: number): Promise<TransactionError[]>;
     validateSwapProcess(params: ValidateSwapProcessParams): Promise<TransactionError[]>;
+    validateSwapProcessV2(params: ValidateSwapProcessParams): Promise<TransactionError[]>;
 }

package/services/swap-service/handler/asset-hub/handler.js

@@ -1,16 +1,16 @@
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
+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 { XCM_MIN_AMOUNT_RATIO } from '@subwallet/extension-base/constants';
 import { _validateBalanceToSwapOnAssetHub, _validateSwapRecipient } from '@subwallet/extension-base/core/logic-validation/swap';
 import { createXcmExtrinsic } from '@subwallet/extension-base/services/balance-service/transfer/xcm';
-import { _getChainNativeTokenSlug, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
-import { getSwapAlternativeAsset } from '@subwallet/extension-base/services/swap-service/utils';
-import { BasicTxErrorType } from '@subwallet/extension-base/types';
-import { CommonStepType } from '@subwallet/extension-base/types/service-base';
-import { SwapErrorType, SwapFeeType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types/swap';
+import { _getChainNativeTokenSlug, _getTokenMinAmount, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
+import { DynamicSwapType } from '@subwallet/extension-base/services/swap-service/interface';
+import { FEE_RATE_MULTIPLIER, getSwapAlternativeAsset } from '@subwallet/extension-base/services/swap-service/utils';
+import { BasicTxErrorType, CommonStepType, SwapErrorType, SwapFeeType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types';
 import { getId } from '@subwallet/extension-base/utils/getId';
 import BigN from 'bignumber.js';
 import { SwapBaseHandler } from "../base-handler.js";
@@ -145,39 +145,131 @@ export class AssetHubSwapHandler {
     }
     return Promise.resolve(undefined);
   }
+  async getXcmStepV2(params) {
+    var _params$path$find;
+    // todo: improve this function for Round 2
+
+    const xcmPairInfo = (_params$path$find = params.path.find((step, i) => i === 0 && step.action === DynamicSwapType.BRIDGE)) === null || _params$path$find === void 0 ? void 0 : _params$path$find.pair;
+    if (!xcmPairInfo) {
+      return undefined;
+    }
+    const fromTokenInfo = this.chainService.getAssetBySlug(xcmPairInfo.from);
+    const toTokenInfo = this.chainService.getAssetBySlug(xcmPairInfo.to);
+    const fromChainInfo = this.chainService.getChainInfoByKey(fromTokenInfo.originChain);
+    const toChainInfo = this.chainService.getChainInfoByKey(toTokenInfo.originChain);
+    const substrateApi = await this.chainService.getSubstrateApi(fromTokenInfo.originChain).isReady;
+    if (!fromChainInfo || !toChainInfo || !fromChainInfo || !toChainInfo) {
+      throw Error('Token and chain not found');
+    }
+    try {
+      const id = getId();
+      const [feeInfo, toTokenBalance] = await Promise.all([this.swapBaseHandler.feeService.subscribeChainFee(id, fromTokenInfo.originChain, 'substrate'), this.balanceService.getTotalBalance(params.request.address, toTokenInfo.originChain, toTokenInfo.slug, ExtrinsicType.TRANSFER_BALANCE)]);
+      const xcmTransfer = await createXcmExtrinsic({
+        originTokenInfo: fromTokenInfo,
+        destinationTokenInfo: toTokenInfo,
+        // Mock sending value to get payment info
+        sendingValue: params.request.fromAmount,
+        recipient: params.request.address,
+        substrateApi: substrateApi,
+        sender: params.request.address,
+        originChain: fromChainInfo,
+        destinationChain: toChainInfo,
+        feeInfo
+      });
+      const _xcmFeeInfo = await xcmTransfer.paymentInfo(params.request.address);
+      const xcmFeeInfo = _xcmFeeInfo.toPrimitive();
+      const fee = {
+        feeComponent: [{
+          feeType: SwapFeeType.NETWORK_FEE,
+          amount: Math.ceil(xcmFeeInfo.partialFee * FEE_RATE_MULTIPLIER.high).toString(),
+          tokenSlug: _getChainNativeTokenSlug(fromChainInfo)
+        }],
+        defaultFeeToken: _getChainNativeTokenSlug(fromChainInfo),
+        feeOptions: [_getChainNativeTokenSlug(fromChainInfo)]
+      };
+      let bnTransferAmount = new BigN(params.request.fromAmount);
+      if (_isNativeToken(fromTokenInfo)) {
+        // xcm fee is paid in native token but swap token is not always native token
+        // add amount of fee into sending value to ensure has enough token to swap
+        const bnXcmFee = new BigN(fee.feeComponent[0].amount);
+        bnTransferAmount = bnTransferAmount.plus(bnXcmFee);
+      } else {
+        bnTransferAmount = bnTransferAmount.plus(BigN(_getTokenMinAmount(toTokenInfo)).multipliedBy(FEE_RATE_MULTIPLIER.medium));
+      }
+      if (BigN(toTokenBalance.value).lte(0)) {
+        bnTransferAmount = bnTransferAmount.plus(_getTokenMinAmount(toTokenInfo));
+      }
+      const step = {
+        metadata: {
+          sendingValue: bnTransferAmount.toString(),
+          originTokenInfo: fromTokenInfo,
+          destinationTokenInfo: toTokenInfo
+        },
+        name: `Transfer ${fromTokenInfo.symbol} from ${fromChainInfo.name}`,
+        type: CommonStepType.XCM
+      };
+      return [step, fee];
+    } catch (e) {
+      console.error('Error creating xcm step', e);
+      return undefined;
+    }
+  }
+  async getSwapStepV2(params) {
+    var _params$path$find2;
+    const swapPairInfo = (_params$path$find2 = params.path.find(step => step.action === DynamicSwapType.SWAP)) === null || _params$path$find2 === void 0 ? void 0 : _params$path$find2.pair;
+    if (!swapPairInfo) {
+      return Promise.resolve(undefined);
+    }
+    if (params.selectedQuote) {
+      const submitStep = {
+        name: 'Swap',
+        type: SwapStepType.SWAP,
+        metadata: {
+          sendingValue: params.request.fromAmount.toString(),
+          originTokenInfo: this.chainService.getAssetBySlug(swapPairInfo.from),
+          destinationTokenInfo: this.chainService.getAssetBySlug(swapPairInfo.to)
+        }
+      };
+      return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
+    }
+    return Promise.resolve(undefined);
+  }
   generateOptimalProcess(params) {
     return this.swapBaseHandler.generateOptimalProcess(params, [this.getXcmStep.bind(this), this.getSubmitStep.bind(this)]);
   }
+  generateOptimalProcessV2(params) {
+    const stepFuncList = params.path.map(step => {
+      if (step.action === DynamicSwapType.BRIDGE) {
+        return this.getXcmStepV2.bind(this);
+      }
+      if (step.action === DynamicSwapType.SWAP) {
+        return this.getSwapStepV2.bind(this);
+      }
+      throw new Error(`Error generating optimal process: Action ${step.action} is not supported`);
+    });
+    return this.swapBaseHandler.generateOptimalProcessV2(params, stepFuncList);
+  }
   async handleXcmStep(params) {
-    const pair = params.quote.pair;
-    const alternativeAssetSlug = getSwapAlternativeAsset(pair);
-    const originAsset = this.chainService.getAssetBySlug(alternativeAssetSlug);
-    const destinationAsset = this.chainService.getAssetBySlug(pair.from);
+    const briefXcmStep = params.process.steps[params.currentStep].metadata;
+    if (!briefXcmStep || !briefXcmStep.originTokenInfo || !briefXcmStep.destinationTokenInfo || !briefXcmStep.sendingValue) {
+      throw new Error('XCM metadata error');
+    }
+    const originAsset = briefXcmStep.originTokenInfo;
+    const destinationAsset = briefXcmStep.destinationTokenInfo;
     const originChain = this.chainService.getChainInfoByKey(originAsset.originChain);
     const destinationChain = this.chainService.getChainInfoByKey(destinationAsset.originChain);
     const substrateApi = this.chainService.getSubstrateApi(originAsset.originChain);
     const chainApi = await substrateApi.isReady;
-    const destinationAssetBalance = await this.balanceService.getTransferableBalance(params.address, destinationAsset.originChain, destinationAsset.slug);
-    const xcmFee = params.process.totalFee[params.currentStep];
-    const bnAmount = new BigN(params.quote.fromAmount);
-    const bnDestinationAssetBalance = new BigN(destinationAssetBalance.value);
-    const id = getId();
-    const feeInfo = await this.swapBaseHandler.feeService.subscribeChainFee(id, originChain.slug, 'substrate');
-    let bnTotalAmount = bnAmount.minus(bnDestinationAssetBalance);
-    if (_isNativeToken(originAsset)) {
-      const bnXcmFee = new BigN(xcmFee.feeComponent[0].amount); // xcm fee is paid in native token but swap token is not always native token
-
-      bnTotalAmount = bnTotalAmount.plus(bnXcmFee);
-    }
+    const feeInfo = await this.swapBaseHandler.feeService.subscribeChainFee(getId(), originAsset.originChain, 'substrate');
     const xcmTransfer = await createXcmExtrinsic({
       originTokenInfo: originAsset,
       destinationTokenInfo: destinationAsset,
-      sendingValue: bnTotalAmount.toString(),
+      sendingValue: briefXcmStep.sendingValue,
       recipient: params.address,
       substrateApi: chainApi,
       sender: params.address,
-      originChain: originChain,
-      destinationChain: destinationChain,
+      destinationChain,
+      originChain,
       feeInfo
     });
     const xcmData = {
@@ -185,14 +277,14 @@ export class AssetHubSwapHandler {
       destinationNetworkKey: destinationAsset.originChain,
       from: params.address,
       to: params.address,
-      value: bnTotalAmount.toString(),
+      value: briefXcmStep.sendingValue,
       tokenSlug: originAsset.slug,
       showExtraWarning: true
     };
     return {
       txChain: originAsset.originChain,
       extrinsic: xcmTransfer,
-      transferNativeAmount: _isNativeToken(originAsset) ? bnTotalAmount.toString() : '0',
+      transferNativeAmount: _isNativeToken(originAsset) ? briefXcmStep.sendingValue : '0',
       extrinsicType: ExtrinsicType.TRANSFER_XCM,
       chainType: ChainType.SUBSTRATE,
       txData: xcmData
@@ -200,7 +292,11 @@ export class AssetHubSwapHandler {
   }
   async handleSubmitStep(params) {
     var _this$router;
-    const fromAsset = this.chainService.getAssetBySlug(params.quote.pair.from);
+    const metadata = params.process.steps[params.currentStep].metadata;
+    if (!metadata || !metadata.sendingValue || !metadata.destinationTokenInfo || !metadata.originTokenInfo) {
+      return new SwapError(SwapErrorType.UNKNOWN);
+    }
+    const fromAsset = metadata.originTokenInfo;
     const txData = {
       provider: this.providerInfo,
       quote: params.quote,
@@ -213,7 +309,12 @@ export class AssetHubSwapHandler {
       fromAmount,
       toAmount
     } = params.quote;
+
+    // todo: move to gen process
     const minReceive = new BigN(1 - params.slippage).times(toAmount).integerValue(BigN.ROUND_DOWN);
+    if (!params.address || !paths || !fromAmount || !minReceive) {
+      throw new SwapError(SwapErrorType.UNKNOWN);
+    }
     const extrinsic = await ((_this$router = this.router) === null || _this$router === void 0 ? void 0 : _this$router.buildSwapExtrinsic(paths, params.address, fromAmount, minReceive.toString()));
     return {
       txChain: fromAsset.originChain,
@@ -286,14 +387,22 @@ export class AssetHubSwapHandler {
     if (bnAmount.lte(0)) {
       return [new TransactionError(BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')];
     }
+    const swapStep = params.process.steps.find(item => item.type === SwapStepType.SWAP);
+    if (!swapStep) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR, 'Swap step not found')];
+    }
     let isXcmOk = false;
+    const currentStep = params.currentStep;
     for (const [index, step] of params.process.steps.entries()) {
+      if (currentStep > index) {
+        continue;
+      }
       const getErrors = async () => {
         switch (step.type) {
           case CommonStepType.DEFAULT:
             return Promise.resolve([]);
           case CommonStepType.XCM:
-            return this.swapBaseHandler.validateXcmStep(params, index);
+            return this.swapBaseHandler.validateXcmStepV2(params, index);
           case SwapStepType.SWAP:
             return this.validateSwapStep(params, isXcmOk, index);
           default:
@@ -309,4 +418,37 @@ export class AssetHubSwapHandler {
     }
     return [];
   }
+  async validateSwapProcessV2(params) {
+    // todo: recheck address and recipient format in params
+    const {
+      process,
+      selectedQuote
+    } = params; // todo: review flow, currentStep param.
+
+    // todo: validate path with optimalProcess
+    // todo: review error message in case many step swap
+    if (BigN(selectedQuote.fromAmount).lte(0)) {
+      return [new TransactionError(BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')];
+    }
+    const actionList = process.steps.map(step => step.type);
+    const [firstStep, secondStep, thirdStep, fourthStep, fifthStep] = actionList;
+    const swap = firstStep === CommonStepType.DEFAULT && secondStep === SwapStepType.SWAP && !thirdStep;
+    const swapXcm = firstStep === CommonStepType.DEFAULT && secondStep === SwapStepType.SWAP && thirdStep === CommonStepType.XCM && !fourthStep;
+    const xcmSwap = firstStep === CommonStepType.DEFAULT && secondStep === CommonStepType.XCM && thirdStep === SwapStepType.SWAP && !fourthStep;
+    const xcmSwapXcm = firstStep === CommonStepType.DEFAULT && secondStep === CommonStepType.XCM && thirdStep === SwapStepType.SWAP && fourthStep === CommonStepType.XCM && !fifthStep;
+    if (swap) {
+      return this.swapBaseHandler.validateSwapOnlyProcess(params, 1); // todo: create interface for input request
+    }
+
+    if (swapXcm) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (xcmSwap) {
+      return this.swapBaseHandler.validateXcmSwapProcess(params, 2, 1);
+    }
+    if (xcmSwapXcm) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+  }
 }

package/services/swap-service/handler/asset-hub/utils.js

@@ -128,6 +128,9 @@ export const checkMinAmountForPath = (reserves, amounts, minAmounts) => {
 export const buildSwapExtrinsic = (api, paths, recipient, amountIn, amountOutMin, keepAlive = true) => {
   const pathsInfo = paths.map(asset => {
     const multilocation = _getXcmAssetMultilocation(asset);
+    if (!multilocation) {
+      throw new Error('Error getting multilocation');
+    }
     return api.createType('MultiLocation', multilocation).toU8a();
   });
   return api.tx.assetConversion.swapExactTokensForTokens(pathsInfo, amountIn, amountOutMin, recipient, keepAlive);

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

@@ -2,13 +2,16 @@ import { TransactionError } from '@subwallet/extension-base/background/errors/Tr
 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 { BaseStepDetail, CommonOptimalPath, CommonStepFeeInfo } from '@subwallet/extension-base/types/service-base';
+import { GenSwapStepFuncV2, OptimalSwapPathParamsV2 } from '@subwallet/extension-base/types';
+import { BaseStepDetail, CommonOptimalSwapPath, CommonStepFeeInfo } from '@subwallet/extension-base/types/service-base';
 import { GenSwapStepFunc, OptimalSwapPathParams, SwapProvider, SwapProviderId, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types/swap';
 export interface SwapBaseInterface {
     providerSlug: SwapProviderId;
-    generateOptimalProcess: (params: OptimalSwapPathParams) => Promise<CommonOptimalPath>;
+    generateOptimalProcess: (params: OptimalSwapPathParams) => Promise<CommonOptimalSwapPath>;
+    generateOptimalProcessV2: (params: OptimalSwapPathParamsV2) => Promise<CommonOptimalSwapPath>;
     getSubmitStep: (params: OptimalSwapPathParams) => Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
     validateSwapProcess: (params: ValidateSwapProcessParams) => Promise<TransactionError[]>;
+    validateSwapProcessV2: (params: ValidateSwapProcessParams) => Promise<TransactionError[]>;
     handleSwapProcess: (params: SwapSubmitParams) => Promise<SwapSubmitStepData>;
     handleSubmitStep: (params: SwapSubmitParams) => Promise<SwapSubmitStepData>;
     isReady?: boolean;
@@ -28,11 +31,17 @@ export declare class SwapBaseHandler {
     balanceService: BalanceService;
     feeService: FeeService;
     constructor({ balanceService, chainService, feeService, providerName, providerSlug }: SwapBaseHandlerInitParams);
-    generateOptimalProcess(params: OptimalSwapPathParams, genStepFuncList: GenSwapStepFunc[]): Promise<CommonOptimalPath>;
+    generateOptimalProcess(params: OptimalSwapPathParams, genStepFuncList: GenSwapStepFunc[]): Promise<CommonOptimalSwapPath>;
+    generateOptimalProcessV2(params: OptimalSwapPathParamsV2, genStepFuncList: GenSwapStepFuncV2[]): Promise<CommonOptimalSwapPath>;
     validateXcmStep(params: ValidateSwapProcessParams, stepIndex: number): Promise<TransactionError[]>;
+    validateXcmStepV2(params: ValidateSwapProcessParams, stepIndex: number): Promise<TransactionError[]>;
     validateTokenApproveStep(params: ValidateSwapProcessParams, stepIndex: number): Promise<TransactionError[]>;
     validateSetFeeTokenStep(params: ValidateSwapProcessParams, stepIndex: number): Promise<TransactionError[]>;
     validateSwapStep(params: ValidateSwapProcessParams, isXcmOk: boolean, stepIndex: number): Promise<TransactionError[]>;
+    private validateBridgeStep;
+    private validateSwapStepV2;
+    validateSwapOnlyProcess(params: ValidateSwapProcessParams, swapIndex: number): Promise<TransactionError[]>;
+    validateXcmSwapProcess(params: ValidateSwapProcessParams, swapIndex: number, xcmIndex: number): Promise<TransactionError[]>;
     get name(): string;
     get slug(): string;
     get providerInfo(): SwapProvider;