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

package/services/balance-service/helpers/subscribe/index.js

@@ -67,18 +67,8 @@ const filterAddress = (addresses, chainInfo) => {
   }
 };
 
-// interface SubscribeBlanceOptions {
-//   addresses: string[];
-//   chains: string[];
-//   tokens: string[];
-//   chainInfoMap: Record<string, _ChainInfo>;
-//   substrateApiMap: Record<string, _SubstrateApi>;
-//   evmApiMap: Record<string, _EvmApi>;
-//   callback: (rs: BalanceItem[]) => void;
-// }
-
 // main subscription, use for multiple chains, multiple addresses and multiple tokens
-export function subscribeBalance(addresses, chains, tokens, _chainAssetMap, _chainInfoMap, substrateApiMap, evmApiMap, callback) {
+export function subscribeBalance(addresses, chains, tokens, _chainAssetMap, _chainInfoMap, substrateApiMap, evmApiMap, callback, extrinsicType) {
   // Filter chain and token
   const chainAssetMap = Object.fromEntries(Object.entries(_chainAssetMap).filter(([token]) => tokens.includes(token)));
   const chainInfoMap = Object.fromEntries(Object.entries(_chainInfoMap).filter(([chain]) => chains.includes(chain)));
@@ -112,26 +102,8 @@ export function subscribeBalance(addresses, chains, tokens, _chainAssetMap, _cha
         evmApi
       });
     }
-
-    // if (!useAddresses || useAddresses.length === 0 || _PURE_EVM_CHAINS.indexOf(chainSlug) > -1) {
-    //   const fungibleTokensByChain = state.chainService.getFungibleTokensByChain(chainSlug, true);
-    //   const now = new Date().getTime();
-    //
-    //   Object.values(fungibleTokensByChain).map((token) => {
-    //     return {
-    //       tokenSlug: token.slug,
-    //       free: '0',
-    //       locked: '0',
-    //       state: APIItemState.READY,
-    //       timestamp: now
-    //     } as BalanceItem;
-    //   }).forEach(callback);
-    //
-    //   return undefined;
-    // }
-
     const substrateApi = await substrateApiMap[chainSlug].isReady;
