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

package/background/KoniTypes.d.ts

@@ -487,6 +487,7 @@ export interface BasicTokenInfo {
 }
 export interface AmountData extends BasicTokenInfo {
     value: string;
+    metadata?: unknown;
 }
 export interface FeeData extends AmountData {
     tooHigh?: boolean;
@@ -926,6 +927,7 @@ export interface RequestFreeBalance {
     address: string;
     networkKey: string;
     token?: string;
+    extrinsicType?: ExtrinsicType;
 }
 export interface RequestMaxTransferable {
     address: string;
@@ -1669,6 +1671,8 @@ export interface ResponseSubscribeHistory {
     id: string;
     items: TransactionHistoryItem[];
 }
+export declare type _Address = string;
+export declare type _BalanceMetadata = unknown;
 export interface KoniRequestSignatures {
     'pri(staking.submitTuringCancelCompound)': [RequestTuringCancelStakeCompound, SWTransactionResponse];
     'pri(staking.submitTuringCompound)': [RequestTuringStakeCompound, SWTransactionResponse];

package/cjs/core/logic-validation/earning.js

@@ -0,0 +1,47 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.INSUFFICIENT_MESSAGES = void 0;
+exports._handleDisplayForEarningError = _handleDisplayForEarningError;
+exports._handleDisplayInsufficientEarningError = _handleDisplayInsufficientEarningError;
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+function _handleDisplayForEarningError(error) {
+  if (error.message.startsWith('UnknownError Connection to Indexed DataBase server lost') || error.message.startsWith('Provided address is invalid, the capitalization checksum test failed') || error.message.startsWith('connection not open on send()')) {
+    return {
+      title: 'Connection error',
+      message: 'Your selected network has lost connection. Update it by re-enabling it or changing network provider'
+    };
+  }
+  return undefined;
+}
+const INSUFFICIENT_MESSAGES = ['残高不足', 'Недостаточный баланс', 'Insufficient balance'];
+exports.INSUFFICIENT_MESSAGES = INSUFFICIENT_MESSAGES;
+function _handleDisplayInsufficientEarningError(error, availableBalance, amount, minJoinPool) {
+  if (!INSUFFICIENT_MESSAGES.some(v => error.message.includes(v))) {
+    return undefined;
+  }
+  const bnAvailableBalance = new _bignumber.default(availableBalance);
+  const bnAmount = new _bignumber.default(amount);
+  if (bnAvailableBalance.gt(0) && bnAmount.gte(bnAvailableBalance)) {
+    return {
+      title: 'Insufficient balance',
+      message: 'Insufficient balance. Amount must be smaller than available balance'
+    };
+  }
+  if (bnAvailableBalance.lte(minJoinPool)) {
+    return {
+      title: 'Insufficient balance',
+      message: 'You don\'t have enough {{symbol}} ({{chain}}) to stake, make sure your available balance is higher than {{minJoinPool}} {{symbol}}'
+    };
+  }
+  return {
+    title: 'Insufficient balance',
+    message: 'You don\'t have enough {{symbol}} ({{chain}}) to pay gas fee. Lower your amount and try again'
+  };
+}

package/cjs/core/logic-validation/swap.js

@@ -0,0 +1,99 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._getChainflipEarlyValidationError = _getChainflipEarlyValidationError;
+exports._getEarlyHydradxValidationError = _getEarlyHydradxValidationError;
+exports._validateBalanceToSwap = _validateBalanceToSwap;
+exports._validateSwapRecipient = _validateSwapRecipient;
+var _SwapError = require("@subwallet/extension-base/background/errors/SwapError");
+var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _swap = require("@subwallet/extension-base/types/swap");
+var _utils2 = require("@subwallet/extension-base/utils");
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+var _utilCrypto = require("@polkadot/util-crypto");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+function _validateBalanceToSwap(fromToken, feeToken, feeTokenChainInfo, feeAmount, fromTokenBalance, feeTokenBalance, swapAmount, isXcmOk, minSwap) {
+  if (new _bignumber.default(feeTokenBalance).lte(feeAmount)) {
+    return new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.NOT_ENOUGH_BALANCE, `You don't have enough ${feeToken.symbol} (${feeTokenChainInfo.name}) to pay transaction fee`);
+  }
+  if (fromToken.slug === feeToken.slug) {
+    if (new _bignumber.default(fromTokenBalance).lte(new _bignumber.default(feeAmount).plus(swapAmount))) {
+      return new _TransactionError.TransactionError(_KoniTypes.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 _bignumber.default(fromTokenBalance).lte(minSwap)) {
+      const parsedMinSwapValue = (0, _utils2.formatNumber)(minSwap, (0, _utils._getAssetDecimals)(fromToken));
+      return new _TransactionError.TransactionError(_swap.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 _bignumber.default(swapAmount).gte(fromTokenBalance)) {
+    const parsedMaxBalanceSwap = (0, _utils2.formatNumber)(fromTokenBalance, (0, _utils._getAssetDecimals)(fromToken));
+    return new _TransactionError.TransactionError(_swap.SwapErrorType.SWAP_EXCEED_ALLOWANCE, `Amount too high. Lower your amount ${new _bignumber.default(fromTokenBalance).gt(0) ? `below ${parsedMaxBalanceSwap} ${fromToken.symbol}` : ''} and try again`);
+  }
+  return undefined;
+}
+function _validateSwapRecipient(destChainInfo, recipient) {
+  const isEvmAddress = (0, _utilCrypto.isEthereumAddress)(recipient);
+  const isEvmDestChain = (0, _utils._isChainEvmCompatible)(destChainInfo);
+  if (isEvmAddress && !isEvmDestChain || !isEvmAddress && isEvmDestChain) {
+    return new _TransactionError.TransactionError(_swap.SwapErrorType.INVALID_RECIPIENT);
+  }
+  return undefined;
+}
+function _getChainflipEarlyValidationError(error, metadata) {
+  // todo: support more providers
+  switch (error) {
+    case _swap.SwapErrorType.NOT_MEET_MIN_SWAP:
+      {
+        const parsedMinSwapValue = (0, _utils2.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.SwapError(error, message);
+      }
+    case _swap.SwapErrorType.SWAP_EXCEED_ALLOWANCE:
+      {
+        if (metadata.maxSwap) {
+          const parsedMaxSwapValue = (0, _utils2.formatNumber)(metadata.maxSwap.value, metadata.maxSwap.decimals);
+          return new _SwapError.SwapError(error, `Amount too high. Lower your amount below ${parsedMaxSwapValue} ${metadata.maxSwap.symbol} and try again`);
+        } else {
+          return new _SwapError.SwapError(error, 'Amount too high. Lower your amount and try again');
+        }
+      }
+    case _swap.SwapErrorType.ASSET_NOT_SUPPORTED:
+      return new _SwapError.SwapError(error, 'This swap pair is not supported');
+    case _swap.SwapErrorType.UNKNOWN:
+      return new _SwapError.SwapError(error, `Undefined error. Check your Internet and ${metadata.chain.slug} connection or contact support`);
+    case _swap.SwapErrorType.ERROR_FETCHING_QUOTE:
+      return new _SwapError.SwapError(error, 'No swap quote found. Adjust your amount or try again later.');
+    default:
+      return new _SwapError.SwapError(error);
+  }
+}
+function _getEarlyHydradxValidationError(error, metadata) {
+  switch (error) {
+    case _swap.SwapErrorType.AMOUNT_CANNOT_BE_ZERO:
+      {
+        return new _SwapError.SwapError(error, 'Amount too low. Increase your amount above 0 and try again');
+      }
+    case _swap.SwapErrorType.ASSET_NOT_SUPPORTED:
+      return new _SwapError.SwapError(error, 'This swap pair is not supported');
+    case _swap.SwapErrorType.UNKNOWN:
+      return new _SwapError.SwapError(error, `Undefined error. Check your Internet and ${metadata.chain.slug} connection or contact support`);
+    case _swap.SwapErrorType.ERROR_FETCHING_QUOTE:
+      return new _SwapError.SwapError(error, 'No swap quote found. Adjust your amount or try again later.');
+    default:
+      return new _SwapError.SwapError(error);
+  }
+}

package/cjs/core/logic-validation/transfer.js

@@ -0,0 +1,219 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.additionalValidateTransfer = additionalValidateTransfer;
+exports.additionalValidateXcmTransfer = additionalValidateXcmTransfer;
+exports.checkBalanceWithTransactionFee = checkBalanceWithTransactionFee;
+exports.checkSigningAccountForTransaction = checkSigningAccountForTransaction;
+exports.checkSupportForTransaction = checkSupportForTransaction;
+exports.estimateFeeForTransaction = estimateFeeForTransaction;
+exports.validateTransferRequest = validateTransferRequest;
+exports.validateXcmTransferRequest = validateXcmTransferRequest;
+var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _TransactionWarning = require("@subwallet/extension-base/background/warnings/TransactionWarning");
+var _constants = require("@subwallet/extension-base/constants");
+var _systemPallet = require("@subwallet/extension-base/core/substrate/system-pallet");
+var _constants2 = require("@subwallet/extension-base/services/chain-service/constants");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _utils2 = require("@subwallet/extension-base/services/fee-service/utils");
+var _helpers = require("@subwallet/extension-base/services/transaction-service/helpers");
+var _utils3 = require("@subwallet/extension-base/utils");
+var _uiKeyring = require("@subwallet/ui-keyring");
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+var _i18next = require("i18next");
+var _utilCrypto = require("@polkadot/util-crypto");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// normal transfer
+function validateTransferRequest(tokenInfo, from, to, value, transferAll) {
+  const errors = [];
+  const keypair = _uiKeyring.keyring.getPair(from);
+  let transferValue;
+  if (!transferAll) {
+    if (value === undefined) {
+      errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS, (0, _i18next.t)('Transfer amount is required')));
+    }
+    if (value) {
+      transferValue = new _bignumber.default(value);
+    }
+  }
+  if (!tokenInfo) {
+    errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS, (0, _i18next.t)('Not found token from registry')));
+  }
+  if ((0, _utilCrypto.isEthereumAddress)(from) && (0, _utilCrypto.isEthereumAddress)(to) && (0, _utils._isTokenEvmSmartContract)(tokenInfo) && (0, _utils._getContractAddressOfToken)(tokenInfo).length === 0) {
+    errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS, (0, _i18next.t)('Not found ERC20 address for this token')));
+  }
+  return [errors, keypair, transferValue];
+}
+function additionalValidateTransfer(tokenInfo, extrinsicType, receiverTransferTokenFreeBalance, transferAmount, senderTransferTokenTransferable) {
+  const minAmount = (0, _utils._getTokenMinAmount)(tokenInfo);
+  let warning;
+  let error;
+
+  // Check ed of not native token for sender
+  if (extrinsicType === _KoniTypes.ExtrinsicType.TRANSFER_TOKEN && senderTransferTokenTransferable) {
+    if (new _bignumber.default(senderTransferTokenTransferable).minus(transferAmount).lt(minAmount)) {
+      warning = new _TransactionWarning.TransactionWarning(_KoniTypes.BasicTxWarningCode.NOT_ENOUGH_EXISTENTIAL_DEPOSIT);
+    }
+  }
+
+  // Check ed for receiver
+  if (new _bignumber.default(receiverTransferTokenFreeBalance).plus(transferAmount).lt(minAmount)) {
+    const atLeast = new _bignumber.default(minAmount).minus(receiverTransferTokenFreeBalance).plus((tokenInfo.decimals || 0) === 0 ? 0 : 1);
+    const atLeastStr = (0, _utils3.formatNumber)(atLeast, tokenInfo.decimals || 0, _utils3.balanceFormatter, {
+      maxNumberFormat: tokenInfo.decimals || 6
+    });
+    error = new _TransactionError.TransactionError(_KoniTypes.TransferTxErrorType.RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT, (0, _i18next.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
+function validateXcmTransferRequest(destTokenInfo, sender, sendingValue) {
+  const errors = [];
+  const keypair = _uiKeyring.keyring.getPair(sender);
+  const transferValue = new _bignumber.default(sendingValue);
+  if (!destTokenInfo) {
+    errors.push(new _TransactionError.TransactionError(_KoniTypes.TransferTxErrorType.INVALID_TOKEN, (0, _i18next.t)('Not found token from registry')));
+  }
+  return [errors, keypair, transferValue];
+}
+function additionalValidateXcmTransfer(originTokenInfo, destinationTokenInfo, sendingAmount, senderTransferable) {
+  const destMinAmount = (0, _utils._getTokenMinAmount)(destinationTokenInfo);
+  const minSendingRequired = new _bignumber.default(destMinAmount).multipliedBy(_constants.XCM_MIN_AMOUNT_RATIO);
+  let error;
+  let warning;
+
+  // Check ed for receiver
+  if (new _bignumber.default(sendingAmount).lt(minSendingRequired)) {
+    const atLeastStr = (0, _utils3.formatNumber)(minSendingRequired, destinationTokenInfo.decimals || 0, _utils3.balanceFormatter, {
+      maxNumberFormat: destinationTokenInfo.decimals || 6
+    });
+    error = new _TransactionError.TransactionError(_KoniTypes.TransferTxErrorType.RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT, (0, _i18next.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 (!(0, _utils._isNativeToken)(originTokenInfo)) {
+    if (new _bignumber.default(senderTransferable).minus(sendingAmount).lt((0, _utils._getTokenMinAmount)(originTokenInfo))) {
+      warning = new _TransactionWarning.TransactionWarning(_KoniTypes.BasicTxWarningCode.NOT_ENOUGH_EXISTENTIAL_DEPOSIT);
+    }
+  }
+  return [warning, error];
+}
+
+// general validations
+function checkSupportForTransaction(validationResponse, transaction) {
+  const {
+    extrinsicType
+  } = validationResponse;
+  if (!transaction) {
+    if (extrinsicType === _KoniTypes.ExtrinsicType.SEND_NFT) {
+      validationResponse.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNSUPPORTED, (0, _i18next.t)('This feature is not yet available for this NFT')));
+    } else {
+      validationResponse.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNSUPPORTED));
+    }
+  }
+}
+async function estimateFeeForTransaction(validationResponse, transaction, chainInfo, evmApi) {
+  const estimateFee = {
+    symbol: '',
+    decimals: 0,
+    value: '0',
+    tooHigh: false
+  };
+  const {
+    decimals,
+    symbol
+  } = (0, _utils._getChainNativeTokenBasicInfo)(chainInfo);
+  estimateFee.decimals = decimals;
+  estimateFee.symbol = symbol;
+  if (transaction) {
+    try {
+      if ((0, _helpers.isSubstrateTransaction)(transaction)) {
+        estimateFee.value = (await transaction.paymentInfo(validationResponse.address)).partialFee.toString();
+      } else {
+        const gasLimit = await evmApi.api.eth.estimateGas(transaction);
+        const priority = await (0, _utils2.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 _bignumber.default(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.TransactionError(_KoniTypes.BasicTxErrorType.NOT_ENOUGH_BALANCE));
+      }
+    }
+  }
+  return estimateFee;
+}
+function checkSigningAccountForTransaction(validationResponse) {
+  const pair = _uiKeyring.keyring.getPair(validationResponse.address);
+  if (!pair) {
+    validationResponse.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR, (0, _i18next.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.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR, (0, _i18next.t)('This account is watch-only')));
+    }
+  }
+}
+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 _bignumber.default(validationResponse.estimateFee.value);
+  const bnNativeTokenAvailable = new _bignumber.default(nativeTokenAvailable.value);
+  const bnNativeTokenTransferAmount = new _bignumber.default(validationResponse.transferNativeAmount || '0');
+  if (!bnNativeTokenAvailable.gt(0)) {
+    validationResponse.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.NOT_ENOUGH_BALANCE));
+  }
+  const isChainNotSupportTransferAll = [..._constants2._TRANSFER_CHAIN_GROUP.acala, ..._constants2._TRANSFER_CHAIN_GROUP.genshiro, ..._constants2._TRANSFER_CHAIN_GROUP.bitcountry, ..._constants2._TRANSFER_CHAIN_GROUP.statemine].includes(nativeTokenInfo.originChain);
+  if (bnNativeTokenTransferAmount.plus(bnFee).gt(bnNativeTokenAvailable) && (!isTransferAll || isChainNotSupportTransferAll)) {
+    validationResponse.errors.push(new _TransactionError.TransactionError(_KoniTypes.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 === _KoniTypes.ExtrinsicType.TRANSFER_BALANCE && nativeTokenAvailable.metadata && (0, _systemPallet._canAccountBeReaped)(nativeTokenAvailable.metadata);
+  const isRemainingBalanceValid = bnNativeTokenAvailable.minus(bnNativeTokenTransferAmount).minus(bnFee).lt((0, _utils._getTokenMinAmount)(nativeTokenInfo));
+  if (isNeedCheckRemainingBalance && isRemainingBalanceValid) {
+    edAsWarning ? validationResponse.warnings.push(new _TransactionWarning.TransactionWarning(_KoniTypes.BasicTxWarningCode.NOT_ENOUGH_EXISTENTIAL_DEPOSIT)) : validationResponse.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.NOT_ENOUGH_EXISTENTIAL_DEPOSIT));
+  }
+}

