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

package/cjs/services/earning-service/handlers/special.js

@@ -13,6 +13,7 @@ var _xcm = require("@subwallet/extension-base/services/balance-service/transfer/
 var _utils2 = require("@subwallet/extension-base/services/chain-service/utils");
 var _types = require("@subwallet/extension-base/types");
 var _utils3 = require("@subwallet/extension-base/utils");
+var _getId = require("@subwallet/extension-base/utils/getId");
 var _i18next = require("i18next");
 var _util = require("@polkadot/util");
 var _base = _interopRequireDefault(require("./base"));
@@ -80,17 +81,27 @@ class BaseSpecialStakingPoolHandler extends _base.default {
       value: '0'
     }), this.state.balanceService.getTransferableBalance(request.address, feeAssetInfo.originChain, feeAssetInfo.slug)]);
     const bnInputAssetBalance = new _util.BN(inputAssetBalance.value);
-    const bnAltInputAssetBalance = new _util.BN(altInputAssetBalance.value);
     const bnMinJoinPool = new _util.BN(poolInfo.statistic.earningThreshold.join);
     const inputTokenInfo = this.state.chainService.getAssetBySlug(this.inputAsset);
     const altInputTokenInfo = this.state.chainService.getAssetBySlug(this.altInputAsset);
+    const existentialDeposit = new _util.BN((0, _utils2._getAssetExistentialDeposit)(altInputTokenInfo));
+    const bnAltInputAssetBalance = new _util.BN(altInputAssetBalance.value);
     if (bnInputAssetBalance.add(bnAltInputAssetBalance).lt(bnMinJoinPool)) {
+      const missingAmount = bnMinJoinPool.sub(bnInputAssetBalance).sub(bnAltInputAssetBalance);
+      const isTheSame = missingAmount.toString() === bnMinJoinPool.toString();
       const originChain = this.state.getChainInfo(inputTokenInfo.originChain);
       const altChain = this.state.getChainInfo(altInputTokenInfo.originChain);
-      const parsedMinJoinPool = (0, _utils3.formatNumber)(bnMinJoinPool.toString(), inputAssetInfo.decimals || 0);
+      const originSymbol = (0, _utils2._getAssetSymbol)(inputTokenInfo);
+      const altSymbol = (0, _utils2._getAssetSymbol)(altInputTokenInfo);
+      const originName = originChain.name;
+      const altName = altChain.name;
+      const parsedMinJoinPool = (0, _utils3.formatNumber)(missingAmount.toString(), inputAssetInfo.decimals || 0);
+      const formatparsedMinJoinPool = isTheSame ? parsedMinJoinPool : Number(parsedMinJoinPool) + 0.01;
+      const parsedMinAltJoinPool = (0, _utils3.formatNumber)(missingAmount.add(existentialDeposit).toString(), inputAssetInfo.decimals || 0);
+      const formatParsedMinAltJoinPool = isTheSame ? parsedMinAltJoinPool : Number(parsedMinAltJoinPool) + 0.01;
       return {
         passed: false,
-        errorMessage: `You need at least ${parsedMinJoinPool} ${inputTokenInfo.symbol} (${originChain.name}) or ${altInputTokenInfo.symbol} (${altChain.name}) to start earning`
+        errorMessage: `You need to deposit an additional ${formatparsedMinJoinPool} ${originSymbol} (${originName}) or ${formatParsedMinAltJoinPool} ${altSymbol} (${altName}) to start earning`
       };
     }
     if (this.feeAssets.length === 1) {
@@ -222,13 +233,18 @@ class BaseSpecialStakingPoolHandler extends _base.default {
             type: _types.YieldStepType.XCM
           };
           const xcmOriginSubstrateApi = await this.state.getSubstrateApi(altInputTokenInfo.originChain).isReady;
+          const id = (0, _getId.getId)();
+          const feeInfo = await this.state.feeService.subscribeChainFee(id, altChainInfo.slug, 'substrate');
           const xcmTransfer = await (0, _xcm.createXcmExtrinsic)({
+            sender: address,
             originTokenInfo: altInputTokenInfo,
             destinationTokenInfo: inputTokenInfo,
             sendingValue: bnAmount.toString(),
             recipient: address,
-            chainInfoMap: this.state.getChainInfoMap(),
-            substrateApi: xcmOriginSubstrateApi
+            destinationChain: this.chainInfo,
+            originChain: altChainInfo,
+            substrateApi: xcmOriginSubstrateApi,
+            feeInfo
           });
           const _xcmFeeInfo = await xcmTransfer.paymentInfo(address);
           const xcmFeeInfo = _xcmFeeInfo.toPrimitive();
@@ -288,16 +304,15 @@ class BaseSpecialStakingPoolHandler extends _base.default {
       processValidation.failedStep = path.steps[1];
       processValidation.ok = false;
       processValidation.status = _types.YieldValidationStatus.NOT_ENOUGH_BALANCE;
+      const bnMaxXCM = new _util.BN(altInputTokenBalance.value).sub(xcmFee.mul(new _util.BN(_constants.XCM_FEE_RATIO)));
+      const inputTokenDecimal = (0, _utils2._getAssetDecimals)(inputTokenInfo);
       const maxBn = bnInputTokenBalance.add(new _util.BN(altInputTokenBalance.value)).sub(xcmFee).sub(xcmFee);
       const maxValue = (0, _utils3.formatNumber)(maxBn.toString(), inputTokenInfo.decimals || 0);
-      const altInputTokenInfo = this.state.getAssetBySlug(altInputTokenSlug);
-      const symbol = altInputTokenInfo.symbol;
-      const altNetwork = this.state.getChainInfo(altInputTokenInfo.originChain);
+      const maxXCMValue = (0, _utils3.formatNumber)(bnMaxXCM.toString(), inputTokenDecimal);
+      const symbol = (0, _utils2._getAssetSymbol)(altInputTokenInfo);
       const inputNetworkName = this.chainInfo.name;
-      const altNetworkName = altNetwork.name;
-      const currentValue = (0, _utils3.formatNumber)(bnInputTokenBalance.toString(), inputTokenInfo.decimals || 0);
-      const bnMaxXCM = new _util.BN(altInputTokenBalance.value).sub(xcmFee).sub(xcmFee);
-      const maxXCMValue = (0, _utils3.formatNumber)(bnMaxXCM.toString(), inputTokenInfo.decimals || 0);
+      const altNetworkName = (0, _utils2._getAssetName)(altInputTokenInfo);
+      const currentValue = (0, _utils3.formatNumber)(bnInputTokenBalance.toString(), inputTokenDecimal);
       processValidation.message = (0, _i18next.t)('You can only enter a maximum of {{maxValue}} {{symbol}}, which is {{currentValue}} {{symbol}} ({{inputNetworkName}}) and {{maxXCMValue}} {{symbol}} ({{altNetworkName}}). Lower your amount and try again.', {
         replace: {
           symbol,
@@ -426,13 +441,18 @@ class BaseSpecialStakingPoolHandler extends _base.default {
     const bnXcmFee = new _util.BN(xcmFee);
     const bnAmount = new _util.BN(amount);
     const bnTotalAmount = bnAmount.sub(bnInputTokenBalance).add(bnXcmFee);
+    const id = (0, _getId.getId)();
+    const feeInfo = await this.state.feeService.subscribeChainFee(id, originChainInfo.slug, 'substrate');
     const extrinsic = await (0, _xcm.createXcmExtrinsic)({
-      chainInfoMap: this.state.getChainInfoMap(),
       destinationTokenInfo,
       originTokenInfo,
       recipient: address,
       sendingValue: bnTotalAmount.toString(),
-      substrateApi
+      substrateApi,
+      sender: address,
+      originChain: originChainInfo,
+      destinationChain: this.chainInfo,
+      feeInfo
     });
     const xcmData = {
       originNetworkKey: originChainInfo.slug,

package/cjs/services/fee-service/interfaces.js

@@ -0,0 +1 @@
+"use strict";

package/cjs/services/fee-service/service.js

@@ -12,6 +12,11 @@ var _rxjs = require("rxjs");
 
 class FeeService {
   evmFeeSubject = new _rxjs.BehaviorSubject({});
+  chainFeeSubscriptionMap = {
+    evm: {},
+    substrate: {},
+    ton: {}
+  };
   constructor(state) {
     this.state = state;
     this.useInfura = true;
@@ -66,5 +71,111 @@ 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 _rxjs.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) {
+              (0, _utils2.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];
+      }
+    }
+  }
 }
 exports.default = FeeService;

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

@@ -4,9 +4,10 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.recalculateGasPrice = exports.parseInfuraFee = exports.fetchSubWalletFeeData = exports.fetchOnlineFeeData = exports.fetchInfuraFeeData = exports.calculateGasFeeParams = void 0;
+exports.recalculateGasPrice = exports.parseInfuraFee = exports.getEIP1559GasFee = exports.fetchSubWalletFeeData = exports.fetchOnlineFeeData = exports.fetchInfuraFeeData = exports.calculateToAmountByReservePool = exports.calculateGasFeeParams = exports.FEE_COVERAGE_PERCENTAGE_SPECIAL_CASE = void 0;
 var _constants = require("@subwallet/extension-base/constants");
-var _utils = require("@subwallet/extension-base/utils");
+var _utils = require("@subwallet/extension-base/services/swap-service/handler/asset-hub/utils");
+var _utils2 = require("@subwallet/extension-base/utils");
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
 var _polygonBridge = require("../../balance-service/transfer/xcm/polygonBridge");
 // Copyright 2019-2022 @subwallet/extension-base
@@ -15,60 +16,79 @@ var _polygonBridge = require("../../balance-service/transfer/xcm/polygonBridge")
 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');
-const parseInfuraFee = info => {
-  const base = new _bignumber.default(info.estimatedBaseFee).multipliedBy(_utils.BN_WEI);
-  const low = new _bignumber.default(info.low.suggestedMaxPriorityFeePerGas).multipliedBy(_utils.BN_WEI);
-  const busyNetwork = base.gt(_utils.BN_ZERO) ? low.dividedBy(base).gte(0.3) : false;
-  const data = !busyNetwork ? info.low : info.medium;
+const FEE_COVERAGE_PERCENTAGE_SPECIAL_CASE = 105; // percentage
+exports.FEE_COVERAGE_PERCENTAGE_SPECIAL_CASE = FEE_COVERAGE_PERCENTAGE_SPECIAL_CASE;
+const parseInfuraFee = (info, threshold) => {
+  const base = new _bignumber.default(info.estimatedBaseFee).multipliedBy(_utils2.BN_WEI);
+  const thresholdBN = new _bignumber.default(threshold.busyThreshold).multipliedBy(_utils2.BN_WEI);
+  const busyNetwork = thresholdBN.gte(_utils2.BN_ZERO) ? base.gt(thresholdBN) : false;
   return {
     busyNetwork,
     gasPrice: undefined,
-    baseGasFee: base,
-    maxFeePerGas: new _bignumber.default(data.suggestedMaxFeePerGas).multipliedBy(_utils.BN_WEI).integerValue(_bignumber.default.ROUND_UP),
-    maxPriorityFeePerGas: new _bignumber.default(data.suggestedMaxPriorityFeePerGas).multipliedBy(_utils.BN_WEI).integerValue(_bignumber.default.ROUND_UP)
+    baseGasFee: base.toFixed(0),
+    type: 'evm',
+    options: {
+      slow: {
+        maxFeePerGas: new _bignumber.default(info.low.suggestedMaxFeePerGas).multipliedBy(_utils2.BN_WEI).integerValue(_bignumber.default.ROUND_UP).toFixed(0),
+        maxPriorityFeePerGas: new _bignumber.default(info.low.suggestedMaxPriorityFeePerGas).multipliedBy(_utils2.BN_WEI).integerValue(_bignumber.default.ROUND_UP).toFixed(0),
+        maxWaitTimeEstimate: info.low.maxWaitTimeEstimate || 0,
+        minWaitTimeEstimate: info.low.minWaitTimeEstimate || 0
+      },
+      average: {
+        maxFeePerGas: new _bignumber.default(info.medium.suggestedMaxFeePerGas).multipliedBy(_utils2.BN_WEI).integerValue(_bignumber.default.ROUND_UP).toFixed(0),
+        maxPriorityFeePerGas: new _bignumber.default(info.medium.suggestedMaxPriorityFeePerGas).multipliedBy(_utils2.BN_WEI).integerValue(_bignumber.default.ROUND_UP).toFixed(0),
+        maxWaitTimeEstimate: info.medium.maxWaitTimeEstimate || 0,
+        minWaitTimeEstimate: info.medium.minWaitTimeEstimate || 0
+      },
+      fast: {
+        maxFeePerGas: new _bignumber.default(info.high.suggestedMaxFeePerGas).multipliedBy(_utils2.BN_WEI).integerValue(_bignumber.default.ROUND_UP).toFixed(0),
+        maxPriorityFeePerGas: new _bignumber.default(info.high.suggestedMaxPriorityFeePerGas).multipliedBy(_utils2.BN_WEI).integerValue(_bignumber.default.ROUND_UP).toFixed(0),
+        maxWaitTimeEstimate: info.high.maxWaitTimeEstimate || 0,
+        minWaitTimeEstimate: info.high.minWaitTimeEstimate || 0
+      },
+      default: busyNetwork ? 'average' : 'slow'
+    }
   };
 };
 exports.parseInfuraFee = parseInfuraFee;
 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;
+  }
 };
 exports.fetchInfuraFeeData = fetchInfuraFeeData;
 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 _bignumber.default(info.baseGasFee),
-          maxFeePerGas: new _bignumber.default(info.maxFeePerGas),
-          maxPriorityFeePerGas: new _bignumber.default(info.maxPriorityFeePerGas)
-        });
-      }
+      resolve(info);
     }).catch(e => {
       console.warn(e);
       resolve(null);
@@ -94,9 +114,20 @@ const recalculateGasPrice = (_price, chain) => {
   return needMulti ? new _bignumber.default(_price).multipliedBy(_constants.GAS_PRICE_RATIO).toFixed(0) : _price;
 };
 exports.recalculateGasPrice = recalculateGasPrice;
+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
+  };
+};
+exports.getEIP1559GasFee = getEIP1559GasFee;
 const calculateGasFeeParams = async function (web3, networkKey) {
   let useOnline = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-  let useInfura = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  let useInfura = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
   if (useOnline) {
     try {
       const chainId = await web3.api.eth.getChainId();
@@ -113,19 +144,19 @@ const calculateGasFeeParams = async function (web3, networkKey) {
       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 _bignumber.default(history.baseFeePerGas[history.baseFeePerGas.length - 1]); // Last element is latest
 
     const blocksBusy = history.reward.reduce((previous, rewards, currentIndex) => {
@@ -137,87 +168,42 @@ const calculateGasFeeParams = async function (web3, networkKey) {
       /*
       * True if priority >= 0.3 * base
       *  */
-      const blockIsBusy = baseBN.gt(_utils.BN_ZERO) ? priorityBN.dividedBy(baseBN).gte(0.3) ? 1 : 0 : 0; // Special for bsc, base fee = 0
+      const blockIsBusy = baseBN.gt(_utils2.BN_ZERO) ? priorityBN.dividedBy(baseBN).gte(0.3) ? 1 : 0 : 0; // Special for bsc, base fee = 0
 
       return previous + blockIsBusy;
     }, 0);
     const busyNetwork = blocksBusy >= numBlock / 2; // True, if half of block is busy
 
-    const maxPriorityFeePerGas = history.reward.reduce((previous, rewards) => {
-      let firstBN = _utils.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 _bignumber.default(current);
-        if (currentBN.gt(_utils.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 _bignumber.default(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(_utils.BN_ZERO)) {
-          return current; // get min priority
-        } else if (current.eq(_utils.BN_ZERO)) {
-          return previous;
-        }
-        return current.lte(previous) ? current : previous; // get min priority
-      }
-    }, _utils.BN_ZERO);
-    if (maxPriorityFeePerGas.eq(_utils.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]), _utils2.BN_ZERO).dividedBy(numBlock).decimalPlaces(0);
+    const averagePriorityFee = history.reward.reduce((previous, rewards) => previous.plus(rewards[1]), _utils2.BN_ZERO).dividedBy(numBlock).decimalPlaces(0);
+    const fastPriorityFee = history.reward.reduce((previous, rewards) => previous.plus(rewards[2]), _utils2.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
     };
   }
 };
-exports.calculateGasFeeParams = calculateGasFeeParams;
+exports.calculateGasFeeParams = calculateGasFeeParams;
+const calculateToAmountByReservePool = async (api, fromToken, toToken, fromAmount) => {
+  const reserve = await (0, _utils.getReserveForPool)(api, fromToken, toToken);
+  return (0, _utils.estimateTokensForPool)(fromAmount, reserve);
+};
+exports.calculateToAmountByReservePool = calculateToAmountByReservePool;

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

@@ -13,6 +13,9 @@ class BalanceStore extends _BaseStoreWithAddress.default {
   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/cjs/services/swap-service/handler/asset-hub/handler.js

@@ -15,6 +15,7 @@ var _utils2 = require("@subwallet/extension-base/services/swap-service/utils");
 var _types = require("@subwallet/extension-base/types");
 var _serviceBase = require("@subwallet/extension-base/types/service-base");
 var _swap2 = require("@subwallet/extension-base/types/swap");
+var _getId = require("@subwallet/extension-base/utils/getId");
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
 var _baseHandler = require("../base-handler");
 var _router = require("./router");
@@ -24,14 +25,15 @@ var _router = require("./router");
 const PAH_LOW_LIQUIDITY_THRESHOLD = 0.15;
 class AssetHubSwapHandler {
   isReady = false;
-  constructor(chainService, balanceService, chain) {
+  constructor(chainService, balanceService, feeService, chain) {
     const chainInfo = chainService.getChainInfoByKey(chain);
     const providerSlug = chain === 'statemint' ? _swap2.SwapProviderId.POLKADOT_ASSET_HUB : chain === 'statemine' ? _swap2.SwapProviderId.KUSAMA_ASSET_HUB : _swap2.SwapProviderId.ROCOCO_ASSET_HUB;
     this.swapBaseHandler = new _baseHandler.SwapBaseHandler({
       balanceService,
       chainService,
       providerName: chainInfo.name,
-      providerSlug
+      providerSlug,
+      feeService
     });
     this.providerSlug = providerSlug;
     this.chain = chain;
@@ -82,6 +84,7 @@ class AssetHubSwapHandler {
     }
     try {
       const alternativeChainInfo = this.chainService.getChainInfoByKey(alternativeAsset.originChain);
+      const originalChainInfo = this.chainService.getChainInfoByKey(this.chain);
       const step = {
         metadata: {
           sendingValue: bnAmount.toString(),
@@ -92,13 +95,18 @@ class AssetHubSwapHandler {
         type: _serviceBase.CommonStepType.XCM
       };
       const xcmOriginSubstrateApi = await this.chainService.getSubstrateApi(alternativeAsset.originChain).isReady;
+      const id = (0, _getId.getId)();
+      const feeInfo = await this.swapBaseHandler.feeService.subscribeChainFee(id, alternativeChainInfo.slug, 'substrate');
       const xcmTransfer = await (0, _xcm.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();
@@ -185,12 +193,16 @@ class AssetHubSwapHandler {
     const alternativeAssetSlug = (0, _utils2.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 _bignumber.default(params.quote.fromAmount);
     const bnDestinationAssetBalance = new _bignumber.default(destinationAssetBalance.value);
+    const id = (0, _getId.getId)();
+    const feeInfo = await this.swapBaseHandler.feeService.subscribeChainFee(id, originChain.slug, 'substrate');
     let bnTotalAmount = bnAmount.minus(bnDestinationAssetBalance);
     if ((0, _utils._isNativeToken)(originAsset)) {
       const bnXcmFee = new _bignumber.default(xcmFee.feeComponent[0].amount); // xcm fee is paid in native token but swap token is not always native token
@@ -202,8 +214,11 @@ 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/cjs/services/swap-service/handler/asset-hub/router.js

@@ -45,7 +45,7 @@ class AssetHubRouter {
     const reserves = await (0, _utils2.getReserveForPath)(api, paths);
     const amounts = (0, _utils2.estimateTokensForPath)(amount, reserves);
     const marketRate = (0, _utils2.estimateRateForPath)(reserves);
-    const marketRateAfter = (0, _utils2.estimateRateAfter)(amount, reserves);
+    const marketRateAfter = (0, _utils2.estimateRateAfterForPath)(amount, reserves);
     const priceImpactPct = (0, _utils2.estimatePriceImpactPct)(marketRate, marketRateAfter);
     const errors = [];
 

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

@@ -4,7 +4,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getReserveForPool = exports.getReserveForPath = exports.estimateTokensForPool = exports.estimateTokensForPath = exports.estimateRateForPath = exports.estimateRateAfter = exports.estimatePriceImpactPct = exports.estimateActualRate = exports.checkMinAmountForPool = exports.checkMinAmountForPath = exports.checkLiquidityForPool = exports.checkLiquidityForPath = exports.buildSwapExtrinsic = exports._getPoolInfo = void 0;
+exports.getReserveForPool = exports.getReserveForPath = exports.estimateTokensForPool = exports.estimateTokensForPath = exports.estimateRateForPath = exports.estimateRateAfterForPath = exports.estimatePriceImpactPct = exports.estimateActualRate = exports.checkMinAmountForPool = exports.checkMinAmountForPath = exports.checkLiquidityForPool = exports.checkLiquidityForPath = exports.buildSwapExtrinsic = exports._getPoolInfo = void 0;
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
 var _swap = require("@subwallet/extension-base/types/swap");
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
@@ -47,7 +47,7 @@ const getReserveForPath = async (api, paths) => {
 };
 exports.getReserveForPath = getReserveForPath;
 const estimateTokensForPool = (amount, reserves) => {
-  if (amount === '0') {
+  if (!amount || amount === '0') {
     return '0';
   }
   return new _bignumber.default(amount).times(reserves[1]).div(reserves[0]).integerValue(_bignumber.default.ROUND_DOWN).toString();
@@ -85,7 +85,7 @@ const estimateActualRate = (amount, reserves) => {
   return result.toString();
 };
 exports.estimateActualRate = estimateActualRate;
-const estimateRateAfter = (amount, reserves) => {
+const estimateRateAfterForPath = (amount, reserves) => {
   const m = new _bignumber.default(amount);
   const reserve = reserves[0];
   const x = new _bignumber.default(reserve[0]);
@@ -94,7 +94,7 @@ const estimateRateAfter = (amount, reserves) => {
   const result = x.plus(m).div(y.minus(n));
   return result.toString();
 };
-exports.estimateRateAfter = estimateRateAfter;
+exports.estimateRateAfterForPath = estimateRateAfterForPath;
 const estimatePriceImpactPct = (marketRate, marketRateAfter) => {
   const bnMarketRate = new _bignumber.default(marketRate);
   const bnActualRate = new _bignumber.default(marketRateAfter);