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

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

@@ -1,5 +1,6 @@
 import { SwapError } from '@subwallet/extension-base/background/errors/SwapError';
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import FeeService from '@subwallet/extension-base/services/fee-service/service';
 import { BaseStepDetail, CommonOptimalPath, CommonStepFeeInfo, OptimalSwapPathParams, SwapEarlyValidation, SwapProviderId, SwapQuote, SwapRequest, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types';
 import { BalanceService } from '../../balance-service';
 import { ChainService } from '../../chain-service';
@@ -8,7 +9,7 @@ export declare const simpleSwapApiKey: string;
 export declare class SimpleSwapHandler implements SwapBaseInterface {
     private swapBaseHandler;
     providerSlug: SwapProviderId;
-    constructor(chainService: ChainService, balanceService: BalanceService);
+    constructor(chainService: ChainService, balanceService: BalanceService, feeService: FeeService);
     validateSwapProcess(params: ValidateSwapProcessParams): Promise<TransactionError[]>;
     get chainService(): ChainService;
     get balanceService(): BalanceService;

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

@@ -8,6 +8,7 @@ import { _getSimpleSwapEarlyValidationError } from '@subwallet/extension-base/co
 import { _getAssetDecimals, _getChainNativeTokenSlug, _getContractAddressOfToken, _isChainSubstrateCompatible, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
 import { BasicTxErrorType, CommonStepType, SwapErrorType, SwapFeeType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types';
 import { _reformatAddressWithChain, formatNumber } from '@subwallet/extension-base/utils';
+import { getId } from '@subwallet/extension-base/utils/getId';
 import BigN, { BigNumber } from 'bignumber.js';
 import { getERC20TransactionObject, getEVMTransactionObject } from "../../balance-service/transfer/smart-contract.js";
 import { createTransferExtrinsic, getTransferMockTxFee } from "../../balance-service/transfer/token.js";
@@ -116,10 +117,11 @@ const createSwapRequest = async params => {
   };
 };
 export class SimpleSwapHandler {
-  constructor(chainService, balanceService) {
+  constructor(chainService, balanceService, feeService) {
     this.swapBaseHandler = new SwapBaseHandler({
       chainService,
       balanceService,
+      feeService,
       providerName: 'SimpleSwap',
       providerSlug: SwapProviderId.SIMPLE_SWAP
     });
@@ -414,11 +416,29 @@ export class SimpleSwapHandler {
       });
       extrinsic = submittableExtrinsic;
     } else {
+      const feeInfo = await this.swapBaseHandler.feeService.subscribeChainFee(getId(), chainInfo.slug, 'evm');
       if (_isNativeToken(fromAsset)) {
-        const [transactionConfig] = await getEVMTransactionObject(chainInfo, address, addressFrom, quote.fromAmount, false, this.chainService.getEvmApi(chainInfo.slug));
+        const [transactionConfig] = await getEVMTransactionObject({
+          evmApi: this.chainService.getEvmApi(chainInfo.slug),
+          transferAll: false,
+          value: quote.fromAmount,
+          from: address,
+          to: addressFrom,
+          chain: chainInfo.slug,
+          feeInfo
+        });
         extrinsic = transactionConfig;
       } else {
-        const [transactionConfig] = await getERC20TransactionObject(_getContractAddressOfToken(fromAsset), chainInfo, address, addressFrom, quote.fromAmount, false, this.chainService.getEvmApi(chainInfo.slug));
+        const [transactionConfig] = await getERC20TransactionObject({
+          assetAddress: _getContractAddressOfToken(fromAsset),
+          chain: chainInfo.slug,
+          evmApi: this.chainService.getEvmApi(chainInfo.slug),
+          feeInfo,
+          from: address,
+          to: addressFrom,
+          value: quote.fromAmount,
+          transferAll: false
+        });
         extrinsic = transactionConfig;
       }
     }

package/services/swap-service/index.js

@@ -138,28 +138,28 @@ export class SwapService {
     _SUPPORTED_SWAP_PROVIDERS.forEach(providerId => {
       switch (providerId) {
         case SwapProviderId.CHAIN_FLIP_TESTNET:
-          this.handlers[providerId] = new ChainflipSwapHandler(this.chainService, this.state.balanceService);
+          this.handlers[providerId] = new ChainflipSwapHandler(this.chainService, this.state.balanceService, this.state.feeService);
           break;
         case SwapProviderId.CHAIN_FLIP_MAINNET:
-          this.handlers[providerId] = new ChainflipSwapHandler(this.chainService, this.state.balanceService, false);
+          this.handlers[providerId] = new ChainflipSwapHandler(this.chainService, this.state.balanceService, this.state.feeService, false);
           break;
         case SwapProviderId.HYDRADX_TESTNET:
-          this.handlers[providerId] = new HydradxHandler(this.chainService, this.state.balanceService);
+          this.handlers[providerId] = new HydradxHandler(this.chainService, this.state.balanceService, this.state.feeService);
           break;
         case SwapProviderId.HYDRADX_MAINNET:
-          this.handlers[providerId] = new HydradxHandler(this.chainService, this.state.balanceService, false);
+          this.handlers[providerId] = new HydradxHandler(this.chainService, this.state.balanceService, this.state.feeService, false);
           break;
         case SwapProviderId.POLKADOT_ASSET_HUB:
-          this.handlers[providerId] = new AssetHubSwapHandler(this.chainService, this.state.balanceService, 'statemint');
+          this.handlers[providerId] = new AssetHubSwapHandler(this.chainService, this.state.balanceService, this.state.feeService, 'statemint');
           break;
         case SwapProviderId.KUSAMA_ASSET_HUB:
-          this.handlers[providerId] = new AssetHubSwapHandler(this.chainService, this.state.balanceService, 'statemine');
+          this.handlers[providerId] = new AssetHubSwapHandler(this.chainService, this.state.balanceService, this.state.feeService, 'statemine');
           break;
         case SwapProviderId.ROCOCO_ASSET_HUB:
-          this.handlers[providerId] = new AssetHubSwapHandler(this.chainService, this.state.balanceService, 'rococo_assethub');
+          this.handlers[providerId] = new AssetHubSwapHandler(this.chainService, this.state.balanceService, this.state.feeService, 'rococo_assethub');
           break;
         case SwapProviderId.SIMPLE_SWAP:
-          this.handlers[providerId] = new SimpleSwapHandler(this.chainService, this.state.balanceService);
+          this.handlers[providerId] = new SimpleSwapHandler(this.chainService, this.state.balanceService, this.state.feeService);
           break;
         default:
           throw new Error('Unsupported provider');

package/services/transaction-service/index.js

@@ -18,8 +18,10 @@ import { BasicTxErrorType, YieldPoolType } from '@subwallet/extension-base/types
 import { anyNumberToBN, pairToAccount, reformatAddress } from '@subwallet/extension-base/utils';
 import { mergeTransactionAndSignature } from '@subwallet/extension-base/utils/eth/mergeTransactionAndSignature';
 import { isContractAddress, parseContractInput } from '@subwallet/extension-base/utils/eth/parseTransaction';
+import { getId } from '@subwallet/extension-base/utils/getId';
 import { BN_ZERO } from '@subwallet/extension-base/utils/number';
 import keyring from '@subwallet/ui-keyring';
+import BigN from 'bignumber.js';
 import { addHexPrefix } from 'ethereumjs-util';
 import { ethers } from 'ethers';
 import EventEmitter from 'eventemitter3';
@@ -83,6 +85,8 @@ export default class TransactionService {
       checkSupportForAction(validationResponse, blockedActionsMap);
     }
     const transaction = transactionInput.transaction;
+    const nativeTokenInfo = this.state.chainService.getNativeTokenInfo(chain);
+    const tokenPayFeeInfo = transactionInput.nonNativeTokenPayFeeSlug ? this.chainService.getAssetBySlug(transactionInput.nonNativeTokenPayFeeSlug) : undefined;
 
     // Check duplicated transaction
     validationResponse.errors.push(...this.checkDuplicate(transactionInput));
@@ -92,6 +96,7 @@ export default class TransactionService {
     if (!chainInfo) {
       validationResponse.errors.push(new TransactionError(BasicTxErrorType.INTERNAL_ERROR, t('Cannot find network')));
     }
+    const substrateApi = this.state.chainService.getSubstrateApi(chainInfo.slug);
     const evmApi = this.state.chainService.getEvmApi(chainInfo.slug);
     const tonApi = this.state.chainService.getTonApi(chainInfo.slug);
     const isNoEvmApi = transaction && !isSubstrateTransaction(transaction) && !isTonTransaction(transaction) && !evmApi; // todo: should split isEvmTx && isNoEvmApi. Because other chains type also has no Evm Api
@@ -101,12 +106,13 @@ export default class TransactionService {
     }
 
     // Estimate fee for transaction
-    validationResponse.estimateFee = await estimateFeeForTransaction(validationResponse, transaction, chainInfo, evmApi);
+    const id = getId();
+    const feeInfo = await this.state.feeService.subscribeChainFee(id, chain, 'evm');
+    validationResponse.estimateFee = await estimateFeeForTransaction(validationResponse, transaction, chainInfo, evmApi, substrateApi, feeInfo, nativeTokenInfo, tokenPayFeeInfo, transactionInput.isTransferLocalTokenAndPayThatTokenAsFee);
     const chainInfoMap = this.state.chainService.getChainInfoMap();
 
     // Check account signing transaction
     checkSigningAccountForTransaction(validationResponse, chainInfoMap);
-    const nativeTokenInfo = this.state.chainService.getNativeTokenInfo(chain);
     const nativeTokenAvailable = await this.state.balanceService.getTransferableBalance(address, chain, nativeTokenInfo.slug, extrinsicType);
 
     // Check available balance against transaction fee
@@ -898,6 +904,13 @@ export default class TransactionService {
     if (!payload.from) {
       payload.from = address;
     }
+    if (!payload.estimateGas) {
+      if (payload.maxFeePerGas) {
+        payload.estimateGas = new BigN(anyNumberToBN(payload.maxFeePerGas).toNumber()).multipliedBy(payload.gas || '0').toFixed(0);
+      } else {
+        payload.estimateGas = new BigN(anyNumberToBN(payload.gasPrice).toNumber()).multipliedBy(payload.gas || '0').toFixed(0);
+      }
+    }
     const isExternal = !!account.isExternal;
     const isInjected = !!account.isInjected;
     if (!hasError) {
@@ -1050,10 +1063,15 @@ export default class TransactionService {
   signAndSendSubstrateTransaction({
     address,
     chain,
+    feeCustom,
     id,
+    nonNativeTokenPayFeeSlug,
     transaction,
     url
   }) {
+    var _this$state$chainServ;
+    const tip = (feeCustom === null || feeCustom === void 0 ? void 0 : feeCustom.tip) || '0';
+    const feeAssetId = nonNativeTokenPayFeeSlug ? (_this$state$chainServ = this.state.chainService.getAssetBySlug(nonNativeTokenPayFeeSlug).metadata) === null || _this$state$chainServ === void 0 ? void 0 : _this$state$chainServ.multilocation : undefined;
     const emitter = new EventEmitter();
     const eventData = {
       id,
@@ -1079,7 +1097,9 @@ export default class TransactionService {
           };
         }
       },
-      withSignedTransaction: true
+      tip,
+      withSignedTransaction: true,
+      assetId: feeAssetId
     };
 
     // if (_isRuntimeUpdated(signedExtensions)) {

package/services/transaction-service/types.d.ts

@@ -1,11 +1,11 @@
 import { ChainType, ExtrinsicDataTypeMap, ExtrinsicStatus, ExtrinsicType, FeeData, ValidateTransactionResponse } from '@subwallet/extension-base/background/KoniTypes';
 import { TonTransactionConfig } from '@subwallet/extension-base/services/balance-service/transfer/ton-transfer';
-import { BaseRequestSign } from '@subwallet/extension-base/types';
+import { BaseRequestSign, TransactionFee } from '@subwallet/extension-base/types';
 import EventEmitter from 'eventemitter3';
 import { TransactionConfig } from 'web3-core';
 import { SubmittableExtrinsic } from '@polkadot/api/promise/types';
 import { EventRecord } from '@polkadot/types/interfaces';
-export interface SWTransaction extends ValidateTransactionResponse, Partial<Pick<BaseRequestSign, 'ignoreWarnings'>> {
+export interface SWTransaction extends ValidateTransactionResponse, Partial<Pick<BaseRequestSign, 'ignoreWarnings'>>, TransactionFee {
     id: string;
     url?: string;
     isInternal: boolean;
@@ -25,17 +25,18 @@ export interface SWTransaction extends ValidateTransactionResponse, Partial<Pick
 }
 export declare type SWTransactionResult = Omit<SWTransaction, 'transaction' | 'additionalValidator' | 'eventsHandler'>;
 declare type SwInputBase = Pick<SWTransaction, 'address' | 'url' | 'data' | 'extrinsicType' | 'chain' | 'chainType' | 'ignoreWarnings' | 'transferNativeAmount'> & Partial<Pick<SWTransaction, 'additionalValidator' | 'eventsHandler'>>;
-export interface SWTransactionInput extends SwInputBase, Partial<Pick<SWTransaction, 'estimateFee'>> {
+export interface SWTransactionInput extends SwInputBase, Partial<Pick<SWTransaction, 'estimateFee'>>, TransactionFee {
     id?: string;
     transaction?: SWTransaction['transaction'] | null;
     warnings?: SWTransaction['warnings'];
     errors?: SWTransaction['errors'];
     edAsWarning?: boolean;
     isTransferAll?: boolean;
+    isTransferLocalTokenAndPayThatTokenAsFee?: boolean;
     resolveOnDone?: boolean;
     skipFeeValidation?: boolean;
 }
-export declare type SWTransactionResponse = SwInputBase & Pick<SWTransaction, 'warnings' | 'errors'> & Partial<Pick<SWTransaction, 'id' | 'extrinsicHash' | 'status' | 'estimateFee'>>;
+export declare type SWTransactionResponse = SwInputBase & Pick<SWTransaction, 'warnings' | 'errors'> & Partial<Pick<SWTransaction, 'id' | 'extrinsicHash' | 'status' | 'estimateFee'>> & TransactionFee;
 export declare type ValidateTransactionResponseInput = SWTransactionInput;
 export declare type TransactionEmitter = EventEmitter<TransactionEventMap>;
 export interface TransactionEventResponse extends ValidateTransactionResponse {

package/types/balance/transfer.d.ts

@@ -0,0 +1,25 @@
+import { BaseRequestSign } from '@subwallet/extension-base/types';
+import { FeeChainType, FeeDetail, TransactionFee } from '../fee';
+export interface RequestSubscribeTransfer extends TransactionFee {
+    address: string;
+    chain: string;
+    token: string;
+    destChain: string;
+}
+export interface ResponseSubscribeTransfer {
+    id: string;
+    maxTransferable: string;
+    feeOptions: FeeDetail;
+    feeType: FeeChainType;
+    feePercentageSpecialCase?: number;
+    error?: string;
+}
+export interface RequestSubmitTransfer extends BaseRequestSign, TransactionFee {
+    chain: string;
+    from: string;
+    to: string;
+    tokenSlug: string;
+    transferAll: boolean;
+    value: string;
+    transferBounceable?: boolean;
+}

package/types/balance/transfer.js

@@ -0,0 +1 @@
+export {};

package/types/fee/base.d.ts

@@ -0,0 +1,8 @@
+export declare type FeeChainType = 'evm' | 'substrate' | 'ton';
+export interface BaseFeeInfo {
+    busyNetwork: boolean;
+    type: FeeChainType;
+}
+export interface BaseFeeDetail {
+    estimatedFee: string;
+}

package/types/fee/base.js

@@ -0,0 +1 @@
+export {};

package/types/fee/evm.d.ts

@@ -1,33 +1,61 @@
-import BigN from 'bignumber.js';
-interface BaseFeeInfo {
-    busyNetwork: boolean;
-}
+import { BaseFeeDetail, BaseFeeInfo, FeeDefaultOption } from '@subwallet/extension-base/types';
 export interface EvmLegacyFeeInfo extends BaseFeeInfo {
+    type: 'evm';
     gasPrice: string;
-    maxFeePerGas: undefined;
-    maxPriorityFeePerGas: undefined;
     baseGasFee: undefined;
+    options: undefined;
+}
+export interface EvmEIP1559FeeOption {
+    maxFeePerGas: string;
+    maxPriorityFeePerGas: string;
+    minWaitTimeEstimate?: number;
+    maxWaitTimeEstimate?: number;
+}
+export declare enum FeeOptionKey {
+    SLOW = "slow",
+    AVERAGE = "average",
+    FAST = "fast",
+    DEFAULT = "default"
 }
-export interface EvmEIP1995FeeInfo extends BaseFeeInfo {
+export interface EvmEIP1559FeeInfo extends BaseFeeInfo {
+    type: 'evm';
     gasPrice: undefined;
-    maxFeePerGas: BigN;
-    maxPriorityFeePerGas: BigN;
-    baseGasFee: BigN;
+    baseGasFee: string;
+    options: {
+        [FeeOptionKey.SLOW]: EvmEIP1559FeeOption;
+        [FeeOptionKey.AVERAGE]: EvmEIP1559FeeOption;
+        [FeeOptionKey.FAST]: EvmEIP1559FeeOption;
+        [FeeOptionKey.DEFAULT]: FeeDefaultOption;
+    };
 }
-export declare type EvmFeeInfo = EvmLegacyFeeInfo | EvmEIP1995FeeInfo;
+export declare type EvmFeeInfo = EvmLegacyFeeInfo | EvmEIP1559FeeInfo;
 export interface EvmLegacyFeeInfoCache extends BaseFeeInfo {
+    type: 'evm';
     gasPrice: string;
     maxFeePerGas: undefined;
     maxPriorityFeePerGas: undefined;
     baseGasFee: undefined;
+    options: undefined;
 }
-export interface EvmEIP1995FeeInfoCache extends BaseFeeInfo {
+export interface EvmEIP1559FeeInfoCache extends BaseFeeInfo {
+    type: 'evm';
     gasPrice: undefined;
-    maxFeePerGas: string;
-    maxPriorityFeePerGas: string;
     baseGasFee: string;
+    options: {
+        [FeeOptionKey.SLOW]: EvmEIP1559FeeOption;
+        [FeeOptionKey.AVERAGE]: EvmEIP1559FeeOption;
+        [FeeOptionKey.FAST]: EvmEIP1559FeeOption;
+        [FeeOptionKey.DEFAULT]: FeeDefaultOption;
+    };
 }
-export declare type EvmFeeInfoCache = EvmLegacyFeeInfoCache | EvmEIP1995FeeInfoCache;
+export interface EvmLegacyFeeDetail extends EvmLegacyFeeInfo, BaseFeeDetail {
+    gasLimit: string;
+}
+export interface EvmEIP1559FeeDetail extends EvmEIP1559FeeInfo, BaseFeeDetail {
+    gasLimit: string;
+}
+export declare type EvmFeeInfoCache = EvmLegacyFeeInfoCache | EvmEIP1559FeeInfoCache;
+export declare type EvmFeeDetail = EvmLegacyFeeDetail | EvmEIP1559FeeDetail;
 export interface InfuraFeeDetail {
     suggestedMaxPriorityFeePerGas: string;
     suggestedMaxFeePerGas: string;
@@ -46,4 +74,6 @@ export interface InfuraFeeInfo {
     priorityFeeTrend: 'down' | 'up';
     baseFeeTrend: 'down' | 'up';
 }
-export {};
+export interface InfuraThresholdInfo {
+    busyThreshold: string;
+}

package/types/fee/evm.js

@@ -1 +1,10 @@
-export {};
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+export let FeeOptionKey;
+(function (FeeOptionKey) {
+  FeeOptionKey["SLOW"] = "slow";
+  FeeOptionKey["AVERAGE"] = "average";
+  FeeOptionKey["FAST"] = "fast";
+  FeeOptionKey["DEFAULT"] = "default";
+})(FeeOptionKey || (FeeOptionKey = {}));

package/types/fee/index.d.ts

@@ -1,2 +1,5 @@
+export * from './base';
 export * from './evm';
-export * from './fee';
+export * from './option';
+export * from './subscription';
+export * from './substrate';

package/types/fee/index.js

@@ -1,5 +1,8 @@
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
+export * from "./base.js";
 export * from "./evm.js";
-export * from "./fee.js";
+export * from "./option.js";
+export * from "./subscription.js";
+export * from "./substrate.js";

package/types/fee/option.d.ts

@@ -0,0 +1,8 @@
+import { FeeCustom } from '@subwallet/extension-base/types';
+export declare type FeeDefaultOption = 'slow' | 'average' | 'fast';
+export declare type FeeOption = FeeDefaultOption | 'custom';
+export declare type TransactionFee = {
+    feeOption?: FeeOption;
+    feeCustom?: FeeCustom;
+    nonNativeTokenPayFeeSlug?: string;
+};

package/types/fee/option.js

@@ -0,0 +1 @@
+export {};

package/types/fee/subscription.d.ts

@@ -0,0 +1,12 @@
+import { BehaviorSubject } from 'rxjs';
+import { EvmEIP1559FeeOption, EvmFeeDetail, EvmFeeInfo } from './evm';
+import { SubstrateFeeDetail, SubstrateFeeInfo, SubstrateTipInfo } from './substrate';
+import { TonFeeDetail, TonFeeInfo, TonTipInfo } from './ton';
+export declare type FeeInfo = EvmFeeInfo | SubstrateFeeInfo | TonFeeInfo;
+export declare type FeeDetail = EvmFeeDetail | SubstrateFeeDetail | TonFeeDetail;
+export declare type FeeCustom = EvmEIP1559FeeOption | SubstrateTipInfo | TonTipInfo;
+export interface FeeSubscription {
+    observer: BehaviorSubject<FeeInfo | undefined>;
+    subscription: Record<string, VoidFunction>;
+    unsubscribe: VoidFunction;
+}

package/types/fee/subscription.js

@@ -0,0 +1 @@
+export {};

package/types/fee/substrate.d.ts

@@ -0,0 +1,15 @@
+import { BaseFeeDetail, BaseFeeInfo } from './base';
+import { FeeDefaultOption } from './option';
+export interface SubstrateTipInfo {
+    tip: string;
+}
+export interface SubstrateFeeInfo extends BaseFeeInfo {
+    type: 'substrate';
+    options: {
+        slow: SubstrateTipInfo;
+        average: SubstrateTipInfo;
+        fast: SubstrateTipInfo;
+        default: FeeDefaultOption;
+    };
+}
+export declare type SubstrateFeeDetail = SubstrateFeeInfo & BaseFeeDetail;

package/types/fee/substrate.js

@@ -0,0 +1 @@
+export {};

package/types/fee/ton.d.ts

@@ -0,0 +1,18 @@
+import { BaseFeeDetail, BaseFeeInfo } from './base';
+import { FeeDefaultOption } from './option';
+/** @deprecated */
+export interface TonTipInfo {
+    tip: string;
+}
+/** @deprecated */
+export interface TonFeeInfo extends BaseFeeInfo {
+    type: 'ton';
+    options: {
+        slow: TonTipInfo;
+        average: TonTipInfo;
+        fast: TonTipInfo;
+        default: FeeDefaultOption;
+    };
+}
+/** @deprecated */
+export declare type TonFeeDetail = TonFeeInfo & BaseFeeDetail;

package/types/fee/ton.js

@@ -0,0 +1 @@
+export {};

package/types/transaction/request.d.ts

@@ -1,4 +1,4 @@
-import { TransactionWarningType } from '@subwallet/extension-base/types';
+import { TransactionFee, TransactionWarningType } from '@subwallet/extension-base/types';
 export declare type BaseRequestSign = {
     ignoreWarnings?: TransactionWarningType[];
 };
@@ -11,14 +11,24 @@ export interface RequestBaseTransfer {
     transferAll?: boolean;
     transferBounceable?: boolean;
 }
-export interface RequestCheckTransfer extends RequestBaseTransfer {
+export interface RequestCheckTransfer extends RequestBaseTransfer, TransactionFee {
     networkKey: string;
 }
 export declare type RequestTransfer = InternalRequestSign<RequestCheckTransfer>;
-export interface RequestCheckCrossChainTransfer extends RequestBaseTransfer {
+export interface RequestCheckCrossChainTransfer extends RequestBaseTransfer, TransactionFee {
     value: string;
     originNetworkKey: string;
     destinationNetworkKey: string;
     showExtraWarning?: boolean;
 }
 export declare type RequestCrossChainTransfer = InternalRequestSign<RequestCheckCrossChainTransfer>;
+export interface RequestGetTokensCanPayFee {
+    address: string;
+    chain: string;
+    feeAmount?: string;
+}
+export interface RequestGetAmountForPair {
+    nativeTokenFeeAmount: string;
+    nativeTokenSlug: string;
+    toTokenSlug: string;
+}

package/utils/fee/combine.d.ts

@@ -0,0 +1,12 @@
+import { EvmEIP1559FeeOption, EvmFeeInfo, FeeOption, SubstrateFeeInfo, SubstrateTipInfo } from '@subwallet/extension-base/types';
+interface EvmFeeCombine {
+    gasPrice?: string;
+    maxFeePerGas?: string;
+    maxPriorityFeePerGas?: string;
+}
+export declare const combineEthFee: (feeInfo: EvmFeeInfo, feeOptions?: FeeOption, feeCustom?: EvmEIP1559FeeOption) => EvmFeeCombine;
+interface SubstrateFeeCombine {
+    tip: string;
+}
+export declare const combineSubstrateFee: (_fee: SubstrateFeeInfo, _feeOptions?: FeeOption, feeCustom?: SubstrateTipInfo) => SubstrateFeeCombine;
+export {};

package/utils/fee/combine.js

@@ -0,0 +1,42 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+export const combineEthFee = (feeInfo, feeOptions, feeCustom) => {
+  let maxFeePerGas;
+  let maxPriorityFeePerGas;
+  if (feeOptions && feeOptions !== 'custom') {
+    var _feeInfo$options, _feeInfo$options2;
+    maxFeePerGas = (_feeInfo$options = feeInfo.options) === null || _feeInfo$options === void 0 ? void 0 : _feeInfo$options[feeOptions].maxFeePerGas;
+    maxPriorityFeePerGas = (_feeInfo$options2 = feeInfo.options) === null || _feeInfo$options2 === void 0 ? void 0 : _feeInfo$options2[feeOptions].maxPriorityFeePerGas;
+  } else if (feeOptions === 'custom' && feeCustom) {
+    maxFeePerGas = feeCustom.maxFeePerGas;
+    maxPriorityFeePerGas = feeCustom.maxPriorityFeePerGas;
+  } else {
+    var _feeInfo$options3, _feeInfo$options4;
+    maxFeePerGas = (_feeInfo$options3 = feeInfo.options) === null || _feeInfo$options3 === void 0 ? void 0 : _feeInfo$options3[feeInfo.options.default].maxFeePerGas;
+    maxPriorityFeePerGas = (_feeInfo$options4 = feeInfo.options) === null || _feeInfo$options4 === void 0 ? void 0 : _feeInfo$options4[feeInfo.options.default].maxPriorityFeePerGas;
+  }
+  if (feeInfo.gasPrice) {
+    return {
+      gasPrice: feeInfo.gasPrice
+    };
+  } else {
+    return {
+      maxFeePerGas,
+      maxPriorityFeePerGas
+    };
+  }
+};
+export const combineSubstrateFee = (_fee, _feeOptions, feeCustom) => {
+  let tip;
+  if (_feeOptions && _feeOptions !== 'custom') {
+    tip = _fee.options[_feeOptions].tip;
+  } else if (_feeOptions === 'custom' && feeCustom && 'tip' in feeCustom) {
+    tip = feeCustom.tip;
+  } else {
+    tip = _fee.options[_fee.options.default].tip;
+  }
+  return {
+    tip
+  };
+};

package/utils/fee/index.d.ts

@@ -0,0 +1,2 @@
+export * from './combine';
+export * from './transfer';

package/utils/fee/index.js

@@ -0,0 +1,5 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+export * from "./combine.js";
+export * from "./transfer.js";

package/utils/fee/transfer.d.ts

@@ -0,0 +1,22 @@
+import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
+import { AmountData } from '@subwallet/extension-base/background/KoniTypes';
+import { _EvmApi, _SubstrateApi, _TonApi } from '@subwallet/extension-base/services/chain-service/types';
+import { FeeChainType, FeeInfo, TransactionFee } from '@subwallet/extension-base/types';
+import { ResponseSubscribeTransfer } from '@subwallet/extension-base/types/balance/transfer';
+export interface CalculateMaxTransferable extends TransactionFee {
+    address: string;
+    srcToken: _ChainAsset;
+    destToken?: _ChainAsset;
+    srcChain: _ChainInfo;
+    destChain: _ChainInfo;
+    substrateApi: _SubstrateApi;
+    evmApi: _EvmApi;
+    tonApi: _TonApi;
+    isTransferLocalTokenAndPayThatTokenAsFee: boolean;
+    isTransferNativeTokenAndPayLocalTokenAsFee: boolean;
+    nativeToken: _ChainAsset;
+}
+export declare const detectTransferTxType: (srcToken: _ChainAsset, srcChain: _ChainInfo, destChain: _ChainInfo) => FeeChainType;
+export declare const calculateMaxTransferable: (id: string, request: CalculateMaxTransferable, freeBalance: AmountData, fee: FeeInfo) => Promise<ResponseSubscribeTransfer>;
+export declare const calculateTransferMaxTransferable: (id: string, request: CalculateMaxTransferable, freeBalance: AmountData, fee: FeeInfo) => Promise<ResponseSubscribeTransfer>;
+export declare const calculateXCMMaxTransferable: (id: string, request: CalculateMaxTransferable, freeBalance: AmountData, fee: FeeInfo) => Promise<ResponseSubscribeTransfer>;