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

package/cjs/utils/fee/transfer.js

@@ -0,0 +1,374 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.detectTransferTxType = exports.calculateXCMMaxTransferable = exports.calculateTransferMaxTransferable = exports.calculateMaxTransferable = void 0;
+var _constants = require("@subwallet/extension-base/constants");
+var _xcmParser = require("@subwallet/extension-base/core/substrate/xcm-parser");
+var _smartContract = require("@subwallet/extension-base/services/balance-service/transfer/smart-contract");
+var _token = require("@subwallet/extension-base/services/balance-service/transfer/token");
+var _tonTransfer = require("@subwallet/extension-base/services/balance-service/transfer/ton-transfer");
+var _xcm = require("@subwallet/extension-base/services/balance-service/transfer/xcm");
+var _availBridge = require("@subwallet/extension-base/services/balance-service/transfer/xcm/availBridge");
+var _polygonBridge = require("@subwallet/extension-base/services/balance-service/transfer/xcm/polygonBridge");
+var _posBridge = require("@subwallet/extension-base/services/balance-service/transfer/xcm/posBridge");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _utils2 = require("@subwallet/extension-base/services/fee-service/utils");
+var _helpers = require("@subwallet/extension-base/services/transaction-service/helpers");
+var _utils3 = require("@subwallet/extension-base/utils");
+var _keyring = require("@subwallet/keyring");
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+var _util = require("@polkadot/util");
+var _utilCrypto = require("@polkadot/util-crypto");
+var _combine = require("./combine");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const detectTransferTxType = (srcToken, srcChain, destChain) => {
+  const isXcmTransfer = srcChain.slug !== destChain.slug;
+  if (isXcmTransfer) {
+    const isAvailBridgeFromEvm = (0, _utils._isPureEvmChain)(srcChain) && (0, _availBridge.isAvailChainBridge)(destChain.slug);
+    const isSnowBridgeEvmTransfer = (0, _utils._isPureEvmChain)(srcChain) && (0, _xcmParser._isSnowBridgeXcm)(srcChain, destChain) && !isAvailBridgeFromEvm;
+    const isPolygonBridgeTransfer = (0, _polygonBridge._isPolygonChainBridge)(srcChain.slug, destChain.slug);
+    const isPosBridgeTransfer = (0, _posBridge._isPosChainBridge)(srcChain.slug, destChain.slug);
+    return isAvailBridgeFromEvm || isSnowBridgeEvmTransfer || isPolygonBridgeTransfer || isPosBridgeTransfer ? 'evm' : 'substrate';
+  } else {
+    if ((0, _utils._isChainEvmCompatible)(srcChain) && (0, _utils._isTokenTransferredByEvm)(srcToken)) {
+      return 'evm';
+    } else if ((0, _utils._isChainTonCompatible)(srcChain) && (0, _utils._isTokenTransferredByTon)(srcToken)) {
+      return 'ton';
+    } else {
+      return 'substrate';
+    }
+  }
+};
+exports.detectTransferTxType = detectTransferTxType;
+const calculateMaxTransferable = async (id, request, freeBalance, fee) => {
+  const {
+    destChain,
+    srcChain
+  } = request;
+  const isXcmTransfer = srcChain.slug !== destChain.slug;
+  let maxTransferableAmount;
+  if (isXcmTransfer) {
+    maxTransferableAmount = await calculateXCMMaxTransferable(id, request, freeBalance, fee);
+  } else {
+    maxTransferableAmount = await calculateTransferMaxTransferable(id, request, freeBalance, fee);
+  }
+  maxTransferableAmount.feePercentageSpecialCase = _utils2.FEE_COVERAGE_PERCENTAGE_SPECIAL_CASE;
+  return maxTransferableAmount;
+};
+exports.calculateMaxTransferable = calculateMaxTransferable;
+const calculateTransferMaxTransferable = async (id, request, freeBalance, fee) => {
+  const {
+    address,
+    destChain,
+    evmApi,
+    feeCustom,
+    feeOption,
+    isTransferLocalTokenAndPayThatTokenAsFee,
+    isTransferNativeTokenAndPayLocalTokenAsFee,
+    nativeToken,
+    srcChain,
+    srcToken,
+    substrateApi,
+    tonApi
+  } = request;
+  const feeChainType = fee.type;
+  let estimatedFee;
+  let feeOptions;
+  let maxTransferable;
+  let error;
+  const fakeAddress = '5DRewsYzhJqZXU3SRaWy1FSt5iDr875ao91aw5fjrJmDG4Ap'; // todo: move this
+  const substrateAddress = fakeAddress; // todo: move this
+  const evmAddress = (0, _util.u8aToHex)((0, _utilCrypto.addressToEvm)(fakeAddress)); // todo: move this
+
+  const recipient = (0, _utils._isChainEvmCompatible)(destChain) ? evmAddress : substrateAddress;
+  try {
+    let transaction;
+    if ((0, _utilCrypto.isEthereumAddress)(address) && (0, _utilCrypto.isEthereumAddress)(recipient) && (0, _utils._isTokenTransferredByEvm)(srcToken)) {
+      // todo: refactor: merge getERC20TransactionObject & getEVMTransactionObject
+      // Estimate with EVM API
+      if ((0, _utils._isTokenEvmSmartContract)(srcToken) || (0, _utils._isLocalToken)(srcToken)) {
+        [transaction] = await (0, _smartContract.getERC20TransactionObject)({
+          assetAddress: (0, _utils._getContractAddressOfToken)(srcToken),
+          chain: srcChain.slug,
+          evmApi,
+          feeCustom,
+          feeInfo: fee,
+          feeOption,
+          from: address,
+          to: recipient,
+          transferAll: false,
+          value: '0'
+        });
+      } else {
+        [transaction] = await (0, _smartContract.getEVMTransactionObject)({
+          chain: srcChain.slug,
+          evmApi,
+          feeCustom,
+          feeInfo: fee,
+          feeOption,
+          from: address,
+          to: recipient,
+          transferAll: false,
+          value: '0'
+        });
+      }
+    } else if ((0, _keyring.isTonAddress)(address) && (0, _utils._isTokenTransferredByTon)(srcToken)) {
+      [transaction] = await (0, _tonTransfer.createTonTransaction)({
+        tokenInfo: srcToken,
+        from: address,
+        to: address,
+        networkKey: srcChain.slug,
+        value: '0',
+        transferAll: false,
+        // currently not used
+        tonApi
+      });
+    } else {
+      [transaction] = await (0, _token.createTransferExtrinsic)({
+        transferAll: false,
+        value: '0',
+        from: address,
+        networkKey: srcChain.slug,
+        tokenInfo: srcToken,
+        to: recipient,
+        substrateApi
+      });
+    }
+    if (feeChainType === 'evm') {
+      var _tx$gas;
+      // Calculate fee for evm transaction
+      const tx = transaction;
+      const gasLimit = ((_tx$gas = tx.gas) === null || _tx$gas === void 0 ? void 0 : _tx$gas.toString()) || (await evmApi.api.eth.estimateGas(tx)).toString();
+      const _feeCustom = feeCustom;
+      const combineFee = (0, _combine.combineEthFee)(fee, feeOption, _feeCustom);
+      if (combineFee.maxFeePerGas) {
+        estimatedFee = new _bignumber.default(combineFee.maxFeePerGas).multipliedBy(gasLimit).toFixed(0);
+      } else {
+        estimatedFee = new _bignumber.default(combineFee.gasPrice || '0').multipliedBy(gasLimit).toFixed(0);
+      }
+      feeOptions = {
+        ...fee,
+        estimatedFee,
+        gasLimit: gasLimit.toString()
+      };
+    } else if (feeChainType === 'substrate') {
+      // Calculate fee for substrate transaction
+      try {
+        var _paymentInfo$partialF;
+        const mockTx = transaction;
+        const paymentInfo = await mockTx.paymentInfo(address);
+        estimatedFee = (paymentInfo === null || paymentInfo === void 0 ? void 0 : (_paymentInfo$partialF = paymentInfo.partialFee) === null || _paymentInfo$partialF === void 0 ? void 0 : _paymentInfo$partialF.toString()) || '0';
+      } catch (e) {
+        estimatedFee = '0';
+      }
+      const _feeCustom = feeCustom;
+      const tip = (0, _combine.combineSubstrateFee)(fee, feeOption, _feeCustom).tip;
+      estimatedFee = new _bignumber.default(estimatedFee).plus(tip).toFixed(0);
+      feeOptions = {
+        ...fee,
+        estimatedFee
+      };
+    } else {
+      if (transaction && (0, _helpers.isTonTransaction)(transaction)) {
+        estimatedFee = transaction.estimateFee;
+        feeOptions = {
+          ...fee,
+          estimatedFee: estimatedFee
+        };
+      } else {
+        // Not implemented yet
+        estimatedFee = '0';
+        feeOptions = {
+          ...fee,
+          estimatedFee: '0'
+        };
+      }
+    }
+  } catch (e) {
+    estimatedFee = '0';
+    if (fee.type === 'evm') {
+      feeOptions = {
+        ...fee,
+        estimatedFee,
+        gasLimit: '0'
+      };
+    } else {
+      feeOptions = {
+        ...fee,
+        estimatedFee
+      };
+    }
+    error = e.message || 'Unable to estimate fee';
+    console.warn('Unable to estimate fee', e);
+  }
+  if (isTransferLocalTokenAndPayThatTokenAsFee && feeChainType === 'substrate') {
+    const estimatedFeeNative = (BigInt(estimatedFee) * BigInt(_utils2.FEE_COVERAGE_PERCENTAGE_SPECIAL_CASE) / BigInt(100)).toString();
+    const estimatedFeeLocal = await (0, _utils2.calculateToAmountByReservePool)(substrateApi.api, nativeToken, srcToken, estimatedFeeNative);
+    maxTransferable = (0, _bignumber.default)(freeBalance.value).minus(estimatedFeeLocal);
+  } else if (isTransferNativeTokenAndPayLocalTokenAsFee) {
+    maxTransferable = (0, _bignumber.default)(freeBalance.value);
+  } else {
+    if (!(0, _utils._isNativeToken)(srcToken)) {
+      maxTransferable = (0, _bignumber.default)(freeBalance.value);
+    } else {
+      maxTransferable = (0, _bignumber.default)(freeBalance.value).minus(new _bignumber.default(estimatedFee));
+    }
+  }
+  return {
+    maxTransferable: maxTransferable.gt(_utils3.BN_ZERO) ? maxTransferable.toFixed(0) || '0' : '0',
+    feeOptions: feeOptions,
+    feeType: feeChainType,
+    id: id,
+    error
+  };
+};
+exports.calculateTransferMaxTransferable = calculateTransferMaxTransferable;
+const calculateXCMMaxTransferable = async (id, request, freeBalance, fee) => {
+  const {
+    address,
+    destChain,
+    destToken,
+    evmApi,
+    feeCustom,
+    feeOption,
+    isTransferLocalTokenAndPayThatTokenAsFee,
+    isTransferNativeTokenAndPayLocalTokenAsFee,
+    nativeToken,
+    srcChain,
+    srcToken,
+    substrateApi
+  } = request;
+  const feeChainType = fee.type;
+  let estimatedFee;
+  let feeOptions;
+  let maxTransferable;
+  let error;
+  const isAvailBridgeFromEvm = (0, _utils._isPureEvmChain)(srcChain) && (0, _availBridge.isAvailChainBridge)(destChain.slug);
+  const isAvailBridgeFromAvail = (0, _availBridge.isAvailChainBridge)(srcChain.slug) && (0, _utils._isPureEvmChain)(destChain);
+  const isSnowBridgeEvmTransfer = (0, _utils._isPureEvmChain)(srcChain) && (0, _xcmParser._isSnowBridgeXcm)(srcChain, destChain) && !isAvailBridgeFromEvm;
+  const isPolygonBridgeTransfer = (0, _polygonBridge._isPolygonChainBridge)(srcChain.slug, destChain.slug);
+  const isPosBridgeTransfer = (0, _posBridge._isPosChainBridge)(srcChain.slug, destChain.slug);
+  const fakeAddress = '5DRewsYzhJqZXU3SRaWy1FSt5iDr875ao91aw5fjrJmDG4Ap'; // todo: move this
+  const substrateAddress = fakeAddress; // todo: move this
+  const evmAddress = (0, _util.u8aToHex)((0, _utilCrypto.addressToEvm)(fakeAddress)); // todo: move this
+
+  const recipient = (0, _utils._isChainEvmCompatible)(destChain) ? evmAddress : substrateAddress;
+  try {
+    if (!destToken) {
+      throw Error('Destination token is not available');
+    }
+    const params = {
+      destinationTokenInfo: destToken,
+      originTokenInfo: srcToken,
+      // If value is 0, substrate will throw error when estimating fee
+      sendingValue: feeChainType === 'substrate' ? '1000000000000000000' : '0',
+      sender: address,
+      recipient,
+      destinationChain: destChain,
+      originChain: srcChain,
+      substrateApi,
+      evmApi,
+      feeCustom,
+      feeOption,
+      feeInfo: fee
+    };
+    let funcCreateExtrinsic;
+    if (isPosBridgeTransfer || isPolygonBridgeTransfer) {
+      funcCreateExtrinsic = _xcm.createPolygonBridgeExtrinsic;
+    } else if (isSnowBridgeEvmTransfer) {
+      funcCreateExtrinsic = _xcm.createSnowBridgeExtrinsic;
+    } else if (isAvailBridgeFromEvm) {
+      funcCreateExtrinsic = _xcm.createAvailBridgeTxFromEth;
+    } else if (isAvailBridgeFromAvail) {
+      funcCreateExtrinsic = _xcm.createAvailBridgeExtrinsicFromAvail;
+    } else {
+      funcCreateExtrinsic = _xcm.createXcmExtrinsic;
+    }
+    const extrinsic = await funcCreateExtrinsic(params);
+    if (feeChainType === 'evm') {
+      var _tx$gas2;
+      // Calculate fee for evm transaction
+      const tx = extrinsic;
+      const gasLimit = ((_tx$gas2 = tx.gas) === null || _tx$gas2 === void 0 ? void 0 : _tx$gas2.toString()) || (await evmApi.api.eth.estimateGas(tx)).toString();
+      const _feeCustom = feeCustom;
+      const combineFee = (0, _combine.combineEthFee)(fee, feeOption, _feeCustom);
+      if (combineFee.maxFeePerGas) {
+        estimatedFee = new _bignumber.default(combineFee.maxFeePerGas).multipliedBy(gasLimit).toFixed(0);
+      } else {
+        estimatedFee = new _bignumber.default(combineFee.gasPrice || '0').multipliedBy(gasLimit).toFixed(0);
+      }
+      feeOptions = {
+        ...fee,
+        estimatedFee,
+        gasLimit: gasLimit.toString()
+      };
+    } else if (feeChainType === 'substrate') {
+      // Calculate fee for substrate transaction
+      try {
+        var _paymentInfo$partialF2;
+        const paymentInfo = await extrinsic.paymentInfo(address);
+        estimatedFee = (paymentInfo === null || paymentInfo === void 0 ? void 0 : (_paymentInfo$partialF2 = paymentInfo.partialFee) === null || _paymentInfo$partialF2 === void 0 ? void 0 : _paymentInfo$partialF2.toString()) || '0';
+      } catch (e) {
+        estimatedFee = '0';
+      }
+      const _feeCustom = feeCustom;
+      const tip = (0, _combine.combineSubstrateFee)(fee, feeOption, _feeCustom).tip;
+      estimatedFee = new _bignumber.default(estimatedFee).plus(tip).toFixed(0);
+      feeOptions = {
+        ...fee,
+        estimatedFee
+      };
+    } else {
+      // Not implemented yet
+      estimatedFee = '0';
+      feeOptions = {
+        ...fee,
+        estimatedFee: '0'
+      };
+    }
+  } catch (e) {
+    estimatedFee = '0';
+    if (fee.type === 'evm') {
+      feeOptions = {
+        ...fee,
+        estimatedFee,
+        gasLimit: '0'
+      };
+    } else {
+      feeOptions = {
+        ...fee,
+        estimatedFee
+      };
+    }
+    error = e.message || 'Unable to estimate fee';
+    console.warn('Unable to estimate fee', e);
+  }
+  if (!destToken) {
+    maxTransferable = _utils3.BN_ZERO;
+  } else if (isTransferLocalTokenAndPayThatTokenAsFee && feeChainType === 'substrate') {
+    const estimatedFeeNative = (BigInt(estimatedFee) * BigInt(_utils2.FEE_COVERAGE_PERCENTAGE_SPECIAL_CASE) / BigInt(100)).toString();
+    const estimatedFeeLocal = await (0, _utils2.calculateToAmountByReservePool)(substrateApi.api, nativeToken, srcToken, estimatedFeeNative);
+    maxTransferable = (0, _bignumber.default)(freeBalance.value).minus(estimatedFeeLocal);
+  } else if (isTransferNativeTokenAndPayLocalTokenAsFee) {
+    maxTransferable = (0, _bignumber.default)(freeBalance.value);
+  } else {
+    if (!(0, _utils._isNativeToken)(srcToken)) {
+      maxTransferable = (0, _bignumber.default)(freeBalance.value);
+    } else {
+      maxTransferable = (0, _bignumber.default)(freeBalance.value).minus(new _bignumber.default(estimatedFee).multipliedBy(_constants.XCM_FEE_RATIO));
+    }
+  }
+  return {
+    maxTransferable: maxTransferable.gt(_utils3.BN_ZERO) ? maxTransferable.toFixed(0) || '0' : '0',
+    feeOptions: feeOptions,
+    feeType: feeChainType,
+    id: id,
+    error
+  };
+};
+exports.calculateXCMMaxTransferable = calculateXCMMaxTransferable;

