@subwallet/extension-base 1.3.54-1 → 1.3.55-1

package/cjs/background/errors/TransactionError.js

@@ -14,51 +14,51 @@ var _SWError = require("./SWError");
 // Todo: finish this map in the future
 const defaultErrorMap = {
   NOT_ENOUGH_BALANCE: {
-    message: (0, _utils.detectTranslate)('Insufficient balance'),
+    message: (0, _utils.detectTranslate)('bg.TRANSACTION.background.error.Transaction.insufficientBalance'),
     code: undefined
   },
   CHAIN_DISCONNECTED: {
-    message: (0, _utils.detectTranslate)('Network is disconnected'),
+    message: (0, _utils.detectTranslate)('bg.TRANSACTION.background.error.Transaction.networkIsDisconnected'),
     code: undefined
   },
   INVALID_PARAMS: {
-    message: (0, _utils.detectTranslate)('Undefined error. Please contact SubWallet support'),
+    message: (0, _utils.detectTranslate)('bg.TRANSACTION.background.error.Transaction.undefinedErrorContactSupport'),
     code: undefined
   },
   INTERNAL_ERROR: {
-    message: (0, _utils.detectTranslate)('Undefined error. Please contact SubWallet support'),
+    message: (0, _utils.detectTranslate)('bg.TRANSACTION.background.error.Transaction.undefinedErrorContactSupport'),
     code: undefined
   },
   DUPLICATE_TRANSACTION: {
-    message: (0, _utils.detectTranslate)('Another transaction is in queue. Please try again later'),
+    message: (0, _utils.detectTranslate)('bg.TRANSACTION.background.error.Transaction.transactionInQueue'),
     code: undefined
   },
   UNABLE_TO_SIGN: {
-    message: (0, _utils.detectTranslate)('Unable to sign'),
+    message: (0, _utils.detectTranslate)('bg.TRANSACTION.background.error.Transaction.unableToSign'),
     code: undefined
   },
   USER_REJECT_REQUEST: {
-    message: (0, _utils.detectTranslate)('Rejected by user'),
+    message: (0, _utils.detectTranslate)('bg.TRANSACTION.background.error.Transaction.rejectedByUser'),
     code: undefined
   },
   UNABLE_TO_SEND: {
-    message: (0, _utils.detectTranslate)('Unable to send'),
+    message: (0, _utils.detectTranslate)('bg.TRANSACTION.background.error.Transaction.unableToSend'),
     code: undefined
   },
   SEND_TRANSACTION_FAILED: {
-    message: (0, _utils.detectTranslate)('Send transaction failed'),
+    message: (0, _utils.detectTranslate)('bg.TRANSACTION.background.error.Transaction.sendTransactionFailed'),
     code: undefined
   },
   NOT_ENOUGH_EXISTENTIAL_DEPOSIT: {
-    message: (0, _utils.detectTranslate)('Insufficient balance to cover existential deposit. Please decrease the transaction amount or increase your current balance'),
+    message: (0, _utils.detectTranslate)('bg.TRANSACTION.background.error.Transaction.insufficientBalanceForExistentialDeposit'),
     code: undefined
   },
   [_types.BasicTxErrorType.UNSUPPORTED]: {
-    message: (0, _utils.detectTranslate)('This feature is not available with this token'),
+    message: (0, _utils.detectTranslate)('bg.TRANSACTION.background.error.Transaction.featureNotAvailableForToken'),
     code: undefined
   },
   [_types.BasicTxErrorType.TIMEOUT]: {
-    message: (0, _utils.detectTranslate)('Transaction timeout'),
+    message: (0, _utils.detectTranslate)('bg.TRANSACTION.background.error.Transaction.transactionTimeout'),
     code: undefined
   },
   [_types.StakingTxErrorType.NOT_ENOUGH_MIN_STAKE]: {
@@ -77,43 +77,43 @@ const defaultErrorMap = {
     code: undefined
   },
   [_types.StakingTxErrorType.INVALID_ACTIVE_STAKE]: {
-    message: (0, _utils.detectTranslate)('Invalid. If you unstake this amount your active stake would fall below minimum active threshold'),
+    message: (0, _utils.detectTranslate)('bg.TRANSACTION.background.error.Transaction.invalidUnstakeBelowMinimum'),
     code: undefined
   },
   [_types.StakingTxErrorType.EXCEED_MAX_UNSTAKING]: {
-    message: (0, _utils.detectTranslate)('You reached the maximum number of unstake requests'),
+    message: (0, _utils.detectTranslate)('bg.TRANSACTION.background.error.Transaction.maxUnstakeRequestsReached'),
     code: undefined
   },
   [_types.StakingTxErrorType.INACTIVE_NOMINATION_POOL]: {
-    message: (0, _utils.detectTranslate)('Invalid. Inactive nomination pool'),
+    message: (0, _utils.detectTranslate)('bg.TRANSACTION.background.error.Transaction.invalidInactiveNominationPool'),
     code: undefined
   },
   [_types.StakingTxErrorType.CAN_NOT_GET_METADATA]: {
-    message: (0, _utils.detectTranslate)('Unable to fetch staking data. Re-enable current network and try again'),
+    message: (0, _utils.detectTranslate)('bg.TRANSACTION.background.error.Transaction.unableToFetchStakingData'),
     code: undefined
   },
   [_types.StakingTxErrorType.REMAINING_AMOUNT_TOO_LOW]: {
-    message: (0, _utils.detectTranslate)('Remaining amount too low'),
+    message: (0, _utils.detectTranslate)('bg.TRANSACTION.background.error.Transaction.remainingAmountTooLow'),
     code: undefined
   },
   [_types.TransferTxErrorType.RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT]: {
-    message: (0, _utils.detectTranslate)('Receiver is not enough existential deposit'),
+    message: (0, _utils.detectTranslate)('bg.TRANSACTION.background.error.Transaction.receiverNotEnoughExistentialDeposit'),
     code: undefined
   },
   [_types.YieldValidationStatus.NOT_ENOUGH_FEE]: {
-    message: (0, _utils.detectTranslate)('Insufficient balance'),
+    message: (0, _utils.detectTranslate)('bg.TRANSACTION.background.error.Transaction.insufficientBalance'),
     code: undefined
   },
   [_types.YieldValidationStatus.NOT_ENOUGH_MIN_JOIN_POOL]: {
-    message: (0, _utils.detectTranslate)('Not enough min earning amount'),
+    message: (0, _utils.detectTranslate)('bg.TRANSACTION.background.error.Transaction.notEnoughMinEarningAmount'),
     code: undefined
   },
   [_types.SwapErrorType.QUOTE_TIMEOUT]: {
-    message: (0, _utils.detectTranslate)('Quote timeout'),
+    message: (0, _utils.detectTranslate)('bg.TRANSACTION.background.error.Transaction.quoteTimeout'),
     code: undefined
   },
   [_types.SwapErrorType.INVALID_RECIPIENT]: {
-    message: (0, _utils.detectTranslate)('Invalid recipient'),
+    message: (0, _utils.detectTranslate)('bg.TRANSACTION.background.error.Transaction.invalidRecipient'),
     code: undefined
   }
 };

package/cjs/background/warnings/TransactionWarning.js

@@ -14,11 +14,11 @@ var _TransactionError = require("../errors/TransactionError");
 
 const defaultWarningMap = {
   [_types.BasicTxWarningCode.NOT_ENOUGH_EXISTENTIAL_DEPOSIT]: {
-    message: (0, _utils.detectTranslate)('Insufficient balance to cover existential deposit. Please decrease the transaction amount or increase your current balance'),
+    message: (0, _utils.detectTranslate)('bg.TRANSACTION.background.warning.Transaction.insufficientBalanceForExistentialDeposit'),
     code: undefined
   },
   [_types.BasicTxWarningCode.IS_BOUNCEABLE_ADDRESS]: {
-    message: (0, _utils.detectTranslate)('We are not supporting for bounceable address. The send mode is work as non-bounceable address.'),
+    message: (0, _utils.detectTranslate)('bg.TRANSACTION.background.warning.Transaction.bounceableAddressNotSupported'),
     code: undefined
   }
 };

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

@@ -66,14 +66,26 @@ Object.keys(_transfer).forEach(function (key) {
 function validateSpendingAndFeePayment(spendingToken, feeToken, bnSpendingAmount, bnFromTokenBalance, bnFeeAmount, bnFeeTokenBalance) {
   if (spendingToken.slug === feeToken.slug) {
     if (bnFromTokenBalance.lte(bnSpendingAmount.plus(bnFeeAmount).plus((0, _utils._isNativeToken)(spendingToken) ? '0' : (0, _utils._getTokenMinAmount)(spendingToken)))) {
-      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.NOT_ENOUGH_BALANCE, (0, _i18next.t)(`Insufficient balance. Deposit ${spendingToken.symbol} and try again.`))];
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.NOT_ENOUGH_BALANCE, (0, _i18next.t)('bg.core.validation.insufficientSpendingTokenBalance', {
+        replace: {
+          spendingTokenSymbol: spendingToken.symbol
+        }
+      }))];
     }
   } else {
     if (bnFromTokenBalance.lte(bnSpendingAmount.plus((0, _utils._isNativeToken)(spendingToken) ? '0' : (0, _utils._getTokenMinAmount)(spendingToken)))) {
-      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.NOT_ENOUGH_BALANCE, (0, _i18next.t)(`Insufficient balance. Deposit ${spendingToken.symbol} and try again.`))];
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.NOT_ENOUGH_BALANCE, (0, _i18next.t)('bg.core.validation.insufficientSpendingTokenBalance', {
+        replace: {
+          spendingTokenSymbol: spendingToken.symbol
+        }
+      }))];
     }
     if (bnFeeTokenBalance.lte(bnFeeAmount.plus((0, _utils._isNativeToken)(feeToken) ? '0' : (0, _utils._getTokenMinAmount)(feeToken)))) {
-      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.NOT_ENOUGH_BALANCE, (0, _i18next.t)(`Insufficient balance. Deposit ${feeToken.symbol} and try again.`))];
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.NOT_ENOUGH_BALANCE, (0, _i18next.t)('bg.core.validation.insufficientFeeTokenBalance', {
+        replace: {
+          feeTokenSymbol: feeToken.symbol
+        }
+      }))];
     }
   }
   return [];

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

