@subwallet/extension-base 1.3.16-0 → 1.3.18-0

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

@@ -2,64 +2,84 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { GAS_PRICE_RATIO, NETWORK_MULTI_GAS_FEE } from '@subwallet/extension-base/constants';
+import { estimateTokensForPool, getReserveForPool } from '@subwallet/extension-base/services/swap-service/handler/asset-hub/utils';
 import { BN_WEI, BN_ZERO } from '@subwallet/extension-base/utils';
 import BigN from 'bignumber.js';
 import { POLYGON_GAS_INDEXER } from "../../balance-service/transfer/xcm/polygonBridge.js";
 const INFURA_API_KEY = process.env.INFURA_API_KEY || '';
 const INFURA_API_KEY_SECRET = process.env.INFURA_API_KEY_SECRET || '';
 const INFURA_AUTH = 'Basic ' + Buffer.from(INFURA_API_KEY + ':' + INFURA_API_KEY_SECRET).toString('base64');
-export const parseInfuraFee = info => {
+export const FEE_COVERAGE_PERCENTAGE_SPECIAL_CASE = 105; // percentage
+
+export const parseInfuraFee = (info, threshold) => {
   const base = new BigN(info.estimatedBaseFee).multipliedBy(BN_WEI);
-  const low = new BigN(info.low.suggestedMaxPriorityFeePerGas).multipliedBy(BN_WEI);
-  const busyNetwork = base.gt(BN_ZERO) ? low.dividedBy(base).gte(0.3) : false;
-  const data = !busyNetwork ? info.low : info.medium;
+  const thresholdBN = new BigN(threshold.busyThreshold).multipliedBy(BN_WEI);
+  const busyNetwork = thresholdBN.gte(BN_ZERO) ? base.gt(thresholdBN) : false;
   return {
     busyNetwork,
     gasPrice: undefined,
-    baseGasFee: base,
-    maxFeePerGas: new BigN(data.suggestedMaxFeePerGas).multipliedBy(BN_WEI).integerValue(BigN.ROUND_UP),
-    maxPriorityFeePerGas: new BigN(data.suggestedMaxPriorityFeePerGas).multipliedBy(BN_WEI).integerValue(BigN.ROUND_UP)
+    baseGasFee: base.toFixed(0),
+    type: 'evm',
+    options: {
+      slow: {
+        maxFeePerGas: new BigN(info.low.suggestedMaxFeePerGas).multipliedBy(BN_WEI).integerValue(BigN.ROUND_UP).toFixed(0),
+        maxPriorityFeePerGas: new BigN(info.low.suggestedMaxPriorityFeePerGas).multipliedBy(BN_WEI).integerValue(BigN.ROUND_UP).toFixed(0),
+        maxWaitTimeEstimate: info.low.maxWaitTimeEstimate || 0,
+        minWaitTimeEstimate: info.low.minWaitTimeEstimate || 0
+      },
+      average: {
+        maxFeePerGas: new BigN(info.medium.suggestedMaxFeePerGas).multipliedBy(BN_WEI).integerValue(BigN.ROUND_UP).toFixed(0),
+        maxPriorityFeePerGas: new BigN(info.medium.suggestedMaxPriorityFeePerGas).multipliedBy(BN_WEI).integerValue(BigN.ROUND_UP).toFixed(0),
+        maxWaitTimeEstimate: info.medium.maxWaitTimeEstimate || 0,
+        minWaitTimeEstimate: info.medium.minWaitTimeEstimate || 0
+      },
+      fast: {
+        maxFeePerGas: new BigN(info.high.suggestedMaxFeePerGas).multipliedBy(BN_WEI).integerValue(BigN.ROUND_UP).toFixed(0),
+        maxPriorityFeePerGas: new BigN(info.high.suggestedMaxPriorityFeePerGas).multipliedBy(BN_WEI).integerValue(BigN.ROUND_UP).toFixed(0),
+        maxWaitTimeEstimate: info.high.maxWaitTimeEstimate || 0,
+        minWaitTimeEstimate: info.high.minWaitTimeEstimate || 0
+      },
+      default: busyNetwork ? 'average' : 'slow'
+    }
   };
 };
 export const fetchInfuraFeeData = async (chainId, infuraAuth) => {
-  return await new Promise(resolve => {
-    const baseUrl = 'https://gas.api.infura.io/networks/{{chainId}}/suggestedGasFees';
-    const url = baseUrl.replaceAll('{{chainId}}', chainId.toString());
-    fetch(url, {
-      method: 'GET',
-      headers: {
-        Authorization: infuraAuth || INFURA_AUTH
-      }
-    }).then(rs => {
-      return rs.json();
-    }).then(info => {
-      resolve(parseInfuraFee(info));
-    }).catch(e => {
-      console.warn(e);
-      resolve(null);
-    });
-  });
+  const baseUrl = 'https://gas.api.infura.io/networks/{{chainId}}/suggestedGasFees';
+  const baseThressholdUrl = 'https://gas.api.infura.io/networks/{{chainId}}/busyThreshold';
+  // const baseFeeHistoryUrl = 'https://gas.api.infura.io/networks/{{chainId}}/baseFeeHistory';
+  // const baseFeePercentileUrl = 'https://gas.api.infura.io/networks/{{chainId}}/baseFeePercentile';
+  const feeUrl = baseUrl.replaceAll('{{chainId}}', chainId.toString());
+  const thressholdUrl = baseThressholdUrl.replaceAll('{{chainId}}', chainId.toString());
+  try {
+    const [feeResp, thressholdResp] = await Promise.all([feeUrl, thressholdUrl].map(url => {
+      return fetch(url, {
+        method: 'GET',
+        headers: {
+          Authorization: INFURA_AUTH
+        }
+      });
+    }));
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const [feeInfo, thresholdInfo] = await Promise.all([feeResp.json(), thressholdResp.json()]);
+    return parseInfuraFee(feeInfo, thresholdInfo);
+  } catch (e) {
+    console.warn(e);
+    return null;
+  }
 };
 export const fetchSubWalletFeeData = async (chainId, networkKey) => {
   return await new Promise(resolve => {
     const baseUrl = 'https://api-cache.subwallet.app/sw-evm-gas/{{chain}}';
     const url = baseUrl.replaceAll('{{chain}}', networkKey);
+
+    // TODO: Update the logo to follow the new estimateFee format or move the logic to the backend
     fetch(url, {
       method: 'GET'
     }).then(rs => {
       return rs.json();
     }).then(info => {
-      if (info.gasPrice !== undefined) {
-        resolve(info);
-      } else {
-        resolve({
-          busyNetwork: info.busyNetwork,
-          gasPrice: info.gasPrice,
-          baseGasFee: new BigN(info.baseGasFee),
-          maxFeePerGas: new BigN(info.maxFeePerGas),
-          maxPriorityFeePerGas: new BigN(info.maxPriorityFeePerGas)
-        });
-      }
+      resolve(info);
     }).catch(e => {
       console.warn(e);
       resolve(null);
@@ -81,7 +101,17 @@ export const recalculateGasPrice = (_price, chain) => {
   const needMulti = NETWORK_MULTI_GAS_FEE.includes(chain) || NETWORK_MULTI_GAS_FEE.includes('*');
   return needMulti ? new BigN(_price).multipliedBy(GAS_PRICE_RATIO).toFixed(0) : _price;
 };
-export const calculateGasFeeParams = async (web3, networkKey, useOnline = true, useInfura = false) => {
+export const getEIP1559GasFee = (baseFee, maxPriorityFee, blockNumber, blockTime) => {
+  // https://www.blocknative.com/blog/eip-1559-fees
+  const maxFee = baseFee.multipliedBy(1.2).plus(maxPriorityFee);
+  return {
+    maxFeePerGas: maxFee.toFixed(0),
+    maxPriorityFeePerGas: maxPriorityFee.toFixed(0),
+    minWaitTimeEstimate: blockTime * (blockNumber - 2),
+    maxWaitTimeEstimate: blockTime * blockNumber
+  };
+};
+export const calculateGasFeeParams = async (web3, networkKey, useOnline = true, useInfura = true) => {
   if (useOnline) {
     try {
       const chainId = await web3.api.eth.getChainId();
@@ -98,19 +128,19 @@ export const calculateGasFeeParams = async (web3, networkKey, useOnline = true,
       const gasResponse = await fetch(`${gasDomain}`).then(res => res.json());
       const gasPriceInWei = gasResponse.standard * 1e9 + 200000;
       return {
+        type: 'evm',
         gasPrice: gasPriceInWei.toString(),
-        maxFeePerGas: undefined,
-        maxPriorityFeePerGas: undefined,
         baseGasFee: undefined,
-        busyNetwork: false
+        busyNetwork: false,
+        options: undefined
       };
     }
     const numBlock = 20;
-    const rewardPercent = [];
-    for (let i = 0; i <= 100; i = i + 5) {
-      rewardPercent.push(i);
-    }
+    const rewardPercent = [25, 50, 75];
     const history = await web3.api.eth.getFeeHistory(numBlock, 'latest', rewardPercent);
+    const currentBlock = history.oldestBlock - 1;
+    const [newBlock, oldBlock] = await Promise.all([web3.api.eth.getBlock(currentBlock), web3.api.eth.getBlock(currentBlock - numBlock)]);
+    const blockTime = Number((BigInt(newBlock.timestamp || 0) - BigInt(oldBlock.timestamp || 0)) / BigInt(numBlock) * BigInt(1000));
     const baseGasFee = new BigN(history.baseFeePerGas[history.baseFeePerGas.length - 1]); // Last element is latest
 
     const blocksBusy = history.reward.reduce((previous, rewards, currentIndex) => {
@@ -128,80 +158,34 @@ export const calculateGasFeeParams = async (web3, networkKey, useOnline = true,
     }, 0);
     const busyNetwork = blocksBusy >= numBlock / 2; // True, if half of block is busy
 
-    const maxPriorityFeePerGas = history.reward.reduce((previous, rewards) => {
-      let firstBN = BN_ZERO;
-      let firstIndex = 0;
-
-      /* Get first priority which greater than 0 */
-      for (let i = 0; i < rewards.length; i++) {
-        firstIndex = i;
-        const current = rewards[i];
-        const currentBN = new BigN(current);
-        if (currentBN.gt(BN_ZERO)) {
-          firstBN = currentBN;
-          break;
-        }
-      }
-      let secondBN = firstBN;
-
-      /* Get second priority which greater than first priority */
-      for (let i = firstIndex; i < rewards.length; i++) {
-        const current = rewards[i];
-        const currentBN = new BigN(current);
-        if (currentBN.gt(firstBN)) {
-          secondBN = currentBN;
-          break;
-        }
-      }
-      let current;
-      if (busyNetwork) {
-        current = secondBN.dividedBy(2).gte(firstBN) ? firstBN : secondBN; // second too larger than first (> 2 times), use first else use second
-      } else {
-        current = firstBN;
-      }
-      if (busyNetwork) {
-        /* Get max value */
-        return current.gte(previous) ? current : previous; // get max priority
-      } else {
-        /* Get min value which greater than 0 */
-        if (previous.eq(BN_ZERO)) {
-          return current; // get min priority
-        } else if (current.eq(BN_ZERO)) {
-          return previous;
-        }
-        return current.lte(previous) ? current : previous; // get min priority
-      }
-    }, BN_ZERO);
-    if (maxPriorityFeePerGas.eq(BN_ZERO)) {
-      const _price = await web3.api.eth.getGasPrice();
-      const gasPrice = recalculateGasPrice(_price, networkKey);
-      return {
-        gasPrice,
-        maxFeePerGas: undefined,
-        maxPriorityFeePerGas: undefined,
-        baseGasFee: undefined,
-        busyNetwork: false
-      };
-    }
-
-    /* Max gas = (base + priority) * 1.5 (if not busy or 2 when busy); */
-    const maxFeePerGas = baseGasFee.plus(maxPriorityFeePerGas).multipliedBy(busyNetwork ? 2 : 1.5).decimalPlaces(0);
+    const slowPriorityFee = history.reward.reduce((previous, rewards) => previous.plus(rewards[0]), BN_ZERO).dividedBy(numBlock).decimalPlaces(0);
+    const averagePriorityFee = history.reward.reduce((previous, rewards) => previous.plus(rewards[1]), BN_ZERO).dividedBy(numBlock).decimalPlaces(0);
+    const fastPriorityFee = history.reward.reduce((previous, rewards) => previous.plus(rewards[2]), BN_ZERO).dividedBy(numBlock).decimalPlaces(0);
     return {
+      type: 'evm',
       gasPrice: undefined,
-      maxFeePerGas,
-      maxPriorityFeePerGas,
-      baseGasFee,
-      busyNetwork
+      baseGasFee: baseGasFee.toString(),
+      busyNetwork,
+      options: {
+        slow: getEIP1559GasFee(baseGasFee, slowPriorityFee, 10, blockTime),
+        average: getEIP1559GasFee(baseGasFee, averagePriorityFee, 5, blockTime),
+        fast: getEIP1559GasFee(baseGasFee, fastPriorityFee, 3, blockTime),
+        default: busyNetwork ? 'average' : 'slow'
+      }
     };
   } catch (e) {
     const _price = await web3.api.eth.getGasPrice();
     const gasPrice = recalculateGasPrice(_price, networkKey);
     return {
+      type: 'evm',
+      busyNetwork: false,
       gasPrice,
-      maxFeePerGas: undefined,
-      maxPriorityFeePerGas: undefined,
       baseGasFee: undefined,
-      busyNetwork: false
+      options: undefined
     };
   }
+};
+export const calculateToAmountByReservePool = async (api, fromToken, toToken, fromAmount) => {
+  const reserve = await getReserveForPool(api, fromToken, toToken);
+  return estimateTokensForPool(fromAmount, reserve);
 };

package/services/storage-service/db-stores/Balance.d.ts

@@ -3,6 +3,7 @@ import { IBalance } from '../databases';
 import BaseStoreWithAddress from '../db-stores/BaseStoreWithAddress';
 export default class BalanceStore extends BaseStoreWithAddress<IBalance> {
     getBalanceMapByAddresses(addresses: string): Promise<BalanceItem[]>;
+    getBalanceHasAmount(address: string, chain: string): Promise<BalanceItem[]>;
     removeBySlugs(tokenSlugs: string[]): Promise<number>;
     removeByAddresses(addresses: string[]): Promise<number>;
     checkBalanceByTokens(tokens: string[], filterFunc: (i: IBalance) => boolean): Promise<number>;

package/services/storage-service/db-stores/Balance.js

@@ -6,6 +6,9 @@ export default class BalanceStore extends BaseStoreWithAddress {
   async getBalanceMapByAddresses(addresses) {
     return this.table.where('address').anyOf(addresses).toArray();
   }
+  async getBalanceHasAmount(address, chain) {
+    return this.table.filter(item => item.address === address && item.free !== '0' && item.tokenSlug.startsWith(chain)).toArray();
+  }
   async removeBySlugs(tokenSlugs) {
     return this.table.where('tokenSlug').anyOfIgnoreCase(tokenSlugs).delete();
   }

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

@@ -2,6 +2,7 @@ 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';
 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 { AssetHubSwapEarlyValidation, OptimalSwapPathParams, SwapProviderId, SwapQuote, SwapRequest, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types/swap';
 import { SwapBaseInterface } from '../base-handler';
@@ -11,7 +12,7 @@ export declare class AssetHubSwapHandler implements SwapBaseInterface {
     private router;
     isReady: boolean;
     providerSlug: SwapProviderId;
-    constructor(chainService: ChainService, balanceService: BalanceService, chain: string);
+    constructor(chainService: ChainService, balanceService: BalanceService, feeService: FeeService, chain: string);
     get chainService(): ChainService;
     get balanceService(): BalanceService;
     get providerInfo(): import("@subwallet/extension-base/types").SwapProvider;

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

@@ -11,20 +11,22 @@ import { convertSwapRate, getSwapAlternativeAsset, SWAP_QUOTE_TIMEOUT_MAP } from
 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 { getId } from '@subwallet/extension-base/utils/getId';
 import BigN from 'bignumber.js';
 import { SwapBaseHandler } from "../base-handler.js";
 import { AssetHubRouter } from "./router.js";
 const PAH_LOW_LIQUIDITY_THRESHOLD = 0.15;
 export class AssetHubSwapHandler {
   isReady = false;
-  constructor(chainService, balanceService, chain) {
+  constructor(chainService, balanceService, feeService, chain) {
     const chainInfo = chainService.getChainInfoByKey(chain);
     const providerSlug = chain === 'statemint' ? SwapProviderId.POLKADOT_ASSET_HUB : chain === 'statemine' ? SwapProviderId.KUSAMA_ASSET_HUB : SwapProviderId.ROCOCO_ASSET_HUB;
     this.swapBaseHandler = new SwapBaseHandler({
       balanceService,
       chainService,
       providerName: chainInfo.name,
-      providerSlug
+      providerSlug,
+      feeService
     });
     this.providerSlug = providerSlug;
     this.chain = chain;
@@ -75,6 +77,7 @@ export class AssetHubSwapHandler {
     }
     try {
       const alternativeChainInfo = this.chainService.getChainInfoByKey(alternativeAsset.originChain);
+      const originalChainInfo = this.chainService.getChainInfoByKey(this.chain);
       const step = {
         metadata: {
           sendingValue: bnAmount.toString(),
@@ -85,13 +88,18 @@ export class AssetHubSwapHandler {
         type: CommonStepType.XCM
       };
       const xcmOriginSubstrateApi = await this.chainService.getSubstrateApi(alternativeAsset.originChain).isReady;
+      const id = getId();
+      const feeInfo = await this.swapBaseHandler.feeService.subscribeChainFee(id, alternativeChainInfo.slug, 'substrate');
       const xcmTransfer = await createXcmExtrinsic({
         originTokenInfo: alternativeAsset,
         destinationTokenInfo: fromAsset,
         sendingValue: bnAmount.toString(),
         recipient: params.request.address,
-        chainInfoMap: this.chainService.getChainInfoMap(),
-        substrateApi: xcmOriginSubstrateApi
+        sender: params.request.address,
+        feeInfo: feeInfo,
+        substrateApi: xcmOriginSubstrateApi,
+        destinationChain: originalChainInfo,
+        originChain: alternativeChainInfo
       });
       const _xcmFeeInfo = await xcmTransfer.paymentInfo(params.request.address);
       const xcmFeeInfo = _xcmFeeInfo.toPrimitive();
@@ -178,12 +186,16 @@ export class AssetHubSwapHandler {
     const alternativeAssetSlug = getSwapAlternativeAsset(pair);
     const originAsset = this.chainService.getAssetBySlug(alternativeAssetSlug);
     const destinationAsset = this.chainService.getAssetBySlug(pair.from);
+    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
@@ -195,8 +207,11 @@ export class AssetHubSwapHandler {
       destinationTokenInfo: destinationAsset,
       sendingValue: bnTotalAmount.toString(),
       recipient: params.address,
-      chainInfoMap: this.chainService.getChainInfoMap(),
-      substrateApi: chainApi
+      substrateApi: chainApi,
+      sender: params.address,
+      originChain: originChain,
+      destinationChain: destinationChain,
+      feeInfo
     });
     const xcmData = {
       originNetworkKey: originAsset.originChain,

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

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { _getTokenMinAmount } from '@subwallet/extension-base/services/chain-service/utils';
-import { buildSwapExtrinsic, checkLiquidityForPath, checkMinAmountForPath, estimatePriceImpactPct, estimateRateAfter, estimateRateForPath, estimateTokensForPath, getReserveForPath } from '@subwallet/extension-base/services/swap-service/handler/asset-hub/utils';
+import { buildSwapExtrinsic, checkLiquidityForPath, checkMinAmountForPath, estimatePriceImpactPct, estimateRateAfterForPath, estimateRateForPath, estimateTokensForPath, getReserveForPath } from '@subwallet/extension-base/services/swap-service/handler/asset-hub/utils';
 import { SwapErrorType } from '@subwallet/extension-base/types/swap';
 import BigN from 'bignumber.js';
 export class AssetHubRouter {
@@ -38,7 +38,7 @@ export class AssetHubRouter {
     const reserves = await getReserveForPath(api, paths);
     const amounts = estimateTokensForPath(amount, reserves);
     const marketRate = estimateRateForPath(reserves);
-    const marketRateAfter = estimateRateAfter(amount, reserves);
+    const marketRateAfter = estimateRateAfterForPath(amount, reserves);
     const priceImpactPct = estimatePriceImpactPct(marketRate, marketRateAfter);
     const errors = [];
 

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

@@ -9,7 +9,7 @@ export declare const estimateTokensForPool: (amount: string, reserves: [string,
 export declare const estimateTokensForPath: (amount: string, reserves: Array<[string, string]>) => string[];
 export declare const estimateRateForPath: (reserves: Array<[string, string]>) => string;
 export declare const estimateActualRate: (amount: string, reserves: Array<[string, string]>) => string;
-export declare const estimateRateAfter: (amount: string, reserves: Array<[string, string]>) => string;
+export declare const estimateRateAfterForPath: (amount: string, reserves: Array<[string, string]>) => string;
 export declare const estimatePriceImpactPct: (marketRate: string, marketRateAfter: string) => string;
 export declare const checkLiquidityForPool: (amount: string, reserve1: string, reserve2: string) => SwapErrorType | undefined;
 export declare const checkLiquidityForPath: (amounts: string[], reserves: Array<[string, string]>) => SwapErrorType | undefined;

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

@@ -34,7 +34,7 @@ export const getReserveForPath = async (api, paths) => {
   return await Promise.all(pairs.map(async ([asset1, asset2]) => getReserveForPool(api, asset1, asset2)));
 };
 export const estimateTokensForPool = (amount, reserves) => {
-  if (amount === '0') {
+  if (!amount || amount === '0') {
     return '0';
   }
   return new BigN(amount).times(reserves[1]).div(reserves[0]).integerValue(BigN.ROUND_DOWN).toString();
@@ -68,7 +68,7 @@ export const estimateActualRate = (amount, reserves) => {
   }
   return result.toString();
 };
-export const estimateRateAfter = (amount, reserves) => {
+export const estimateRateAfterForPath = (amount, reserves) => {
   const m = new BigN(amount);
   const reserve = reserves[0];
   const x = new BigN(reserve[0]);

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

@@ -2,6 +2,7 @@ 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';
 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 { GenSwapStepFunc, OptimalSwapPathParams, SwapEarlyValidation, SwapProvider, SwapProviderId, SwapQuote, SwapRequest, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types/swap';
 export interface SwapBaseInterface {
@@ -21,13 +22,15 @@ export interface SwapBaseHandlerInitParams {
     providerName: string;
     chainService: ChainService;
     balanceService: BalanceService;
+    feeService: FeeService;
 }
 export declare class SwapBaseHandler {
     private readonly providerSlug;
     private readonly providerName;
     chainService: ChainService;
     balanceService: BalanceService;
-    constructor({ balanceService, chainService, providerName, providerSlug }: SwapBaseHandlerInitParams);
+    feeService: FeeService;
+    constructor({ balanceService, chainService, feeService, providerName, providerSlug }: SwapBaseHandlerInitParams);
     generateOptimalProcess(params: OptimalSwapPathParams, genStepFuncList: GenSwapStepFunc[]): Promise<CommonOptimalPath>;
     validateXcmStep(params: ValidateSwapProcessParams, stepIndex: number): Promise<TransactionError[]>;
     validateTokenApproveStep(params: ValidateSwapProcessParams, stepIndex: number): Promise<TransactionError[]>;

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

@@ -15,6 +15,7 @@ export class SwapBaseHandler {
   constructor({
     balanceService,
     chainService,
+    feeService,
     providerName,
     providerSlug
   }) {
@@ -22,6 +23,7 @@ export class SwapBaseHandler {
     this.providerSlug = providerSlug;
     this.chainService = chainService;
     this.balanceService = balanceService;
+    this.feeService = feeService;
   }
 
   // public abstract getSwapQuote(request: SwapRequest): Promise<SwapQuote | SwapError>;

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

@@ -4,6 +4,7 @@ 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';
 import { ChainService } from '@subwallet/extension-base/services/chain-service';
+import FeeService from '@subwallet/extension-base/services/fee-service/service';
 import { SwapBaseInterface } from '@subwallet/extension-base/services/swap-service/handler/base-handler';
 import { BaseStepDetail, CommonOptimalPath, CommonStepFeeInfo } from '@subwallet/extension-base/types/service-base';
 import { OptimalSwapPathParams, SwapEarlyValidation, SwapProviderId, SwapQuote, SwapRequest, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types/swap';
@@ -13,7 +14,7 @@ export declare class ChainflipSwapHandler implements SwapBaseInterface {
     private readonly isTestnet;
     private swapBaseHandler;
     providerSlug: SwapProviderId;
-    constructor(chainService: ChainService, balanceService: BalanceService, isTestnet?: boolean);
+    constructor(chainService: ChainService, balanceService: BalanceService, feeService: FeeService, isTestnet?: boolean);
     get chainService(): ChainService;
     get balanceService(): BalanceService;
     get providerInfo(): import("@subwallet/extension-base/types").SwapProvider;

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

@@ -15,6 +15,7 @@ import { calculateSwapRate, CHAIN_FLIP_SUPPORTED_MAINNET_ASSET_MAPPING, CHAIN_FL
 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 { getId } from '@subwallet/extension-base/utils/getId';
 import BigNumber from 'bignumber.js';
 var ChainflipFeeType;
 (function (ChainflipFeeType) {
@@ -34,10 +35,11 @@ var CHAINFLIP_QUOTE_ERROR;
   CHAINFLIP_QUOTE_ERROR["InsufficientIngress"] = "amount is lower than estimated ingress fee";
 })(CHAINFLIP_QUOTE_ERROR || (CHAINFLIP_QUOTE_ERROR = {}));
 export class ChainflipSwapHandler {
-  constructor(chainService, balanceService, isTestnet = true) {
+  constructor(chainService, balanceService, feeService, isTestnet = true) {
     this.swapBaseHandler = new SwapBaseHandler({
       chainService,
       balanceService,
+      feeService,
       providerName: isTestnet ? 'Chainflip Testnet' : 'Chainflip',
       providerSlug: isTestnet ? SwapProviderId.CHAIN_FLIP_TESTNET : SwapProviderId.CHAIN_FLIP_MAINNET
     });
@@ -388,11 +390,30 @@ export class ChainflipSwapHandler {
       });
       extrinsic = submittableExtrinsic;
     } else {
+      const id = getId();
+      const feeInfo = await this.swapBaseHandler.feeService.subscribeChainFee(id, chainInfo.slug, 'evm');
       if (_isNativeToken(fromAsset)) {
-        const [transactionConfig] = await getEVMTransactionObject(chainInfo, address, depositAddressResponse.depositAddress, quote.fromAmount, false, this.chainService.getEvmApi(chainInfo.slug));
+        const [transactionConfig] = await getEVMTransactionObject({
+          chain: chainInfo.slug,
+          evmApi: this.chainService.getEvmApi(chainInfo.slug),
+          from: address,
+          to: depositAddressResponse.depositAddress,
+          value: quote.fromAmount,
+          feeInfo,
+          transferAll: false
+        });
         extrinsic = transactionConfig;
       } else {
-        const [transactionConfig] = await getERC20TransactionObject(_getContractAddressOfToken(fromAsset), chainInfo, address, depositAddressResponse.depositAddress, quote.fromAmount, false, this.chainService.getEvmApi(chainInfo.slug));
+        const [transactionConfig] = await getERC20TransactionObject({
+          assetAddress: _getContractAddressOfToken(fromAsset),
+          chain: chainInfo.slug,
+          evmApi: this.chainService.getEvmApi(chainInfo.slug),
+          from: address,
+          to: depositAddressResponse.depositAddress,
+          value: quote.fromAmount,
+          feeInfo,
+          transferAll: false
+        });
         extrinsic = transactionConfig;
       }
     }

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

@@ -2,6 +2,7 @@ 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';
 import { ChainService } from '@subwallet/extension-base/services/chain-service';
+import FeeService from '@subwallet/extension-base/services/fee-service/service';
 import { SwapBaseInterface } from '@subwallet/extension-base/services/swap-service/handler/base-handler';
 import { BaseStepDetail, CommonOptimalPath, CommonStepFeeInfo } from '@subwallet/extension-base/types/service-base';
 import { OptimalSwapPathParams, SwapEarlyValidation, SwapProviderId, SwapQuote, SwapRequest, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types/swap';
@@ -11,7 +12,7 @@ export declare class HydradxHandler implements SwapBaseInterface {
     private readonly isTestnet;
     isReady: boolean;
     providerSlug: SwapProviderId;
-    constructor(chainService: ChainService, balanceService: BalanceService, isTestnet?: boolean);
+    constructor(chainService: ChainService, balanceService: BalanceService, feeService: FeeService, isTestnet?: boolean);
     init(): Promise<void>;
     chain: () => string;
     get chainService(): ChainService;

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

@@ -15,6 +15,7 @@ import { calculateSwapRate, getSwapAlternativeAsset, SWAP_QUOTE_TIMEOUT_MAP } fr
 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 { getId } from '@subwallet/extension-base/utils/getId';
 import BigNumber from 'bignumber.js';
 const HYDRADX_LOW_LIQUIDITY_THRESHOLD = 0.15;
 const HYDRADX_SUBWALLET_REFERRAL_CODE = 'WALLET';
@@ -24,10 +25,11 @@ const HYDRADX_TESTNET_SUBWALLET_REFERRAL_ACCOUNT = '7LCt6dFqtxzdKVB2648jWW9d85do
 export class HydradxHandler {
   isTestnet = true;
   isReady = false;
-  constructor(chainService, balanceService, isTestnet = true) {
+  constructor(chainService, balanceService, feeService, isTestnet = true) {
     this.swapBaseHandler = new SwapBaseHandler({
       balanceService,
       chainService,
+      feeService,
       providerName: isTestnet ? 'Hydration Testnet' : 'Hydration',
       providerSlug: isTestnet ? SwapProviderId.HYDRADX_TESTNET : SwapProviderId.HYDRADX_MAINNET
     });
@@ -89,6 +91,7 @@ export class HydradxHandler {
     }
     try {
       const alternativeChainInfo = this.chainService.getChainInfoByKey(alternativeAsset.originChain);
+      const destChainInfo = this.chainService.getChainInfoByKey(this.chain());
       const step = {
         metadata: {
           sendingValue: bnAmount.toString(),
@@ -99,13 +102,18 @@ export class HydradxHandler {
         type: CommonStepType.XCM
       };
       const xcmOriginSubstrateApi = await this.chainService.getSubstrateApi(alternativeAsset.originChain).isReady;
+      const id = getId();
+      const feeInfo = await this.swapBaseHandler.feeService.subscribeChainFee(id, alternativeAsset.originChain, 'substrate');
       const xcmTransfer = await createXcmExtrinsic({
         originTokenInfo: alternativeAsset,
         destinationTokenInfo: fromAsset,
         sendingValue: bnAmount.toString(),
         recipient: params.request.address,
-        chainInfoMap: this.chainService.getChainInfoMap(),
-        substrateApi: xcmOriginSubstrateApi
+        substrateApi: xcmOriginSubstrateApi,
+        sender: params.request.address,
+        destinationChain: destChainInfo,
+        originChain: alternativeChainInfo,
+        feeInfo
       });
       const _xcmFeeInfo = await xcmTransfer.paymentInfo(params.request.address);
       const xcmFeeInfo = _xcmFeeInfo.toPrimitive();
@@ -297,6 +305,8 @@ export class HydradxHandler {
     const alternativeAssetSlug = getSwapAlternativeAsset(pair);
     const originAsset = this.chainService.getAssetBySlug(alternativeAssetSlug);
     const destinationAsset = this.chainService.getAssetBySlug(pair.from);
+    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);
@@ -309,13 +319,17 @@ export class HydradxHandler {
 
       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(),
       recipient: params.address,
-      chainInfoMap: this.chainService.getChainInfoMap(),
-      substrateApi: chainApi
+      substrateApi: chainApi,
+      sender: params.address,
+      destinationChain,
+      originChain,
+      feeInfo
     });
     const xcmData = {
       originNetworkKey: originAsset.originChain,