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

package/core/logic-validation/swap.js

@@ -0,0 +1,89 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { SwapError } from '@subwallet/extension-base/background/errors/SwapError';
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { BasicTxErrorType } from '@subwallet/extension-base/background/KoniTypes';
+import { _getAssetDecimals, _isChainEvmCompatible } from '@subwallet/extension-base/services/chain-service/utils';
+import { SwapErrorType } from '@subwallet/extension-base/types/swap';
+import { formatNumber } from '@subwallet/extension-base/utils';
+import BigN from 'bignumber.js';
+import { isEthereumAddress } from '@polkadot/util-crypto';
+export function _validateBalanceToSwap(fromToken, feeToken, feeTokenChainInfo, feeAmount, fromTokenBalance, feeTokenBalance, swapAmount, isXcmOk, minSwap) {
+  if (new BigN(feeTokenBalance).lte(feeAmount)) {
+    return new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE, `You don't have enough ${feeToken.symbol} (${feeTokenChainInfo.name}) to pay transaction fee`);
+  }
+  if (fromToken.slug === feeToken.slug) {
+    if (new BigN(fromTokenBalance).lte(new BigN(feeAmount).plus(swapAmount))) {
+      return new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE, `Insufficient balance. Deposit ${fromToken.symbol} and try again.`);
+    }
+  }
+  if (isXcmOk) {
+    // assume that the swap is valid if XCM is in the process and it was successful
+    return undefined;
+  }
+  if (minSwap) {
+    if (new BigN(fromTokenBalance).lte(minSwap)) {
+      const parsedMinSwapValue = formatNumber(minSwap, _getAssetDecimals(fromToken));
+      return new TransactionError(SwapErrorType.SWAP_NOT_ENOUGH_BALANCE, `Insufficient balance. You need more than ${parsedMinSwapValue} ${fromToken.symbol} to start swapping. Deposit ${fromToken.symbol} and try again.`); // todo: min swap or amount?
+    }
+  }
+
+  if (new BigN(swapAmount).gte(fromTokenBalance)) {
+    const parsedMaxBalanceSwap = formatNumber(fromTokenBalance, _getAssetDecimals(fromToken));
+    return new TransactionError(SwapErrorType.SWAP_EXCEED_ALLOWANCE, `Amount too high. Lower your amount ${new BigN(fromTokenBalance).gt(0) ? `below ${parsedMaxBalanceSwap} ${fromToken.symbol}` : ''} and try again`);
+  }
+  return undefined;
+}
+export function _validateSwapRecipient(destChainInfo, recipient) {
+  const isEvmAddress = isEthereumAddress(recipient);
+  const isEvmDestChain = _isChainEvmCompatible(destChainInfo);
+  if (isEvmAddress && !isEvmDestChain || !isEvmAddress && isEvmDestChain) {
+    return new TransactionError(SwapErrorType.INVALID_RECIPIENT);
+  }
+  return undefined;
+}
+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/core/logic-validation/transfer.d.ts