@@ -181,7 +181,7 @@ async function validationAuthMiddleware(koni, url, payload) {
           return handleAuthError(payload, 'Account not in allowed list', 'dApp', errors);
         }
         if (payload.pair.meta.noPublicKey) {
-          return handleAuthError(payload, (0, _i18next.t)('This account is not supported for this action'), 'dApp', errors);
+          return handleAuthError(payload, (0, _i18next.t)('bg.TRANSACTION.core.validation.request.accountNotSupportedForAction'), 'dApp', errors);
         }
         payload.authInfo = authInfo;
       }
@@ -768,14 +768,14 @@ async function validationBitcoinSignMessageMiddleware(koni, url, payload_) {
     errors.push(error);
   };
   if (address === '' || !message) {
-    handleError((0, _i18next.t)('not found address or payload to sign'));
+    handleError((0, _i18next.t)('bg.TRANSACTION.core.validation.request.notFoundAddressOrPayload'));
   }
   if (!(0, _validate.isBitcoinAddress)(address)) {
-    handleError((0, _i18next.t)('Invalid bitcoin address'));
+    handleError((0, _i18next.t)('bg.TRANSACTION.core.validation.request.invalidBitcoinAddress'));
   }
   const pair = pair_ || _uiKeyring.keyring.getPair(address);
   if (!pair) {
-    handleError((0, _i18next.t)('Unable to find account'));
+    handleError((0, _i18next.t)('bg.TRANSACTION.core.validation.request.unableToFindAccount'));
   }
   const hashPayload = '';
   let canSign = false;
