@subwallet/extension-base 1.2.31-0 → 1.2.33-0

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

@@ -0,0 +1,106 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateRecipientAddress = validateRecipientAddress;
+var _types = require("@subwallet/extension-base/core/types");
+var _utils = require("@subwallet/extension-base/core/utils");
+var _types2 = require("@subwallet/extension-base/types");
+var _utils2 = require("@subwallet/extension-base/utils");
+var _keyring = require("@subwallet/keyring");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+function getConditions(validateRecipientParams) {
+  const {
+    account,
+    actionType,
+    autoFormatValue,
+    destChainInfo,
+    srcChain,
+    toAddress
+  } = validateRecipientParams;
+  const conditions = [];
+  const isSendAction = [_types.ActionType.SEND_FUND, _types.ActionType.SEND_NFT].includes(actionType);
+  conditions.push(_types.ValidationCondition.IS_NOT_NULL);
+  conditions.push(_types.ValidationCondition.IS_ADDRESS);
+  conditions.push(_types.ValidationCondition.IS_VALID_ADDRESS_FOR_ECOSYSTEM);
+  if ((0, _keyring.isSubstrateAddress)(toAddress) && !autoFormatValue) {
+    // todo: need isSubstrateAddress util function to check exactly
+    conditions.push(_types.ValidationCondition.IS_VALID_SUBSTRATE_ADDRESS_FORMAT);
+  }
+  if ((0, _keyring.isTonAddress)(toAddress)) {
+    conditions.push(_types.ValidationCondition.IS_VALID_TON_ADDRESS_FORMAT);
+  }
+  if (srcChain === destChainInfo.slug && isSendAction && !destChainInfo.tonInfo) {
+    conditions.push(_types.ValidationCondition.IS_NOT_DUPLICATE_ADDRESS);
+  }
+  if (account !== null && account !== void 0 && account.isHardware) {
+    conditions.push(_types.ValidationCondition.IS_SUPPORT_LEDGER_ACCOUNT);
+    if (account.signMode === _types2.AccountSignMode.LEGACY_LEDGER) {
+      conditions.push(_types.ValidationCondition.IS_VALID_SUBSTRATE_ADDRESS_FORMAT);
+    }
+  }
+  return conditions;
+}
+function getValidationFunctions(conditions) {
+  const validationFunctions = [];
+  for (const condition of conditions) {
+    switch (condition) {
+      case _types.ValidationCondition.IS_NOT_NULL:
+        {
+          validationFunctions.push(_utils._isNotNull);
+          break;
+        }
+      case _types.ValidationCondition.IS_ADDRESS:
+        {
+          validationFunctions.push(_utils._isAddress);
+          break;
+        }
+      case _types.ValidationCondition.IS_VALID_ADDRESS_FOR_ECOSYSTEM:
+        {
+          validationFunctions.push(_utils._isValidAddressForEcosystem);
+          break;
+        }
+      case _types.ValidationCondition.IS_VALID_SUBSTRATE_ADDRESS_FORMAT:
+        {
+          validationFunctions.push(_utils._isValidSubstrateAddressFormat);
+          break;
+        }
+      case _types.ValidationCondition.IS_VALID_TON_ADDRESS_FORMAT:
+        {
+          validationFunctions.push(_utils._isValidTonAddressFormat);
+          break;
+        }
+      case _types.ValidationCondition.IS_NOT_DUPLICATE_ADDRESS:
+        {
+          validationFunctions.push(_utils._isNotDuplicateAddress);
+          break;
+        }
+      case _types.ValidationCondition.IS_SUPPORT_LEDGER_ACCOUNT:
+        {
+          validationFunctions.push(_utils._isSupportLedgerAccount);
+          break;
+        }
+    }
+  }
+  return validationFunctions;
+}
+function runValidationFunctions(validateRecipientParams, validationFunctions) {
+  const validationResults = [];
+  for (const validationFunction of validationFunctions) {
+    validationResults.push(validationFunction(validateRecipientParams));
+  }
+  for (const result of validationResults) {
+    if (result) {
+      return Promise.reject((0, _utils2.detectTranslate)(result));
+    }
+  }
+  return Promise.resolve();
+}
+function validateRecipientAddress(validateRecipientParams) {
+  const conditions = getConditions(validateRecipientParams);
+  const validationFunctions = getValidationFunctions(conditions);
+  return runValidationFunctions(validateRecipientParams, validationFunctions);
+}

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

