@subwallet/extension-base 1.1.53-beta.0 → 1.1.55-0

package/services/chain-service/index.js

@@ -9,7 +9,7 @@ import { MantaPrivateHandler } from '@subwallet/extension-base/services/chain-se
 import { SubstrateChainHandler } from '@subwallet/extension-base/services/chain-service/handler/SubstrateChainHandler';
 import { _CHAIN_VALIDATION_ERROR } from '@subwallet/extension-base/services/chain-service/handler/types';
 import { _ChainConnectionStatus, _CUSTOM_PREFIX, _NFT_CONTRACT_STANDARDS, _SMART_CONTRACT_STANDARDS } from '@subwallet/extension-base/services/chain-service/types';
-import { _isAssetAutoEnable, _isAssetFungibleToken, _isChainEnabled, _isCustomAsset, _isCustomChain, _isCustomProvider, _isEqualContractAddress, _isEqualSmartContractAsset, _isMantaZkAsset, _isPureEvmChain, _isPureSubstrateChain, _parseAssetRefKey, fetchPatchData, randomizeProvider, updateLatestChainInfo } from '@subwallet/extension-base/services/chain-service/utils';
+import { _isAssetAutoEnable, _isAssetCanPayTxFee, _isAssetFungibleToken, _isChainEnabled, _isCustomAsset, _isCustomChain, _isCustomProvider, _isEqualContractAddress, _isEqualSmartContractAsset, _isMantaZkAsset, _isPureEvmChain, _isPureSubstrateChain, _parseAssetRefKey, fetchPatchData, randomizeProvider, updateLatestChainInfo } from '@subwallet/extension-base/services/chain-service/utils';
 import AssetSettingStore from '@subwallet/extension-base/stores/AssetSetting';
 import { addLazy, fetchStaticData, filterAssetsByChainAndType, MODULE_SUPPORT } from '@subwallet/extension-base/utils';
 import { BehaviorSubject, Subject } from 'rxjs';
@@ -609,15 +609,6 @@ export class ChainService {
       }
     }));
   }
-  async initSingleApi(slug) {
-    const chainInfoMap = this.getChainInfoMap();
-    const chainStateMap = this.getChainStateMap();
-    if (!chainStateMap[slug].active) {
-      return false;
-    }
-    await this.initApiForChain(chainInfoMap[slug]);
-    return true;
-  }
   async initApiForChain(chainInfo) {
     const {
       endpoint,
@@ -1634,4 +1625,9 @@ export class ChainService {
     }
     return result;
   }
+  getFeeTokensByChain(chainSlug) {
+    return Object.values(this.getAssetRegistry()).filter(chainAsset => {
+      return chainAsset.originChain === chainSlug && (chainAsset.assetType === _AssetType.NATIVE || _isAssetCanPayTxFee(chainAsset));
+    }).map(chainAsset => chainAsset.slug);
+  }
 }

package/services/chain-service/utils/index.d.ts

@@ -75,6 +75,7 @@ export declare function randomizeProvider(providers: Record<string, string>, exc
     providerKey: string;
     providerValue: string;
 };
+export declare function _isAssetCanPayTxFee(chainAsset: _ChainAsset): boolean;
 export declare function updateLatestChainInfo(currentDataMap: _DataMap, latestChainInfoList: _ChainInfo[]): {
     storedChainInfoList: IChain[];
     needUpdateChainApiList: _ChainInfo[];

package/services/chain-service/utils/index.js

@@ -398,6 +398,10 @@ export function randomizeProvider(providers, excludedKeys) {
     providerValue: selectedProviderValue
   };
 }