@@ -825,23 +825,23 @@ async function validationBitcoinSignPsbtMiddleware(koni, url, payload_) {
     errors.push(error);
   };
   if (!(psbtParams.network === 'mainnet' || psbtParams.network === 'testnet')) {
-    handleError((0, _i18next.t)('Network to try this request is must be mainnet or testnet'));
+    handleError((0, _i18next.t)('bg.TRANSACTION.core.validation.request.networkMustBeMainnetOrTestnet'));
   }
   if (!networkKey) {
-    handleError((0, _i18next.t)('Network unavailable. Please switch network or manually add network to wallet'));
+    handleError((0, _i18next.t)('bg.TRANSACTION.core.validation.request.networkUnavailableSwitchOrAdd'));
   }
   if (!psbt || !address) {
-    handleError((0, _i18next.t)('Not found payload to sign'));
+    handleError((0, _i18next.t)('bg.TRANSACTION.core.validation.request.notFoundPayloadToSign'));
   }
   if (!(0, _util.isHex)(`0x${psbt}`)) {
-    handleError((0, _i18next.t)('Psbt to be signed must be hex-encoded'));
+    handleError((0, _i18next.t)('bg.TRANSACTION.core.validation.request.psbtMustBeHexEncoded'));
   }
   if (!(0, _validate.isBitcoinAddress)(address)) {
-    handleError((0, _i18next.t)('Not found address'));
+    handleError((0, _i18next.t)('bg.TRANSACTION.core.validation.request.notFoundAddress'));
   }
   const addressInfo = (0, _utils3.getBitcoinAddressInfo)(address);
   if (psbtParams.network !== addressInfo.network) {
-    handleError((0, _i18next.t)('The account or the network is not matched'));
+    handleError((0, _i18next.t)('bg.TRANSACTION.core.validation.request.accountOrNetworkNotMatched'));
   }
   const payload = {
     broadcast: !!broadcast,
@@ -898,13 +898,13 @@ async function validationBitcoinSendTransactionMiddleware(koni, url, payload_) {
     return val;
   };
   if (transactionParams.network !== senderAccountInfo.network) {
-    handleError((0, _i18next.t)('The account or the network is not matched'));
+    handleError((0, _i18next.t)('bg.TRANSACTION.core.validation.request.accountOrNetworkNotMatched'));
   }
   if (!((_transactionParams$re = transactionParams.recipients) !== null && _transactionParams$re !== void 0 && _transactionParams$re.length)) {
-    handleError((0, _i18next.t)('please provide the recipient and the amount'));
+    handleError((0, _i18next.t)('bg.TRANSACTION.core.validation.request.provideRecipientAndAmount'));
   }
   if (((_transactionParams$re2 = transactionParams.recipients) === null || _transactionParams$re2 === void 0 ? void 0 : _transactionParams$re2.length) > 1) {
-    handleError((0, _i18next.t)("we don't support multiple recipients yet. Please provide only one for now."));
+    handleError((0, _i18next.t)('bg.TRANSACTION.core.validation.request.multipleRecipientsNotSupported'));
   }
   if (transactionParams.recipients.filter(_ref => {
     let {
@@ -917,17 +917,17 @@ async function validationBitcoinSendTransactionMiddleware(koni, url, payload_) {
   }
   const recipientAccountInfo = (0, _utils3.getBitcoinAddressInfo)(transactionParams.recipients[0].address);
   if (recipientAccountInfo.network !== transactionParams.network) {
-    handleError((0, _i18next.t)('invalid recipient address'));
+    handleError((0, _i18next.t)('bg.TRANSACTION.core.validation.request.invalidRecipientAddress'));
   }
   if (transactionParams.recipients.length !== 1) {
-    handleError((0, _i18next.t)('receiving address must be a single account'));
+    handleError((0, _i18next.t)('bg.TRANSACTION.core.validation.request.receivingAddressMustBeSingleAccount'));
   }
   if (address === transactionParams.recipients[0].address) {
-    handleError((0, _i18next.t)('must be different from sending address'));
+    handleError((0, _i18next.t)('bg.TRANSACTION.core.validation.request.mustBeDifferentFromSendingAddress'));
   }
   const pair = pair_ || _uiKeyring.keyring.getPair(address);
   if (!pair) {
-    handleError((0, _i18next.t)('unable to find account'));
+    handleError((0, _i18next.t)('bg.TRANSACTION.core.validation.request.unableToFindAccountError'));
   }
   const tokenInfo = koni.getNativeTokenInfo(networkKey);
   let freeBalance = {
@@ -940,15 +940,15 @@ async function validationBitcoinSendTransactionMiddleware(koni, url, payload_) {
     freeBalance = await koni.balanceService.getTransferableBalance(address, networkKey, tokenInfo.slug);
   } catch (e) {
     const message = e.message;
-    if (message.toLowerCase().includes((0, _i18next.t)('please enable network'))) {
+    if (message.toLowerCase().includes((0, _i18next.t)('bg.TRANSACTION.core.validation.request.pleaseEnableNetwork'))) {
       const chainInfo = koni.chainService.getChainInfoByKey(networkKey);
       payload_.errorPosition = 'ui';
       payload_.confirmationType = 'bitcoinSendTransactionRequestAfterConfirmation';
-      const [message, name] = [(0, _i18next.t)('Enable {{chain}} network on the extension and try again', {
+      const [message, name] = [(0, _i18next.t)('bg.TRANSACTION.core.validation.request.enableChainOnExtension', {
         replace: {
           chain: chainInfo.name
         }
-      }), (0, _i18next.t)('Network not enabled')];
+      }), (0, _i18next.t)('bg.TRANSACTION.core.validation.request.networkNotEnabled')];
       const error = new _BitcoinProviderError.BitcoinProviderError(_KoniTypes.BitcoinProviderErrorType.INVALID_PARAMS, message, undefined, name);
       console.error(error);
       errors.push(error);
@@ -965,7 +965,7 @@ async function validationBitcoinSendTransactionMiddleware(koni, url, payload_) {
     };
   });
   if (new _bignumber.default(freeBalance.value).lte(totalValue)) {
-    handleError((0, _i18next.t)('insufficient balance'));
+    handleError((0, _i18next.t)('bg.TRANSACTION.core.validation.request.insufficientBalanceError'));
   }
   const sendTransactionRequest = {
     networkKey,
@@ -990,10 +990,10 @@ function convertErrorMessage(message_, name) {
 
   // Network error
   if (message.includes('connection error') || message.includes('connection not open') || message.includes('connection timeout') || message.includes('can not active chain') || message.includes('invalid json rpc') || message.includes('internet connection')) {
-    return [(0, _i18next.t)('Re-enable the network or change RPC on the extension and try again'), (0, _i18next.t)('Unstable network connection')];
+    return [(0, _i18next.t)('bg.TRANSACTION.core.validation.request.reEnableOrChangeRpc'), (0, _i18next.t)('bg.TRANSACTION.core.validation.request.unstableNetworkConnection')];
   }
   if (message.includes('network is currently not supported')) {
-    return [(0, _i18next.t)('This network is not yet supported on SubWallet. (Import the network)[https://docs.subwallet.app/main/extension-user-guide/customize-your-networks#import-networks] on SubWallet and try again'), (0, _i18next.t)('Network not supported')];
+    return [(0, _i18next.t)('bg.TRANSACTION.core.validation.request.networkNotSupportedImport'), (0, _i18next.t)('bg.TRANSACTION.core.validation.request.networkNotSupported')];
   }
 
   // Authentication
@@ -1007,48 +1007,48 @@ function convertErrorMessage(message_, name) {
   // Transaction
 
   if (message.includes('recipient address not found')) {
-    return [(0, _i18next.t)('Enter recipient address and try again'), (0, _i18next.t)('Recipient address not found')];
+    return [(0, _i18next.t)('bg.TRANSACTION.core.validation.request.enterRecipientAddress'), (0, _i18next.t)('bg.TRANSACTION.core.validation.request.recipientAddressNotFound')];
   }
   if (message.includes('is not a number') || message.includes('invalid number value') || message.includes('invalid bignumberish')) {
-    return [(0, _i18next.t)('Amount must be an integer. Enter an integer and try again'), (0, _i18next.t)('Invalid amount')];
+    return [(0, _i18next.t)('bg.TRANSACTION.core.validation.request.amountMustBeInteger'), (0, _i18next.t)('bg.TRANSACTION.core.validation.request.invalidAmount')];
   }
   if (message.includes('calculate estimate gas fee') || message.includes('invalidcode')) {
-    return [(0, _i18next.t)('Unable to calculate estimated gas for this transaction. Try again or contact support at agent@subwallet.app'), (0, _i18next.t)('Gas calculation error')];
+    return [(0, _i18next.t)('bg.TRANSACTION.core.validation.request.gasCalculationError'), (0, _i18next.t)('bg.TRANSACTION.core.validation.request.gasCalculationErrorTitle')];
   }
   if (message.includes('invalid recipient address')) {
-    return [(0, _i18next.t)('Make sure the recipient address is valid and in the same type as the sender address, then try again'), (0, _i18next.t)('Invalid recipient address')];
+    return [(0, _i18next.t)('bg.TRANSACTION.core.validation.request.recipientAddressTypeMismatch'), (0, _i18next.t)('bg.TRANSACTION.core.validation.request.invalidRecipientAddressError')];
   }
   if (message.includes('must be different from sending address')) {
-    return [(0, _i18next.t)('The recipient address must be different from the sender address'), (0, _i18next.t)('Invalid recipient address')];
+    return [(0, _i18next.t)('bg.TRANSACTION.core.validation.request.recipientMustBeDifferentFromSender'), (0, _i18next.t)('bg.TRANSACTION.core.validation.request.invalidRecipientAddressError')];
   }
   if (message.includes('the sender address must be the ethereum address type')) {
-    return [(0, _i18next.t)('The sender address must be the ethereum address type'), (0, _i18next.t)('Invalid address type')];
+    return [(0, _i18next.t)('bg.TRANSACTION.core.validation.request.senderMustBeEthereumAddress'), (0, _i18next.t)('bg.TRANSACTION.core.validation.request.invalidAddressType')];
   }
   if (message.includes('the sender address must be the ethereum address type')) {
-    return [(0, _i18next.t)('The sender address must be the bitcoin address type'), (0, _i18next.t)('Invalid address type')];
+    return [(0, _i18next.t)('bg.TRANSACTION.core.validation.request.senderMustBeBitcoinAddress'), (0, _i18next.t)('bg.TRANSACTION.core.validation.request.invalidAddressType')];
   }
   if (message.includes('account or the network is not matched')) {
-    return [(0, _i18next.t)('The account does not match the selected network'), (0, _i18next.t)('Invalid address type')];
+    return [(0, _i18next.t)('bg.TRANSACTION.core.validation.request.accountDoesNotMatchNetwork'), (0, _i18next.t)('bg.TRANSACTION.core.validation.request.invalidAddressType')];
   }
   if (message.includes('receiving address must be a single account')) {
-    return [(0, _i18next.t)('The receiving address must be a single account'), (0, _i18next.t)('Invalid recipient address')];
+    return [(0, _i18next.t)('bg.TRANSACTION.core.validation.request.receivingAddressMustBeSingle'), (0, _i18next.t)('bg.TRANSACTION.core.validation.request.invalidRecipientAddressError')];
   }
   if (message.includes('insufficient balance') || message.includes('insufficient funds')) {
-    return [(0, _i18next.t)('Insufficient balance on the sender address. Top up your balance and try again'), (0, _i18next.t)('Unable to sign transaction')];
+    return [(0, _i18next.t)('bg.TRANSACTION.core.validation.request.insufficientSenderBalance'), (0, _i18next.t)('bg.TRANSACTION.core.validation.request.unableToSignTransaction')];
   }
   if (message.includes('substrate') && message.includes('receive this token')) {
-    return [(0, _i18next.t)('The recipient account is a Ledger Polkadot (EVM) account, which is not supported for this transaction. Change recipient account and try again'), (0, _i18next.t)('Invalid account type')];
+    return [(0, _i18next.t)('bg.TRANSACTION.core.validation.request.recipientLedgerEvmNotSupported'), (0, _i18next.t)('bg.TRANSACTION.core.validation.request.invalidAccountType')];
   }
 
   // Sign Message
   if (message.includes('not found address or payload to sign')) {
-    return [(0, _i18next.t)('An error occurred when signing this request. Try again or contact support at agent@subwallet.app'), (0, _i18next.t)('Unable to sign')];
+    return [(0, _i18next.t)('bg.TRANSACTION.core.validation.request.errorSigningRequest'), (0, _i18next.t)('bg.TRANSACTION.core.validation.request.unableToSign')];
   }
   if (message.includes('unsupported method') || message.includes('unsupported action')) {
-    return [(0, _i18next.t)('This sign method is not supported by SubWallet. Try again or contact support at agent@subwallet.app'), (0, _i18next.t)('Method not supported')];
+    return [(0, _i18next.t)('bg.TRANSACTION.core.validation.request.signMethodNotSupported'), (0, _i18next.t)('bg.TRANSACTION.core.validation.request.methodNotSupported')];
   }
   if (message.includes('eip712 typed data') || message.includes('invalid message')) {
-    return [(0, _i18next.t)('An error occurred when attempting to sign this request. Contact support at email: agent@subwallet.app'), (0, _i18next.t)('Unable to sign')];
+    return [(0, _i18next.t)('bg.TRANSACTION.core.validation.request.errorAttemptingToSign'), (0, _i18next.t)('bg.TRANSACTION.core.validation.request.unableToSign')];
   }
   return [message, name || 'Error'];
 }

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

@@ -41,20 +41,20 @@ function validateTransferRequest(tokenInfo, from, to, value, transferAll) {
   const errors = [];
   if (!transferAll) {
     if (value === undefined) {
-      errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, (0, _i18next.t)('Transfer amount is required')));
+      errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, (0, _i18next.t)('bg.TRANSACTION.core.validation.transfer.transferAmountRequired')));
     }
   }
   if (!tokenInfo) {
-    errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, (0, _i18next.t)('Not found token from registry')));
+    errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, (0, _i18next.t)('bg.TRANSACTION.core.validation.transfer.tokenNotFoundInRegistry')));
   }
   if ((0, _utilCrypto.isEthereumAddress)(from) && (0, _utilCrypto.isEthereumAddress)(to) && (0, _utils3._isTokenEvmSmartContract)(tokenInfo) && (0, _utils3._getContractAddressOfToken)(tokenInfo).length === 0) {
-    errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, (0, _i18next.t)('Not found ERC20 address for this token')));
+    errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, (0, _i18next.t)('bg.TRANSACTION.core.validation.transfer.erc20AddressNotFound')));
   }
   if ((0, _keyring.isTonAddress)(from) && (0, _keyring.isTonAddress)(to) && (0, _utils3._isTokenTonSmartContract)(tokenInfo) && (0, _utils3._getContractAddressOfToken)(tokenInfo).length === 0) {
-    errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, (0, _i18next.t)('Not found TEP74 address for this token')));
+    errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, (0, _i18next.t)('bg.TRANSACTION.core.validation.transfer.tep74AddressNotFound')));
   }
   if ((0, _keyring.isCardanoAddress)(from) && (0, _keyring.isCardanoAddress)(to) && (0, _utils3._isCIP26Token)(tokenInfo) && (0, _utils.getCardanoAssetId)(tokenInfo).length === 0) {
-    errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, (0, _i18next.t)('Not found policy id of this token')));
+    errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, (0, _i18next.t)('bg.TRANSACTION.core.validation.transfer.policyIdNotFound')));
   }
   return errors;
 }