@@ -0,0 +1,16 @@
+import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { _Address, AmountData, ExtrinsicType, FeeData } from '@subwallet/extension-base/background/KoniTypes';
+import { TransactionWarning } from '@subwallet/extension-base/background/warnings/TransactionWarning';
+import { _EvmApi } from '@subwallet/extension-base/services/chain-service/types';
+import { OptionalSWTransaction, SWTransactionInput, SWTransactionResponse } from '@subwallet/extension-base/services/transaction-service/types';
+import { KeyringPair } from '@subwallet/keyring/types';
+import BigN from 'bignumber.js';
+export declare function validateTransferRequest(tokenInfo: _ChainAsset, from: _Address, to: _Address, value: string | undefined, transferAll: boolean | undefined): [TransactionError[], KeyringPair | undefined, BigN | undefined];
+export declare function additionalValidateTransfer(tokenInfo: _ChainAsset, extrinsicType: ExtrinsicType, receiverTransferTokenFreeBalance: string, transferAmount: string, senderTransferTokenTransferable?: string): [TransactionWarning | undefined, TransactionError | undefined];
+export declare function validateXcmTransferRequest(destTokenInfo: _ChainAsset | undefined, sender: _Address, sendingValue: string): [TransactionError[], KeyringPair | undefined, BigN | undefined];
+export declare function additionalValidateXcmTransfer(originTokenInfo: _ChainAsset, destinationTokenInfo: _ChainAsset, sendingAmount: string, senderTransferable: string): [TransactionWarning | undefined, TransactionError | undefined];
+export declare function checkSupportForTransaction(validationResponse: SWTransactionResponse, transaction: OptionalSWTransaction): void;
+export declare function estimateFeeForTransaction(validationResponse: SWTransactionResponse, transaction: OptionalSWTransaction, chainInfo: _ChainInfo, evmApi: _EvmApi): Promise<FeeData>;
+export declare function checkSigningAccountForTransaction(validationResponse: SWTransactionResponse): void;
+export declare function checkBalanceWithTransactionFee(validationResponse: SWTransactionResponse, transactionInput: SWTransactionInput, nativeTokenInfo: _ChainAsset, nativeTokenAvailable: AmountData): void;

package/core/logic-validation/transfer.js