+export function _isAssetCanPayTxFee(chainAsset) {
+  var _ref, _chainAsset$metadata;
+  return (_ref = (_chainAsset$metadata = chainAsset.metadata) === null || _chainAsset$metadata === void 0 ? void 0 : _chainAsset$metadata.canPayTxFee) !== null && _ref !== void 0 ? _ref : false;
+}
 export function updateLatestChainInfo(currentDataMap, latestChainInfoList) {
   const currentChainInfoMap = currentDataMap.chainInfoMap;
   const currentChainStateMap = currentDataMap.chainStateMap;

package/services/chain-service/utils/patch.js

@@ -5,7 +5,7 @@ import fetch from 'cross-fetch';
 const PRODUCTION_BRANCHES = ['master', 'webapp', 'webapp-dev'];
 const branchName = process.env.BRANCH_NAME || 'subwallet-dev';
 const fetchDomain = PRODUCTION_BRANCHES.indexOf(branchName) > -1 ? 'https://chain-list-assets.subwallet.app' : 'https://dev.sw-chain-list-assets.pages.dev';
-const ChainListVersion = '0.2.55-beta.3';
+const ChainListVersion = '0.2.55';
 export async function fetchPatchData(slug) {
   try {
     const fetchPromise = fetch(`${fetchDomain}/patch/${ChainListVersion}/${slug}`);

package/services/migration-service/scripts/MigrateTransactionHistoryBySymbol.js

@@ -7,23 +7,10 @@ export default class MigrateTransactionHistoryBySymbol extends BaseMigrationJob
     const state = this.state;
     try {
       const changeSlugsMap = {
-        'ethereum-ERC20-WFTM-0x4E15361FD6b4BB609Fa63C81A2be19d873717870': 'ethereum-ERC20-FTM-0x4E15361FD6b4BB609Fa63C81A2be19d873717870',
-        'moonbeam-ERC20-CSG-0x2Dfc76901bB2ac2A5fA5fc479590A490BBB10a5F': 'moonbeam-ERC20-CGS-0x2Dfc76901bB2ac2A5fA5fc479590A490BBB10a5F',
-        'astar-LOCAL-aUSD': 'astar-LOCAL-aSEED',
-        'astarEvm-ERC20-aUSD-0xfFFFFfFF00000000000000010000000000000001': 'astarEvm-ERC20-aSEED-0xfFFFFfFF00000000000000010000000000000001',
-        'moonriver-LOCAL-xcaUSD': 'moonriver-LOCAL-xcaSeed',
-        'moonriver-LOCAL-xckBTC': 'moonriver-LOCAL-xcKBTC',
-        'bifrost-LOCAL-aUSD': 'bifrost-LOCAL-KUSD',
-        'calamari-LOCAL-aUSD': 'calamari-LOCAL-AUSD',
-        'shiden-LOCAL-aUSD': 'shiden-LOCAL-aSEED',
-        'shidenEvm-ERC20-aUSD-0xfFFfFFfF00000000000000010000000000000000': 'shidenEvm-ERC20-aSEED-0xfFFfFFfF00000000000000010000000000000000',
-        'ethereum_goerli-NATIVE-GoerliETH': 'ethereum_goerli-NATIVE-ETH',
-        'binance_test-NATIVE-BNB': 'binance_test-NATIVE-tBNB',
-        'pangolin-LOCAL-CKTON': 'pangolin-LOCAL-PKTON',
-        'zeta_test-NATIVE-aZETA': 'zeta_test-NATIVE-ZETA',
-        'origintrail-NATIVE-OTP': 'origintrail-NATIVE-NEURO',
-        'moonbeam-LOCAL-xciBTC': 'moonbeam-LOCAL-xcIBTC',
-        'tomochain-NATIVE-TOMO': 'tomochain-NATIVE-VIC'
+        'moonbeam-LOCAL-xcaUSD': 'moonbeam-LOCAL-xcaSEED',
+        'calamari-LOCAL-AUSD': 'calamari-LOCAL-aSEED',
+        'moonriver-LOCAL-xcaSeed': 'moonriver-LOCAL-xcaSEED',
+        'bifrost-LOCAL-KUSD': 'bifrost-LOCAL-aSEED'
       };
       const allTxs = [];
       await Promise.all(Object.entries(changeSlugsMap).map(async ([oldSlug, newSlug], i) => {

package/services/migration-service/scripts/databases/MigrateAssetSetting.js

@@ -6,23 +6,10 @@ export default class MigrateAssetSetting extends BaseMigrationJob {
   async run() {
     try {
       const changeSlugsMap = {
-        'ethereum-ERC20-WFTM-0x4E15361FD6b4BB609Fa63C81A2be19d873717870': 'ethereum-ERC20-FTM-0x4E15361FD6b4BB609Fa63C81A2be19d873717870',
-        'moonbeam-ERC20-CSG-0x2Dfc76901bB2ac2A5fA5fc479590A490BBB10a5F': 'moonbeam-ERC20-CGS-0x2Dfc76901bB2ac2A5fA5fc479590A490BBB10a5F',
-        'astar-LOCAL-aUSD': 'astar-LOCAL-aSEED',
-        'astarEvm-ERC20-aUSD-0xfFFFFfFF00000000000000010000000000000001': 'astarEvm-ERC20-aSEED-0xfFFFFfFF00000000000000010000000000000001',
-        'moonriver-LOCAL-xcaUSD': 'moonriver-LOCAL-xcaSeed',
-        'moonriver-LOCAL-xckBTC': 'moonriver-LOCAL-xcKBTC',
-        'bifrost-LOCAL-aUSD': 'bifrost-LOCAL-KUSD',
-        'calamari-LOCAL-aUSD': 'calamari-LOCAL-AUSD',
-        'shiden-LOCAL-aUSD': 'shiden-LOCAL-aSEED',
-        'shidenEvm-ERC20-aUSD-0xfFFfFFfF00000000000000010000000000000000': 'shidenEvm-ERC20-aSEED-0xfFFfFFfF00000000000000010000000000000000',
-        'ethereum_goerli-NATIVE-GoerliETH': 'ethereum_goerli-NATIVE-ETH',
-        'binance_test-NATIVE-BNB': 'binance_test-NATIVE-tBNB',
-        'pangolin-LOCAL-CKTON': 'pangolin-LOCAL-PKTON',
-        'zeta_test-NATIVE-aZETA': 'zeta_test-NATIVE-ZETA',
-        'origintrail-NATIVE-OTP': 'origintrail-NATIVE-NEURO',
-        'moonbeam-LOCAL-xciBTC': 'moonbeam-LOCAL-xcIBTC',
-        'tomochain-NATIVE-TOMO': 'tomochain-NATIVE-VIC'
+        'moonbeam-LOCAL-xcaUSD': 'moonbeam-LOCAL-xcaSEED',
+        'calamari-LOCAL-AUSD': 'calamari-LOCAL-aSEED',
+        'moonriver-LOCAL-xcaSeed': 'moonriver-LOCAL-xcaSEED',
+        'bifrost-LOCAL-KUSD': 'bifrost-LOCAL-aSEED'
       };
       const assetSetting = await this.state.chainService.getAssetSettings();
       const migratedAssetSetting = {};

package/services/migration-service/scripts/index.js

@@ -47,9 +47,9 @@ export default {
   '1.1.26-01': MigratePolygonUSDCProvider,
   '1.1.28-01': MigrateEarningVersion,
   '1.1.41-01': DeleteChainStaking,
-  '1.1.44-01': MigrateAssetSetting,
-  '1.1.45-01': MigrateTransactionHistoryBySymbol,
-  '1.1.46-01': AutoEnableSomeTokens
+  '1.1.46-01': AutoEnableSomeTokens,
+  '1.1.53-01': MigrateAssetSetting,
+  '1.1.53-02': MigrateTransactionHistoryBySymbol
   // [`${EVERYTIME}-1.1.42-02`]: MigrateTransactionHistoryBySymbol
   // [`${EVERYTIME}-1`]: AutoEnableChainsTokens
 };

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

@@ -96,7 +96,19 @@ export class SwapBaseHandler {
     return Promise.resolve([]);
   }
   async validateSetFeeTokenStep(params, stepIndex) {
-    return Promise.resolve([]);
+    if (!params.selectedQuote) {
+      return Promise.resolve([new TransactionError(BasicTxErrorType.INTERNAL_ERROR)]);
+    }
+    const feeInfo = params.process.totalFee[stepIndex];
+    const feeAmount = feeInfo.feeComponent[0];
+    const feeTokenInfo = this.chainService.getAssetBySlug(feeInfo.defaultFeeToken);
+    const feeTokenBalance = await this.balanceService.getTokenFreeBalance(params.address, feeTokenInfo.originChain, feeTokenInfo.slug);
+    const bnFeeTokenBalance = new BigNumber(feeTokenBalance.value);
+    const bnFeeAmount = new BigNumber(feeAmount.amount);
+    if (bnFeeAmount.gte(bnFeeTokenBalance)) {
+      return Promise.resolve([new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE)]);
+    }
+    return [];
   }
   async validateSwapStep(params, isXcmOk, stepIndex) {
     if (!params.selectedQuote) {
@@ -119,9 +131,15 @@ export class SwapBaseHandler {
     const [feeTokenBalance, fromAssetBalance] = await Promise.all([this.balanceService.getTokenFreeBalance(params.address, feeTokenInfo.originChain, feeTokenInfo.slug), this.balanceService.getTokenFreeBalance(params.address, fromAsset.originChain, fromAsset.slug)]);
     const bnFeeTokenBalance = new BigNumber(feeTokenBalance.value);
     const bnFromAssetBalance = new BigNumber(fromAssetBalance.value);
-    if (bnFeeTokenBalance.lte(new BigNumber(networkFee.amount))) {
+    const bnFeeAmount = new BigNumber(networkFee.amount);
+    if (bnFeeTokenBalance.lte(bnFeeAmount)) {
       return Promise.resolve([new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE, `You don't have enough ${feeTokenInfo.symbol} (${feeTokenChain.name}) to pay transaction fee`)]);
     }
+    if (fromAsset.slug === feeTokenInfo.slug) {
+      if (bnFromAssetBalance.lte(bnFeeAmount.plus(bnAmount))) {
+        return Promise.resolve([new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE, `Insufficient balance. Deposit ${fromAsset.symbol} and try again.`)]);
+      }
+    }
     if (params.selectedQuote.minSwap) {
       const minProtocolSwap = new BigNumber(params.selectedQuote.minSwap);
       if (!isXcmOk && bnFromAssetBalance.lte(minProtocolSwap)) {

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

@@ -1,4 +1,3 @@
-import { COMMON_CHAIN_SLUGS } from '@subwallet/chain-list';
 import { SwapError } from '@subwallet/extension-base/background/errors/SwapError';
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { BalanceService } from '@subwallet/extension-base/services/balance-service';
@@ -13,7 +12,7 @@ export declare class HydradxHandler implements SwapBaseInterface {
     isReady: boolean;
     constructor(chainService: ChainService, balanceService: BalanceService, isTestnet?: boolean);
     init(): Promise<void>;
-    get chain(): COMMON_CHAIN_SLUGS.HYDRADX | COMMON_CHAIN_SLUGS.HYDRADX_TESTNET;
+    chain: () => string;
     get chainService(): ChainService;
     get balanceService(): BalanceService;
     get providerInfo(): import("@subwallet/extension-base/types/swap").SwapProvider;
@@ -27,6 +26,7 @@ export declare class HydradxHandler implements SwapBaseInterface {
     private parseSwapPath;
     getSwapQuote(request: SwapRequest): Promise<SwapQuote | SwapError>;
     handleXcmStep(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
+    handleSetFeeStep(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
     handleSubmitStep(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
     handleSwapProcess(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
     validateSwapProcess(params: ValidateSwapProcessParams): Promise<TransactionError[]>;

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

@@ -19,9 +19,9 @@ const HYDRADX_SUBWALLET_REFERRAL_ACCOUNT = '7PCsCpkgsHdNaZhv79wCCQ5z97uxVbSeSCtD
 const HYDRADX_TESTNET_SUBWALLET_REFERRAL_CODE = 'ASSETHUB';
 const HYDRADX_TESTNET_SUBWALLET_REFERRAL_ACCOUNT = '7LCt6dFqtxzdKVB2648jWW9d85doiFfLSbZJDNAMVJNxh5rJ';
 export class HydradxHandler {
+  isTestnet = true;
   isReady = false;
   constructor(chainService, balanceService, isTestnet = true) {
-    // todo: pass in baseHandler from service
     this.swapBaseHandler = new SwapBaseHandler({
       balanceService,
       chainService,
@@ -31,24 +31,24 @@ export class HydradxHandler {
     this.isTestnet = isTestnet;
   }
   async init() {
-    const chainState = this.chainService.getChainStateByKey(this.chain);
+    const chainState = this.chainService.getChainStateByKey(this.chain());
     if (!chainState.active) {
-      await this.chainService.enableChain(this.chain);
+      await this.chainService.enableChain(this.chain());
     }
-    const substrateApi = this.chainService.getSubstrateApi(this.chain);
+    const substrateApi = this.chainService.getSubstrateApi(this.chain());
     await substrateApi.api.isReady;
     const poolService = new PoolService(substrateApi.api);
     this.tradeRouter = new TradeRouter(poolService);
     this.isReady = true;
   }
-  get chain() {
+  chain = () => {
     // TODO: check origin chain of tokens in swap pair to determine support
     if (!this.isTestnet) {
       return COMMON_CHAIN_SLUGS.HYDRADX;
     } else {
       return COMMON_CHAIN_SLUGS.HYDRADX_TESTNET;
     }
-  }
+  };
   get chainService() {
     return this.swapBaseHandler.chainService;
   }
@@ -120,7 +120,44 @@ export class HydradxHandler {
     }
   }
   async getFeeOptionStep(params) {
-    return Promise.resolve(undefined);
+    if (!params.selectedQuote) {
+      return Promise.resolve(undefined);
+    }
+    const selectedFeeToken = params.selectedQuote.feeInfo.selectedFeeToken;
+    if (!selectedFeeToken) {
+      return undefined;
+    }
+    const feeStep = {
+      name: 'Set fee token',
+      type: SwapStepType.SET_FEE_TOKEN
+    };
+    try {
+      const substrateApi = this.chainService.getSubstrateApi(this.chain());
+      const chainApi = await substrateApi.isReady;
+      const _currentFeeAssetId = await chainApi.api.query.multiTransactionPayment.accountCurrencyMap(params.request.address);
+      const currentFeeAssetId = _currentFeeAssetId.toString();
+      const selectedFeeAsset = this.chainService.getAssetBySlug(selectedFeeToken);
+      const assetId = _getTokenOnChainAssetId(selectedFeeAsset);
+      if (currentFeeAssetId === assetId) {
+        return;
+      }
+      const setFeeTx = chainApi.api.tx.multiTransactionPayment.setCurrency(assetId);
+      const _txFee = await setFeeTx.paymentInfo(params.request.address);
+      const txFee = _txFee.toPrimitive();
+      const fee = {
+        feeComponent: [{
+          feeType: SwapFeeType.NETWORK_FEE,
+          amount: Math.round(txFee.partialFee).toString(),
+          tokenSlug: selectedFeeAsset.slug
+        }],
+        selectedFeeToken: selectedFeeAsset.slug,
+        defaultFeeToken: selectedFeeAsset.slug,
+        feeOptions: [selectedFeeAsset.slug]
+      };
+      return [feeStep, fee];
+    } catch (e) {
+      return undefined;
+    }
   }
   async getSubmitStep(params) {
     if (params.selectedQuote) {
@@ -133,7 +170,9 @@ export class HydradxHandler {
     return Promise.resolve(undefined);
   }
   generateOptimalProcess(params) {
-    return this.swapBaseHandler.generateOptimalProcess(params, [this.getXcmStep, this.getFeeOptionStep, this.getSubmitStep]);
+    return this.swapBaseHandler.generateOptimalProcess(params, [this.getXcmStep,
+    // this.getFeeOptionStep.bind(this),
+    this.getSubmitStep]);
   }
   getSwapPathErrors(swapList) {
     return swapList.reduce((prev, current) => {
@@ -141,7 +180,7 @@ export class HydradxHandler {
     }, []);
   }
   parseSwapPath(swapList) {
-    const swapAssets = this.chainService.getAssetByChainAndType(this.chain, [_AssetType.NATIVE, _AssetType.LOCAL]);
+    const swapAssets = this.chainService.getAssetByChainAndType(this.chain(), [_AssetType.NATIVE, _AssetType.LOCAL]);
     const swapAssetIdMap = Object.values(swapAssets).reduce((accumulator, asset) => {
       return {
         ...accumulator,
@@ -185,7 +224,7 @@ export class HydradxHandler {
       const toAmount = quoteResponse.amountOut;
       const minReceive = toAmount.times(1 - request.slippage).integerValue();
       const txHex = quoteResponse.toTx(minReceive).hex;
-      const substrateApi = this.chainService.getSubstrateApi(this.chain);
+      const substrateApi = this.chainService.getSubstrateApi(this.chain());
       const extrinsic = substrateApi.api.tx(txHex);
       const paymentInfo = await extrinsic.paymentInfo(request.address);
       const networkFee = {
@@ -217,6 +256,16 @@ export class HydradxHandler {
             return new SwapError(SwapErrorType.NOT_ENOUGH_LIQUIDITY);
         }
       }
+
+      // const feeTokenOptions = this.chainService.getFeeTokensByChain(this.chain());
+      const feeTokenOptions = [fromChainNativeTokenSlug];
+
+      // if (request.feeToken && !feeTokenOptions.includes(request.feeToken)) {
+      //   return new SwapError(SwapErrorType.UNKNOWN);
+      // }
+
+      // const selectedFeeToken = request.feeToken || fromChainNativeTokenSlug;
+      const selectedFeeToken = fromChainNativeTokenSlug;
       return {
         pair: request.pair,
         fromAmount: request.fromAmount,
@@ -227,9 +276,10 @@ export class HydradxHandler {
         feeInfo: {
           feeComponent: [networkFee, tradeFee],
           defaultFeeToken: fromChainNativeTokenSlug,
-          feeOptions: [fromChainNativeTokenSlug] // todo: parse fee options
+          feeOptions: feeTokenOptions,
+          // TODO: enable fee options
+          selectedFeeToken
         },
-
         isLowLiquidity: Math.abs(quoteResponse.priceImpactPct) >= HYDRADX_LOW_LIQUIDITY_THRESHOLD,
         route: swapRoute,
         metadata: txHex
@@ -281,10 +331,34 @@ export class HydradxHandler {
       txData: xcmData
     };
   }
+  async handleSetFeeStep(params) {
+    var _swapFeeInfo$selected;
+    const substrateApi = this.chainService.getSubstrateApi(this.chain());
+    const chainApi = await substrateApi.isReady;
+    const swapStepIndex = params.process.steps.findIndex(step => step.type === SwapStepType.SWAP);
+    if (swapStepIndex <= -1) {
+      return Promise.reject(new TransactionError(BasicTxErrorType.INTERNAL_ERROR));
+    }
+    const swapFeeInfo = params.process.totalFee[swapStepIndex];
+    const selectedFeeTokenSlug = (_swapFeeInfo$selected = swapFeeInfo.selectedFeeToken) !== null && _swapFeeInfo$selected !== void 0 ? _swapFeeInfo$selected : swapFeeInfo.defaultFeeToken;
+    const selectedFeeAsset = this.chainService.getAssetBySlug(selectedFeeTokenSlug);
+    const extrinsic = chainApi.api.tx.multiTransactionPayment.setCurrency(_getTokenOnChainAssetId(selectedFeeAsset));
+    const txData = {
+      selectedFeeToken: selectedFeeTokenSlug
+    };
+    return {
+      txChain: this.chain(),
+      extrinsic,
+      // extrinsicType: ExtrinsicType.SET_FEE_TOKEN,
+      extrinsicType: ExtrinsicType.SWAP,
+      chainType: ChainType.SUBSTRATE,
+      txData
+    };
+  }
   async handleSubmitStep(params) {
     const txHex = params.quote.metadata;
     const fromAsset = this.chainService.getAssetBySlug(params.quote.pair.from);
-    const substrateApi = this.chainService.getSubstrateApi(this.chain);
+    const substrateApi = this.chainService.getSubstrateApi(this.chain());
     const chainApi = await substrateApi.isReady;
     const txData = {
       provider: this.providerInfo,
@@ -295,12 +369,25 @@ export class HydradxHandler {
       process: params.process
     };
     let extrinsic;
+    const txList = [];
+    const swapTx = chainApi.api.tx(txHex);
     const _referral = await chainApi.api.query.referrals.linkedAccounts(params.address);
     const referral = _referral === null || _referral === void 0 ? void 0 : _referral.toString();
-    if (!referral || referral === '') {
-      extrinsic = chainApi.api.tx.utility.batchAll([chainApi.api.tx.referrals.linkCode(this.referralCode), chainApi.api.tx(txHex)]);
+    const needSetReferral = !referral || referral === '';
+    const steps = params.process.steps.map(step => step.type);
+    const needSetFeeToken = steps.includes(SwapStepType.SET_FEE_TOKEN);
+    if (!needSetReferral && !needSetFeeToken) {
+      extrinsic = swapTx;
     } else {
-      extrinsic = chainApi.api.tx(txHex);
+      if (needSetReferral) {
+        txList.push(chainApi.api.tx.referrals.linkCode(this.referralCode));
+      }
+      if (needSetFeeToken) {
+        const nativeTokenInfo = this.chainService.getNativeTokenInfo(this.chain());
+        txList.push(chainApi.api.tx.multiTransactionPayment.setCurrency(_getTokenOnChainAssetId(nativeTokenInfo)));
+      }
+      txList.push(swapTx);
+      extrinsic = chainApi.api.tx.utility.batchAll(txList);
     }
     return {
       txChain: fromAsset.originChain,
@@ -324,7 +411,7 @@ export class HydradxHandler {
       case SwapStepType.XCM:
         return this.handleXcmStep(params);
       case SwapStepType.SET_FEE_TOKEN:
-        return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
+        return this.handleSetFeeStep(params);
       case SwapStepType.SWAP:
         return this.handleSubmitStep(params);
       default:
@@ -393,7 +480,7 @@ export class HydradxHandler {
           error: SwapErrorType.ASSET_NOT_SUPPORTED
         };
       }
-      if (!(fromAsset.originChain === this.chain && toAsset.originChain === this.chain)) {
+      if (!(fromAsset.originChain === this.chain() && toAsset.originChain === this.chain())) {
         return {
           error: SwapErrorType.ASSET_NOT_SUPPORTED
         };
@@ -411,7 +498,7 @@ export class HydradxHandler {
       }
       return {
         metadata: {
-          chain: this.chainService.getChainInfoByKey(this.chain)
+          chain: this.chainService.getChainInfoByKey(this.chain())
         }
       };
     } catch (e) {

package/services/swap-service/index.js

@@ -84,6 +84,7 @@ export class SwapService {
       request,
       selectedQuote: swapQuoteResponse.optimalQuote
     });
+    console.log('optimalProcess', optimalProcess);
     return {
       process: optimalProcess,
       quote: swapQuoteResponse

package/types/swap/index.d.ts

@@ -74,6 +74,7 @@ export interface SwapFeeInfo {
     feeComponent: SwapFeeComponent[];
     defaultFeeToken: string;
     feeOptions: string[];
+    selectedFeeToken?: string;
 }
 export interface SwapStepDetail extends BaseStepDetail {
     id: number;
@@ -119,6 +120,7 @@ export interface SwapRequest {
     fromAmount: string;
     slippage: number;
     recipient?: string;
+    feeToken?: string;
 }
 export interface SwapRequestResult {
     process: OptimalSwapPath;