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

package/core/logic-validation/request.js

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

package/core/logic-validation/transfer.js

@@ -25,20 +25,20 @@ export function validateTransferRequest(tokenInfo, from, to, value, transferAll)
   const errors = [];
   if (!transferAll) {
     if (value === undefined) {
-      errors.push(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('Transfer amount is required')));
+      errors.push(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('bg.TRANSACTION.core.validation.transfer.transferAmountRequired')));
     }
   }
   if (!tokenInfo) {
-    errors.push(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('Not found token from registry')));
+    errors.push(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('bg.TRANSACTION.core.validation.transfer.tokenNotFoundInRegistry')));
   }
   if (isEthereumAddress(from) && isEthereumAddress(to) && _isTokenEvmSmartContract(tokenInfo) && _getContractAddressOfToken(tokenInfo).length === 0) {
-    errors.push(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('Not found ERC20 address for this token')));
+    errors.push(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('bg.TRANSACTION.core.validation.transfer.erc20AddressNotFound')));
   }
   if (isTonAddress(from) && isTonAddress(to) && _isTokenTonSmartContract(tokenInfo) && _getContractAddressOfToken(tokenInfo).length === 0) {
-    errors.push(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('Not found TEP74 address for this token')));
+    errors.push(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('bg.TRANSACTION.core.validation.transfer.tep74AddressNotFound')));
   }
   if (isCardanoAddress(from) && isCardanoAddress(to) && _isCIP26Token(tokenInfo) && getCardanoAssetId(tokenInfo).length === 0) {
-    errors.push(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('Not found policy id of this token')));
+    errors.push(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('bg.TRANSACTION.core.validation.transfer.policyIdNotFound')));
   }
   return errors;
 }