@@ -0,0 +1,206 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { BasicTxErrorType, BasicTxWarningCode, ExtrinsicType, TransferTxErrorType } from '@subwallet/extension-base/background/KoniTypes';
+import { TransactionWarning } from '@subwallet/extension-base/background/warnings/TransactionWarning';
+import { XCM_MIN_AMOUNT_RATIO } from '@subwallet/extension-base/constants';
+import { _canAccountBeReaped } from '@subwallet/extension-base/core/substrate/system-pallet';
+import { _TRANSFER_CHAIN_GROUP } from '@subwallet/extension-base/services/chain-service/constants';
+import { _getChainNativeTokenBasicInfo, _getContractAddressOfToken, _getTokenMinAmount, _isNativeToken, _isTokenEvmSmartContract } from '@subwallet/extension-base/services/chain-service/utils';
+import { calculateGasFeeParams } from '@subwallet/extension-base/services/fee-service/utils';
+import { isSubstrateTransaction } from '@subwallet/extension-base/services/transaction-service/helpers';
+import { balanceFormatter, formatNumber } from '@subwallet/extension-base/utils';
+import { keyring } from '@subwallet/ui-keyring';
+import BigN from 'bignumber.js';
+import { t } from 'i18next';
+import { isEthereumAddress } from '@polkadot/util-crypto';
+
+// normal transfer
+export function validateTransferRequest(tokenInfo, from, to, value, transferAll) {
+  const errors = [];
+  const keypair = keyring.getPair(from);
+  let transferValue;
+  if (!transferAll) {
+    if (value === undefined) {
+      errors.push(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('Transfer amount is required')));
+    }
+    if (value) {
+      transferValue = new BigN(value);
+    }
+  }
+  if (!tokenInfo) {
+    errors.push(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('Not found token from registry')));
+  }
+  if (isEthereumAddress(from) && isEthereumAddress(to) && _isTokenEvmSmartContract(tokenInfo) && _getContractAddressOfToken(tokenInfo).length === 0) {
+    errors.push(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('Not found ERC20 address for this token')));
+  }
+  return [errors, keypair, transferValue];
+}
+export function additionalValidateTransfer(tokenInfo, extrinsicType, receiverTransferTokenFreeBalance, transferAmount, senderTransferTokenTransferable) {
+  const minAmount = _getTokenMinAmount(tokenInfo);
+  let warning;
+  let error;
+
+  // Check ed of not native token for sender
+  if (extrinsicType === ExtrinsicType.TRANSFER_TOKEN && senderTransferTokenTransferable) {
+    if (new BigN(senderTransferTokenTransferable).minus(transferAmount).lt(minAmount)) {
+      warning = new TransactionWarning(BasicTxWarningCode.NOT_ENOUGH_EXISTENTIAL_DEPOSIT);
+    }
+  }
+
+  // Check ed for receiver
+  if (new BigN(receiverTransferTokenFreeBalance).plus(transferAmount).lt(minAmount)) {
+    const atLeast = new BigN(minAmount).minus(receiverTransferTokenFreeBalance).plus((tokenInfo.decimals || 0) === 0 ? 0 : 1);
+    const atLeastStr = formatNumber(atLeast, tokenInfo.decimals || 0, balanceFormatter, {
+      maxNumberFormat: tokenInfo.decimals || 6
+    });
+    error = new TransactionError(TransferTxErrorType.RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT, t('You must transfer at least {{amount}} {{symbol}} to keep the destination account alive', {
+      replace: {
+        amount: atLeastStr,
+        symbol: tokenInfo.symbol
+      }
+    }));
+  }
+  return [warning, error];
+}
+
+// xcm transfer
+export function validateXcmTransferRequest(destTokenInfo, sender, sendingValue) {
+  const errors = [];
+  const keypair = keyring.getPair(sender);
+  const transferValue = new BigN(sendingValue);
+  if (!destTokenInfo) {
+    errors.push(new TransactionError(TransferTxErrorType.INVALID_TOKEN, t('Not found token from registry')));
+  }
+  return [errors, keypair, transferValue];
+}
+export function additionalValidateXcmTransfer(originTokenInfo, destinationTokenInfo, sendingAmount, senderTransferable) {
+  const destMinAmount = _getTokenMinAmount(destinationTokenInfo);
+  const minSendingRequired = new BigN(destMinAmount).multipliedBy(XCM_MIN_AMOUNT_RATIO);
+  let error;
+  let warning;
+
+  // Check ed for receiver
+  if (new BigN(sendingAmount).lt(minSendingRequired)) {
+    const atLeastStr = formatNumber(minSendingRequired, destinationTokenInfo.decimals || 0, balanceFormatter, {
+      maxNumberFormat: destinationTokenInfo.decimals || 6
+    });
+    error = new TransactionError(TransferTxErrorType.RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT, t('You must transfer at least {{amount}} {{symbol}} to keep the destination account alive', {
+      replace: {
+        amount: atLeastStr,
+        symbol: originTokenInfo.symbol
+      }
+    }));
+  }
+
+  // Check ed for sender
+  if (!_isNativeToken(originTokenInfo)) {
+    if (new BigN(senderTransferable).minus(sendingAmount).lt(_getTokenMinAmount(originTokenInfo))) {
+      warning = new TransactionWarning(BasicTxWarningCode.NOT_ENOUGH_EXISTENTIAL_DEPOSIT);
+    }
+  }
+  return [warning, error];
+}
+
+// general validations
+export function checkSupportForTransaction(validationResponse, transaction) {
+  const {
+    extrinsicType
+  } = validationResponse;
+  if (!transaction) {
+    if (extrinsicType === ExtrinsicType.SEND_NFT) {
+      validationResponse.errors.push(new TransactionError(BasicTxErrorType.UNSUPPORTED, t('This feature is not yet available for this NFT')));
+    } else {
+      validationResponse.errors.push(new TransactionError(BasicTxErrorType.UNSUPPORTED));
+    }
+  }
+}
+export async function estimateFeeForTransaction(validationResponse, transaction, chainInfo, evmApi) {
+  const estimateFee = {
+    symbol: '',
+    decimals: 0,
+    value: '0',
+    tooHigh: false
+  };
+  const {
+    decimals,
+    symbol
+  } = _getChainNativeTokenBasicInfo(chainInfo);
+  estimateFee.decimals = decimals;
+  estimateFee.symbol = symbol;
+  if (transaction) {
+    try {
+      if (isSubstrateTransaction(transaction)) {
+        estimateFee.value = (await transaction.paymentInfo(validationResponse.address)).partialFee.toString();
+      } else {
+        const gasLimit = await evmApi.api.eth.estimateGas(transaction);
+        const priority = await calculateGasFeeParams(evmApi, 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));
+      }
+    }
+  }
+  return estimateFee;
+}
+export function checkSigningAccountForTransaction(validationResponse) {
+  const pair = keyring.getPair(validationResponse.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')));
+    }
+  }
+}
+export function checkBalanceWithTransactionFee(validationResponse, transactionInput, nativeTokenInfo, nativeTokenAvailable) {
+  if (!validationResponse.estimateFee) {
+    // todo: estimateFee should be must-have, need to refactor interface
+    return;
+  }
+
+  // if (!nativeTokenAvailable.metadata) {
+  //   validationResponse.errors.push(new TransactionError(BasicTxErrorType.INTERNAL_ERROR));
+  //
+  //   return;
+  // }
+
+  const {
+    edAsWarning,
+    extrinsicType,
+    isTransferAll,
+    skipFeeValidation
+  } = transactionInput;
+  if (skipFeeValidation) {
+    return;
+  }
+  const bnFee = new BigN(validationResponse.estimateFee.value);
+  const bnNativeTokenAvailable = new BigN(nativeTokenAvailable.value);
+  const bnNativeTokenTransferAmount = new BigN(validationResponse.transferNativeAmount || '0');
+  if (!bnNativeTokenAvailable.gt(0)) {
+    validationResponse.errors.push(new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE));
+  }
+  const isChainNotSupportTransferAll = [..._TRANSFER_CHAIN_GROUP.acala, ..._TRANSFER_CHAIN_GROUP.genshiro, ..._TRANSFER_CHAIN_GROUP.bitcountry, ..._TRANSFER_CHAIN_GROUP.statemine].includes(nativeTokenInfo.originChain);
+  if (bnNativeTokenTransferAmount.plus(bnFee).gt(bnNativeTokenAvailable) && (!isTransferAll || isChainNotSupportTransferAll)) {
+    validationResponse.errors.push(new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE)); // todo: should be generalized and reused in all features
+  }
+
+  // todo: only system.pallet has metadata, we should add for other pallets and mechanisms as well
+  const isNeedCheckRemainingBalance = !isTransferAll && extrinsicType === ExtrinsicType.TRANSFER_BALANCE && nativeTokenAvailable.metadata && _canAccountBeReaped(nativeTokenAvailable.metadata);
+  const isRemainingBalanceValid = bnNativeTokenAvailable.minus(bnNativeTokenTransferAmount).minus(bnFee).lt(_getTokenMinAmount(nativeTokenInfo));
+  if (isNeedCheckRemainingBalance && isRemainingBalanceValid) {
+    edAsWarning ? validationResponse.warnings.push(new TransactionWarning(BasicTxWarningCode.NOT_ENOUGH_EXISTENTIAL_DEPOSIT)) : validationResponse.errors.push(new TransactionError(BasicTxErrorType.NOT_ENOUGH_EXISTENTIAL_DEPOSIT));
+  }
+}