package/cjs/utils/index.js

@@ -174,6 +174,18 @@ Object.keys(_eth).forEach(function (key) {
     }
   });
 });
+var _fee = require("./fee");
+Object.keys(_fee).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _fee[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _fee[key];
+    }
+  });
+});
 var _fetchEvmChainInfo = require("./fetchEvmChainInfo");
 Object.keys(_fetchEvmChainInfo).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

package/constants/index.d.ts

@@ -35,6 +35,7 @@ export declare const NETWORK_MULTI_GAS_FEE: string[];
 export declare const ORDINAL_COLLECTION = "__Ordinal__";
 export declare const ORDINAL_METHODS: string[];
 export declare const PERMISSIONS_TO_REVOKE: string[];
+export declare const ASSET_HUB_CHAIN_SLUGS: string[];
 export * from './blocked-actions';
 export * from './environment';
 export * from './signing';

package/constants/index.js

@@ -37,6 +37,7 @@ export const NETWORK_MULTI_GAS_FEE = ['*'];
 export const ORDINAL_COLLECTION = '__Ordinal__';
 export const ORDINAL_METHODS = ['drc-20', 'pol-20'];
 export const PERMISSIONS_TO_REVOKE = ['eth_accounts'];
+export const ASSET_HUB_CHAIN_SLUGS = ['paseo_assethub', 'westend_assethub', 'rococo_assethub', 'statemine', 'statemint'];
 export * from "./blocked-actions.js";
 export * from "./environment.js";
 export * from "./signing.js";

