@subwallet/extension-base 1.2.2-0 → 1.2.3-1

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

@@ -5,11 +5,12 @@ import { BalanceService } from '@subwallet/extension-base/services/balance-servi
 import { ChainService } from '@subwallet/extension-base/services/chain-service';
 import { SwapBaseInterface } from '@subwallet/extension-base/services/swap-service/handler/base-handler';
 import { BaseStepDetail } from '@subwallet/extension-base/types/service-base';
-import { OptimalSwapPath, OptimalSwapPathParams, SwapEarlyValidation, SwapFeeInfo, SwapQuote, SwapRequest, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types/swap';
+import { OptimalSwapPath, OptimalSwapPathParams, SwapEarlyValidation, SwapFeeInfo, SwapProviderId, SwapQuote, SwapRequest, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types/swap';
 export declare class ChainflipSwapHandler implements SwapBaseInterface {
     private swapSdk;
     private readonly isTestnet;
     private swapBaseHandler;
+    providerSlug: SwapProviderId;
     constructor(chainService: ChainService, balanceService: BalanceService, isTestnet?: boolean);
     get chainService(): ChainService;
     get balanceService(): BalanceService;

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

@@ -6,11 +6,12 @@ import { COMMON_ASSETS } from '@subwallet/chain-list';
 import { SwapError } from '@subwallet/extension-base/background/errors/SwapError';
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { BasicTxErrorType, ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { _getChainflipEarlyValidationError } from '@subwallet/extension-base/core/logic-validation/swap';
 import { createTransferExtrinsic } from '@subwallet/extension-base/koni/api/dotsama/transfer';
 import { getERC20TransactionObject, getEVMTransactionObject } from '@subwallet/extension-base/koni/api/tokens/evm/transfer';
 import { _getAssetDecimals, _getChainNativeTokenSlug, _getContractAddressOfToken, _isNativeToken, _isSubstrateChain } from '@subwallet/extension-base/services/chain-service/utils';
 import { SwapBaseHandler } from '@subwallet/extension-base/services/swap-service/handler/base-handler';
-import { calculateSwapRate, CHAIN_FLIP_SUPPORTED_MAINNET_ASSET_MAPPING, CHAIN_FLIP_SUPPORTED_MAINNET_MAPPING, CHAIN_FLIP_SUPPORTED_TESTNET_ASSET_MAPPING, CHAIN_FLIP_SUPPORTED_TESTNET_MAPPING, getChainflipEarlyValidationError, SWAP_QUOTE_TIMEOUT_MAP } from '@subwallet/extension-base/services/swap-service/utils';
+import { calculateSwapRate, CHAIN_FLIP_SUPPORTED_MAINNET_ASSET_MAPPING, CHAIN_FLIP_SUPPORTED_MAINNET_MAPPING, CHAIN_FLIP_SUPPORTED_TESTNET_ASSET_MAPPING, CHAIN_FLIP_SUPPORTED_TESTNET_MAPPING, SWAP_QUOTE_TIMEOUT_MAP } from '@subwallet/extension-base/services/swap-service/utils';
 import { SwapErrorType, SwapFeeType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types/swap';
 import BigNumber from 'bignumber.js';
 var ChainflipFeeType;
@@ -37,6 +38,7 @@ export class ChainflipSwapHandler {
       providerSlug: isTestnet ? SwapProviderId.CHAIN_FLIP_TESTNET : SwapProviderId.CHAIN_FLIP_MAINNET
     });
     this.isTestnet = isTestnet;
+    this.providerSlug = isTestnet ? SwapProviderId.CHAIN_FLIP_TESTNET : SwapProviderId.CHAIN_FLIP_MAINNET;
     this.swapSdk = new SwapSDK({
       network: isTestnet ? 'perseverance' : 'mainnet'
     });
@@ -191,7 +193,7 @@ export class ChainflipSwapHandler {
     const earlyValidation = await this.validateSwapRequest(request);
     const metadata = earlyValidation.metadata;
     if (earlyValidation.error) {
-      return getChainflipEarlyValidationError(earlyValidation.error, metadata);
+      return _getChainflipEarlyValidationError(earlyValidation.error, metadata);
     }
     const srcChainId = this.chainMapping[fromAsset.originChain];
     const destChainId = this.chainMapping[toAsset.originChain];

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

@@ -4,12 +4,13 @@ import { BalanceService } from '@subwallet/extension-base/services/balance-servi
 import { ChainService } from '@subwallet/extension-base/services/chain-service';
 import { SwapBaseInterface } from '@subwallet/extension-base/services/swap-service/handler/base-handler';
 import { BaseStepDetail } from '@subwallet/extension-base/types/service-base';
-import { OptimalSwapPath, OptimalSwapPathParams, SwapEarlyValidation, SwapFeeInfo, SwapQuote, SwapRequest, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types/swap';
+import { OptimalSwapPath, OptimalSwapPathParams, SwapEarlyValidation, SwapFeeInfo, SwapProviderId, SwapQuote, SwapRequest, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types/swap';
 export declare class HydradxHandler implements SwapBaseInterface {
     private swapBaseHandler;
     private tradeRouter;
     private readonly isTestnet;
     isReady: boolean;
+    providerSlug: SwapProviderId;
     constructor(chainService: ChainService, balanceService: BalanceService, isTestnet?: boolean);
     init(): Promise<void>;
     chain: () => string;

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

@@ -7,10 +7,11 @@ import { _AssetType } from '@subwallet/chain-list/types';
 import { SwapError } from '@subwallet/extension-base/background/errors/SwapError';
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { BasicTxErrorType, ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { _getEarlyHydradxValidationError } from '@subwallet/extension-base/core/logic-validation/swap';
 import { createXcmExtrinsic } from '@subwallet/extension-base/koni/api/xcm';
 import { _getAssetDecimals, _getChainNativeTokenSlug, _getTokenOnChainAssetId, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
 import { SwapBaseHandler } from '@subwallet/extension-base/services/swap-service/handler/base-handler';
-import { calculateSwapRate, getEarlyHydradxValidationError, getSwapAlternativeAsset, SWAP_QUOTE_TIMEOUT_MAP } from '@subwallet/extension-base/services/swap-service/utils';
+import { calculateSwapRate, getSwapAlternativeAsset, SWAP_QUOTE_TIMEOUT_MAP } from '@subwallet/extension-base/services/swap-service/utils';
 import { SwapErrorType, SwapFeeType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types/swap';
 import BigNumber from 'bignumber.js';
 const HYDRADX_LOW_LIQUIDITY_THRESHOLD = 0.15;
@@ -28,6 +29,7 @@ export class HydradxHandler {
       providerName: isTestnet ? 'HydraDX Testnet' : 'HydraDX',
       providerSlug: isTestnet ? SwapProviderId.HYDRADX_TESTNET : SwapProviderId.HYDRADX_MAINNET
     });
+    this.providerSlug = isTestnet ? SwapProviderId.HYDRADX_TESTNET : SwapProviderId.HYDRADX_MAINNET;
     this.isTestnet = isTestnet;
   }
   async init() {
@@ -67,7 +69,7 @@ export class HydradxHandler {
   async getXcmStep(params) {
     const bnAmount = new BigNumber(params.request.fromAmount);
     const fromAsset = this.chainService.getAssetBySlug(params.request.pair.from);
-    const fromAssetBalance = await this.balanceService.getTokenFreeBalance(params.request.address, fromAsset.originChain, fromAsset.slug);
+    const fromAssetBalance = await this.balanceService.getTransferableBalance(params.request.address, fromAsset.originChain, fromAsset.slug);
     const bnFromAssetBalance = new BigNumber(fromAssetBalance.value);
     if (bnFromAssetBalance.gte(bnAmount)) {
       return undefined; // enough balance, no need to xcm
@@ -78,7 +80,7 @@ export class HydradxHandler {
       return undefined;
     }
     const alternativeAsset = this.chainService.getAssetBySlug(alternativeAssetSlug);
-    const alternativeAssetBalance = await this.balanceService.getTokenFreeBalance(params.request.address, alternativeAsset.originChain, alternativeAsset.slug);
+    const alternativeAssetBalance = await this.balanceService.getTransferableBalance(params.request.address, alternativeAsset.originChain, alternativeAsset.slug);
     const bnAlternativeAssetBalance = new BigNumber(alternativeAssetBalance.value);
     if (bnAlternativeAssetBalance.lte(0)) {
       return undefined;
@@ -214,7 +216,7 @@ export class HydradxHandler {
     const earlyValidation = await this.validateSwapRequest(request);
     if (earlyValidation.error) {
       const metadata = earlyValidation.metadata;
-      return getEarlyHydradxValidationError(earlyValidation.error, metadata);
+      return _getEarlyHydradxValidationError(earlyValidation.error, metadata);
     }
     try {
       const fromAssetId = _getTokenOnChainAssetId(fromAsset);
@@ -295,7 +297,7 @@ export class HydradxHandler {
     const destinationAsset = this.chainService.getAssetBySlug(pair.from);
     const substrateApi = this.chainService.getSubstrateApi(originAsset.originChain);
     const chainApi = await substrateApi.isReady;
-    const destinationAssetBalance = await this.balanceService.getTokenFreeBalance(params.address, destinationAsset.originChain, destinationAsset.slug);
+    const destinationAssetBalance = await this.balanceService.getTransferableBalance(params.address, destinationAsset.originChain, destinationAsset.slug);
     const xcmFee = params.process.totalFee[params.currentStep];
     const bnAmount = new BigNumber(params.quote.fromAmount);
     const bnDestinationAssetBalance = new BigNumber(destinationAssetBalance.value);

package/services/swap-service/index.js

@@ -7,7 +7,7 @@ import { BasicTxErrorType } from '@subwallet/extension-base/background/KoniTypes
 import { ServiceStatus } from '@subwallet/extension-base/services/base/types';
 import { ChainflipSwapHandler } from '@subwallet/extension-base/services/swap-service/handler/chainflip-handler';
 import { HydradxHandler } from '@subwallet/extension-base/services/swap-service/handler/hydradx-handler';
-import { DEFAULT_SWAP_FIRST_STEP, getSwapAltToken, MOCK_SWAP_FEE, SWAP_QUOTE_TIMEOUT_MAP } from '@subwallet/extension-base/services/swap-service/utils';
+import { _PROVIDER_TO_SUPPORTED_PAIR_MAP, DEFAULT_SWAP_FIRST_STEP, getSwapAltToken, MOCK_SWAP_FEE, SWAP_QUOTE_TIMEOUT_MAP } from '@subwallet/extension-base/services/swap-service/utils';
 import { _SUPPORTED_SWAP_PROVIDERS, SwapErrorType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types/swap';
 import { createPromiseHandler } from '@subwallet/extension-base/utils';
 import { BehaviorSubject } from 'rxjs';
@@ -24,12 +24,18 @@ export class SwapService {
   }
   async askProvidersForQuote(request) {
     const availableQuotes = [];
+    const swappingSrcChain = this.chainService.getAssetBySlug(request.pair.from).originChain;
     await Promise.all(Object.values(this.handlers).map(async handler => {
+      // temporary solution to reduce number of requests to providers, will work as long as there's only 1 provider for 1 chain
+      if (!_PROVIDER_TO_SUPPORTED_PAIR_MAP[handler.providerSlug].includes(swappingSrcChain)) {
+        return;
+      }
       if (handler.init && handler.isReady === false) {
         await handler.init();
       }
       const quote = await handler.getSwapQuote(request);
       if (!(quote instanceof SwapError)) {
+        // todo: can do better
         availableQuotes.push({
           quote
         });

package/services/swap-service/utils.d.ts

@@ -1,7 +1,6 @@
 import { Asset, Chain } from '@chainflip/sdk/swap';
 import { _ChainAsset } from '@subwallet/chain-list/types';
-import { SwapError } from '@subwallet/extension-base/background/errors/SwapError';
-import { ChainflipPreValidationMetadata, HydradxPreValidationMetadata, SwapErrorType, SwapFeeInfo, SwapPair, SwapStepDetail } from '@subwallet/extension-base/types/swap';
+import { SwapFeeInfo, SwapPair, SwapStepDetail } from '@subwallet/extension-base/types/swap';
 export declare const CHAIN_FLIP_TESTNET_EXPLORER = "https://blocks-perseverance.chainflip.io";
 export declare const CHAIN_FLIP_MAINNET_EXPLORER = "https://scan.chainflip.io";
 export declare const CHAIN_FLIP_SUPPORTED_MAINNET_MAPPING: Record<string, Chain>;
@@ -11,8 +10,7 @@ export declare const CHAIN_FLIP_SUPPORTED_TESTNET_ASSET_MAPPING: Record<string,
 export declare const SWAP_QUOTE_TIMEOUT_MAP: Record<string, number>;
 export declare const DEFAULT_SWAP_FIRST_STEP: SwapStepDetail;
 export declare const MOCK_SWAP_FEE: SwapFeeInfo;
+export declare const _PROVIDER_TO_SUPPORTED_PAIR_MAP: Record<string, string[]>;
 export declare function getSwapAlternativeAsset(swapPair: SwapPair): string | undefined;
 export declare function getSwapAltToken(chainAsset: _ChainAsset): string | undefined;
 export declare function calculateSwapRate(fromAmount: string, toAmount: string, fromAsset: _ChainAsset, toAsset: _ChainAsset): number;
-export declare function getChainflipEarlyValidationError(error: SwapErrorType, metadata: ChainflipPreValidationMetadata): SwapError;
-export declare function getEarlyHydradxValidationError(error: SwapErrorType, metadata: HydradxPreValidationMetadata): SwapError;

package/services/swap-service/utils.js

@@ -3,10 +3,8 @@
 
 import { Assets, Chains } from '@chainflip/sdk/swap';
 import { COMMON_ASSETS, COMMON_CHAIN_SLUGS } from '@subwallet/chain-list';
-import { SwapError } from '@subwallet/extension-base/background/errors/SwapError';
 import { _getAssetDecimals } from '@subwallet/extension-base/services/chain-service/utils';
-import { SwapErrorType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types/swap';
-import { formatNumber } from '@subwallet/extension-base/utils';
+import { SwapProviderId, SwapStepType } from '@subwallet/extension-base/types/swap';
 import BigN from 'bignumber.js';
 export const CHAIN_FLIP_TESTNET_EXPLORER = 'https://blocks-perseverance.chainflip.io';
 export const CHAIN_FLIP_MAINNET_EXPLORER = 'https://scan.chainflip.io';
@@ -44,6 +42,12 @@ export const MOCK_SWAP_FEE = {
   defaultFeeToken: '',
   feeOptions: []
 };
+export const _PROVIDER_TO_SUPPORTED_PAIR_MAP = {
+  [SwapProviderId.HYDRADX_MAINNET]: [COMMON_CHAIN_SLUGS.HYDRADX],
+  [SwapProviderId.HYDRADX_TESTNET]: [COMMON_CHAIN_SLUGS.HYDRADX_TESTNET],
+  [SwapProviderId.CHAIN_FLIP_MAINNET]: [COMMON_CHAIN_SLUGS.POLKADOT, COMMON_CHAIN_SLUGS.ETHEREUM],
+  [SwapProviderId.CHAIN_FLIP_TESTNET]: [COMMON_CHAIN_SLUGS.CHAINFLIP_POLKADOT, COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA]
+};
 export function getSwapAlternativeAsset(swapPair) {
   var _swapPair$metadata;
   return swapPair === null || swapPair === void 0 ? void 0 : (_swapPair$metadata = swapPair.metadata) === null || _swapPair$metadata === void 0 ? void 0 : _swapPair$metadata.alternativeAsset;
@@ -58,48 +62,4 @@ export function calculateSwapRate(fromAmount, toAmount, fromAsset, toAsset) {
   const decimalDiff = _getAssetDecimals(toAsset) - _getAssetDecimals(fromAsset);
   const bnRate = bnFromAmount.div(bnToAmount);
   return 1 / bnRate.times(10 ** decimalDiff).toNumber();
-}
-export function getChainflipEarlyValidationError(error, metadata) {
-  // todo: support more providers
-  switch (error) {
-    case SwapErrorType.NOT_MEET_MIN_SWAP:
-      {
-        const parsedMinSwapValue = formatNumber(metadata.minSwap.value, metadata.minSwap.decimals);
-        const message = `Amount too low. Increase your amount above ${parsedMinSwapValue} ${metadata.minSwap.symbol} and try again`;
-        return new SwapError(error, message);
-      }
-    case SwapErrorType.SWAP_EXCEED_ALLOWANCE:
-      {
-        if (metadata.maxSwap) {
-          const parsedMaxSwapValue = formatNumber(metadata.maxSwap.value, metadata.maxSwap.decimals);
-          return new SwapError(error, `Amount too high. Lower your amount below ${parsedMaxSwapValue} ${metadata.maxSwap.symbol} and try again`);
-        } else {
-          return new SwapError(error, 'Amount too high. Lower your amount and try again');
-        }
-      }
-    case SwapErrorType.ASSET_NOT_SUPPORTED:
-      return new SwapError(error, 'This swap pair is not supported');
-    case SwapErrorType.UNKNOWN:
-      return new SwapError(error, `Undefined error. Check your Internet and ${metadata.chain.slug} connection or contact support`);
-    case SwapErrorType.ERROR_FETCHING_QUOTE:
-      return new SwapError(error, 'No swap quote found. Adjust your amount or try again later.');
-    default:
-      return new SwapError(error);
-  }
-}
-export function getEarlyHydradxValidationError(error, metadata) {
-  switch (error) {
-    case SwapErrorType.AMOUNT_CANNOT_BE_ZERO:
-      {
-        return new SwapError(error, 'Amount too low. Increase your amount above 0 and try again');
-      }
-    case SwapErrorType.ASSET_NOT_SUPPORTED:
-      return new SwapError(error, 'This swap pair is not supported');
-    case SwapErrorType.UNKNOWN:
-      return new SwapError(error, `Undefined error. Check your Internet and ${metadata.chain.slug} connection or contact support`);
-    case SwapErrorType.ERROR_FETCHING_QUOTE:
-      return new SwapError(error, 'No swap quote found. Adjust your amount or try again later.');
-    default:
-      return new SwapError(error);
-  }
 }

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

@@ -18,7 +18,7 @@ export default class TransactionService {
     private get processingTransactions();
     getTransaction(id: string): SWTransaction;
     private checkDuplicate;
-    generalValidate(validationInput: SWTransactionInput): Promise<SWTransactionResponse>;
+    validateTransaction(transactionInput: SWTransactionInput): Promise<SWTransactionResponse>;
     getTransactionSubject(): BehaviorSubject<Record<string, SWTransaction>>;
     private fillTransactionDefaultInfo;
     addTransaction(inputTransaction: SWTransactionInput): Promise<TransactionEmitter>;

package/services/transaction-service/index.js

@@ -3,11 +3,10 @@
 
 import { EvmProviderError } from '@subwallet/extension-base/background/errors/EvmProviderError';
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
-import { BasicTxErrorType, BasicTxWarningCode, ChainType, EvmProviderErrorType, ExtrinsicStatus, ExtrinsicType, NotificationType, TransactionDirection } from '@subwallet/extension-base/background/KoniTypes';
-import { TransactionWarning } from '@subwallet/extension-base/background/warnings/TransactionWarning';
+import { BasicTxErrorType, ChainType, EvmProviderErrorType, ExtrinsicStatus, ExtrinsicType, NotificationType, TransactionDirection } from '@subwallet/extension-base/background/KoniTypes';
 import { ALL_ACCOUNT_KEY } from '@subwallet/extension-base/constants';
+import { checkBalanceWithTransactionFee, checkSigningAccountForTransaction, checkSupportForTransaction, estimateFeeForTransaction } from '@subwallet/extension-base/core/logic-validation/transfer';
 import { _getAssetDecimals, _getAssetSymbol, _getChainNativeTokenBasicInfo, _getEvmChainId, _isChainEvmCompatible } from '@subwallet/extension-base/services/chain-service/utils';
-import { calculateGasFeeParams } from '@subwallet/extension-base/services/fee-service/utils';
 import { EXTENSION_REQUEST_URL } from '@subwallet/extension-base/services/request-service/constants';
 import { TRANSACTION_TIMEOUT } from '@subwallet/extension-base/services/transaction-service/constants';
 import { parseLiquidStakingEvents, parseLiquidStakingFastUnstakeEvents, parseTransferEventLogs, parseXcmEventLogs } from '@subwallet/extension-base/services/transaction-service/event-parser';
@@ -20,14 +19,12 @@ import { mergeTransactionAndSignature } from '@subwallet/extension-base/utils/et
 import { isContractAddress, parseContractInput } from '@subwallet/extension-base/utils/eth/parseTransaction';
 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';
 import { t } from 'i18next';
 import { BehaviorSubject, interval as rxjsInterval } from 'rxjs';
 import { isHex } from '@polkadot/util';
-import { _TRANSFER_CHAIN_GROUP } from "../chain-service/constants.js";
 export default class TransactionService {
   transactionSubject = new BehaviorSubject({});
   watchTransactionSubscribes = {};
@@ -58,134 +55,48 @@ export default class TransactionService {
     }
     return [];
   }
-  async generalValidate(validationInput) {
-    const validation = {
-      ...validationInput,
-      errors: validationInput.errors || [],
-      warnings: validationInput.warnings || []
+  async validateTransaction(transactionInput) {
+    const validationResponse = {
+      ...transactionInput,
+      status: undefined,
+      errors: transactionInput.errors || [],
+      warnings: transactionInput.warnings || []
     };
     const {
       additionalValidator,
       address,
       chain,
-      edAsWarning,
-      extrinsicType,
-      isTransferAll,
-      transaction
-    } = validation;
-
-    // Check duplicate transaction
-    validation.errors.push(...this.checkDuplicate(validationInput));
+      extrinsicType
+    } = validationResponse;
+    const transaction = transactionInput.transaction;
 
-    // Return unsupported error if not found transaction
-    if (!transaction) {
-      if (extrinsicType === ExtrinsicType.SEND_NFT) {
-        validation.errors.push(new TransactionError(BasicTxErrorType.UNSUPPORTED, t('This feature is not yet available for this NFT')));
-      } else {
-        validation.errors.push(new TransactionError(BasicTxErrorType.UNSUPPORTED));
-      }
-    }
-    const validationResponse = {
-      status: undefined,
-      ...validation
-    };
+    // Check duplicated transaction
+    validationResponse.errors.push(...this.checkDuplicate(transactionInput));
 
-    // Estimate fee
-    const estimateFee = {
-      symbol: '',
-      decimals: 0,
-      value: '',
-      tooHigh: false
-    };
+    // Check support for transaction
+    checkSupportForTransaction(validationResponse, transaction);
     const chainInfo = this.state.chainService.getChainInfoByKey(chain);
     if (!chainInfo) {
       validationResponse.errors.push(new TransactionError(BasicTxErrorType.INTERNAL_ERROR, t('Cannot find network')));
-    } else {
-      const {
-        decimals,
-        symbol
-      } = _getChainNativeTokenBasicInfo(chainInfo);
-      estimateFee.decimals = decimals;
-      estimateFee.symbol = symbol;
-      if (transaction) {
-        try {
-          if (isSubstrateTransaction(transaction)) {
-            estimateFee.value = (await transaction.paymentInfo(address)).partialFee.toString();
-          } else {
-            const web3 = this.state.chainService.getEvmApi(chain);
-            if (!web3) {
-              validationResponse.errors.push(new TransactionError(BasicTxErrorType.CHAIN_DISCONNECTED, undefined));
-            } else {
-              const gasLimit = await web3.api.eth.estimateGas(transaction);
-              const priority = await calculateGasFeeParams(web3, chainInfo.slug);
-              if (priority.baseGasFee) {
-                const maxFee = priority.maxFeePerGas; // TODO: Need review
-
-                estimateFee.value = maxFee.multipliedBy(gasLimit).toFixed(0);
-              } else {
-                estimateFee.value = new BigN(priority.gasPrice).multipliedBy(gasLimit).toFixed(0);
-              }
-              estimateFee.tooHigh = priority.busyNetwork;
-            }
-          }
-        } catch (e) {
-          const error = e;
-          if (error.message.includes('gas required exceeds allowance') && error.message.includes('insufficient funds')) {
-            validationResponse.errors.push(new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE));
-          }
-          estimateFee.value = '0';
-        }
-      }
     }
-    validationResponse.estimateFee = estimateFee;
-
-    // Read-only account
-    const pair = keyring.getPair(address);
-    if (!pair) {
-      validationResponse.errors.push(new TransactionError(BasicTxErrorType.INTERNAL_ERROR, t('Unable to find account')));
-    } else {
-      var _pair$meta;
-      if ((_pair$meta = pair.meta) !== null && _pair$meta !== void 0 && _pair$meta.isReadOnly) {
-        validationResponse.errors.push(new TransactionError(BasicTxErrorType.INTERNAL_ERROR, t('This account is watch-only')));
-      }
+    const evmApi = this.state.chainService.getEvmApi(chainInfo.slug);
+    const isNeedEvmApi = transaction && !isSubstrateTransaction(transaction) && !evmApi;
+    if (isNeedEvmApi) {
+      validationResponse.errors.push(new TransactionError(BasicTxErrorType.CHAIN_DISCONNECTED, undefined));
     }
 
-    // Balance
-    const transferNative = validationResponse.transferNativeAmount || '0';
+    // Estimate fee for transaction
+    validationResponse.estimateFee = await estimateFeeForTransaction(validationResponse, transaction, chainInfo, evmApi);
+
+    // Check account signing transaction
+    checkSigningAccountForTransaction(validationResponse);
     const nativeTokenInfo = this.state.chainService.getNativeTokenInfo(chain);
-    const balance = await this.state.balanceService.getTokenFreeBalance(address, chain, nativeTokenInfo.slug);
-    const existentialDeposit = nativeTokenInfo.minAmount || '0';
-    const feeNum = parseInt(estimateFee.value);
-    const balanceNum = parseInt(balance.value);
-    const edNum = parseInt(existentialDeposit);
-    const transferNativeNum = parseInt(transferNative);
-    if (!validationInput.skipFeeValidation) {
-      // TODO
-      if (!new BigN(balance.value).gt(0)) {
-        validationResponse.errors.push(new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE));
-      }
-      if (transferNativeNum + feeNum > balanceNum) {
-        if (!isTransferAll) {
-          validationResponse.errors.push(new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE));
-        } else {
-          if ([..._TRANSFER_CHAIN_GROUP.acala, ..._TRANSFER_CHAIN_GROUP.genshiro, ..._TRANSFER_CHAIN_GROUP.bitcountry, ..._TRANSFER_CHAIN_GROUP.statemine].includes(chain)) {
-            // Chain not have transfer all function
-            validationResponse.errors.push(new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE));
-          }
-        }
-      }
-      if (!isTransferAll) {
-        if (balanceNum - (transferNativeNum + feeNum) < edNum) {
-          if (edAsWarning) {
-            validationResponse.warnings.push(new TransactionWarning(BasicTxWarningCode.NOT_ENOUGH_EXISTENTIAL_DEPOSIT));
-          } else {
-            validationResponse.errors.push(new TransactionError(BasicTxErrorType.NOT_ENOUGH_EXISTENTIAL_DEPOSIT));
-          }
-        }
-      }
-    }
+    const nativeTokenAvailable = await this.state.balanceService.getTransferableBalance(address, chain, nativeTokenInfo.slug, extrinsicType);
+
+    // Check available balance against transaction fee
+    checkBalanceWithTransactionFee(validationResponse, transactionInput, nativeTokenInfo, nativeTokenAvailable);
 
-    // Validate transaction with additionalValidator method
+    // Check additional validations
     additionalValidator && (await additionalValidator(validationResponse));
     return validationResponse;
   }
@@ -235,7 +146,7 @@ export default class TransactionService {
     };
   }
   async handleTransaction(transaction) {
-    const validatedTransaction = await this.generalValidate(transaction);
+    const validatedTransaction = await this.validateTransaction(transaction);
     const stopByErrors = validatedTransaction.errors.length > 0;
     const stopByWarnings = validatedTransaction.warnings.length > 0 && !validatedTransaction.ignoreWarnings;
     if (stopByErrors || stopByWarnings) {

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

@@ -53,4 +53,5 @@ export interface TransactionEventMap {
     success: (response: TransactionEventResponse) => void;
     timeout: (response: TransactionEventResponse) => void;
 }
+export declare type OptionalSWTransaction = SWTransaction['transaction'] | null | undefined;
 export {};

package/types/balance/index.d.ts

@@ -1,5 +1,5 @@
 import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
-import { APIItemState } from '@subwallet/extension-base/background/KoniTypes';
+import { _BalanceMetadata, APIItemState, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 import { _EvmApi } from '@subwallet/extension-base/services/chain-service/types';
 import { ApiPromise } from '@polkadot/api';
 import { BN } from '@polkadot/util';
@@ -8,20 +8,15 @@ export interface TokenBalanceRaw {
     frozen: BN;
     free: BN;
 }
-export interface SubstrateBalance {
-    reserved?: string;
-    miscFrozen?: string;
-    feeFrozen?: string;
-}
 /**
  * Balance info of a token on an address
  * @property {string} address - Address
  * @property {string} tokenSlug - Slug of token
  * @property {APIItemState} state - State of information
  * @property {number} [timestamp] - Time to get information
- * @property {string} free - Free balance
- * @property {string} locked - Locked balance
- * @property {SubstrateBalance} [substrateInfo] - Substrate info of balance
+ * @property {string} free - Transferable balance
+ * @property {string} locked - Locked balance, cannot be transferred, locked here is only meaningful in the context of token transfer
+ * @property {metadata} [metadata] - Could be anything, supposed to be generic to handle various contexts
  */
 export interface BalanceItem {
     address: string;
@@ -30,7 +25,7 @@ export interface BalanceItem {
     timestamp?: number;
     free: string;
     locked: string;
-    substrateInfo?: SubstrateBalance;
+    metadata?: _BalanceMetadata;
 }
 /** Balance info of all tokens on an address */
 export declare type BalanceInfo = Record<string, BalanceItem>;
@@ -45,6 +40,7 @@ export interface SubscribeBasePalletBalance {
     assetMap: Record<string, _ChainAsset>;
     chainInfo: _ChainInfo;
     callback: (rs: BalanceItem[]) => void;
+    extrinsicType?: ExtrinsicType;
 }
 export interface SubscribeSubstratePalletBalance extends SubscribeBasePalletBalance {
     substrateApi: ApiPromise;

package/types/yield/info/pallet.d.ts

@@ -1,10 +1,4 @@
 import { BN } from '@polkadot/util';
-export interface PalletNominationPoolsPoolMember {
-    poolId: number;
-    points: number;
-    lasRecordedRewardCounter: number;
-    unbondingEras: Record<string, number>;
-}
 export interface PalletStakingExposureItem {
     who: string;
     value: number;