-    return subscribeSubstrateBalance(useAddresses, chainInfo, chainAssetMap, substrateApi, evmApi, callback);
+    return subscribeSubstrateBalance(useAddresses, chainInfo, chainAssetMap, substrateApi, evmApi, callback, extrinsicType);
   });
   return () => {
     unsubList.forEach(subProm => {

package/services/balance-service/helpers/subscribe/substrate/index.d.ts

@@ -1,4 +1,5 @@
 import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
+import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 import { _EvmApi, _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
 import { BalanceItem } from '@subwallet/extension-base/types';
-export declare const subscribeSubstrateBalance: (addresses: string[], chainInfo: _ChainInfo, assetMap: Record<string, _ChainAsset>, substrateApi: _SubstrateApi, evmApi: _EvmApi, callback: (rs: BalanceItem[]) => void) => Promise<() => void>;
+export declare const subscribeSubstrateBalance: (addresses: string[], chainInfo: _ChainInfo, assetMap: Record<string, _ChainAsset>, substrateApi: _SubstrateApi, evmApi: _EvmApi, callback: (rs: BalanceItem[]) => void, extrinsicType?: ExtrinsicType) => Promise<() => void>;

package/services/balance-service/helpers/subscribe/substrate/index.js

@@ -5,10 +5,12 @@ import { GearApi } from '@gear-js/api';
 import { _AssetType } from '@subwallet/chain-list/types';
 import { APIItemState } from '@subwallet/extension-base/background/KoniTypes';
 import { SUB_TOKEN_REFRESH_BALANCE_INTERVAL } from '@subwallet/extension-base/constants';
+import { _getActiveStakeInNominationPool } from '@subwallet/extension-base/core/substrate/nominationpools-pallet';
+import { _getSystemPalletTotalBalance, _getSystemPalletTransferable } from '@subwallet/extension-base/core/substrate/system-pallet';
 import { getPSP22ContractPromise } from '@subwallet/extension-base/koni/api/tokens/wasm';
 import { getDefaultWeightV2 } from '@subwallet/extension-base/koni/api/tokens/wasm/utils';
 import { _BALANCE_CHAIN_GROUP, _MANTA_ZK_CHAIN_GROUP, _ZK_ASSET_PREFIX } from '@subwallet/extension-base/services/chain-service/constants';
-import { _checkSmartContractSupportByChain, _getChainNativeTokenSlug, _getContractAddressOfToken, _getTokenOnChainAssetId, _getTokenOnChainInfo, _getTokenTypesSupportedByChain, _getXcmAssetMultilocation, _isBridgedToken, _isChainEvmCompatible, _isSubstrateRelayChain } from '@subwallet/extension-base/services/chain-service/utils';
+import { _checkSmartContractSupportByChain, _getChainExistentialDeposit, _getChainNativeTokenSlug, _getContractAddressOfToken, _getTokenOnChainAssetId, _getTokenOnChainInfo, _getTokenTypesSupportedByChain, _getXcmAssetMultilocation, _isBridgedToken, _isChainEvmCompatible, _isSubstrateRelayChain } from '@subwallet/extension-base/services/chain-service/utils';
 import { filterAssetsByChainAndType, getGRC20ContractPromise } from '@subwallet/extension-base/utils';
 import BigN from 'bignumber.js';
 import { combineLatest, Observable } from 'rxjs';
@@ -16,7 +18,7 @@ import { BN, BN_ZERO, noop, u8aToHex } from '@polkadot/util';
 import { decodeAddress } from '@polkadot/util-crypto';
 import { subscribeERC20Interval } from "../evm.js";
 import { subscribeEquilibriumTokenBalance } from "./equilibrium.js";
-export const subscribeSubstrateBalance = async (addresses, chainInfo, assetMap, substrateApi, evmApi, callback) => {
+export const subscribeSubstrateBalance = async (addresses, chainInfo, assetMap, substrateApi, evmApi, callback, extrinsicType) => {
   let unsubNativeToken;
   let unsubLocalToken;
   let unsubEvmContractToken;
@@ -28,7 +30,8 @@ export const subscribeSubstrateBalance = async (addresses, chainInfo, assetMap,
     addresses,
     chainInfo,
     assetMap,
-    callback
+    callback,
+    extrinsicType
   };
   const substrateParams = {
     ...baseParams,
@@ -98,11 +101,13 @@ const subscribeWithSystemAccountPallet = async ({
   addresses,
   callback,
   chainInfo,
+  extrinsicType,
   substrateApi
 }) => {
   const chainNativeTokenSlug = _getChainNativeTokenSlug(chainInfo);
   const balanceSubscribe = substrateApi.rx.query.system.account.multi(addresses);
-  let poolSubscribe;
+  let poolSubscribe; // add points in nomination pool back to user's balance
+
   if (_isSubstrateRelayChain(chainInfo) && substrateApi.query.nominationPools) {
     var _substrateApi$rx$quer;
     poolSubscribe = (_substrateApi$rx$quer = substrateApi.rx.query.nominationPools.poolMembers) === null || _substrateApi$rx$quer === void 0 ? void 0 : _substrateApi$rx$quer.multi(addresses);
@@ -118,52 +123,25 @@ const subscribeWithSystemAccountPallet = async ({
   }
   const subscription = combineLatest({
     balances: balanceSubscribe,
-    pools: poolSubscribe
+    poolMemberInfos: poolSubscribe
   }).subscribe(({
-    balances: _balances,
-    pools: poolMemberDatas
+    balances,
+    poolMemberInfos
   }) => {
-    const balances = _balances;
-    const pooledStakingBalances = [];
-    for (const _poolMemberData of poolMemberDatas) {
-      const poolMemberData = _poolMemberData.toPrimitive();
-      if (poolMemberData) {
-        let pooled = new BN(poolMemberData.points.toString());
-        Object.entries(poolMemberData.unbondingEras).forEach(([, amount]) => {
-          pooled = pooled.add(new BN(amount));
-        });
-        pooledStakingBalances.push(pooled);
-      } else {
-        pooledStakingBalances.push(BN_ZERO);
-      }
-    }
-    const items = balances.map((balance, index) => {
-      var _balance$data, _balance$data$free, _balance$data2, _balance$data2$reserv, _balance$data3, _balance$data3$miscFr, _balance$data4, _balance$data4$frozen, _balance$data5, _balance$data5$feeFro;
-      let total = ((_balance$data = balance.data) === null || _balance$data === void 0 ? void 0 : (_balance$data$free = _balance$data.free) === null || _balance$data$free === void 0 ? void 0 : _balance$data$free.toBn()) || new BN(0);
-      const reserved = ((_balance$data2 = balance.data) === null || _balance$data2 === void 0 ? void 0 : (_balance$data2$reserv = _balance$data2.reserved) === null || _balance$data2$reserv === void 0 ? void 0 : _balance$data2$reserv.toBn()) || new BN(0);
-      // @ts-ignore
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
-      const miscFrozen = ((_balance$data3 = balance.data) === null || _balance$data3 === void 0 ? void 0 : (_balance$data3$miscFr = _balance$data3.miscFrozen) === null || _balance$data3$miscFr === void 0 ? void 0 : _balance$data3$miscFr.toBn()) || (balance === null || balance === void 0 ? void 0 : (_balance$data4 = balance.data) === null || _balance$data4 === void 0 ? void 0 : (_balance$data4$frozen = _balance$data4.frozen) === null || _balance$data4$frozen === void 0 ? void 0 : _balance$data4$frozen.toBn()) || new BN(0);
-      const feeFrozen = ((_balance$data5 = balance.data) === null || _balance$data5 === void 0 ? void 0 : (_balance$data5$feeFro = _balance$data5.feeFrozen) === null || _balance$data5$feeFro === void 0 ? void 0 : _balance$data5$feeFro.toBn()) || new BN(0);
-      let locked = reserved.add(miscFrozen);
-      total = total.add(reserved);
-      const pooledStakingBalance = pooledStakingBalances[index] || BN_ZERO;
-      if (pooledStakingBalance.gt(BN_ZERO)) {
-        total = total.add(pooledStakingBalance);
-        locked = locked.add(pooledStakingBalance);
-      }
-      const free = total.sub(locked);
+    const items = balances.map((_balance, index) => {
+      const balanceInfo = _balance.toPrimitive();
+      const poolMemberInfo = poolMemberInfos[index].toPrimitive();
+      const nominationPoolBalance = poolMemberInfo ? _getActiveStakeInNominationPool(poolMemberInfo) : '0';
+      const transferableBalance = _getSystemPalletTransferable(balanceInfo, _getChainExistentialDeposit(chainInfo), extrinsicType);
+      const totalBalance = _getSystemPalletTotalBalance(balanceInfo);
+      const totalLockedFromTransfer = new BigN(totalBalance).minus(transferableBalance).plus(nominationPoolBalance);
       return {
         address: addresses[index],
         tokenSlug: chainNativeTokenSlug,
-        free: free.gte(BN_ZERO) ? free.toString() : '0',
-        locked: locked.toString(),
+        free: transferableBalance,
+        locked: totalLockedFromTransfer.toFixed(),
         state: APIItemState.READY,
-        substrateInfo: {
-          miscFrozen: miscFrozen.toString(),
-          reserved: reserved.toString(),
-          feeFrozen: feeFrozen.toString()
-        }
+        metadata: balanceInfo
       };
     });
     callback(items);
@@ -211,11 +189,7 @@ const subscribeBridgedBalance = async ({
               tokenSlug: tokenInfo.slug,
               free: free.toString(),
               locked: frozen.toString(),
-              state: APIItemState.READY,
-              substrateInfo: {
-                miscFrozen: frozen.toString(),
-                reserved: '0'
-              }
+              state: APIItemState.READY
             };
           });
           callback(items);
@@ -331,11 +305,7 @@ const subscribeTokensAccountsPallet = async ({
             tokenSlug: tokenInfo.slug,
             state: APIItemState.READY,
             free: freeBalance.toString(),
-            locked: lockedBalance.toString(),
-            substrateInfo: {
-              reserved: tokenBalance.reserved.toString(),
-              miscFrozen: tokenBalance.frozen.toString()
-            }
+            locked: lockedBalance.toString()
           };
         });
         callback(items);
@@ -393,11 +363,7 @@ const subscribeAssetsAccountPallet = async ({
             tokenSlug: tokenInfo.slug,
             free: free.toString(),
             locked: frozen.toString(),
-            state: APIItemState.READY,
-            substrateInfo: {
-              miscFrozen: frozen.toString(),
-              reserved: '0'
-            }
+            state: APIItemState.READY
           };
         });
         callback(items);
@@ -448,11 +414,7 @@ const subscribeOrmlTokensPallet = async ({
             tokenSlug: tokenInfo.slug,
             state: APIItemState.READY,
             free: freeBalance.toString(),
-            locked: lockedBalance.toString(),
-            substrateInfo: {
-              reserved: tokenBalance.reserved.toString(),
-              miscFrozen: tokenBalance.frozen.toString()
-            }
+            locked: lockedBalance.toString()
           };
         });
         callback(items);

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

@@ -1,4 +1,4 @@
-import { AmountData, DetectBalanceCache } from '@subwallet/extension-base/background/KoniTypes';
+import { AmountData, DetectBalanceCache, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
 import { ServiceStatus, StoppableServiceInterface } from '@subwallet/extension-base/services/base/types';
 import { EventItem, EventType } from '@subwallet/extension-base/services/event-service/types';
@@ -44,19 +44,20 @@ export declare class BalanceService implements StoppableServiceInterface {
     handleEvents(events: EventItem<EventType>[], eventTypes: EventType[]): void;
     getBalanceDetectCache(update: (value: DetectBalanceCache) => void): void;
     setBalanceDetectCache(addresses: string[]): void;
-    /** Subscribe token free balance of a address on chain */
-    subscribeTokenFreeBalance(address: string, chain: string, tokenSlug: string | undefined, callback?: (rs: AmountData) => void): Promise<[() => void, AmountData]>;
+    /** Subscribe token free balance of an address on chain */
+    subscribeTransferableBalance(address: string, chain: string, tokenSlug: string | undefined, extrinsicType?: ExtrinsicType, callback?: (rs: AmountData) => void): Promise<[() => void, AmountData]>;
     /**
      * @public
      * @async
-     * @function getTokenFreeBalance
+     * @function getTransferableBalance
      * @desc Fetch free balance on chain
      * @param {string} address - Address
      * @param {string} chain - Slug of chain
      * @param {string} [tokenSlug] - Slug of token
+     * @param extrinsicType - Customize transferable based on context
      * @return {Promise<AmountData>} - Free token balance of address on chain
-    */
-    getTokenFreeBalance(address: string, chain: string, tokenSlug?: string): Promise<AmountData>;
+     */
+    getTransferableBalance(address: string, chain: string, tokenSlug?: string, extrinsicType?: ExtrinsicType): Promise<AmountData>;
     /** Remove balance from the subject object by addresses */
     removeBalanceByAddresses(addresses: string[]): void;
     /** Remove inactive asset from the balance map */

package/services/balance-service/index.js

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { BalanceError } from '@subwallet/extension-base/background/errors/BalanceError';
-import { BalanceErrorType } from '@subwallet/extension-base/background/KoniTypes';
+import { BalanceErrorType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 import { ALL_ACCOUNT_KEY } from '@subwallet/extension-base/constants';
 import { ServiceStatus } from '@subwallet/extension-base/services/base/types';
 import { _getChainNativeTokenSlug } from '@subwallet/extension-base/services/chain-service/utils';
@@ -159,8 +159,8 @@ export class BalanceService {
     });
   }
 
-  /** Subscribe token free balance of a address on chain */
-  async subscribeTokenFreeBalance(address, chain, tokenSlug, callback) {
+  /** Subscribe token free balance of an address on chain */
+  async subscribeTransferableBalance(address, chain, tokenSlug, extrinsicType, callback) {
     const chainInfo = this.state.chainService.getChainInfoByKey(chain);
     const chainState = this.state.chainService.getChainStateByKey(chain);
     if (!chainInfo || !chainState || !chainState.active) {
@@ -193,7 +193,8 @@ export class BalanceService {
           const balance = {
             value: rs.free,
             decimals: tokenInfo.decimals || 0,
-            symbol: tokenInfo.symbol
+            symbol: tokenInfo.symbol,
+            metadata: rs.metadata
           };
           if (callback) {
             callback(balance);
@@ -204,7 +205,7 @@ export class BalanceService {
           }
           resolve([unsub, balance]);
         }
-      });
+      }, extrinsicType);
       setTimeout(() => {
         if (hasError) {
           var _unsub2;
@@ -218,15 +219,16 @@ export class BalanceService {
   /**
    * @public
    * @async
-   * @function getTokenFreeBalance
+   * @function getTransferableBalance
    * @desc Fetch free balance on chain
    * @param {string} address - Address
    * @param {string} chain - Slug of chain
    * @param {string} [tokenSlug] - Slug of token
+   * @param extrinsicType - Customize transferable based on context
    * @return {Promise<AmountData>} - Free token balance of address on chain
-  */
-  async getTokenFreeBalance(address, chain, tokenSlug) {
-    const [, balance] = await this.subscribeTokenFreeBalance(address, chain, tokenSlug);
+   */
+  async getTransferableBalance(address, chain, tokenSlug, extrinsicType) {
+    const [, balance] = await this.subscribeTransferableBalance(address, chain, tokenSlug, extrinsicType);
     return balance;
   }
 
@@ -328,7 +330,7 @@ export class BalanceService {
     }).map(asset => asset.slug);
     const unsub = subscribeBalance(addresses, activeChainSlugs, assets, assetMap, chainInfoMap, substrateApiMap, evmApiMap, result => {
       !cancel && this.setBalanceItem(result);
-    });
+    }, ExtrinsicType.TRANSFER_BALANCE);
     const unsub2 = this.state.subscribeMantaPayBalance();
     this._unsubscribeBalance = () => {
       cancel = true;

package/services/chain-service/index.js

@@ -474,7 +474,6 @@ export class ChainService {
           needUpdateChainApiList,
           storedChainInfoList
         } = updateLatestChainInfo(this.dataMap, latestChainInfo);
-        console.log('here', needUpdateChainApiList, storedChainInfoList);
         this.dbService.bulkUpdateChainStore(storedChainInfoList).catch(console.error);
         this.updateChainSubscription();
         needUpdateChainApiList.forEach(chainInfo => {

package/services/chain-service/utils/index.d.ts

@@ -88,6 +88,7 @@ export declare function _generateCustomProviderKey(index: number): string;
 export declare const findChainInfoByHalfGenesisHash: (chainMap: Record<string, _ChainInfo>, halfGenesisHash?: string) => _ChainInfo | null;
 export declare const findChainInfoByChainId: (chainMap: Record<string, _ChainInfo>, chainId?: number) => _ChainInfo | null;
 export declare function _isMantaZkAsset(chainAsset: _ChainAsset): boolean;
+export declare function _getChainExistentialDeposit(chainInfo: _ChainInfo): string;
 export declare function randomizeProvider(providers: Record<string, string>, excludedKeys?: string[]): {
     providerKey: string;
     providerValue: string;

package/services/chain-service/utils/index.js

@@ -406,6 +406,10 @@ export const findChainInfoByChainId = (chainMap, chainId) => {
 export function _isMantaZkAsset(chainAsset) {
   return _MANTA_ZK_CHAIN_GROUP.includes(chainAsset.originChain) && chainAsset.symbol.startsWith(_ZK_ASSET_PREFIX);
 }
+export function _getChainExistentialDeposit(chainInfo) {
+  var _chainInfo$substrateI18;
+  return (chainInfo === null || chainInfo === void 0 ? void 0 : (_chainInfo$substrateI18 = chainInfo.substrateInfo) === null || _chainInfo$substrateI18 === void 0 ? void 0 : _chainInfo$substrateI18.existentialDeposit) || '0';
+}
 export function randomizeProvider(providers, excludedKeys) {
   if (Object.keys(providers).length === 0) {
     return {

package/services/earning-service/handlers/base.js

@@ -129,7 +129,7 @@ export default class BasePoolHandler {
       };
     }
     const nativeTokenInfo = this.state.chainService.getNativeTokenInfo(this.chain);
-    const nativeTokenBalance = await this.state.balanceService.getTokenFreeBalance(request.address, this.chain);
+    const nativeTokenBalance = await this.state.balanceService.getTransferableBalance(request.address, this.chain);
     const bnNativeTokenBalance = new BN(nativeTokenBalance.value);
     const bnMinBalanceToJoin = new BN(((_poolInfo$statistic2 = poolInfo.statistic) === null || _poolInfo$statistic2 === void 0 ? void 0 : (_poolInfo$statistic2$ = _poolInfo$statistic2.earningThreshold) === null || _poolInfo$statistic2$ === void 0 ? void 0 : _poolInfo$statistic2$.join) || '0').add(new BN(poolInfo.metadata.maintainBalance));
     if (bnNativeTokenBalance.lte(bnMinBalanceToJoin)) {

package/services/earning-service/handlers/nomination-pool/index.d.ts

@@ -1,8 +1,9 @@
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { ExtrinsicType, UnstakingInfo } from '@subwallet/extension-base/background/KoniTypes';
+import { PalletNominationPoolsPoolMember } from '@subwallet/extension-base/core/substrate/nominationpools-pallet';
 import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
 import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
-import { BaseYieldPositionInfo, EarningRewardHistoryItem, EarningRewardItem, HandleYieldStepData, NominationPoolInfo, OptimalYieldPath, OptimalYieldPathParams, PalletNominationPoolsPoolMember, StakeCancelWithdrawalParams, SubmitJoinNominationPool, SubmitYieldJoinData, TransactionData, YieldPoolInfo, YieldPoolMethodInfo, YieldPoolType, YieldPositionInfo, YieldStepBaseInfo, YieldTokenBaseInfo } from '@subwallet/extension-base/types';
+import { BaseYieldPositionInfo, EarningRewardHistoryItem, EarningRewardItem, HandleYieldStepData, NominationPoolInfo, OptimalYieldPath, OptimalYieldPathParams, StakeCancelWithdrawalParams, SubmitJoinNominationPool, SubmitYieldJoinData, TransactionData, YieldPoolInfo, YieldPoolMethodInfo, YieldPoolType, YieldPositionInfo, YieldStepBaseInfo, YieldTokenBaseInfo } from '@subwallet/extension-base/types';
 import { DeriveSessionProgress } from '@polkadot/api-derive/types';
 import BasePoolHandler from '../base';
 export default class NominationPoolHandler extends BasePoolHandler {

package/services/earning-service/handlers/special.js

@@ -67,11 +67,11 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
     const feeAssetInfo = this.state.chainService.getAssetBySlug(this.feeAssets[0]);
     const altInputAssetInfo = this.state.chainService.getAssetBySlug(this.altInputAsset);
     const inputAssetInfo = this.state.chainService.getAssetBySlug(this.inputAsset);
-    const [inputAssetBalance, altInputAssetBalance, feeAssetBalance] = await Promise.all([this.state.balanceService.getTokenFreeBalance(request.address, inputAssetInfo.originChain, inputAssetInfo.slug), altInputAssetInfo ? this.state.balanceService.getTokenFreeBalance(request.address, altInputAssetInfo.originChain, altInputAssetInfo.slug) : Promise.resolve({
+    const [inputAssetBalance, altInputAssetBalance, feeAssetBalance] = await Promise.all([this.state.balanceService.getTransferableBalance(request.address, inputAssetInfo.originChain, inputAssetInfo.slug), altInputAssetInfo ? this.state.balanceService.getTransferableBalance(request.address, altInputAssetInfo.originChain, altInputAssetInfo.slug) : Promise.resolve({
       symbol: '',
       decimals: 0,
       value: '0'
-    }), this.state.balanceService.getTokenFreeBalance(request.address, feeAssetInfo.originChain, feeAssetInfo.slug)]);
+    }), this.state.balanceService.getTransferableBalance(request.address, feeAssetInfo.originChain, feeAssetInfo.slug)]);
     const bnInputAssetBalance = new BN(inputAssetBalance.value);
     const bnAltInputAssetBalance = new BN(altInputAssetBalance.value);
     const bnMinJoinPool = new BN(poolInfo.statistic.earningThreshold.join);
@@ -193,13 +193,13 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
     const bnAmount = new BN(amount);
     const inputTokenSlug = this.inputAsset; // assume that the pool only has 1 input token, will update later
     const inputTokenInfo = this.state.getAssetBySlug(inputTokenSlug);
-    const inputTokenBalance = await this.state.balanceService.getTokenFreeBalance(address, inputTokenInfo.originChain, inputTokenSlug);
+    const inputTokenBalance = await this.state.balanceService.getTransferableBalance(address, inputTokenInfo.originChain, inputTokenSlug);
     const bnInputTokenBalance = new BN(inputTokenBalance.value);
     if (!bnInputTokenBalance.gte(bnAmount)) {
       if (this.altInputAsset) {
         const altInputTokenSlug = this.altInputAsset;
         const altInputTokenInfo = this.state.getAssetBySlug(altInputTokenSlug);
-        const altInputTokenBalance = await this.state.balanceService.getTokenFreeBalance(address, altInputTokenInfo.originChain, altInputTokenSlug);
+        const altInputTokenBalance = await this.state.balanceService.getTransferableBalance(address, altInputTokenInfo.originChain, altInputTokenSlug);
         const bnAltInputTokenBalance = new BN(altInputTokenBalance.value || '0');
         if (bnAltInputTokenBalance.gt(BN_ZERO)) {
           const altChainInfo = this.state.getChainInfo(altInputTokenInfo.originChain);
@@ -272,17 +272,16 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
     const altInputTokenSlug = this.altInputAsset || '';
     const altInputTokenInfo = this.state.getAssetBySlug(altInputTokenSlug);
     const inputTokenInfo = this.state.getAssetBySlug(this.inputAsset);
-    const altInputTokenBalance = await this.state.balanceService.getTokenFreeBalance(params.address, altInputTokenInfo.originChain, altInputTokenSlug);
+    const altInputTokenBalance = await this.state.balanceService.getTransferableBalance(params.address, altInputTokenInfo.originChain, altInputTokenSlug);
     const missingAmount = bnAmount.sub(bnInputTokenBalance); // TODO: what if input token is not LOCAL ??
     const xcmFee = new BN(path.totalFee[1].amount || '0');
     const xcmAmount = missingAmount.add(xcmFee);
     const bnAltInputTokenBalance = new BN(altInputTokenBalance.value || '0');
-    const altInputTokenMinAmount = new BN(altInputTokenInfo.minAmount || '0');
-    if (!bnAltInputTokenBalance.sub(xcmAmount).gte(altInputTokenMinAmount)) {
+    if (!bnAltInputTokenBalance.sub(xcmAmount).gt(BN_ZERO)) {
       processValidation.failedStep = path.steps[1];
       processValidation.ok = false;
       processValidation.status = YieldValidationStatus.NOT_ENOUGH_BALANCE;
-      const maxBn = bnInputTokenBalance.add(new BN(altInputTokenBalance.value)).sub(xcmFee).sub(altInputTokenMinAmount);
+      const maxBn = bnInputTokenBalance.add(new BN(altInputTokenBalance.value)).sub(xcmFee);
       const maxValue = formatNumber(maxBn.toString(), inputTokenInfo.decimals || 0);
       const altInputTokenInfo = this.state.getAssetBySlug(altInputTokenSlug);
       const symbol = altInputTokenInfo.symbol;
@@ -290,7 +289,7 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
       const inputNetworkName = this.chainInfo.name;
       const altNetworkName = altNetwork.name;
       const currentValue = formatNumber(bnInputTokenBalance.toString(), inputTokenInfo.decimals || 0);
-      const bnMaxXCM = new BN(altInputTokenBalance.value).sub(xcmFee).sub(altInputTokenMinAmount);
+      const bnMaxXCM = new BN(altInputTokenBalance.value).sub(xcmFee);
       const maxXCMValue = formatNumber(bnMaxXCM.toString(), inputTokenInfo.decimals || 0);
       processValidation.message = t('You can only enter a maximum of {{maxValue}} {{symbol}}, which is {{currentValue}} {{symbol}} ({{inputNetworkName}}) and {{maxXCMValue}} {{symbol}} ({{altNetworkName}}). Lower your amount and try again.', {
         replace: {
@@ -327,7 +326,7 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
     if (this.feeAssets.length === 1 && feeTokenSlug === defaultFeeTokenSlug) {
       var _path$totalFee$id;
       const bnFeeAmount = new BN(((_path$totalFee$id = path.totalFee[id]) === null || _path$totalFee$id === void 0 ? void 0 : _path$totalFee$id.amount) || '0');
-      const feeTokenBalance = await this.state.balanceService.getTokenFreeBalance(params.address, feeTokenInfo.originChain, feeTokenSlug);
+      const feeTokenBalance = await this.state.balanceService.getTransferableBalance(params.address, feeTokenInfo.originChain, feeTokenSlug);
       const bnFeeTokenBalance = new BN(feeTokenBalance.value || '0');
       const bnFeeTokenMinAmount = new BN((feeTokenInfo === null || feeTokenInfo === void 0 ? void 0 : feeTokenInfo.minAmount) || '0');
       if (!bnFeeTokenBalance.sub(bnFeeAmount).gte(bnFeeTokenMinAmount)) {
@@ -365,7 +364,7 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
     const inputTokenSlug = this.inputAsset;
     const inputTokenInfo = this.state.getAssetBySlug(inputTokenSlug);
     const balanceService = this.state.balanceService;
-    const inputTokenBalance = await balanceService.getTokenFreeBalance(params.address, inputTokenInfo.originChain, inputTokenSlug);
+    const inputTokenBalance = await balanceService.getTransferableBalance(params.address, inputTokenInfo.originChain, inputTokenSlug);
     const bnInputTokenBalance = new BN(inputTokenBalance.value || '0');
     const bnAmount = new BN(params.amount);
     if (bnAmount.lte(BN_ZERO)) {
@@ -415,7 +414,7 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
     const originTokenInfo = this.state.getAssetBySlug(originTokenSlug);
     const destinationTokenInfo = this.state.getAssetBySlug(destinationTokenSlug);
     const substrateApi = this.state.getSubstrateApi(originChainInfo.slug);
-    const inputTokenBalance = await this.state.balanceService.getTokenFreeBalance(address, destinationTokenInfo.originChain, destinationTokenSlug);
+    const inputTokenBalance = await this.state.balanceService.getTransferableBalance(address, destinationTokenInfo.originChain, destinationTokenSlug);
     const bnInputTokenBalance = new BN(inputTokenBalance.value);
     const bnXcmFee = new BN(xcmFee);
     const bnAmount = new BN(amount);

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,7 +54,7 @@ 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
@@ -63,9 +63,8 @@ export class SwapBaseHandler {
     if (_isNativeToken(alternativeAsset)) {
       xcmAmount = xcmAmount.plus(xcmFee);
     }
-    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(xcmAmount).gt(0)) {
+      const maxBn = bnFromAssetBalance.plus(new BigNumber(alternativeAssetBalance.value)).minus(xcmFee);
       const maxValue = formatNumber(maxBn.toString(), fromAsset.decimals || 0);
       const altInputTokenInfo = this.chainService.getAssetBySlug(alternativeAssetSlug);
       const symbol = altInputTokenInfo.symbol;
@@ -74,7 +73,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(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 +101,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 +110,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 +121,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([]);
   }