package/core/logic-validation/request.js

@@ -5,10 +5,10 @@ import { typedSignatureHash } from '@metamask/eth-sig-util';
 import { EvmProviderError } from '@subwallet/extension-base/background/errors/EvmProviderError';
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { EvmProviderErrorType } from '@subwallet/extension-base/background/KoniTypes';
-import { calculateGasFeeParams } from '@subwallet/extension-base/services/fee-service/utils';
 import { BasicTxErrorType } from '@subwallet/extension-base/types';
-import { BN_ZERO, createPromiseHandler, isSameAddress, stripUrl, wait } from '@subwallet/extension-base/utils';
+import { BN_ZERO, combineEthFee, createPromiseHandler, isSameAddress, stripUrl, wait } from '@subwallet/extension-base/utils';
 import { isContractAddress, parseContractInput } from '@subwallet/extension-base/utils/eth/parseTransaction';
+import { getId } from '@subwallet/extension-base/utils/getId';
 import { isSubstrateAddress } from '@subwallet/keyring';
 import { keyring } from '@subwallet/ui-keyring';
 import { getSdkError } from '@walletconnect/utils';
@@ -332,15 +332,22 @@ export async function validationEvmDataTransactionMiddleware(koni, url, payload)
       estimateGas = new BigN(transactionParams.gasPrice).multipliedBy(transaction.gas).toFixed(0);
     } else {
       try {
-        const priority = await calculateGasFeeParams(evmApi, networkKey || '');
-        if (priority.baseGasFee) {
-          transaction.maxPriorityFeePerGas = priority.maxPriorityFeePerGas.toString();
-          transaction.maxFeePerGas = priority.maxFeePerGas.toString();
-          const maxFee = priority.maxFeePerGas;
-          estimateGas = maxFee.multipliedBy(transaction.gas).toFixed(0);
+        const gasLimit = transaction.gas || (await evmApi.api.eth.estimateGas(transaction));
+        const id = getId();
+        const feeInfo = await koni.feeService.subscribeChainFee(id, transaction.chain || '', 'evm');
+        const feeCombine = combineEthFee(feeInfo);
+        if (transaction.maxFeePerGas) {
+          estimateGas = new BigN(transaction.maxFeePerGas.toString()).multipliedBy(gasLimit).toFixed(0);
+        } else if (transaction.gasPrice) {
+          estimateGas = new BigN(transaction.gasPrice.toString()).multipliedBy(gasLimit).toFixed(0);
         } else {
-          transaction.gasPrice = priority.gasPrice;
-          estimateGas = new BigN(priority.gasPrice).multipliedBy(transaction.gas).toFixed(0);
+          if (feeCombine.maxFeePerGas) {
+            const maxFee = new BigN(feeCombine.maxFeePerGas); // TODO: Need review
+
+            estimateGas = maxFee.multipliedBy(gasLimit).toFixed(0);
+          } else if (feeCombine.gasPrice) {
+            estimateGas = new BigN(feeCombine.gasPrice || 0).multipliedBy(gasLimit).toFixed(0);
+          }
         }
       } catch (e) {
         handleError(e.message);

package/core/logic-validation/transfer.d.ts

@@ -3,18 +3,18 @@ import { TransactionError } from '@subwallet/extension-base/background/errors/Tr
 import { _Address, AmountData, ExtrinsicType, FeeData } from '@subwallet/extension-base/background/KoniTypes';
 import { TransactionWarning } from '@subwallet/extension-base/background/warnings/TransactionWarning';
 import { FrameSystemAccountInfo } from '@subwallet/extension-base/core/substrate/types';
-import { _EvmApi, _TonApi } from '@subwallet/extension-base/services/chain-service/types';
+import { _EvmApi, _SubstrateApi, _TonApi } from '@subwallet/extension-base/services/chain-service/types';
 import { OptionalSWTransaction, SWTransactionInput, SWTransactionResponse } from '@subwallet/extension-base/services/transaction-service/types';
+import { EvmFeeInfo } from '@subwallet/extension-base/types';
 import { KeyringPair } from '@subwallet/keyring/types';
-import BigN from 'bignumber.js';
-export declare function validateTransferRequest(tokenInfo: _ChainAsset, from: _Address, to: _Address, value: string | undefined, transferAll: boolean | undefined): [TransactionError[], KeyringPair | undefined, BigN | undefined];
+export declare function validateTransferRequest(tokenInfo: _ChainAsset, from: _Address, to: _Address, value: string | undefined, transferAll: boolean | undefined): TransactionError[];
 export declare function additionalValidateTransferForRecipient(sendingTokenInfo: _ChainAsset, nativeTokenInfo: _ChainAsset, extrinsicType: ExtrinsicType, receiverSendingTokenKeepAliveBalance: bigint, transferAmount: bigint, senderSendingTokenTransferable?: bigint, receiverSystemAccountInfo?: FrameSystemAccountInfo, isSendingTokenSufficient?: boolean): [TransactionWarning[], TransactionError[]];
-export declare function validateXcmTransferRequest(destTokenInfo: _ChainAsset | undefined, sender: _Address, sendingValue: string): [TransactionError[], KeyringPair | undefined, BigN | undefined];
+export declare function validateXcmTransferRequest(destTokenInfo: _ChainAsset | undefined, sender: _Address, sendingValue: string): [TransactionError[], KeyringPair | undefined];
 export declare function additionalValidateXcmTransfer(originTokenInfo: _ChainAsset, destinationTokenInfo: _ChainAsset, sendingAmount: string, senderTransferable: string, receiverNativeBalance: string, destChainInfo: _ChainInfo, isSnowBridge?: boolean): [TransactionWarning | undefined, TransactionError | undefined];
 export declare function checkSupportForFeature(validationResponse: SWTransactionResponse, blockedFeaturesList: string[], chainInfo: _ChainInfo): void;
 export declare function checkSupportForAction(validationResponse: SWTransactionResponse, blockedActionsMap: Record<ExtrinsicType, string[]>): void;
 export declare function checkSupportForTransaction(validationResponse: SWTransactionResponse, transaction: OptionalSWTransaction): void;
-export declare function estimateFeeForTransaction(validationResponse: SWTransactionResponse, transaction: OptionalSWTransaction, chainInfo: _ChainInfo, evmApi: _EvmApi): Promise<FeeData>;
+export declare function estimateFeeForTransaction(validationResponse: SWTransactionResponse, transaction: OptionalSWTransaction, chainInfo: _ChainInfo, evmApi: _EvmApi, substrateApi: _SubstrateApi, feeInfo: EvmFeeInfo, nativeTokenInfo: _ChainAsset, tokenPayFeeInfo: _ChainAsset | undefined, isTransferLocalTokenAndPayThatTokenAsFee: boolean | undefined): Promise<FeeData>;
 export declare function checkSigningAccountForTransaction(validationResponse: SWTransactionResponse, chainInfoMap: Record<string, _ChainInfo>): void;
 export declare function checkBalanceWithTransactionFee(validationResponse: SWTransactionResponse, transactionInput: SWTransactionInput, nativeTokenInfo: _ChainAsset, nativeTokenAvailable: AmountData): void;
 export declare function checkTonAddressBounceableAndAccountNotActive(tonApi: _TonApi, validationResponse: SWTransactionResponse): Promise<void>;

package/core/logic-validation/transfer.js

@@ -9,10 +9,10 @@ import { _canAccountBeReaped, _isAccountActive } from '@subwallet/extension-base
 import { isBounceableAddress } from '@subwallet/extension-base/services/balance-service/helpers/subscribe/ton/utils';
 import { _TRANSFER_CHAIN_GROUP } from '@subwallet/extension-base/services/chain-service/constants';
 import { _getAssetDecimals, _getChainExistentialDeposit, _getChainNativeTokenBasicInfo, _getContractAddressOfToken, _getTokenMinAmount, _isNativeToken, _isTokenEvmSmartContract, _isTokenTonSmartContract } from '@subwallet/extension-base/services/chain-service/utils';
-import { calculateGasFeeParams } from '@subwallet/extension-base/services/fee-service/utils';
+import { calculateToAmountByReservePool, FEE_COVERAGE_PERCENTAGE_SPECIAL_CASE } from '@subwallet/extension-base/services/fee-service/utils';
 import { isSubstrateTransaction, isTonTransaction } from '@subwallet/extension-base/services/transaction-service/helpers';
 import { AccountSignMode, BasicTxErrorType, BasicTxWarningCode, TransferTxErrorType } from '@subwallet/extension-base/types';
-import { balanceFormatter, formatNumber, pairToAccount } from '@subwallet/extension-base/utils';
+import { balanceFormatter, combineEthFee, formatNumber, pairToAccount } from '@subwallet/extension-base/utils';
 import { isTonAddress } from '@subwallet/keyring';
 import { keyring } from '@subwallet/ui-keyring';
 import BigN from 'bignumber.js';
@@ -22,15 +22,10 @@ import { isEthereumAddress } from '@polkadot/util-crypto';
 // normal transfer
 export function validateTransferRequest(tokenInfo, from, to, value, transferAll) {
   const errors = [];
-  const keypair = keyring.getPair(from);
-  let transferValue;
   if (!transferAll) {
     if (value === undefined) {
       errors.push(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('Transfer amount is required')));
     }
-    if (value) {
-      transferValue = new BigN(value);
-    }
   }
   if (!tokenInfo) {
     errors.push(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('Not found token from registry')));
@@ -41,7 +36,7 @@ export function validateTransferRequest(tokenInfo, from, to, value, transferAll)
   if (isTonAddress(from) && isTonAddress(to) && _isTokenTonSmartContract(tokenInfo) && _getContractAddressOfToken(tokenInfo).length === 0) {
     errors.push(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('Not found TEP74 address for this token')));
   }
-  return [errors, keypair, transferValue];
+  return errors;
 }
 export function additionalValidateTransferForRecipient(sendingTokenInfo, nativeTokenInfo, extrinsicType, receiverSendingTokenKeepAliveBalance, transferAmount, senderSendingTokenTransferable, receiverSystemAccountInfo, isSendingTokenSufficient) {
   const sendingTokenMinAmount = BigInt(_getTokenMinAmount(sendingTokenInfo));
@@ -103,11 +98,10 @@ export function additionalValidateTransferForRecipient(sendingTokenInfo, nativeT
 export function validateXcmTransferRequest(destTokenInfo, sender, sendingValue) {
   const errors = [];
   const keypair = keyring.getPair(sender);
-  const transferValue = new BigN(sendingValue);
   if (!destTokenInfo) {
     errors.push(new TransactionError(TransferTxErrorType.INVALID_TOKEN, t('Not found token from registry')));
   }
-  return [errors, keypair, transferValue];
+  return [errors, keypair];
 }
 export function additionalValidateXcmTransfer(originTokenInfo, destinationTokenInfo, sendingAmount, senderTransferable, receiverNativeBalance, destChainInfo, isSnowBridge = false) {
   const destMinAmount = _getTokenMinAmount(destinationTokenInfo);
@@ -333,7 +327,7 @@ export function checkSupportForTransaction(validationResponse, transaction) {
     }
   }
 }
-export async function estimateFeeForTransaction(validationResponse, transaction, chainInfo, evmApi) {
+export async function estimateFeeForTransaction(validationResponse, transaction, chainInfo, evmApi, substrateApi, feeInfo, nativeTokenInfo, tokenPayFeeInfo, isTransferLocalTokenAndPayThatTokenAsFee) {
   const estimateFee = {
     symbol: '',
     decimals: 0,
@@ -354,21 +348,21 @@ export async function estimateFeeForTransaction(validationResponse, transaction,
         estimateFee.value = transaction.estimateFee; // todo: might need to update logic estimate fee inside for future actions excluding normal transfer Ton and Jetton
       } else {
         const gasLimit = transaction.gas || (await evmApi.api.eth.estimateGas(transaction));
-        const priority = await calculateGasFeeParams(evmApi, chainInfo.slug);
+        const feeCombine = combineEthFee(feeInfo, validationResponse.feeOption, validationResponse.feeCustom);
         if (transaction.maxFeePerGas) {
           estimateFee.value = new BigN(transaction.maxFeePerGas.toString()).multipliedBy(gasLimit).toFixed(0);
         } else if (transaction.gasPrice) {
-          estimateFee.value = new BigN((transaction.gasPrice || 0).toString()).multipliedBy(gasLimit).toFixed(0);
+          estimateFee.value = new BigN(transaction.gasPrice.toString()).multipliedBy(gasLimit).toFixed(0);
         } else {
-          if (priority.baseGasFee) {
-            const maxFee = priority.maxFeePerGas; // TODO: Need review
+          if (feeCombine.maxFeePerGas) {
+            const maxFee = new BigN(feeCombine.maxFeePerGas); // TODO: Need review
 
             estimateFee.value = maxFee.multipliedBy(gasLimit).toFixed(0);
-          } else {
-            estimateFee.value = new BigN(priority.gasPrice).multipliedBy(gasLimit).toFixed(0);
+          } else if (feeCombine.gasPrice) {
+            estimateFee.value = new BigN(feeCombine.gasPrice || 0).multipliedBy(gasLimit).toFixed(0);
           }
         }
-        estimateFee.tooHigh = priority.busyNetwork;
+        estimateFee.tooHigh = feeInfo.busyNetwork;
       }
     } catch (e) {
       const error = e;
@@ -377,6 +371,12 @@ export async function estimateFeeForTransaction(validationResponse, transaction,
       }
     }
   }
+  if (tokenPayFeeInfo) {
+    const estimatedFeeAmount = isTransferLocalTokenAndPayThatTokenAsFee ? (BigInt(estimateFee.value) * BigInt(FEE_COVERAGE_PERCENTAGE_SPECIAL_CASE) / BigInt(100)).toString() : estimateFee.value;
+    estimateFee.decimals = tokenPayFeeInfo.decimals || 0;
+    estimateFee.symbol = tokenPayFeeInfo.symbol;
+    estimateFee.value = await calculateToAmountByReservePool(substrateApi.api, nativeTokenInfo, tokenPayFeeInfo, estimatedFeeAmount);
+  }
   return estimateFee;
 }
 export function checkSigningAccountForTransaction(validationResponse, chainInfoMap) {
@@ -415,9 +415,10 @@ export function checkBalanceWithTransactionFee(validationResponse, transactionIn
     edAsWarning,
     extrinsicType,
     isTransferAll,
+    nonNativeTokenPayFeeSlug,
     skipFeeValidation
   } = transactionInput;
-  if (skipFeeValidation) {
+  if (skipFeeValidation || nonNativeTokenPayFeeSlug) {
     return;
   }
   const bnFee = new BigN(validationResponse.estimateFee.value);

package/core/substrate/xcm-parser.d.ts

@@ -1,6 +1,6 @@
 import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
 import { _Address } from '@subwallet/extension-base/background/KoniTypes';
-export declare function _getXcmDestWeight(originChainInfo: _ChainInfo): "Unlimited" | 5000000000;
+export declare function _getXcmDestWeight(originChainInfo: _ChainInfo): 5000000000 | "Unlimited";
 export declare function _getXcmBeneficiary(destChainInfo: _ChainInfo, recipient: _Address, version: number): {
     [x: string]: {
         parents: number;

package/koni/api/contract-handler/evm/web3.js

@@ -3,6 +3,7 @@
 
 import { _ERC20_ABI } from '@subwallet/extension-base/koni/api/contract-handler/utils';
 import { calculateGasFeeParams } from '@subwallet/extension-base/services/fee-service/utils';
+import { combineEthFee } from '@subwallet/extension-base/utils';
 export const getERC20Contract = (assetAddress, evmApi, options = {}) => {
   // @ts-ignore
   // eslint-disable-next-line @typescript-eslint/no-unsafe-argument,@typescript-eslint/no-unsafe-member-access
@@ -22,7 +23,6 @@ export async function getERC20Allowance(spender, owner, contractAddress, evmApi)
   return await allowanceCall.call();
 }
 export async function getERC20SpendingApprovalTx(spender, owner, contractAddress, evmApi, amount = '115792089237316195423570985008687907853269984665640564039457584007913129639935') {
-  var _priority$maxFeePerGa, _priority$maxPriority;
   const tokenContract = getERC20Contract(contractAddress, evmApi);
   // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
   const approveCall = tokenContract.methods.approve(spender, amount); // TODO: need test
@@ -33,13 +33,13 @@ export async function getERC20SpendingApprovalTx(spender, owner, contractAddress
     from: owner
   });
   const priority = await calculateGasFeeParams(evmApi, evmApi.chainSlug);
+  const feeCombine = combineEthFee(priority);
   return {
     from: owner,
     to: contractAddress,
     data: approveEncodedCall,
     gas: gasLimit,
     gasPrice: priority.gasPrice,
-    maxFeePerGas: (_priority$maxFeePerGa = priority.maxFeePerGas) === null || _priority$maxFeePerGa === void 0 ? void 0 : _priority$maxFeePerGa.toString(),
-    maxPriorityFeePerGas: (_priority$maxPriority = priority.maxPriorityFeePerGas) === null || _priority$maxPriority === void 0 ? void 0 : _priority$maxPriority.toString()
+    ...feeCombine
   };
 }

package/koni/api/staking/bonding/utils.js

@@ -352,7 +352,7 @@ export function getAvgValidatorEraReward(supportedDays, eraRewardHistory) {
 export function getSupportedDaysByHistoryDepth(erasPerDay, maxSupportedEras, liveDay) {
   const maxSupportDay = Math.floor(maxSupportedEras / erasPerDay);
   if (liveDay && liveDay <= 30) {
-    return Math.min(liveDay - 1, maxSupportDay);
+    return Math.min(Math.floor(liveDay - 1), maxSupportDay);
   }
   if (maxSupportDay > 30) {
     return 30;