@subwallet/extension-base 1.2.3-0 → 1.2.4-0

package/services/migration-service/scripts/index.js

@@ -49,8 +49,8 @@ export default {
   '1.1.28-01': MigrateEarningVersion,
   '1.1.41-01': DeleteChainStaking,
   '1.1.46-01': AutoEnableSomeTokens,
-  '1.1.62-01': MigrateAssetSetting,
-  '1.1.62-02': MigrateTransactionHistoryBySymbol,
+  '1.1.69-03': MigrateAssetSetting,
+  '1.1.69-02': MigrateTransactionHistoryBySymbol,
   '1.2.69-01': MigrateRemoveGenesisHash
   // [`${EVERYTIME}-1.1.42-02`]: MigrateTransactionHistoryBySymbol
   // [`${EVERYTIME}-1`]: AutoEnableChainsTokens

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

@@ -3,8 +3,9 @@ import { TransactionError } from '@subwallet/extension-base/background/errors/Tr
 import { BalanceService } from '@subwallet/extension-base/services/balance-service';
 import { ChainService } from '@subwallet/extension-base/services/chain-service';
 import { BaseStepDetail } from '@subwallet/extension-base/types/service-base';
-import { GenSwapStepFunc, OptimalSwapPath, OptimalSwapPathParams, SwapEarlyValidation, SwapFeeInfo, SwapProvider, SwapQuote, SwapRequest, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types/swap';
+import { GenSwapStepFunc, OptimalSwapPath, OptimalSwapPathParams, SwapEarlyValidation, SwapFeeInfo, SwapProvider, SwapProviderId, SwapQuote, SwapRequest, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types/swap';
 export interface SwapBaseInterface {
+    providerSlug: SwapProviderId;
     getSwapQuote: (request: SwapRequest) => Promise<SwapQuote | SwapError>;
     generateOptimalProcess: (params: OptimalSwapPathParams) => Promise<OptimalSwapPath>;
     getSubmitStep: (params: OptimalSwapPathParams) => Promise<[BaseStepDetail, SwapFeeInfo] | undefined>;
@@ -16,7 +17,7 @@ export interface SwapBaseInterface {
     init?: () => Promise<void>;
 }
 export interface SwapBaseHandlerInitParams {
-    providerSlug: string;
+    providerSlug: SwapProviderId;
     providerName: string;
     chainService: ChainService;
     balanceService: BalanceService;

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

@@ -3,13 +3,13 @@
 
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { BasicTxErrorType } from '@subwallet/extension-base/background/KoniTypes';
-import { _getAssetDecimals, _getTokenMinAmount, _isChainEvmCompatible, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
+import { _validateBalanceToSwap, _validateSwapRecipient } from '@subwallet/extension-base/core/logic-validation/swap';
+import { _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
 import { DEFAULT_SWAP_FIRST_STEP, getSwapAlternativeAsset, MOCK_SWAP_FEE } from '@subwallet/extension-base/services/swap-service/utils';
 import { SwapErrorType, SwapFeeType } from '@subwallet/extension-base/types/swap';
 import { formatNumber } from '@subwallet/extension-base/utils';
 import BigNumber from 'bignumber.js';
 import { t } from 'i18next';
-import { isEthereumAddress } from '@polkadot/util-crypto';
 export class SwapBaseHandler {
   constructor({
     balanceService,
@@ -54,18 +54,19 @@ export class SwapBaseHandler {
     }
     const alternativeAsset = this.chainService.getAssetBySlug(alternativeAssetSlug);
     const fromAsset = this.chainService.getAssetBySlug(swapPair.from);
-    const [alternativeAssetBalance, fromAssetBalance] = await Promise.all([this.balanceService.getTokenFreeBalance(params.address, alternativeAsset.originChain, alternativeAssetSlug), this.balanceService.getTokenFreeBalance(params.address, fromAsset.originChain, fromAsset.slug)]);
+    const [alternativeAssetBalance, fromAssetBalance] = await Promise.all([this.balanceService.getTransferableBalance(params.address, alternativeAsset.originChain, alternativeAssetSlug), this.balanceService.getTransferableBalance(params.address, fromAsset.originChain, fromAsset.slug)]);
     const bnAlternativeAssetBalance = new BigNumber(alternativeAssetBalance.value);
     const bnFromAssetBalance = new BigNumber(fromAssetBalance.value);
     const xcmFeeComponent = params.process.totalFee[stepIndex].feeComponent[0]; // todo: can do better than indexing
     const xcmFee = new BigNumber(xcmFeeComponent.amount || '0');
     let xcmAmount = bnAmount.minus(bnFromAssetBalance);
+    let editedXcmFee = new BigNumber(0);
     if (_isNativeToken(alternativeAsset)) {
       xcmAmount = xcmAmount.plus(xcmFee);
+      editedXcmFee = xcmFee.times(2);
     }
-    const alternativeTokenMinAmount = new BigNumber(alternativeAsset.minAmount || '0');
-    if (!bnAlternativeAssetBalance.minus(xcmAmount).gte(alternativeTokenMinAmount)) {
-      const maxBn = bnFromAssetBalance.plus(new BigNumber(alternativeAssetBalance.value)).minus(xcmFee).minus(alternativeTokenMinAmount);
+    if (!bnAlternativeAssetBalance.minus(_isNativeToken(alternativeAsset) ? xcmAmount.plus(xcmFee) : xcmFee).gt(0)) {
+      const maxBn = bnFromAssetBalance.plus(new BigNumber(alternativeAssetBalance.value)).minus(_isNativeToken(alternativeAsset) ? editedXcmFee : xcmFee);
       const maxValue = formatNumber(maxBn.toString(), fromAsset.decimals || 0);
       const altInputTokenInfo = this.chainService.getAssetBySlug(alternativeAssetSlug);
       const symbol = altInputTokenInfo.symbol;
@@ -74,7 +75,7 @@ export class SwapBaseHandler {
       const inputNetworkName = chain.name;
       const altNetworkName = alternativeChain.name;
       const currentValue = formatNumber(bnFromAssetBalance.toString(), fromAsset.decimals || 0);
-      const bnMaxXCM = new BigNumber(alternativeAssetBalance.value).minus(xcmFee).minus(alternativeTokenMinAmount);
+      const bnMaxXCM = new BigNumber(alternativeAssetBalance.value).minus(_isNativeToken(alternativeAsset) ? editedXcmFee : xcmFee);
       const maxXCMValue = formatNumber(bnMaxXCM.toString(), fromAsset.decimals || 0);
       if (maxBn.lte(0) || bnFromAssetBalance.lte(0) || bnMaxXCM.lte(0)) {
         return [new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE, t(`Insufficient balance. Deposit ${fromAsset.symbol} and try again.`))];
@@ -102,7 +103,7 @@ export class SwapBaseHandler {
     const feeInfo = params.process.totalFee[stepIndex];
     const feeAmount = feeInfo.feeComponent[0];
     const feeTokenInfo = this.chainService.getAssetBySlug(feeInfo.defaultFeeToken);
-    const feeTokenBalance = await this.balanceService.getTokenFreeBalance(params.address, feeTokenInfo.originChain, feeTokenInfo.slug);
+    const feeTokenBalance = await this.balanceService.getTransferableBalance(params.address, feeTokenInfo.originChain, feeTokenInfo.slug);
     const bnFeeTokenBalance = new BigNumber(feeTokenBalance.value);
     const bnFeeAmount = new BigNumber(feeAmount.amount);
     if (bnFeeAmount.gte(bnFeeTokenBalance)) {
@@ -111,6 +112,9 @@ export class SwapBaseHandler {
     return [];
   }
   async validateSwapStep(params, isXcmOk, stepIndex) {
+    // check swap quote timestamp
+    // check balance to pay transaction fee
+    // check balance against spending amount
     if (!params.selectedQuote) {
       return Promise.resolve([new TransactionError(BasicTxErrorType.INTERNAL_ERROR)]);
     }
@@ -119,49 +123,31 @@ export class SwapBaseHandler {
     if (selectedQuote.aliveUntil <= currentTimestamp) {
       return Promise.resolve([new TransactionError(SwapErrorType.QUOTE_TIMEOUT)]);
     }
-    const bnAmount = new BigNumber(params.selectedQuote.fromAmount);
-    const fromAsset = this.chainService.getAssetBySlug(params.selectedQuote.pair.from);
     const stepFee = params.process.totalFee[stepIndex].feeComponent;
     const networkFee = stepFee.find(fee => fee.feeType === SwapFeeType.NETWORK_FEE);
     if (!networkFee) {
       return Promise.resolve([new TransactionError(BasicTxErrorType.INTERNAL_ERROR)]);
     }
+    const fromAsset = this.chainService.getAssetBySlug(params.selectedQuote.pair.from);
     const feeTokenInfo = this.chainService.getAssetBySlug(networkFee.tokenSlug);
     const feeTokenChain = this.chainService.getChainInfoByKey(feeTokenInfo.originChain);
-    const [feeTokenBalance, fromAssetBalance] = await Promise.all([this.balanceService.getTokenFreeBalance(params.address, feeTokenInfo.originChain, feeTokenInfo.slug), this.balanceService.getTokenFreeBalance(params.address, fromAsset.originChain, fromAsset.slug)]);
-    const bnFeeTokenBalance = new BigNumber(feeTokenBalance.value);
-    const bnFromAssetBalance = new BigNumber(fromAssetBalance.value);
-    const bnFeeAmount = new BigNumber(networkFee.amount);
-    if (bnFeeTokenBalance.lte(bnFeeAmount)) {
-      return Promise.resolve([new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE, `You don't have enough ${feeTokenInfo.symbol} (${feeTokenChain.name}) to pay transaction fee`)]);
+    const {
+      fromAmount,
+      minSwap
+    } = params.selectedQuote;
+    const [feeTokenBalance, fromAssetBalance] = await Promise.all([this.balanceService.getTransferableBalance(params.address, feeTokenInfo.originChain, feeTokenInfo.slug), this.balanceService.getTransferableBalance(params.address, fromAsset.originChain, fromAsset.slug)]);
+    const balanceError = _validateBalanceToSwap(fromAsset, feeTokenInfo, feeTokenChain, networkFee.amount, fromAssetBalance.value, feeTokenBalance.value, fromAmount, isXcmOk, minSwap);
+    if (balanceError) {
+      return Promise.resolve([balanceError]);
     }
-    if (fromAsset.slug === feeTokenInfo.slug) {
-      if (bnFromAssetBalance.lte(bnFeeAmount.plus(bnAmount))) {
-        return Promise.resolve([new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE, `Insufficient balance. Deposit ${fromAsset.symbol} and try again.`)]);
-      }
+    if (!params.recipient) {
+      return Promise.resolve([]);
     }
-    if (params.selectedQuote.minSwap) {
-      const minProtocolSwap = new BigNumber(params.selectedQuote.minSwap);
-      if (!isXcmOk && bnFromAssetBalance.lte(minProtocolSwap)) {
-        const parsedMinSwapValue = formatNumber(minProtocolSwap, _getAssetDecimals(fromAsset));
-        return Promise.resolve([new TransactionError(SwapErrorType.SWAP_NOT_ENOUGH_BALANCE, `Insufficient balance. You need more than ${parsedMinSwapValue} ${fromAsset.symbol} to start swapping. Deposit ${fromAsset.symbol} and try again.`)]); // todo: min swap or amount?
-      }
-    }
-
-    const bnSrcAssetMinAmount = new BigNumber(_getTokenMinAmount(fromAsset));
-    const bnMaxBalanceSwap = bnFromAssetBalance.minus(bnSrcAssetMinAmount);
-    if (!isXcmOk && bnAmount.gte(bnMaxBalanceSwap)) {
-      const parsedMaxBalanceSwap = formatNumber(bnMaxBalanceSwap, _getAssetDecimals(fromAsset));
-      return Promise.resolve([new TransactionError(SwapErrorType.SWAP_EXCEED_ALLOWANCE, `Amount too high. Lower your amount ${bnMaxBalanceSwap.gt(0) ? `below ${parsedMaxBalanceSwap} ${fromAsset.symbol}` : ''} and try again`)]);
-    }
-    if (params.recipient) {
-      const toAsset = this.chainService.getAssetBySlug(params.selectedQuote.pair.to);
-      const destChainInfo = this.chainService.getChainInfoByKey(toAsset.originChain);
-      const isEvmAddress = isEthereumAddress(params.recipient);
-      const isEvmDestChain = _isChainEvmCompatible(destChainInfo);
-      if (isEvmAddress && !isEvmDestChain || !isEvmAddress && isEvmDestChain) {
-        return Promise.resolve([new TransactionError(SwapErrorType.INVALID_RECIPIENT)]);
-      }
+    const toAsset = this.chainService.getAssetBySlug(params.selectedQuote.pair.to);
+    const toAssetChain = this.chainService.getChainInfoByKey(toAsset.originChain);
+    const recipientError = _validateSwapRecipient(toAssetChain, params.recipient);
+    if (recipientError) {
+      return Promise.resolve([recipientError]);
     }
     return Promise.resolve([]);
   }

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;
@@ -25,9 +26,10 @@ export class HydradxHandler {
     this.swapBaseHandler = new SwapBaseHandler({
       balanceService,
       chainService,
-      providerName: isTestnet ? 'HydraDX Testnet' : 'HydraDX',
+      providerName: isTestnet ? 'Hydration Testnet' : 'Hydration',
       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 {};