@@ -21,8 +21,10 @@ var _EvmProviderError = require("@subwallet/extension-base/background/errors/Evm
 var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
 var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
 var _utils = require("@subwallet/extension-base/services/fee-service/utils");
+var _types = require("@subwallet/extension-base/types");
 var _utils2 = require("@subwallet/extension-base/utils");
 var _parseTransaction = require("@subwallet/extension-base/utils/eth/parseTransaction");
+var _keyring = require("@subwallet/keyring");
 var _uiKeyring = require("@subwallet/ui-keyring");
 var _utils3 = require("@walletconnect/utils");
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
@@ -256,8 +258,7 @@ async function validationEvmDataTransactionMiddleware(koni, url, payload) {
   const transactionParams = payload.payloadAfterValidated;
   const {
     address: fromAddress,
-    networkKey,
-    pair
+    networkKey
   } = payload;
   const evmApi = koni.getEvmApi(networkKey || '');
   const web3 = evmApi === null || evmApi === void 0 ? void 0 : evmApi.api;
@@ -273,7 +274,7 @@ async function validationEvmDataTransactionMiddleware(koni, url, payload) {
     payload.errorPosition = 'ui';
     payload.confirmationType = 'evmWatchTransactionRequest';
     const [message, name] = convertErrorMessage(message_);
-    const error = new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS, message, undefined, name);
+    const error = new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, message, undefined, name);
     console.error(error);
     errors.push(error);
   };