package/cjs/core/substrate/nominationpools-pallet.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._getActiveStakeInNominationPool = _getActiveStakeInNominationPool;
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+function _getActiveStakeInNominationPool(memberInfo) {
+  return memberInfo.points.toString();
+}

package/cjs/core/substrate/system-pallet.js

@@ -0,0 +1,78 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._canAccountBeReaped = _canAccountBeReaped;
+exports._getAppliedExistentialDepositWithExtrinsicType = _getAppliedExistentialDepositWithExtrinsicType;
+exports._getSystemPalletTotalBalance = _getSystemPalletTotalBalance;
+exports._getSystemPalletTransferable = _getSystemPalletTransferable;
+exports._isAccountActive = _isAccountActive;
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+function isV1(accountInfo) {
+  return accountInfo.data.miscFrozen !== undefined && accountInfo.data.feeFrozen !== undefined;
+}
+function _getSystemPalletTransferable(accountInfo, existentialDeposit, extrinsicType) {
+  const strictMode = !extrinsicType || ![_KoniTypes.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);
+  }
+}
+function _canAccountBeReaped(accountInfo) {
+  return accountInfo.consumers === 0; // might need to check refCount
+}
+
+function _isAccountActive(accountInfo) {
+  return accountInfo.providers === 0 && accountInfo.consumers === 0;
+}
+function _getSystemPalletTotalBalance(accountInfo) {
+  if (isV1(accountInfo)) {
+    return _getSystemPalletTotalBalanceV1(accountInfo);
+  } else {
+    return _getSystemPalletTotalBalanceV2(accountInfo);
+  }
+}
+function _getAppliedExistentialDepositWithExtrinsicType(accountInfo, existentialDeposit, extrinsicType) {
+  const strictMode = !extrinsicType || ![_KoniTypes.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 _bignumber.default(accountInfo.data.free);
+  const bnLocked = new _bignumber.default(accountInfo.data.frozen).minus(accountInfo.data.reserved); // locked can go below 0 but this shouldn't matter
+  const bnAppliedExistentialDeposit = new _bignumber.default(_getAppliedExistentialDeposit(accountInfo, existentialDeposit, strictMode));
+  const bnTransferableBalance = bnFree.minus(_bignumber.default.max(bnLocked, bnAppliedExistentialDeposit));
+  return _bignumber.default.max(bnTransferableBalance, 0).toFixed();
+}
+function _getSystemPalletTotalBalanceV2(accountInfo) {
+  return new _bignumber.default(accountInfo.data.free).plus(accountInfo.data.reserved).toFixed();
+}
+function _getSystemPalletTransferableV1(accountInfo, existentialDeposit, strictMode) {
+  const bnAppliedExistentialDeposit = new _bignumber.default(_getAppliedExistentialDeposit(accountInfo, existentialDeposit, strictMode));
+  const bnAppliedFrozen = _bignumber.default.max(accountInfo.data.feeFrozen, accountInfo.data.miscFrozen);
+  const bnTotalBalance = new _bignumber.default(_getSystemPalletTotalBalanceV1(accountInfo));
+  const bnTransferableBalance = bnTotalBalance.minus(_bignumber.default.max(bnAppliedFrozen, accountInfo.data.reserved, bnAppliedExistentialDeposit));
+  return _bignumber.default.max(bnTransferableBalance, 0).toFixed();
+}
+function _getSystemPalletTotalBalanceV1(accountInfo) {
+  return new _bignumber.default(accountInfo.data.free).toFixed();
+}

package/cjs/koni/api/dotsama/transfer.js

@@ -1,17 +1,20 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.checkReferenceCount = checkReferenceCount;
 exports.checkSupportTransfer = checkSupportTransfer;
-exports.createTransferExtrinsic = void 0;
+exports.getTransferMockTxFee = exports.createTransferExtrinsic = void 0;
 var _api = require("@gear-js/api");
 var _wasm = require("@subwallet/extension-base/koni/api/tokens/wasm");
 var _utils = require("@subwallet/extension-base/koni/api/tokens/wasm/utils");
 var _constants = require("@subwallet/extension-base/services/chain-service/constants");
 var _utils2 = require("@subwallet/extension-base/services/chain-service/utils");
-var _utils3 = require("@subwallet/extension-base/utils");
+var _utils3 = require("@subwallet/extension-base/services/fee-service/utils");
+var _utils4 = require("@subwallet/extension-base/utils");
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
 var _util = require("@polkadot/util");
 var _utilCrypto = require("@polkadot/util-crypto");
 // Copyright 2019-2022 @subwallet/extension-base
@@ -153,7 +156,7 @@ const createTransferExtrinsic = async _ref => {
     }, to, value, {});
     transferAmount = value;
   } else if ((0, _utils2._isTokenGearSmartContract)(tokenInfo) && api instanceof _api.GearApi) {
-    const contractPromise = (0, _utils3.getGRC20ContractPromise)(api, (0, _utils2._getContractAddressOfToken)(tokenInfo));
+    const contractPromise = (0, _utils4.getGRC20ContractPromise)(api, (0, _utils2._getContractAddressOfToken)(tokenInfo));
     const transaction = await contractPromise.transfer((0, _util.u8aToHex)((0, _utilCrypto.decodeAddress)(to)), BigInt(value)) // Create transfer transaction
     .withAccount(from) // Set sender account
     .calculateGas(); // Add account arg to extrinsic
@@ -221,4 +224,46 @@ const createTransferExtrinsic = async _ref => {
   }
   return [transfer, transferAmount || value];
 };