@@ -56,7 +56,7 @@ export function additionalValidateTransferForRecipient(sendingTokenInfo, nativeT
     const minXCMStr = formatNumber(sendingTokenMinAmountXCM.toString(), _getAssetDecimals(sendingTokenInfo), balanceFormatter, {
       maxNumberFormat: _getAssetDecimals(sendingTokenInfo) || 6
     });
-    const error = new TransactionError(TransferTxErrorType.NOT_ENOUGH_VALUE, t('You must transfer at least {{amount}} {{symbol}} to keep the recipient account alive. Increase amount and try again', {
+    const error = new TransactionError(TransferTxErrorType.NOT_ENOUGH_VALUE, t('bg.TRANSACTION.core.validation.transfer.transferMinimumToKeepAccountAlive', {
       replace: {
         amount: minXCMStr,
         symbol: sendingTokenInfo.symbol
@@ -73,7 +73,7 @@ export function additionalValidateTransferForRecipient(sendingTokenInfo, nativeT
       const balanceKeepAlive = formatNumber(nativeTokenMinAmount, _getAssetDecimals(nativeTokenInfo), balanceFormatter, {
         maxNumberFormat: _getAssetDecimals(nativeTokenInfo) || 6
       });
-      const error = new TransactionError(TransferTxErrorType.RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT, 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(TransferTxErrorType.RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT, t('bg.TRANSACTION.core.validation.transfer.recipientBalanceTooLow', {
         replace: {
           amount: balanceKeepAlive,
           nativeSymbol: nativeTokenInfo.symbol,
@@ -87,7 +87,7 @@ export function additionalValidateTransferForRecipient(sendingTokenInfo, nativeT
       const atLeastStr = formatNumber(atLeast.toString(), _getAssetDecimals(sendingTokenInfo), balanceFormatter, {
         maxNumberFormat: _getAssetDecimals(sendingTokenInfo) || 6
       });
-      const error = new TransactionError(TransferTxErrorType.RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT, 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(TransferTxErrorType.RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT, t('bg.TRANSACTION.core.validation.transfer.transferMinimumToAvoidFundLoss', {
         replace: {
           amount: atLeastStr,
           symbol: sendingTokenInfo.symbol
@@ -101,7 +101,7 @@ export function additionalValidateTransferForRecipient(sendingTokenInfo, nativeT
     const atLeastStr = formatNumber(atLeast.toString(), _getAssetDecimals(sendingTokenInfo), balanceFormatter, {
       maxNumberFormat: _getAssetDecimals(sendingTokenInfo) || 6
     });
-    const error = new TransactionError(TransferTxErrorType.RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT, t('You must transfer at least {{amount}} {{symbol}} to keep the recipient account alive. Increase amount and try again', {
+    const error = new TransactionError(TransferTxErrorType.RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT, t('bg.TRANSACTION.core.validation.transfer.transferMinimumToKeepAccountAlive', {
       replace: {
         amount: atLeastStr,
         symbol: sendingTokenInfo.symbol
@@ -117,7 +117,7 @@ export function validateXcmTransferRequest(destTokenInfo, sender, sendingValue)
   const errors = [];
   const keypair = keyring.getPair(sender);
   if (!destTokenInfo) {
-    errors.push(new TransactionError(TransferTxErrorType.INVALID_TOKEN, t('Not found token from registry')));
+    errors.push(new TransactionError(TransferTxErrorType.INVALID_TOKEN, t('bg.TRANSACTION.core.validation.transfer.tokenNotFoundInRegistry')));
   }
   return [errors, keypair];
 }
@@ -126,7 +126,11 @@ export function checkSupportForFeature(validationResponse, blockedFeaturesList,
   const chain = validationResponse.chain;
   const currentFeature = `${extrinsicType}___${chain}`;
   if (blockedFeaturesList.includes(currentFeature)) {
-    validationResponse.errors.push(new TransactionError(BasicTxErrorType.UNSUPPORTED, t(`Feature under maintenance on ${chainInfo.name} network. Try again later`)));
+    validationResponse.errors.push(new TransactionError(BasicTxErrorType.UNSUPPORTED, t('bg.TRANSACTION.core.validation.transfer.featureUnderMaintenanceOnNetwork', {
+      replace: {
+        chainInfoName: chainInfo.name
+      }
+    })));
   }
 }
 export function checkSupportForAction(validationResponse, blockedActionsMap) {
@@ -289,7 +293,7 @@ export function checkSupportForAction(validationResponse, blockedActionsMap) {
   }
   const blockedActionsList = Object.values(blockedActionsMap).flat();
   if (blockedActionsList.includes(currentAction)) {
-    validationResponse.errors.push(new TransactionError(BasicTxErrorType.UNSUPPORTED, t('Feature under maintenance. Try again later')));
+    validationResponse.errors.push(new TransactionError(BasicTxErrorType.UNSUPPORTED, t('bg.TRANSACTION.core.validation.transfer.featureUnderMaintenance')));
   }
 }
 
@@ -300,7 +304,7 @@ export function checkSupportForTransaction(validationResponse, transaction) {
   } = validationResponse;
   if (!transaction) {
     if (extrinsicType === ExtrinsicType.SEND_NFT) {
-      validationResponse.errors.push(new TransactionError(BasicTxErrorType.UNSUPPORTED, t('This feature is not yet available for this NFT')));
+      validationResponse.errors.push(new TransactionError(BasicTxErrorType.UNSUPPORTED, t('bg.TRANSACTION.core.validation.transfer.featureNotAvailableForNft')));
     } else {
       validationResponse.errors.push(new TransactionError(BasicTxErrorType.UNSUPPORTED));
     }
@@ -404,20 +408,20 @@ export function checkSigningAccountForTransaction(validationResponse, chainInfoM
   } = validationResponse;
   const pair = keyring.getPair(address);
   if (!pair) {
-    validationResponse.errors.push(new TransactionError(BasicTxErrorType.INTERNAL_ERROR, t('Unable to find account')));
+    validationResponse.errors.push(new TransactionError(BasicTxErrorType.INTERNAL_ERROR, t('bg.TRANSACTION.core.validation.transfer.unableToFindAccount')));
   } else {
     const accountJson = pairToAccount(pair, chainInfoMap);
     if (!accountJson.transactionActions.includes(extrinsicType)) {
       // check if the account can sign the transaction type
-      validationResponse.errors.push(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('This feature is not available with this account')));
+      validationResponse.errors.push(new TransactionError(BasicTxErrorType.INVALID_PARAMS, 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(BasicTxErrorType.INVALID_PARAMS, t('This feature is not available with this account')));
+      validationResponse.errors.push(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('bg.TRANSACTION.core.validation.transfer.featureNotAvailableForAccount')));
     } else {
       const compatibleMap = [AccountSignMode.LEGACY_LEDGER, AccountSignMode.GENERIC_LEDGER].includes(accountJson.signMode) ? LEDGER_SIGNING_COMPATIBLE_MAP : 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(BasicTxErrorType.INVALID_PARAMS, t('This feature is not available with this account')));
+        validationResponse.errors.push(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('bg.TRANSACTION.core.validation.transfer.featureNotAvailableForAccount')));
       }
     }
   }

package/koni/api/dotsama/parseTransaction.js

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

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

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

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

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

package/koni/api/staking/paraChain.js

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