package/core/substrate/nominationpools-pallet.d.ts

@@ -0,0 +1,7 @@
+export declare type PalletNominationPoolsPoolMember = {
+    poolId: number;
+    points: number;
+    lastRecordedRewardCounter: number;
+    unbondingEras: Record<string, number>;
+};
+export declare function _getActiveStakeInNominationPool(memberInfo: PalletNominationPoolsPoolMember): string;

package/core/substrate/nominationpools-pallet.js

@@ -0,0 +1,6 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+export function _getActiveStakeInNominationPool(memberInfo) {
+  return memberInfo.points.toString();
+}

package/core/substrate/system-pallet.d.ts

@@ -0,0 +1,27 @@
+import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+export declare type FrameSystemAccountInfoV2 = Omit<FrameSystemAccountInfoV1, 'data'> & {
+    data: {
+        free: number;
+        reserved: number;
+        frozen: number;
+        flags: number;
+    };
+};
+export declare type FrameSystemAccountInfoV1 = {
+    nonce: number;
+    consumers: number;
+    providers: number;
+    sufficients: number;
+    data: {
+        free: number | string;
+        reserved: number;
+        miscFrozen: number;
+        feeFrozen: number;
+    };
+};
+export declare type FrameSystemAccountInfo = FrameSystemAccountInfoV1 | FrameSystemAccountInfoV2;
+export declare function _getSystemPalletTransferable(accountInfo: FrameSystemAccountInfo, existentialDeposit: string, extrinsicType?: ExtrinsicType): string;
+export declare function _canAccountBeReaped(accountInfo: FrameSystemAccountInfo): boolean;
+export declare function _isAccountActive(accountInfo: FrameSystemAccountInfo): boolean;
+export declare function _getSystemPalletTotalBalance(accountInfo: FrameSystemAccountInfo): string;
+export declare function _getAppliedExistentialDepositWithExtrinsicType(accountInfo: FrameSystemAccountInfo, existentialDeposit: string, extrinsicType?: ExtrinsicType): string;