-exports.createTransferExtrinsic = createTransferExtrinsic;
+exports.createTransferExtrinsic = createTransferExtrinsic;
+const getTransferMockTxFee = async (address, chainInfo, tokenInfo, api) => {
+  try {
+    let estimatedFee;
+    if ((0, _utils2._isChainEvmCompatible)(chainInfo) && (0, _utils2._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 (0, _utils3.calculateGasFeeParams)(web3, chainInfo.slug);
+      if (priority.baseGasFee) {
+        const maxFee = priority.maxFeePerGas;
+        estimatedFee = maxFee.multipliedBy(gasLimit);
+      } else {
+        estimatedFee = new _bignumber.default(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 _bignumber.default((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 _bignumber.default(0);
+  }
+};
+exports.getTransferMockTxFee = getTransferMockTxFee;

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

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

package/cjs/koni/api/xcm/index.js

@@ -1,14 +1,18 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.createXcmExtrinsic = void 0;
+exports.getXcmMockTxFee = exports.createXcmExtrinsic = void 0;
 var _polkadotXcm = require("@subwallet/extension-base/koni/api/xcm/polkadotXcm");
 var _xcmPallet = require("@subwallet/extension-base/koni/api/xcm/xcmPallet");
 var _xTokens = require("@subwallet/extension-base/koni/api/xcm/xTokens");
 var _constants = require("@subwallet/extension-base/services/chain-service/constants");
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+var _util = require("@polkadot/util");
+var _utilCrypto = require("@polkadot/util-crypto");
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
@@ -39,4 +43,28 @@ const createXcmExtrinsic = async _ref => {
   }
   return extrinsic;
 };
-exports.createXcmExtrinsic = createXcmExtrinsic;
+exports.createXcmExtrinsic = createXcmExtrinsic;
+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 = !(0, _utilCrypto.isEthereumAddress)(address) && (0, _utils._isChainEvmCompatible)(destChainInfo) && !(0, _utils._isChainEvmCompatible)(originChainInfo) ? (0, _util.u8aToHex)((0, _utilCrypto.addressToEvm)(address)) : address;
+    const mockTx = await createXcmExtrinsic({
+      chainInfoMap,
+      destinationTokenInfo,
+      originTokenInfo,
+      recipient: recipient,
+      sendingValue: '1000000000000000000',
+      substrateApi
+    });
+    const paymentInfo = await mockTx.paymentInfo(address);
+    return new _bignumber.default((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 _bignumber.default(0);
+  }
+};
+exports.getXcmMockTxFee = getXcmMockTxFee;