@subwallet/extension-base 1.3.17-0 → 1.3.18-1

package/services/fee-service/service.js

@@ -6,6 +6,11 @@ import { calculateGasFeeParams } from '@subwallet/extension-base/services/fee-se
 import { BehaviorSubject } from 'rxjs';
 export default class FeeService {
   evmFeeSubject = new BehaviorSubject({});
+  chainFeeSubscriptionMap = {
+    evm: {},
+    substrate: {},
+    ton: {}
+  };
   constructor(state) {
     this.state = state;
     this.useInfura = true;
@@ -60,4 +65,110 @@ export default class FeeService {
       clearInterval(interval);
     };
   }
+  subscribeChainFee(id, chain, type, callback) {
+    return new Promise(resolve => {
+      const _callback = value => {
+        if (value) {
+          callback === null || callback === void 0 ? void 0 : callback(value);
+          resolve(value);
+        }
+      };
+      const feeSubscription = this.chainFeeSubscriptionMap[type][chain];
+      if (feeSubscription) {
+        const observer = feeSubscription.observer;
+        _callback(observer.getValue());
+
+        // If have callback, just subscribe
+        if (callback) {
+          const subscription = observer.subscribe({
+            next: _callback
+          });
+          this.chainFeeSubscriptionMap[type][chain].subscription[id] = () => {
+            if (!subscription.closed) {
+              subscription.unsubscribe();
+            }
+          };
+        }
+      } else {
+        const observer = new BehaviorSubject(undefined);
+        const subscription = observer.subscribe({
+          next: _callback
+        });
+        let cancel = false;
+        let interval;
+        const update = () => {
+          if (cancel) {
+            clearInterval(interval);
+          } else {
+            const api = this.state.getEvmApi(chain);
+            if (api) {
+              calculateGasFeeParams(api, chain).then(info => {
+                observer.next(info);
+              }).catch(e => {
+                console.warn(`Cannot get fee param for ${chain}`, e);
+                observer.next({
+                  type: 'evm',
+                  gasPrice: '0',
+                  baseGasFee: undefined,
+                  options: undefined
+                });
+              });
+            } else {
+              observer.next({
+                type: type,
+                busyNetwork: false,
+                options: {
+                  slow: {
+                    tip: '0'
+                  },
+                  average: {
+                    tip: '0'
+                  },
+                  fast: {
+                    tip: '0'
+                  },
+                  default: 'slow'
+                }
+              });
+              clearInterval(interval);
+            }
+          }
+        };
+        update();
+
+        // If have callback, just subscribe
+        if (callback) {
+          interval = setInterval(update, 15 * 1000);
+          const unsub = () => {
+            cancel = true;
+            observer.complete();
+            clearInterval(interval);
+          };
+          this.chainFeeSubscriptionMap[type][chain] = {
+            observer,
+            subscription: {
+              [id]: () => {
+                if (!subscription.closed) {
+                  subscription.unsubscribe();
+                }
+              }
+            },
+            unsubscribe: unsub
+          };
+        }
+      }
+    });
+  }
+  unsubscribeChainFee(id, chain, type) {
+    const subscription = this.chainFeeSubscriptionMap[type][chain];
+    if (subscription) {
+      const unsub = subscription.subscription[id];
+      unsub && unsub();
+      delete subscription.subscription[id];
+      if (Object.keys(subscription.subscription).length === 0) {
+        subscription.unsubscribe();
+        delete this.chainFeeSubscriptionMap[type][chain];
+      }
+    }
+  }
 }

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

@@ -1,8 +1,14 @@
+import { _ChainAsset } from '@subwallet/chain-list/types';
 import { _EvmApi } from '@subwallet/extension-base/services/chain-service/types';
-import { EvmFeeInfo, InfuraFeeInfo } from '@subwallet/extension-base/types';
-export declare const parseInfuraFee: (info: InfuraFeeInfo) => EvmFeeInfo;
+import { EvmEIP1559FeeOption, EvmFeeInfo, InfuraFeeInfo, InfuraThresholdInfo } from '@subwallet/extension-base/types';
+import BigN from 'bignumber.js';
+import { ApiPromise } from '@polkadot/api';
+export declare const FEE_COVERAGE_PERCENTAGE_SPECIAL_CASE = 105;
+export declare const parseInfuraFee: (info: InfuraFeeInfo, threshold: InfuraThresholdInfo) => EvmFeeInfo;
 export declare const fetchInfuraFeeData: (chainId: number, infuraAuth?: string) => Promise<EvmFeeInfo | null>;
 export declare const fetchSubWalletFeeData: (chainId: number, networkKey: string) => Promise<EvmFeeInfo | null>;
 export declare const fetchOnlineFeeData: (chainId: number, networkKey: string, useInfura?: boolean) => Promise<EvmFeeInfo | null>;
 export declare const recalculateGasPrice: (_price: string, chain: string) => string;
+export declare const getEIP1559GasFee: (baseFee: BigN, maxPriorityFee: BigN, blockNumber: number, blockTime: number) => EvmEIP1559FeeOption;
 export declare const calculateGasFeeParams: (web3: _EvmApi, networkKey: string, useOnline?: boolean, useInfura?: boolean) => Promise<EvmFeeInfo>;
+export declare const calculateToAmountByReservePool: (api: ApiPromise, fromToken: _ChainAsset, toToken: _ChainAsset, fromAmount: string) => Promise<string>;

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();
@@ -106,6 +114,7 @@ export class AssetHubSwapHandler {
       };
       return [step, fee];
     } catch (e) {
+      console.error('Error creating xcm step', e);
       return undefined;
     }
   }
@@ -120,7 +129,7 @@ export class AssetHubSwapHandler {
     return Promise.resolve(undefined);
   }
   generateOptimalProcess(params) {
-    return this.swapBaseHandler.generateOptimalProcess(params, [this.getXcmStep, this.getSubmitStep]);
+    return this.swapBaseHandler.generateOptimalProcess(params, [this.getXcmStep.bind(this), this.getSubmitStep.bind(this)]);
   }
   async getSwapQuote(request) {
     const fromAsset = this.chainService.getAssetBySlug(request.pair.from);
@@ -178,12 +187,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 +208,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>;
@@ -32,7 +34,7 @@ export class SwapBaseHandler {
     };
     try {
       for (const genStepFunc of genStepFuncList) {
-        const step = await genStepFunc.bind(this, params)();
+        const step = await genStepFunc(params);
         if (step) {
           result.steps.push({
             id: result.steps.length,

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;