package/core/substrate/system-pallet.js

@@ -0,0 +1,71 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import BigN from 'bignumber.js';
+
+// https://crates.parity.io/frame_system/struct.AccountInfo.html
+// https://wiki.polkadot.network/docs/learn-account-balances
+
+function isV1(accountInfo) {
+  return accountInfo.data.miscFrozen !== undefined && accountInfo.data.feeFrozen !== undefined;
+}
+export function _getSystemPalletTransferable(accountInfo, existentialDeposit, extrinsicType) {
+  const strictMode = !extrinsicType || ![ExtrinsicType.TRANSFER_BALANCE].includes(extrinsicType); // always apply strict mode to keep account alive unless explicitly specified otherwise
+
+  if (isV1(accountInfo)) {
+    return _getSystemPalletTransferableV1(accountInfo, existentialDeposit, strictMode);
+  } else {
+    return _getSystemPalletTransferableV2(accountInfo, existentialDeposit, strictMode);
+  }
+}
+export function _canAccountBeReaped(accountInfo) {
+  return accountInfo.consumers === 0; // might need to check refCount
+}
+
+export function _isAccountActive(accountInfo) {
+  return accountInfo.providers === 0 && accountInfo.consumers === 0;
+}
+export function _getSystemPalletTotalBalance(accountInfo) {
+  if (isV1(accountInfo)) {
+    return _getSystemPalletTotalBalanceV1(accountInfo);
+  } else {
+    return _getSystemPalletTotalBalanceV2(accountInfo);
+  }
+}
+export function _getAppliedExistentialDepositWithExtrinsicType(accountInfo, existentialDeposit, extrinsicType) {
+  const strictMode = !extrinsicType || ![ExtrinsicType.TRANSFER_BALANCE].includes(extrinsicType); // always apply strict mode to keep account alive unless explicitly specified otherwise
+
+  return _getAppliedExistentialDeposit(accountInfo, existentialDeposit, strictMode);
+}
+
+// ----------------------------------------------------------------------
+
+function _getAppliedExistentialDeposit(accountInfo, existentialDeposit, strictMode) {
+  // strict mode will always apply existential deposit to keep account alive
+  if (strictMode) {
+    return existentialDeposit;
+  }
+  return _canAccountBeReaped(accountInfo) ? '0' : existentialDeposit; // account for ED here will go better with max transfer logic
+}
+
+function _getSystemPalletTransferableV2(accountInfo, existentialDeposit, strictMode) {
+  const bnFree = new BigN(accountInfo.data.free);
+  const bnLocked = new BigN(accountInfo.data.frozen).minus(accountInfo.data.reserved); // locked can go below 0 but this shouldn't matter
+  const bnAppliedExistentialDeposit = new BigN(_getAppliedExistentialDeposit(accountInfo, existentialDeposit, strictMode));
+  const bnTransferableBalance = bnFree.minus(BigN.max(bnLocked, bnAppliedExistentialDeposit));
+  return BigN.max(bnTransferableBalance, 0).toFixed();
+}
+function _getSystemPalletTotalBalanceV2(accountInfo) {
+  return new BigN(accountInfo.data.free).plus(accountInfo.data.reserved).toFixed();
+}
+function _getSystemPalletTransferableV1(accountInfo, existentialDeposit, strictMode) {
+  const bnAppliedExistentialDeposit = new BigN(_getAppliedExistentialDeposit(accountInfo, existentialDeposit, strictMode));
+  const bnAppliedFrozen = BigN.max(accountInfo.data.feeFrozen, accountInfo.data.miscFrozen);
+  const bnTotalBalance = new BigN(_getSystemPalletTotalBalanceV1(accountInfo));
+  const bnTransferableBalance = bnTotalBalance.minus(BigN.max(bnAppliedFrozen, accountInfo.data.reserved, bnAppliedExistentialDeposit));
+  return BigN.max(bnTransferableBalance, 0).toFixed();
+}
+function _getSystemPalletTotalBalanceV1(accountInfo) {
+  return new BigN(accountInfo.data.free).toFixed();
+}