@@ -341,7 +342,7 @@ async function validationEvmDataTransactionMiddleware(koni, url, payload) {
     }
   }
   if (!transaction.gas) {
-    handleError(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR).message);
+    handleError(new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR).message);
   } else {
     if (transactionParams.maxPriorityFeePerGas && transactionParams.maxFeePerGas) {
       const maxFee = new _bignumber.default(transactionParams.maxFeePerGas);
@@ -376,11 +377,6 @@ async function validationEvmDataTransactionMiddleware(koni, url, payload) {
       handleError(e.message);
     }
   }
-  const pair_ = pair || _uiKeyring.keyring.getPair(fromAddress);
-  const account = {
-    address: fromAddress,
-    ...(pair_ === null || pair_ === void 0 ? void 0 : pair_.meta)
-  };
   try {
     transaction.nonce = await web3.eth.getTransactionCount(fromAddress);
   } catch (e) {
@@ -403,7 +399,7 @@ async function validationEvmDataTransactionMiddleware(koni, url, payload) {
     errors,
     payloadAfterValidated: {
       ...transaction,
-      account,
+      address: fromAddress,
       estimateGas,
       hashPayload,
       isToContract,
@@ -438,10 +434,6 @@ async function validationEvmSignMessageMiddleware(koni, url, payload_) {
     handleError('Not found address or payload to sign');
   }
   const pair = pair_ || _uiKeyring.keyring.getPair(address);
-  const account = {
-    address: pair.address,
-    ...pair.meta
-  };
   if (method) {
     if (['eth_sign', 'personal_sign', 'eth_signTypedData', 'eth_signTypedData_v1', 'eth_signTypedData_v3', 'eth_signTypedData_v4'].indexOf(method) < 0) {
       handleError('Unsupported action');
@@ -457,13 +449,13 @@ async function validationEvmSignMessageMiddleware(koni, url, payload_) {
           hashPayload = payload;
           break;
         case 'eth_sign':
-          if (!account.isExternal) {
+          if (!pair.meta.isExternal) {
             canSign = true;
           }
           break;
         case 'eth_signTypedData':
         case 'eth_signTypedData_v1':
-          if (!account.isExternal) {
+          if (!pair.meta.isExternal) {
             canSign = true;
           }
           payload = validateTypedSignMessageDataV1({
@@ -473,7 +465,7 @@ async function validationEvmSignMessageMiddleware(koni, url, payload_) {
           break;
         case 'eth_signTypedData_v3':
         case 'eth_signTypedData_v4':
-          if (!account.isExternal) {
+          if (!pair.meta.isExternal) {
             canSign = true;
           }
           payload = validateTypedSignMessageDataV3V4({
@@ -492,7 +484,7 @@ async function validationEvmSignMessageMiddleware(koni, url, payload_) {
     handleError('Unsupported method');
   }
   const payloadAfterValidated = {
-    account: account,
+    address,
     type: method || '',
     payload: payload,
     hashPayload: hashPayload,
@@ -524,7 +516,7 @@ function validationAuthWCMiddleware(koni, url, payload, topic) {
     if ((0, _utilCrypto.isEthereumAddress)(address)) {
       var _requestSession$names;
       sessionAccounts = ((_requestSession$names = requestSession.namespaces.eip155.accounts) === null || _requestSession$names === void 0 ? void 0 : _requestSession$names.map(account => account.split(':')[2])) || sessionAccounts;
-    } else {
+    } else if ((0, _keyring.isSubstrateAddress)(address)) {
       var _requestSession$names2;
       sessionAccounts = ((_requestSession$names2 = requestSession.namespaces.polkadot.accounts) === null || _requestSession$names2 === void 0 ? void 0 : _requestSession$names2.map(account => account.split(':')[2])) || sessionAccounts;
     }

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

@@ -12,8 +12,8 @@ exports._validateBalanceToSwapOnAssetHub = _validateBalanceToSwapOnAssetHub;
 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 _types = require("@subwallet/extension-base/types");
 var _swap = require("@subwallet/extension-base/types/swap");
 var _utils2 = require("@subwallet/extension-base/utils");
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
@@ -28,12 +28,12 @@ function _validateBalanceToSwapOnAssetHub(fromToken, feeToken, feeTokenChainInfo
     return new _TransactionError.TransactionError(_swap.SwapErrorType.SWAP_EXCEED_ALLOWANCE, `Amount too high. Lower your amount ${bnFromTokenBalance.gt(0) ? `below ${parsedMaxBalanceSwap} ${fromToken.symbol}` : ''} and try again`);
   }
   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`);
+    return new _TransactionError.TransactionError(_types.BasicTxErrorType.NOT_ENOUGH_BALANCE, `You don't have enough ${feeToken.symbol} (${feeTokenChainInfo.name}) to pay transaction fee`);
   }
   if (!(0, _utils._isNativeToken)(fromToken) && fromToken.slug === feeToken.slug) {
     // todo: need review and refactor
     if (bnFromTokenBalance.lte(new _bignumber.default(feeAmount).plus(swapAmount))) {
-      return new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.NOT_ENOUGH_BALANCE, `Insufficient balance. Deposit ${fromToken.symbol} and try again.`);
+      return new _TransactionError.TransactionError(_types.BasicTxErrorType.NOT_ENOUGH_BALANCE, `Insufficient balance. Deposit ${fromToken.symbol} and try again.`);
     }
   }
   if (isXcmOk) {
@@ -56,12 +56,12 @@ function _validateBalanceToSwapOnAssetHub(fromToken, feeToken, feeTokenChainInfo
 function _validateBalanceToSwap(fromToken, feeToken, feeTokenChainInfo, feeAmount, fromTokenBalance, feeTokenBalance, swapAmount, isXcmOk, minSwap) {
   const bnFromTokenBalance = new _bignumber.default(fromTokenBalance);
   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`);
+    return new _TransactionError.TransactionError(_types.BasicTxErrorType.NOT_ENOUGH_BALANCE, `You don't have enough ${feeToken.symbol} (${feeTokenChainInfo.name}) to pay transaction fee`);
   }
   if (fromToken.slug === feeToken.slug) {
     // todo: need review and refactor
     if (bnFromTokenBalance.lte(new _bignumber.default(feeAmount).plus(swapAmount))) {
-      return new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.NOT_ENOUGH_BALANCE, `Insufficient balance. Deposit ${fromToken.symbol} and try again.`);
+      return new _TransactionError.TransactionError(_types.BasicTxErrorType.NOT_ENOUGH_BALANCE, `Insufficient balance. Deposit ${fromToken.symbol} and try again.`);
     }
   }
   if (isXcmOk) {

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

@@ -11,6 +11,7 @@ exports.checkSigningAccountForTransaction = checkSigningAccountForTransaction;
 exports.checkSupportForAction = checkSupportForAction;
 exports.checkSupportForFeature = checkSupportForFeature;
 exports.checkSupportForTransaction = checkSupportForTransaction;
+exports.checkTonAddressBounceableAndAccountNotActive = checkTonAddressBounceableAndAccountNotActive;
 exports.estimateFeeForTransaction = estimateFeeForTransaction;
 exports.validateTransferRequest = validateTransferRequest;
 exports.validateXcmTransferRequest = validateXcmTransferRequest;
@@ -19,11 +20,14 @@ 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 _utils = require("@subwallet/extension-base/services/balance-service/helpers/subscribe/ton/utils");
 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 _utils2 = require("@subwallet/extension-base/services/chain-service/utils");
+var _utils3 = 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 _types = require("@subwallet/extension-base/types");
+var _utils4 = require("@subwallet/extension-base/utils");
+var _keyring = require("@subwallet/keyring");
 var _uiKeyring = require("@subwallet/ui-keyring");
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
 var _i18next = require("i18next");
@@ -38,30 +42,33 @@ function validateTransferRequest(tokenInfo, from, to, value, transferAll) {
   let transferValue;
   if (!transferAll) {
     if (value === undefined) {
-      errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS, (0, _i18next.t)('Transfer amount is required')));
+      errors.push(new _TransactionError.TransactionError(_types.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')));
+    errors.push(new _TransactionError.TransactionError(_types.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')));
+  if ((0, _utilCrypto.isEthereumAddress)(from) && (0, _utilCrypto.isEthereumAddress)(to) && (0, _utils2._isTokenEvmSmartContract)(tokenInfo) && (0, _utils2._getContractAddressOfToken)(tokenInfo).length === 0) {
+    errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, (0, _i18next.t)('Not found ERC20 address for this token')));
+  }
+  if ((0, _keyring.isTonAddress)(from) && (0, _keyring.isTonAddress)(to) && (0, _utils2._isTokenTonSmartContract)(tokenInfo) && (0, _utils2._getContractAddressOfToken)(tokenInfo).length === 0) {
+    errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, (0, _i18next.t)('Not found TEP74 address for this token')));
   }
   return [errors, keypair, transferValue];
 }
 function additionalValidateTransfer(tokenInfo, nativeTokenInfo, extrinsicType, receiverTransferTokenFreeBalance, transferAmount, senderTransferTokenTransferable, receiverNativeTransferable) {
-  const minAmount = (0, _utils._getTokenMinAmount)(tokenInfo);
-  const nativeMinAmount = (0, _utils._getTokenMinAmount)(nativeTokenInfo);
+  const minAmount = (0, _utils2._getTokenMinAmount)(tokenInfo);
+  const nativeMinAmount = (0, _utils2._getTokenMinAmount)(nativeTokenInfo);
   const warnings = [];
   const errors = [];
 
   // Check ed of not native token for sender after sending
   if (extrinsicType === _KoniTypes.ExtrinsicType.TRANSFER_TOKEN && senderTransferTokenTransferable) {
     if (new _bignumber.default(senderTransferTokenTransferable).minus(transferAmount).lt(minAmount)) {
-      const warning = new _TransactionWarning.TransactionWarning(_KoniTypes.BasicTxWarningCode.NOT_ENOUGH_EXISTENTIAL_DEPOSIT);
+      const warning = new _TransactionWarning.TransactionWarning(_types.BasicTxWarningCode.NOT_ENOUGH_EXISTENTIAL_DEPOSIT);
       warnings.push(warning);
     }
   }
@@ -69,7 +76,7 @@ function additionalValidateTransfer(tokenInfo, nativeTokenInfo, extrinsicType, r
   // Check ed for receiver before sending
   if (extrinsicType === _KoniTypes.ExtrinsicType.TRANSFER_TOKEN && receiverNativeTransferable) {
     if (new _bignumber.default(receiverNativeTransferable).lt(nativeMinAmount)) {
-      const error = new _TransactionError.TransactionError(_KoniTypes.TransferTxErrorType.RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT, (0, _i18next.t)('The recipient account has {{amount}} {{nativeSymbol}} which can lead to your {{localSymbol}} being lost. Change recipient account and try again', {
+      const error = new _TransactionError.TransactionError(_types.TransferTxErrorType.RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT, (0, _i18next.t)('The recipient account has {{amount}} {{nativeSymbol}} which can lead to your {{localSymbol}} being lost. Change recipient account and try again', {
         replace: {
           amount: receiverNativeTransferable,
           nativeSymbol: nativeTokenInfo.symbol,
@@ -83,10 +90,10 @@ function additionalValidateTransfer(tokenInfo, nativeTokenInfo, extrinsicType, r
   // Check ed for receiver after sending
   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, {
+    const atLeastStr = (0, _utils4.formatNumber)(atLeast, tokenInfo.decimals || 0, _utils4.balanceFormatter, {
       maxNumberFormat: tokenInfo.decimals || 6
     });
-    const 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', {
+    const error = new _TransactionError.TransactionError(_types.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
@@ -103,23 +110,23 @@ function validateXcmTransferRequest(destTokenInfo, sender, sendingValue) {
   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')));
+    errors.push(new _TransactionError.TransactionError(_types.TransferTxErrorType.INVALID_TOKEN, (0, _i18next.t)('Not found token from registry')));
   }
   return [errors, keypair, transferValue];
 }
 function additionalValidateXcmTransfer(originTokenInfo, destinationTokenInfo, sendingAmount, senderTransferable, receiverNativeBalance, destChainInfo) {
   let isSnowBridge = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : false;
-  const destMinAmount = (0, _utils._getTokenMinAmount)(destinationTokenInfo);
+  const destMinAmount = (0, _utils2._getTokenMinAmount)(destinationTokenInfo);
   const minSendingRequired = new _bignumber.default(destMinAmount).multipliedBy(_constants.XCM_MIN_AMOUNT_RATIO);
   let error;
   let warning;
 
   // Check sending token ED for receiver
   if (new _bignumber.default(sendingAmount).lt(minSendingRequired)) {
-    const atLeastStr = (0, _utils3.formatNumber)(minSendingRequired, destinationTokenInfo.decimals || 0, _utils3.balanceFormatter, {
+    const atLeastStr = (0, _utils4.formatNumber)(minSendingRequired, destinationTokenInfo.decimals || 0, _utils4.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', {
+    error = new _TransactionError.TransactionError(_types.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
@@ -128,16 +135,16 @@ function additionalValidateXcmTransfer(originTokenInfo, destinationTokenInfo, se
   }
 
   // check native token ED on dest chain for receiver
-  const bnKeepAliveBalance = (0, _utils._isNativeToken)(destinationTokenInfo) ? new _bignumber.default(receiverNativeBalance).plus(sendingAmount) : new _bignumber.default(receiverNativeBalance);
-  if (isSnowBridge && bnKeepAliveBalance.lt((0, _utils._getChainExistentialDeposit)(destChainInfo))) {
+  const bnKeepAliveBalance = (0, _utils2._isNativeToken)(destinationTokenInfo) ? new _bignumber.default(receiverNativeBalance).plus(sendingAmount) : new _bignumber.default(receiverNativeBalance);
+  if (isSnowBridge && bnKeepAliveBalance.lt((0, _utils2._getChainExistentialDeposit)(destChainInfo))) {
     const {
       decimals,
       symbol
-    } = (0, _utils._getChainNativeTokenBasicInfo)(destChainInfo);
-    const atLeastStr = (0, _utils3.formatNumber)((0, _utils._getChainExistentialDeposit)(destChainInfo), decimals || 0, _utils3.balanceFormatter, {
+    } = (0, _utils2._getChainNativeTokenBasicInfo)(destChainInfo);
+    const atLeastStr = (0, _utils4.formatNumber)((0, _utils2._getChainExistentialDeposit)(destChainInfo), decimals || 0, _utils4.balanceFormatter, {
       maxNumberFormat: 6
     });
-    error = new _TransactionError.TransactionError(_KoniTypes.TransferTxErrorType.RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT, (0, _i18next.t)(' Insufficient {{symbol}} on {{chain}} to cover min balance ({{amount}} {{symbol}})', {
+    error = new _TransactionError.TransactionError(_types.TransferTxErrorType.RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT, (0, _i18next.t)(' Insufficient {{symbol}} on {{chain}} to cover min balance ({{amount}} {{symbol}})', {
       replace: {
         amount: atLeastStr,
         symbol,
@@ -147,9 +154,9 @@ function additionalValidateXcmTransfer(originTokenInfo, destinationTokenInfo, se
   }
 
   // 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);
+  if (!(0, _utils2._isNativeToken)(originTokenInfo)) {
+    if (new _bignumber.default(senderTransferable).minus(sendingAmount).lt((0, _utils2._getTokenMinAmount)(originTokenInfo))) {
+      warning = new _TransactionWarning.TransactionWarning(_types.BasicTxWarningCode.NOT_ENOUGH_EXISTENTIAL_DEPOSIT);
     }
   }
   return [warning, error];
@@ -159,7 +166,7 @@ function checkSupportForFeature(validationResponse, blockedFeaturesList, chainIn
   const chain = validationResponse.chain;
   const currentFeature = `${extrinsicType}___${chain}`;
   if (blockedFeaturesList.includes(currentFeature)) {
-    validationResponse.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNSUPPORTED, (0, _i18next.t)(`Feature under maintenance on ${chainInfo.name} network. Try again later`)));
+    validationResponse.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED, (0, _i18next.t)(`Feature under maintenance on ${chainInfo.name} network. Try again later`)));
   }
 }
 function checkSupportForAction(validationResponse, blockedActionsMap) {
@@ -315,7 +322,7 @@ function checkSupportForAction(validationResponse, blockedActionsMap) {
   }
   const blockedActionsList = Object.values(blockedActionsMap).flat();
   if (blockedActionsList.includes(currentAction)) {
-    validationResponse.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNSUPPORTED, (0, _i18next.t)('Feature under maintenance. Try again later')));
+    validationResponse.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED, (0, _i18next.t)('Feature under maintenance. Try again later')));
   }
 }
 
@@ -326,9 +333,9 @@ function checkSupportForTransaction(validationResponse, transaction) {
   } = 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')));
+      validationResponse.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED, (0, _i18next.t)('This feature is not yet available for this NFT')));
     } else {
-      validationResponse.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNSUPPORTED));
+      validationResponse.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED));
     }
   }
 }
@@ -342,16 +349,18 @@ async function estimateFeeForTransaction(validationResponse, transaction, chainI
   const {
     decimals,
     symbol
-  } = (0, _utils._getChainNativeTokenBasicInfo)(chainInfo);
+  } = (0, _utils2._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 if ((0, _helpers.isTonTransaction)(transaction)) {
+        estimateFee.value = transaction.estimateFee; // todo: might need to update logic estimate fee inside for future actions excluding normal transfer Ton and Jetton
       } else {
         const gasLimit = await evmApi.api.eth.estimateGas(transaction);
-        const priority = await (0, _utils2.calculateGasFeeParams)(evmApi, chainInfo.slug);
+        const priority = await (0, _utils3.calculateGasFeeParams)(evmApi, chainInfo.slug);
         if (priority.baseGasFee) {
           const maxFee = priority.maxFeePerGas; // TODO: Need review
 
@@ -364,20 +373,36 @@ async function estimateFeeForTransaction(validationResponse, transaction, chainI
     } 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));
+        validationResponse.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.NOT_ENOUGH_BALANCE));
       }
     }
   }
   return estimateFee;
 }
-function checkSigningAccountForTransaction(validationResponse) {
-  const pair = _uiKeyring.keyring.getPair(validationResponse.address);
+function checkSigningAccountForTransaction(validationResponse, chainInfoMap) {
+  const {
+    address,
+    chain,
+    chainType,
+    extrinsicType
+  } = validationResponse;
+  const pair = _uiKeyring.keyring.getPair(address);
   if (!pair) {
-    validationResponse.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR, (0, _i18next.t)('Unable to find account')));
+    validationResponse.errors.push(new _TransactionError.TransactionError(_types.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')));
+    const accountJson = (0, _utils4.pairToAccount)(pair, chainInfoMap);
+    if (!accountJson.transactionActions.includes(extrinsicType)) {
+      // check if the account can sign the transaction type
+      validationResponse.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, (0, _i18next.t)('This feature is not available with this account')));
+    } else if (accountJson.specialChain && accountJson.specialChain !== chain) {
+      // check if the account can only be used on a specific chain (for ledger legacy)
+      validationResponse.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, (0, _i18next.t)('This feature is not available with this account')));
+    } else {
+      const compatibleMap = [_types.AccountSignMode.LEGACY_LEDGER, _types.AccountSignMode.GENERIC_LEDGER].includes(accountJson.signMode) ? _constants.LEDGER_SIGNING_COMPATIBLE_MAP : _constants.SIGNING_COMPATIBLE_MAP;
+      if (!compatibleMap[chainType].includes(accountJson.chainType)) {
+        // check if the account chain type is compatible with the transaction chain type
+        validationResponse.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, (0, _i18next.t)('This feature is not available with this account')));
+      }
     }
   }
 }
@@ -399,17 +424,33 @@ function checkBalanceWithTransactionFee(validationResponse, transactionInput, na
   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));
+    validationResponse.errors.push(new _TransactionError.TransactionError(_types.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
+    validationResponse.errors.push(new _TransactionError.TransactionError(_types.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));
+  const isRemainingBalanceValid = bnNativeTokenAvailable.minus(bnNativeTokenTransferAmount).minus(bnFee).lt((0, _utils2._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));
+    edAsWarning ? validationResponse.warnings.push(new _TransactionWarning.TransactionWarning(_types.BasicTxWarningCode.NOT_ENOUGH_EXISTENTIAL_DEPOSIT)) : validationResponse.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.NOT_ENOUGH_EXISTENTIAL_DEPOSIT));
   }
+}
+async function checkTonAddressBounceableAndAccountNotActive(tonApi, validationResponse) {
+  const {
+    to
+  } = validationResponse.data;
+  const isActive = await isAccountActive(tonApi, to);
+  if (isTonAddressBounceable(to) && !isActive) {
+    validationResponse.warnings.push(new _TransactionWarning.TransactionWarning(_types.BasicTxWarningCode.IS_BOUNCEABLE_ADDRESS));
+  }
+}
+function isTonAddressBounceable(address) {
+  return (0, _utils.isBounceableAddress)(address);
+}
+async function isAccountActive(tonApi, address) {
+  const state = await tonApi.getAccountState(address);
+  return state === 'active';
 }

package/cjs/core/types.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ValidationCondition = exports.ActionType = void 0;
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+let ValidationCondition;
+exports.ValidationCondition = ValidationCondition;
+(function (ValidationCondition) {
+  ValidationCondition["IS_NOT_NULL"] = "IS_NOT_NULL";
+  ValidationCondition["IS_ADDRESS"] = "IS_ADDRESS";
+  ValidationCondition["IS_VALID_ADDRESS_FOR_ECOSYSTEM"] = "IS_VALID_ADDRESS_FOR_ECOSYSTEM";
+  ValidationCondition["IS_VALID_SUBSTRATE_ADDRESS_FORMAT"] = "IS_VALID_SUBSTRATE_ADDRESS_FORMAT";
+  ValidationCondition["IS_VALID_TON_ADDRESS_FORMAT"] = "IS_VALID_TON_ADDRESS_FORMAT";
+  ValidationCondition["IS_NOT_DUPLICATE_ADDRESS"] = "IS_NOT_DUPLICATE_ADDRESS";
+  ValidationCondition["IS_SUPPORT_LEDGER_ACCOUNT"] = "IS_SUPPORT_LEDGER_ACCOUNT";
+})(ValidationCondition || (exports.ValidationCondition = ValidationCondition = {}));
+let ActionType;
+exports.ActionType = ActionType;
+(function (ActionType) {
+  ActionType["SEND_FUND"] = "SEND_FUND";
+  ActionType["SEND_NFT"] = "SEND_NFT";
+  ActionType["SWAP"] = "SWAP";
+})(ActionType || (exports.ActionType = ActionType = {}));