@@ -72,7 +72,7 @@ function additionalValidateTransferForRecipient(sendingTokenInfo, nativeTokenInf
     const minXCMStr = (0, _utils5.formatNumber)(sendingTokenMinAmountXCM.toString(), (0, _utils3._getAssetDecimals)(sendingTokenInfo), _utils5.balanceFormatter, {
       maxNumberFormat: (0, _utils3._getAssetDecimals)(sendingTokenInfo) || 6
     });
-    const error = new _TransactionError.TransactionError(_types.TransferTxErrorType.NOT_ENOUGH_VALUE, (0, _i18next.t)('You must transfer at least {{amount}} {{symbol}} to keep the recipient account alive. Increase amount and try again', {
+    const error = new _TransactionError.TransactionError(_types.TransferTxErrorType.NOT_ENOUGH_VALUE, (0, _i18next.t)('bg.TRANSACTION.core.validation.transfer.transferMinimumToKeepAccountAlive', {
       replace: {
         amount: minXCMStr,
         symbol: sendingTokenInfo.symbol
@@ -89,7 +89,7 @@ function additionalValidateTransferForRecipient(sendingTokenInfo, nativeTokenInf
       const balanceKeepAlive = (0, _utils5.formatNumber)(nativeTokenMinAmount, (0, _utils3._getAssetDecimals)(nativeTokenInfo), _utils5.balanceFormatter, {
         maxNumberFormat: (0, _utils3._getAssetDecimals)(nativeTokenInfo) || 6
       });
-      const error = new _TransactionError.TransactionError(_types.TransferTxErrorType.RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT, (0, _i18next.t)('The recipient account has less than {{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)('bg.TRANSACTION.core.validation.transfer.recipientBalanceTooLow', {
         replace: {
           amount: balanceKeepAlive,
           nativeSymbol: nativeTokenInfo.symbol,
@@ -103,7 +103,7 @@ function additionalValidateTransferForRecipient(sendingTokenInfo, nativeTokenInf
       const atLeastStr = (0, _utils5.formatNumber)(atLeast.toString(), (0, _utils3._getAssetDecimals)(sendingTokenInfo), _utils5.balanceFormatter, {
         maxNumberFormat: (0, _utils3._getAssetDecimals)(sendingTokenInfo) || 6
       });
-      const error = new _TransactionError.TransactionError(_types.TransferTxErrorType.RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT, (0, _i18next.t)('You must transfer at least {{amount}} {{symbol}} to avoid losing funds on the recipient account. Increase amount and try again', {
+      const error = new _TransactionError.TransactionError(_types.TransferTxErrorType.RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT, (0, _i18next.t)('bg.TRANSACTION.core.validation.transfer.transferMinimumToAvoidFundLoss', {
         replace: {
           amount: atLeastStr,
           symbol: sendingTokenInfo.symbol
@@ -117,7 +117,7 @@ function additionalValidateTransferForRecipient(sendingTokenInfo, nativeTokenInf
     const atLeastStr = (0, _utils5.formatNumber)(atLeast.toString(), (0, _utils3._getAssetDecimals)(sendingTokenInfo), _utils5.balanceFormatter, {
       maxNumberFormat: (0, _utils3._getAssetDecimals)(sendingTokenInfo) || 6
     });
-    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 recipient account alive. Increase amount and try again', {
+    const error = new _TransactionError.TransactionError(_types.TransferTxErrorType.RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT, (0, _i18next.t)('bg.TRANSACTION.core.validation.transfer.transferMinimumToKeepAccountAlive', {
       replace: {
         amount: atLeastStr,
         symbol: sendingTokenInfo.symbol
@@ -133,7 +133,7 @@ function validateXcmTransferRequest(destTokenInfo, sender, sendingValue) {
   const errors = [];
   const keypair = _uiKeyring.keyring.getPair(sender);
   if (!destTokenInfo) {
-    errors.push(new _TransactionError.TransactionError(_types.TransferTxErrorType.INVALID_TOKEN, (0, _i18next.t)('Not found token from registry')));
+    errors.push(new _TransactionError.TransactionError(_types.TransferTxErrorType.INVALID_TOKEN, (0, _i18next.t)('bg.TRANSACTION.core.validation.transfer.tokenNotFoundInRegistry')));
   }
   return [errors, keypair];
 }
@@ -142,7 +142,11 @@ function checkSupportForFeature(validationResponse, blockedFeaturesList, chainIn
   const chain = validationResponse.chain;
   const currentFeature = `${extrinsicType}___${chain}`;
   if (blockedFeaturesList.includes(currentFeature)) {
-    validationResponse.errors.push(new _TransactionError.TransactionError(_types.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)('bg.TRANSACTION.core.validation.transfer.featureUnderMaintenanceOnNetwork', {
+      replace: {
+        chainInfoName: chainInfo.name
+      }
+    })));
   }
 }
 function checkSupportForAction(validationResponse, blockedActionsMap) {
@@ -305,7 +309,7 @@ function checkSupportForAction(validationResponse, blockedActionsMap) {
   }
   const blockedActionsList = Object.values(blockedActionsMap).flat();
   if (blockedActionsList.includes(currentAction)) {
-    validationResponse.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED, (0, _i18next.t)('Feature under maintenance. Try again later')));
+    validationResponse.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED, (0, _i18next.t)('bg.TRANSACTION.core.validation.transfer.featureUnderMaintenance')));
   }
 }
 
@@ -316,7 +320,7 @@ function checkSupportForTransaction(validationResponse, transaction) {
   } = validationResponse;
   if (!transaction) {
     if (extrinsicType === _KoniTypes.ExtrinsicType.SEND_NFT) {
-      validationResponse.errors.push(new _TransactionError.TransactionError(_types.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)('bg.TRANSACTION.core.validation.transfer.featureNotAvailableForNft')));
     } else {
       validationResponse.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED));
     }
@@ -420,20 +424,20 @@ function checkSigningAccountForTransaction(validationResponse, chainInfoMap) {
   } = validationResponse;
   const pair = _uiKeyring.keyring.getPair(address);
   if (!pair) {
-    validationResponse.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR, (0, _i18next.t)('Unable to find account')));
+    validationResponse.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR, (0, _i18next.t)('bg.TRANSACTION.core.validation.transfer.unableToFindAccount')));
   } else {
     const accountJson = (0, _utils5.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')));
+      validationResponse.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, (0, _i18next.t)('bg.TRANSACTION.core.validation.transfer.featureNotAvailableForAccount')));
     } 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')));
+      validationResponse.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, (0, _i18next.t)('bg.TRANSACTION.core.validation.transfer.featureNotAvailableForAccount')));
     } 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')));
+        validationResponse.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, (0, _i18next.t)('bg.TRANSACTION.core.validation.transfer.featureNotAvailableForAccount')));
       }
     }
   }

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

@@ -87,7 +87,7 @@ const parseSubstrateTransaction = (data, apiPromise) => {
     } catch (e) {
       return {
         ...baseInfo,
-        message: (0, _i18next.t)('Unable to decode the information'),
+        message: (0, _i18next.t)('bg.DAPP.koni.api.dotsama.parseTransaction.unableToDecodeInformation'),
         method: _method
       };
     }

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

@@ -49,7 +49,7 @@ function validateRelayUnbondingCondition(amount, chainStakingMetadata, nominator
     errors.push(new _TransactionError.TransactionError(_types.StakingTxErrorType.INVALID_ACTIVE_STAKE));
   }
   if (nominatorMetadata.unstakings.length > chainStakingMetadata.maxWithdrawalRequestPerValidator) {
-    errors.push(new _TransactionError.TransactionError(_types.StakingTxErrorType.EXCEED_MAX_UNSTAKING, (0, _i18next.t)('You cannot unstake more than {{number}} times', {
+    errors.push(new _TransactionError.TransactionError(_types.StakingTxErrorType.EXCEED_MAX_UNSTAKING, (0, _i18next.t)('bg.EARNING.koni.api.staking.bonding.relayChain.maxUnstakeTimes', {
       replace: {
         number: chainStakingMetadata.maxWithdrawalRequestPerValidator
       }

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

@@ -497,7 +497,7 @@ async function getRelayMaxNominations(substrateApi) {
 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. You need to stake at least {{number}} {{tokenSymbol}} to earn rewards', {
+  return (0, _i18next.t)('bg.EARNING.koni.api.staking.bonding.utils.insufficientStakeToEarn', {
     replace: {
       tokenSymbol: tokenInfo.symbol,
       number
@@ -506,30 +506,30 @@ const getMinStakeErrorMessage = (chainInfo, bnMinStake) => {
 };
 exports.getMinStakeErrorMessage = getMinStakeErrorMessage;
 const getMaxValidatorErrorMessage = (chainInfo, max) => {
-  let message = (0, _utils2.detectTranslate)('You cannot select more than {{number}} validators for this network');
+  let message = (0, _utils2.detectTranslate)('bg.EARNING.koni.api.staking.bonding.utils.maxValidatorsSelection');
   const label = getValidatorLabel(chainInfo.slug);
   if (max > 1) {
     switch (label) {
       case 'dApp':
-        message = (0, _utils2.detectTranslate)('You cannot select more than {{number}} dApps for this network');
+        message = (0, _utils2.detectTranslate)('bg.EARNING.koni.api.staking.bonding.utils.maxDappsSelection');
         break;
       case 'Collator':
-        message = (0, _utils2.detectTranslate)('You cannot select more than {{number}} collators for this network');
+        message = (0, _utils2.detectTranslate)('bg.EARNING.koni.api.staking.bonding.utils.maxCollatorsSelection');
         break;
       case 'Validator':
-        message = (0, _utils2.detectTranslate)('You cannot select more than {{number}} validators for this network');
+        message = (0, _utils2.detectTranslate)('bg.EARNING.koni.api.staking.bonding.utils.maxValidatorsSelection');
         break;
     }
   } else {
     switch (label) {
       case 'dApp':
-        message = (0, _utils2.detectTranslate)('You cannot select more than {{number}} dApp for this network');
+        message = (0, _utils2.detectTranslate)('bg.EARNING.koni.api.staking.bonding.utils.maxOneDappSelection');
         break;
       case 'Collator':
-        message = (0, _utils2.detectTranslate)('You cannot select more than {{number}} collator for this network');
+        message = (0, _utils2.detectTranslate)('bg.EARNING.koni.api.staking.bonding.utils.maxOneCollatorSelection');
         break;
       case 'Validator':
-        message = (0, _utils2.detectTranslate)('You cannot select more than {{number}} validator for this network');
+        message = (0, _utils2.detectTranslate)('bg.EARNING.koni.api.staking.bonding.utils.maxOneValidatorSelection');
         break;
     }
   }
@@ -545,29 +545,29 @@ const getExistUnstakeErrorMessage = (chain, type, isStakeMore) => {
   if (!isStakeMore) {
     switch (label) {
       case 'dApp':
-        return (0, _i18next.t)('You can unstake from a dApp once');
+        return (0, _i18next.t)('bg.EARNING.koni.api.staking.bonding.utils.unstakeFromDappOnce');
       case 'Collator':
-        return (0, _i18next.t)('You can unstake from a collator once');
+        return (0, _i18next.t)('bg.EARNING.koni.api.staking.bonding.utils.unstakeFromCollatorOnce');
       case 'Validator':
         {
           if (type === _KoniTypes.StakingType.POOLED) {
-            return (0, _i18next.t)('You can unstake from a pool once');
+            return (0, _i18next.t)('bg.EARNING.koni.api.staking.bonding.utils.unstakeFromPoolOnce');
           }
-          return (0, _i18next.t)('You can unstake from a validator once');
+          return (0, _i18next.t)('bg.EARNING.koni.api.staking.bonding.utils.unstakeFromValidatorOnce');
         }
     }
   } else {
     switch (label) {
       case 'dApp':
-        return (0, _i18next.t)('You cannot stake more for a dApp you are unstaking from');
+        return (0, _i18next.t)('bg.EARNING.koni.api.staking.bonding.utils.cannotStakeMoreOnUnstakingDapp');
       case 'Collator':
-        return (0, _i18next.t)('You cannot stake more for a collator you are unstaking from');
+        return (0, _i18next.t)('bg.EARNING.koni.api.staking.bonding.utils.cannotStakeMoreOnUnstakingCollator');
       case 'Validator':
         {
           if (type === _KoniTypes.StakingType.POOLED) {
-            return (0, _i18next.t)('You cannot stake more for a pool you are unstaking from');
+            return (0, _i18next.t)('bg.EARNING.koni.api.staking.bonding.utils.cannotStakeMoreOnUnstakingPool');
           }
-          return (0, _i18next.t)('You cannot stake more for a validator you are unstaking from');
+          return (0, _i18next.t)('bg.EARNING.koni.api.staking.bonding.utils.cannotStakeMoreOnUnstakingValidator');
         }
     }
   }

package/cjs/koni/api/staking/paraChain.js

@@ -194,7 +194,7 @@ async function getAmplitudeUnclaimedStakingReward(substrateApiMap, addresses, ne
   });
   const unclaimedRewardList = [];
   await Promise.all(chains.map(async chain => {
-    if (_constants._STAKING_CHAIN_GROUP.amplitude.includes(chain) && !_constants._STAKING_CHAIN_GROUP.kilt.includes(chain) && !_constants._STAKING_CHAIN_GROUP.krest_network.includes(chain)) {
+    if (_constants._STAKING_CHAIN_GROUP.amplitude.includes(chain) && !_constants._STAKING_CHAIN_GROUP.krest_network.includes(chain)) {
       const networkInfo = networks[chain];
       const apiProps = await substrateApiMap[chain].isReady;
       await Promise.all(useAddresses.map(async address => {