package/koni/api/dotsama/transfer.d.ts

@@ -1,6 +1,7 @@
 import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
 import { SupportTransferResponse } from '@subwallet/extension-base/background/KoniTypes';
-import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+import { _EvmApi, _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+import BigN from 'bignumber.js';
 import { SubmittableExtrinsic } from '@polkadot/api/promise/types';
 export declare function checkReferenceCount(networkKey: string, address: string, substrateApiMap: Record<string, _SubstrateApi>, chainInfo: _ChainInfo): Promise<boolean>;
 export declare function checkSupportTransfer(networkKey: string, tokenInfo: _ChainAsset, substrateApiMap: Record<string, _SubstrateApi>, chainInfo: _ChainInfo): Promise<SupportTransferResponse>;
@@ -14,4 +15,5 @@ interface CreateTransferExtrinsicProps {
     tokenInfo: _ChainAsset;
 }
 export declare const createTransferExtrinsic: ({ from, networkKey, substrateApi, to, tokenInfo, transferAll, value }: CreateTransferExtrinsicProps) => Promise<[SubmittableExtrinsic | null, string]>;
+export declare const getTransferMockTxFee: (address: string, chainInfo: _ChainInfo, tokenInfo: _ChainAsset, api: _SubstrateApi | _EvmApi) => Promise<BigN>;
 export {};

package/koni/api/dotsama/transfer.js

@@ -5,8 +5,10 @@ import { GearApi } from '@gear-js/api';
 import { getPSP22ContractPromise } from '@subwallet/extension-base/koni/api/tokens/wasm';
 import { getWasmContractGasLimit } from '@subwallet/extension-base/koni/api/tokens/wasm/utils';
 import { _BALANCE_TOKEN_GROUP, _MANTA_ZK_CHAIN_GROUP, _TRANSFER_CHAIN_GROUP, _TRANSFER_NOT_SUPPORTED_CHAINS, _ZK_ASSET_PREFIX } from '@subwallet/extension-base/services/chain-service/constants';
-import { _getContractAddressOfToken, _getTokenOnChainAssetId, _getTokenOnChainInfo, _isChainEvmCompatible, _isNativeToken, _isTokenGearSmartContract, _isTokenWasmSmartContract } from '@subwallet/extension-base/services/chain-service/utils';
+import { _getContractAddressOfToken, _getTokenOnChainAssetId, _getTokenOnChainInfo, _isChainEvmCompatible, _isNativeToken, _isTokenGearSmartContract, _isTokenTransferredByEvm, _isTokenWasmSmartContract } from '@subwallet/extension-base/services/chain-service/utils';
+import { calculateGasFeeParams } from '@subwallet/extension-base/services/fee-service/utils';
 import { getGRC20ContractPromise } from '@subwallet/extension-base/utils';
+import BigN from 'bignumber.js';
 import { BN, u8aToHex } from '@polkadot/util';
 import { decodeAddress } from '@polkadot/util-crypto';
 function isRefCount(accountInfo) {
@@ -211,4 +213,45 @@ export const createTransferExtrinsic = async ({
     }
   }
   return [transfer, transferAmount || value];
+};
+export const getTransferMockTxFee = async (address, chainInfo, tokenInfo, api) => {
+  try {
+    let estimatedFee;
+    if (_isChainEvmCompatible(chainInfo) && _isTokenTransferredByEvm(tokenInfo)) {
+      const web3 = api;
+      const transaction = {
+        value: 0,
+        to: '0x0000000000000000000000000000000000000000',
+        // null address
+        from: address
+      };
+      const gasLimit = await web3.api.eth.estimateGas(transaction);
+      const priority = await calculateGasFeeParams(web3, chainInfo.slug);
+      if (priority.baseGasFee) {
+        const maxFee = priority.maxFeePerGas;
+        estimatedFee = maxFee.multipliedBy(gasLimit);
+      } else {
+        estimatedFee = new BigN(priority.gasPrice).multipliedBy(gasLimit);
+      }
+    } else {
+      var _paymentInfo$partialF;
+      const substrateApi = api;
+      const [mockTx] = await createTransferExtrinsic({
+        from: address,
+        networkKey: chainInfo.slug,
+        substrateApi,
+        to: address,
+        tokenInfo,
+        transferAll: true,
+        value: '1000000000000000000'
+      });
+      const paymentInfo = await (mockTx === null || mockTx === void 0 ? void 0 : mockTx.paymentInfo(address));
+      estimatedFee = new BigN((paymentInfo === null || paymentInfo === void 0 ? void 0 : (_paymentInfo$partialF = paymentInfo.partialFee) === null || _paymentInfo$partialF === void 0 ? void 0 : _paymentInfo$partialF.toString()) || '0'); // todo: should handle error case instead of setting fee to 0
+    }
+
+    return estimatedFee;
+  } catch (e) {
+    console.error('error mocking tx fee', e);
+    return new BigN(0);
+  }
 };

package/koni/api/staking/bonding/relayChain.d.ts

@@ -1,8 +1,9 @@
 import { _ChainInfo } from '@subwallet/chain-list/types';
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { ChainStakingMetadata, NominatorMetadata, UnstakingInfo, ValidatorInfo } from '@subwallet/extension-base/background/KoniTypes';
+import { PalletNominationPoolsPoolMember } from '@subwallet/extension-base/core/substrate/nominationpools-pallet';
 import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
-import { NominationPoolInfo, PalletNominationPoolsPoolMember } from '@subwallet/extension-base/types';
+import { NominationPoolInfo } from '@subwallet/extension-base/types';
 export interface PalletStakingNominations {
     targets: string[];
     submittedIn: number;

package/koni/api/staking/bonding/utils.js

@@ -383,7 +383,7 @@ export function getTopValidatorByPoints(validatorPointsList) {
 export const getMinStakeErrorMessage = (chainInfo, bnMinStake) => {
   const tokenInfo = _getChainNativeTokenBasicInfo(chainInfo);
   const number = formatNumber(bnMinStake.toString(), tokenInfo.decimals || 0, balanceFormatter);
-  return t('Insufficient stake. Please stake at least {{number}} {{tokenSymbol}} to get rewards', {
+  return t('Insufficient stake. You need to stake at least {{number}} {{tokenSymbol}} to earn rewards', {
     replace: {
       tokenSymbol: tokenInfo.symbol,
       number

package/koni/api/xcm/index.d.ts

@@ -1,5 +1,6 @@
 import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
 import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+import BigN from 'bignumber.js';
 import { SubmittableExtrinsic } from '@polkadot/api/types';
 interface CreateXcmExtrinsicProps {
     originTokenInfo: _ChainAsset;
@@ -10,4 +11,5 @@ interface CreateXcmExtrinsicProps {
     chainInfoMap: Record<string, _ChainInfo>;
 }
 export declare const createXcmExtrinsic: ({ chainInfoMap, destinationTokenInfo, originTokenInfo, recipient, sendingValue, substrateApi }: CreateXcmExtrinsicProps) => Promise<SubmittableExtrinsic<'promise'>>;
+export declare const getXcmMockTxFee: (substrateApi: _SubstrateApi, chainInfoMap: Record<string, _ChainInfo>, address: string, originTokenInfo: _ChainAsset, destinationTokenInfo: _ChainAsset) => Promise<BigN>;
 export {};

package/koni/api/xcm/index.js

@@ -5,7 +5,10 @@ import { getExtrinsicByPolkadotXcmPallet } from '@subwallet/extension-base/koni/
 import { getExtrinsicByXcmPalletPallet } from '@subwallet/extension-base/koni/api/xcm/xcmPallet';
 import { getExtrinsicByXtokensPallet } from '@subwallet/extension-base/koni/api/xcm/xTokens';
 import { _XCM_CHAIN_GROUP } from '@subwallet/extension-base/services/chain-service/constants';
-import { _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
+import { _isChainEvmCompatible, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
+import BigN from 'bignumber.js';
+import { u8aToHex } from '@polkadot/util';
+import { addressToEvm, isEthereumAddress } from '@polkadot/util-crypto';
 export const createXcmExtrinsic = async ({
   chainInfoMap,
   destinationTokenInfo,
@@ -31,4 +34,27 @@ export const createXcmExtrinsic = async ({
     extrinsic = getExtrinsicByXtokensPallet(originTokenInfo, originChainInfo, destinationChainInfo, recipient, sendingValue, api);
   }
   return extrinsic;
+};
+export const getXcmMockTxFee = async (substrateApi, chainInfoMap, address, originTokenInfo, destinationTokenInfo) => {
+  try {
+    var _paymentInfo$partialF;
+    const destChainInfo = chainInfoMap[destinationTokenInfo.originChain];
+    const originChainInfo = chainInfoMap[originTokenInfo.originChain];
+
+    // mock receiving account from sender
+    const recipient = !isEthereumAddress(address) && _isChainEvmCompatible(destChainInfo) && !_isChainEvmCompatible(originChainInfo) ? u8aToHex(addressToEvm(address)) : address;
+    const mockTx = await createXcmExtrinsic({
+      chainInfoMap,
+      destinationTokenInfo,
+      originTokenInfo,
+      recipient: recipient,
+      sendingValue: '1000000000000000000',
+      substrateApi
+    });
+    const paymentInfo = await mockTx.paymentInfo(address);
+    return new BigN((paymentInfo === null || paymentInfo === void 0 ? void 0 : (_paymentInfo$partialF = paymentInfo.partialFee) === null || _paymentInfo$partialF === void 0 ? void 0 : _paymentInfo$partialF.toString()) || '0');
+  } catch (e) {
+    console.error('error mocking xcm tx fee', e);
+    return new BigN(0);
+  }
 };

package/koni/background/handlers/Extension.d.ts

@@ -124,9 +124,7 @@ export default class KoniExtension {
     private subscribeStaking;
     private subscribeHistory;
     private subscribeHistoryByChainAndAddress;
-    private validateTransfer;
     private makeTransfer;
-    private validateCrossChainTransfer;
     private makeCrossChainTransfer;
     private evmNftSubmitTransaction;
     private upsertChain;
@@ -140,9 +138,11 @@ export default class KoniExtension {
     private upsertCustomToken;
     private deleteCustomAsset;
     private validateCustomAsset;
-    private getAddressFreeBalance;
-    private transferGetMaxTransferable;
-    private subscribeAddressFreeBalance;
+    private getAddressTransferableBalance;
+    private getMaxTransferable;
+    private getXcmMaxTransferable;
+    private getNativeTokenMaxTransferable;
+    private subscribeAddressTransferableBalance;
     private transferCheckReferenceCount;
     private transferCheckSupporting;
     private transferGetExistentialDeposit;