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

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

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

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

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

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

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

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;
+}