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

package/services/chain-service/handler/types.js

@@ -11,4 +11,5 @@ export let _CHAIN_VALIDATION_ERROR;
   _CHAIN_VALIDATION_ERROR["NONE"] = "none";
   _CHAIN_VALIDATION_ERROR["CONNECTION_FAILURE"] = "connectionFailure";
   _CHAIN_VALIDATION_ERROR["PROVIDER_NOT_SAME_CHAIN"] = "providerNotSameChain";
+  _CHAIN_VALIDATION_ERROR["UNSUPPORTED_CHAIN_CANNOT_ADD"] = "unsupportedChainCannotAdd";
 })(_CHAIN_VALIDATION_ERROR || (_CHAIN_VALIDATION_ERROR = {}));

package/services/chain-service/utils/patch.d.ts

@@ -1,5 +1,5 @@
 import { _ChainAsset, _ChainInfo, _MultiChainAsset } from '@subwallet/chain-list/types';
-export declare const ChainListVersion = "0.2.112";
+export declare const ChainListVersion = "0.2.113";
 export interface PatchInfo {
     patchVersion: string;
     appliedVersion: string;

package/services/chain-service/utils/patch.js

@@ -5,7 +5,7 @@ const PRODUCTION_BRANCHES = ['master', 'webapp', 'webapp-dev'];
 const branchName = process.env.BRANCH_NAME || 'subwallet-dev';
 const fetchDomain = process.env.PATCH_CHAIN_LIST_URL || (PRODUCTION_BRANCHES.indexOf(branchName) > -1 ? 'https://chain-list-assets.subwallet.app' : 'https://dev.sw-chain-list-assets.pages.dev');
 const fetchFile = PRODUCTION_BRANCHES.indexOf(branchName) > -1 ? 'list.json' : 'preview.json';
-export const ChainListVersion = '0.2.112'; // update this when build chain-list
+export const ChainListVersion = '0.2.113'; // update this when build chain-list
 
 // todo: move this interface to chainlist
 

package/services/earning-service/constants/chains.d.ts

@@ -4,7 +4,6 @@ export declare const _STAKING_CHAIN_GROUP: {
     para: string[];
     astar: string[];
     amplitude: string[];
-    kilt: string[];
     nominationPool: string[];
     bifrost: string[];
     aleph: string[];

package/services/earning-service/constants/chains.js

@@ -6,9 +6,8 @@ export const _STAKING_CHAIN_GROUP = {
   assetHub: ['statemine', 'statemint', 'westend_assethub'],
   para: ['moonbeam', 'moonriver', 'moonbase', 'turing', 'turingStaging', 'bifrost', 'bifrost_testnet', 'calamari_test', 'calamari', 'manta_network', 'polimec'],
   astar: ['astar', 'shiden', 'shibuya'],
-  amplitude: ['amplitude', 'amplitude_test', 'kilt', 'kilt_peregrine', 'pendulum', 'krest_network'],
+  amplitude: ['amplitude', 'amplitude_test', 'pendulum', 'krest_network'],
   // amplitude and kilt only share some common logic
-  kilt: ['kilt', 'kilt_peregrine'],
   nominationPool: ['polkadot', 'kusama', 'westend', 'alephTest', 'aleph', 'kate', 'vara_network', 'goldberg_testnet', 'availTuringTest', 'avail_mainnet', 'vara_testnet', 'cere', 'analog_timechain'],
   bifrost: ['bifrost', 'bifrost_testnet'],
   aleph: ['aleph', 'alephTest'],

package/services/earning-service/handlers/base.js

@@ -1,7 +1,7 @@
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-import { ChainType } from '@subwallet/extension-base/background/KoniTypes';
+import { ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 import { ALL_ACCOUNT_KEY } from '@subwallet/extension-base/constants';
 import { DEFAULT_YIELD_FIRST_STEP, STAKING_IDENTITY_API_SLUG } from '@subwallet/extension-base/services/earning-service/constants';
 import { createClaimNotification, createWithdrawNotifications } from '@subwallet/extension-base/services/inapp-notification-service/utils';
@@ -153,7 +153,8 @@ export default class BasePoolHandler {
       };
     }
     const nativeTokenInfo = this.state.chainService.getNativeTokenInfo(this.chain);
-    const nativeTokenBalance = await this.state.balanceService.getTransferableBalance(request.address, this.chain);
+    // Use TRANSFER_BALANCE extrinsic in order to get transferable balanace without minus ED
+    const nativeTokenBalance = await this.state.balanceService.getTransferableBalance(request.address, this.chain, undefined, ExtrinsicType.TRANSFER_BALANCE);
     const bnNativeTokenBalance = new BN(nativeTokenBalance.value);
     const bnMinBalanceToJoin = new BN(((_poolInfo$statistic2 = poolInfo.statistic) === null || _poolInfo$statistic2 === void 0 ? void 0 : (_poolInfo$statistic2$ = _poolInfo$statistic2.earningThreshold) === null || _poolInfo$statistic2$ === void 0 ? void 0 : _poolInfo$statistic2$.join) || '0').add(new BN(poolInfo.metadata.maintainBalance));
     if (bnNativeTokenBalance.lte(bnMinBalanceToJoin)) {

package/services/earning-service/handlers/lending/base.js

@@ -37,11 +37,11 @@ export default class BaseLendingPoolHandler extends BaseSpecialStakingPoolHandle
     const maxUnstakeRequest = poolInfo.statistic.maxWithdrawalRequestPerFarmer;
     const derivativeTokenInfo = this.state.getAssetBySlug(this.derivativeAssets[0]);
     if (bnAmount.lte(BN_ZERO)) {
-      return [new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('Amount must be greater than 0'))];
+      return [new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('bg.EARNING.services.service.earning.lending.amountMustBeGreaterThanZero'))];
     }
     if (bnAmount.lt(minUnstake)) {
       const minUnstakeStr = formatNumber(minUnstake.toString(), derivativeTokenInfo.decimals || 0);
-      errors.push(new TransactionError(StakingTxErrorType.NOT_ENOUGH_MIN_UNSTAKE, t('You need to unstake at least {{amount}} {{token}}', {
+      errors.push(new TransactionError(StakingTxErrorType.NOT_ENOUGH_MIN_UNSTAKE, t('bg.EARNING.services.service.earning.lending.unstakeMinimumAmount', {
         replace: {
           amount: minUnstakeStr,
           token: derivativeTokenInfo.symbol
@@ -54,7 +54,7 @@ export default class BaseLendingPoolHandler extends BaseSpecialStakingPoolHandle
       }
 
       if (poolPosition.unstakings.length > maxUnstakeRequest) {
-        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.services.service.earning.lending.maxUnstakeTimes', {
           replace: {
             number: maxUnstakeRequest
           }

package/services/earning-service/handlers/liquid-staking/base.js

@@ -54,11 +54,11 @@ export default class BaseLiquidStakingPoolHandler extends BaseSpecialStakingPool
     const maxUnstakeRequest = poolInfo.statistic.maxWithdrawalRequestPerFarmer;
     const derivativeTokenInfo = this.state.getAssetBySlug(this.derivativeAssets[0]);
     if (bnAmount.lte(BN_ZERO)) {
-      return [new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('Amount must be greater than 0'))];
+      return [new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('bg.EARNING.services.service.earning.liquidStaking.amountMustBeGreaterThanZero'))];
     }
     if (bnAmount.lt(minUnstake)) {
       const minUnstakeStr = formatNumber(minUnstake.toString(), derivativeTokenInfo.decimals || 0);
-      errors.push(new TransactionError(StakingTxErrorType.NOT_ENOUGH_MIN_UNSTAKE, t('You need to unstake at least {{amount}} {{token}}', {
+      errors.push(new TransactionError(StakingTxErrorType.NOT_ENOUGH_MIN_UNSTAKE, t('bg.EARNING.services.service.earning.liquidStaking.unstakeMinimumAmount', {
         replace: {
           amount: minUnstakeStr,
           token: derivativeTokenInfo.symbol
@@ -71,7 +71,7 @@ export default class BaseLiquidStakingPoolHandler extends BaseSpecialStakingPool
       }
 
       if (poolPosition.unstakings.length > maxUnstakeRequest) {
-        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.services.service.earning.liquidStaking.maxUnstakeTimes', {
           replace: {
             number: maxUnstakeRequest
           }

package/services/earning-service/handlers/native-staking/amplitude.js

@@ -272,7 +272,7 @@ export default class AmplitudeNativeStakingPoolHandler extends BaseParaNativeSta
     let cancel = false;
     const substrateApi = this.substrateApi;
     await substrateApi.isReady;
-    if (!_STAKING_CHAIN_GROUP.kilt.includes(this.chain) && !_STAKING_CHAIN_GROUP.krest_network.includes(this.chain)) {
+    if (!_STAKING_CHAIN_GROUP.krest_network.includes(this.chain)) {
       await Promise.all(useAddresses.map(async address => {
         const _unclaimedReward = await substrateApi.api.query.parachainStaking.rewards(address);
         if (cancel) {

package/services/earning-service/handlers/native-staking/base-para.js

@@ -107,7 +107,7 @@ export default class BaseParaNativeStakingPoolHandler extends BaseNativeStakingP
     }
     const bnAmount = new BN(amount);
     if (bnAmount.lte(BN_ZERO)) {
-      errors.push(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('Amount must be greater than 0')));
+      errors.push(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('bg.EARNING.services.service.earning.nativeStakingPara.amountMustBeGreaterThanZero')));
     }
     let targetNomination;
     for (const nomination of poolPosition.nominations) {

package/services/earning-service/handlers/native-staking/relay-chain.js

@@ -627,7 +627,7 @@ export default class RelayNativeStakingPoolHandler extends BaseNativeStakingPool
     }
     const bnAmount = new BN(amount);
     if (bnAmount.lte(BN_ZERO)) {
-      errors.push(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('Amount must be greater than 0')));
+      errors.push(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('bg.EARNING.services.service.earning.nativeStakingRelay.amountMustBeGreaterThanZero')));
     }
     const bnActiveStake = new BN(poolPosition.activeStake);
     const bnRemainingStake = bnActiveStake.sub(new BN(amount));
@@ -637,7 +637,7 @@ export default class RelayNativeStakingPoolHandler extends BaseNativeStakingPool
       errors.push(new TransactionError(StakingTxErrorType.INVALID_ACTIVE_STAKE));
     }
     if (poolPosition.unstakings.length > maxUnstake) {
-      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.services.service.earning.nativeStakingRelay.maxUnstakeTimes', {
         replace: {
           number: maxUnstake
         }

package/services/earning-service/handlers/native-staking/tao.js

@@ -526,7 +526,12 @@ export default class TaoNativeStakingPoolHandler extends BaseParaStakingPoolHand
     } = data;
     const bnMinStake = await this.getMinBond(subnetData === null || subnetData === void 0 ? void 0 : subnetData.netuid);
     if (new BigN(amount).lt(bnMinStake)) {
-      return [new TransactionError(BasicTxErrorType.INVALID_PARAMS, t(`Insufficient stake. You need to stake at least ${formatNumber(bnMinStake, _getAssetDecimals(this.nativeToken))} ${_getAssetSymbol(this.nativeToken)} to earn rewards`))];
+      return [new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('bg.EARNING.services.service.earning.nativeStaking.tao.insufficientStakeToEarn', {
+        replace: {
+          bnMinStake: formatNumber(bnMinStake, _getAssetDecimals(this.nativeToken)),
+          symbol: _getAssetSymbol(this.nativeToken)
+        }
+      }))];
     }
     return baseErrors;
   }
@@ -562,7 +567,12 @@ export default class TaoNativeStakingPoolHandler extends BaseParaStakingPoolHand
     const minUnstake = minDelegatorStake.dividedBy(alphaToTaoPrice);
     if (new BigN(amount).lt(minUnstake)) {
       var _poolInfo$metadata$su2;
-      return [new TransactionError(BasicTxErrorType.INVALID_PARAMS, t(`Amount too low. You need to unstake at least ${formatNumber(minUnstake, _getAssetDecimals(this.nativeToken))} ${((_poolInfo$metadata$su2 = poolInfo.metadata.subnetData) === null || _poolInfo$metadata$su2 === void 0 ? void 0 : _poolInfo$metadata$su2.subnetSymbol) || _getAssetSymbol(this.nativeToken)}`))];
+      return [new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('bg.EARNING.services.service.earning.nativeStaking.tao.unstakeAmountTooLow', {
+        replace: {
+          bnMinUnstake: formatNumber(minUnstake, _getAssetDecimals(this.nativeToken)),
+          symbol: ((_poolInfo$metadata$su2 = poolInfo.metadata.subnetData) === null || _poolInfo$metadata$su2 === void 0 ? void 0 : _poolInfo$metadata$su2.subnetSymbol) || _getAssetSymbol(this.nativeToken)
+        }
+      }))];
     }
     return baseErrors;
   }
@@ -587,10 +597,10 @@ export default class TaoNativeStakingPoolHandler extends BaseParaStakingPoolHand
     const selectedValidatorInfo = targetValidators[0];
     const destValidator = selectedValidatorInfo.address;
     if (new BigN(amount).lte(0)) {
-      return Promise.reject(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('Amount must be greater than 0')));
+      return Promise.reject(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('bg.EARNING.services.service.earning.nativeStaking.tao.amountMustBeGreaterThanZero')));
     }
     if (originValidator === destValidator) {
-      return Promise.reject(new TransactionError(BasicTxErrorType.INVALID_PARAMS, 'From validator is the same with to validator'));
+      return Promise.reject(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('bg.EARNING.services.service.earning.nativeStaking.tao.fromValidatorSameAsTo')));
     }
     const alphaToTaoPrice = new BigN(await getAlphaToTaoRate(this.substrateApi, netuid));
     const bnMinStake = await this.getMinBond(netuid);
@@ -598,12 +608,22 @@ export default class TaoNativeStakingPoolHandler extends BaseParaStakingPoolHand
     const formattedMinUnstake = minUnstake.dividedBy(1000000).integerValue(BigN.ROUND_CEIL).dividedBy(1000);
     const bnMinMoveStake = formattedMinUnstake.multipliedBy(10 ** _getAssetDecimals(this.nativeToken));
     if (new BigN(amount).lt(bnMinMoveStake)) {
-      return Promise.reject(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t(`Amount too low. You need to move at least ${formattedMinUnstake.toString()} ${(metadata === null || metadata === void 0 ? void 0 : metadata.subnetSymbol) || ''}`)));
+      return Promise.reject(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('bg.EARNING.services.service.earning.nativeStaking.tao.moveStakeAmountTooLow', {
+        replace: {
+          bnMinMoveStake: formattedMinUnstake.toString(),
+          symbol: (metadata === null || metadata === void 0 ? void 0 : metadata.subnetSymbol) || ''
+        }
+      })));
     }
 
     // Avoid remaining amount too low -> can't do anything with that amount
     if (!(maxAmount === amount) && new BigN(maxAmount).minus(new BigN(amount)).lt(bnMinMoveStake)) {
-      return Promise.reject(new TransactionError(StakingTxErrorType.REMAINING_AMOUNT_TOO_LOW, t(`Your remaining stake on the initial validator will fall below minimum active stake and cannot be unstaked if you proceed with the chosen amount. Hit "Move all" to move all ${formatNumber(maxAmount, _getAssetDecimals(this.nativeToken))} ${(metadata === null || metadata === void 0 ? void 0 : metadata.subnetSymbol) || _getAssetSymbol(this.nativeToken)} to the new validator, or "Cancel" and lower the amount, then try again`)));
+      return Promise.reject(new TransactionError(StakingTxErrorType.REMAINING_AMOUNT_TOO_LOW, t('bg.EARNING.services.service.earning.nativeStaking.tao.remainingStakeBelowMinimumWarning', {
+        replace: {
+          maxAmount: formatNumber(maxAmount, _getAssetDecimals(this.nativeToken)),
+          subnetSymbol: (metadata === null || metadata === void 0 ? void 0 : metadata.subnetSymbol) || _getAssetSymbol(this.nativeToken)
+        }
+      })));
     }
     const extrinsic = chainApi.api.tx.subtensorModule.moveStake(originValidator, destValidator, netuid, netuid, amount);
     return extrinsic;

package/services/earning-service/handlers/nomination-pool/index.js

@@ -514,7 +514,7 @@ export default class NominationPoolHandler extends BasePoolHandler {
     }
     const bnAmount = new BN(amount);
     if (bnAmount.lte(BN_ZERO)) {
-      errors.push(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('Amount must be greater than 0')));
+      errors.push(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('bg.EARNING.services.service.earning.nominationPool.amountMustBeGreaterThanZero')));
     }
     const bnActiveStake = new BN(poolPosition.activeStake);
     const bnRemainingStake = bnActiveStake.sub(new BN(amount));
@@ -524,7 +524,7 @@ export default class NominationPoolHandler extends BasePoolHandler {
       errors.push(new TransactionError(StakingTxErrorType.INVALID_ACTIVE_STAKE));
     }
     if (poolPosition.unstakings.length > maxUnstake) {
-      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.services.service.earning.nominationPool.maxUnstakeTimes', {
         replace: {
           number: maxUnstake
         }

package/services/earning-service/handlers/special.js

@@ -92,7 +92,11 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
       const altName = altChain.name;
       const parsedMinJoinPool = formatNumber(missingAmount.toString(), inputAssetInfo.decimals || 0);
       const formatparsedMinJoinPool = isTheSame ? parsedMinJoinPool : Number(parsedMinJoinPool) + 0.01;
-      const parsedMinAltJoinPool = formatNumber(missingAmount.add(existentialDeposit).toString(), inputAssetInfo.decimals || 0);
+
+      // If balance can not cover ED, add ED to the missing amount
+      const needExtraED = bnInputAssetBalance.eq(BN_ZERO) && bnAltInputAssetBalance.eq(BN_ZERO);
+      const totalMissingAlt = needExtraED ? missingAmount.add(existentialDeposit) : missingAmount;
+      const parsedMinAltJoinPool = formatNumber(totalMissingAlt.toString(), inputAssetInfo.decimals || 0);
       const formatParsedMinAltJoinPool = isTheSame ? parsedMinAltJoinPool : Number(parsedMinAltJoinPool) + 0.01;
       return {
         passed: false,
@@ -293,23 +297,22 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
     const inputTokenInfo = this.state.getAssetBySlug(this.inputAsset);
     const altInputTokenBalance = await this.state.balanceService.getTransferableBalance(params.address, altInputTokenInfo.originChain, altInputTokenSlug);
     const missingAmount = bnAmount.sub(bnInputTokenBalance); // TODO: what if input token is not LOCAL ??
-    const xcmFee = new BN(path.totalFee[1].amount || '0');
-    const xcmAmount = missingAmount.add(xcmFee);
+    const xcmFeeValidate = new BN(path.totalFee[1].amount || '0').mul(new BN(XCM_FEE_RATIO));
     const bnAltInputTokenBalance = new BN(altInputTokenBalance.value || '0');
-    if (!bnAltInputTokenBalance.sub(xcmAmount).sub(xcmFee).gt(BN_ZERO)) {
+    if (!bnAltInputTokenBalance.sub(missingAmount).sub(xcmFeeValidate).gt(BN_ZERO)) {
       processValidation.failedStep = path.steps[1];
       processValidation.ok = false;
       processValidation.status = YieldValidationStatus.NOT_ENOUGH_BALANCE;
-      const bnMaxXCM = new BN(altInputTokenBalance.value).sub(xcmFee.mul(new BN(XCM_FEE_RATIO)));
+      const bnMaxXCM = new BN(altInputTokenBalance.value).sub(xcmFeeValidate);
       const inputTokenDecimal = _getAssetDecimals(inputTokenInfo);
-      const maxBn = bnInputTokenBalance.add(new BN(altInputTokenBalance.value)).sub(xcmFee).sub(xcmFee);
+      const maxBn = bnInputTokenBalance.add(bnAltInputTokenBalance.sub(xcmFeeValidate));
       const maxValue = formatNumber(maxBn.toString(), inputTokenInfo.decimals || 0);
       const maxXCMValue = formatNumber(bnMaxXCM.toString(), inputTokenDecimal);
       const symbol = _getAssetSymbol(altInputTokenInfo);
       const inputNetworkName = this.chainInfo.name;
       const altNetworkName = _getAssetName(altInputTokenInfo);
       const currentValue = formatNumber(bnInputTokenBalance.toString(), inputTokenDecimal);
-      processValidation.message = t('You can only enter a maximum of {{maxValue}} {{symbol}}, which is {{currentValue}} {{symbol}} ({{inputNetworkName}}) and {{maxXCMValue}} {{symbol}} ({{altNetworkName}}). Lower your amount and try again.', {
+      processValidation.message = t('bg.EARNING.services.service.earning.specialHandler.maximumInputExceeded', {
         replace: {
           symbol,
           maxValue,
@@ -366,13 +369,13 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
       processValidation.status = YieldValidationStatus.NOT_ENOUGH_BALANCE;
       const maxString = formatNumber(bnInputTokenBalance.toString(), inputTokenInfo.decimals || 0);
       if (maxString !== '0') {
-        processValidation.message = t('Amount must be equal or less than {{number}}', {
+        processValidation.message = t('bg.EARNING.services.service.earning.specialHandler.amountMaxError', {
           replace: {
             number: maxString
           }
         });
       } else {
-        processValidation.message = t('You need balance greater than 0 to continue');
+        processValidation.message = t('bg.EARNING.services.service.earning.specialHandler.balanceGreaterThanZeroRequired');
       }
       return [new TransactionError(YieldValidationStatus.NOT_ENOUGH_BALANCE, processValidation.message, processValidation)];
     }

package/services/keyring-service/context/handlers/Derive.js

@@ -344,7 +344,7 @@ export class AccountDeriveHandler extends AccountBaseHandler {
     const addresses = pairs.map(pair => pair.address);
     const exists = this.state.checkAddressExists(addresses);
     if (!isMigration) {
-      assert(!exists, t('Account already exists under the name "{{name}}"', {
+      assert(!exists, t('bg.ACCOUNT.services.keyring.handler.Derive.accountExistsWithName', {
         replace: {
           name: (exists === null || exists === void 0 ? void 0 : exists.name) || (exists === null || exists === void 0 ? void 0 : exists.address) || ''
         }

package/services/keyring-service/context/handlers/Json.js

@@ -85,7 +85,7 @@ export class AccountJsonHandler extends AccountBaseHandler {
         throw new Error(e.message);
       }
     } else {
-      throw new Error(t('Incorrect password'));
+      throw new Error(t('bg.ACCOUNT.services.keyring.handler.Json.incorrectPassword'));
     }
   }
   jsonRestoreV2({
@@ -105,7 +105,7 @@ export class AccountJsonHandler extends AccountBaseHandler {
       try {
         const _pair = keyring.createFromJson(file);
         const exists = this.state.checkAddressExists([_pair.address]);
-        assert(!exists, t('Account already exists under the name {{name}}', {
+        assert(!exists, t('bg.ACCOUNT.services.keyring.handler.Json.accountAlreadyExistsWithName', {
           replace: {
             name: (exists === null || exists === void 0 ? void 0 : exists.name) || (exists === null || exists === void 0 ? void 0 : exists.address) || _pair.address
           }
@@ -131,7 +131,7 @@ export class AccountJsonHandler extends AccountBaseHandler {
         reject(error);
       }
     } else {
-      reject(new Error(t('Incorrect password')));
+      reject(new Error(t('bg.ACCOUNT.services.keyring.handler.Json.incorrectPassword')));
     }
     return promise;
   }
@@ -163,7 +163,7 @@ export class AccountJsonHandler extends AccountBaseHandler {
           return rs;
         }, []);
         if (!(pairs !== null && pairs !== void 0 && pairs.length)) {
-          throw new Error(t('No valid accounts found to import'));
+          throw new Error(t('bg.ACCOUNT.services.keyring.handler.Json.noValidAccountsToImport'));
         }
         const accountProxyMap = combineAccountsWithKeyPair(pairs, modifyPairs, accountProxies);
         const result = Object.values(accountProxyMap).map(proxy => {
@@ -187,7 +187,7 @@ export class AccountJsonHandler extends AccountBaseHandler {
         throw new Error(e.message);
       }
     } else {
-      throw new Error(t('Incorrect password'));
+      throw new Error(t('bg.ACCOUNT.services.keyring.handler.Json.incorrectPassword'));
     }
   }
   batchRestoreV2({
@@ -222,7 +222,7 @@ export class AccountJsonHandler extends AccountBaseHandler {
           return rs;
         }, []);
         if (!(pairs !== null && pairs !== void 0 && pairs.length)) {
-          throw new Error(t('No valid accounts found to import'));
+          throw new Error(t('bg.ACCOUNT.services.keyring.handler.Json.noValidAccountsToImport'));
         }
         const accountProxyMap = combineAccountsWithKeyPair(pairs, modifyPairs, accountProxies);
         const rawProxyIds = _proxyIds && _proxyIds.length ? _proxyIds : Object.keys(accountProxyMap);
@@ -248,13 +248,13 @@ export class AccountJsonHandler extends AccountBaseHandler {
         const proxyIds = Object.values(filteredAccountProxies).flatMap(proxy => proxy.id);
         if (!addresses.length) {
           if (_exists) {
-            throw new Error(t('Account already exists under the name {{name}}', {
+            throw new Error(t('bg.ACCOUNT.services.keyring.handler.Json.accountAlreadyExistsWithName', {
               replace: {
                 name: _exists.name || _exists.address || ''
               }
             }));
           } else {
-            throw new Error(t('No accounts found to import'));
+            throw new Error(t('bg.ACCOUNT.services.keyring.handler.Json.noAccountsFoundToImport'));
           }
         }
         const _accountProxies = this.state.value.accountProxy;
@@ -314,7 +314,7 @@ export class AccountJsonHandler extends AccountBaseHandler {
         throw new Error(error.message);
       }
     } else {
-      reject(new Error(t('Incorrect password')));
+      reject(new Error(t('bg.ACCOUNT.services.keyring.handler.Json.incorrectPassword')));
     }
     return promise;
   }
@@ -325,7 +325,7 @@ export class AccountJsonHandler extends AccountBaseHandler {
     } = request;
     try {
       if (proxyIds && !proxyIds.length) {
-        throw new Error(t('No accounts found to export'));
+        throw new Error(t('bg.ACCOUNT.services.keyring.handler.Json.noAccountsFoundToExport'));
       }
       const _accountProxy = this.state.value.accountProxy;
       const _modifyPair = this.state.value.modifyPair;
@@ -345,7 +345,7 @@ export class AccountJsonHandler extends AccountBaseHandler {
     } catch (e) {
       const error = e;
       if (error.message === 'Invalid master password') {
-        throw new Error(t('Incorrect password'));
+        throw new Error(t('bg.ACCOUNT.services.keyring.handler.Json.incorrectPassword'));
       } else {
         throw error;
       }

package/services/keyring-service/context/handlers/Ledger.js

@@ -30,7 +30,7 @@ export class AccountLedgerHandler extends AccountBaseHandler {
       originGenesisHash
     } = request;
     const exists = this.state.checkAddressExists([address]);
-    assert(!exists, t('Account already exists under the name {{name}}', {
+    assert(!exists, t('bg.ACCOUNT.services.keyring.handler.Ledger.accountAlreadyExistsWithName', {
       replace: {
         name: (exists === null || exists === void 0 ? void 0 : exists.name) || (exists === null || exists === void 0 ? void 0 : exists.address) || address
       }
@@ -74,10 +74,10 @@ export class AccountLedgerHandler extends AccountBaseHandler {
   }) {
     const addresses = [];
     if (!accounts.length) {
-      throw new Error(t('Can\'t find an account. Please try again'));
+      throw new Error(t('bg.ACCOUNT.services.keyring.handler.Ledger.cantFindAccountTryAgain'));
     }
     const exists = this.state.checkAddressExists(accounts.map(account => account.address));
-    assert(!exists, t('Account already exists under the name {{name}}', {
+    assert(!exists, t('bg.ACCOUNT.services.keyring.handler.Ledger.accountAlreadyExistsWithName', {
       replace: {
         name: (exists === null || exists === void 0 ? void 0 : exists.name) || (exists === null || exists === void 0 ? void 0 : exists.address) || ''
       }

package/services/keyring-service/context/handlers/Mnemonic.js

@@ -50,20 +50,20 @@ export class AccountMnemonicHandler extends AccountBaseHandler {
     let mnemonicTypes = 'general';
     let pairTypes = [];
     if (isHex(phrase)) {
-      assert(isHex(phrase, 256), t('Invalid seed phrase. Please try again.'));
+      assert(isHex(phrase, 256), t('bg.ACCOUNT.services.keyring.handler.Mnemonic.invalidSeedPhraseTryAgain'));
     } else {
       // sadly isHex detects as string, so we need a cast here
-      assert(SEED_LENGTHS.includes(phrase.split(' ').length), t('Seed phrase needs to contain {{x}} words', {
+      assert(SEED_LENGTHS.includes(phrase.split(' ').length), t('bg.ACCOUNT.services.keyring.handler.Mnemonic.seedPhraseWordCount', {
         replace: {
           x: SEED_LENGTHS.join(', ')
         }
       }));
       try {
-        assert(mnemonicValidate(phrase), t('Invalid seed phrase. Please try again.'));
+        assert(mnemonicValidate(phrase), t('bg.ACCOUNT.services.keyring.handler.Mnemonic.invalidSeedPhraseTryAgain'));
         mnemonicTypes = 'general';
         pairTypes = ['sr25519', ...EthereumKeypairTypes, 'ton', ...CardanoKeypairTypes, ...BitcoinKeypairTypes];
       } catch (e) {
-        assert(tonMnemonicValidate(phrase), t('Invalid seed phrase. Please try again.'));
+        assert(tonMnemonicValidate(phrase), t('bg.ACCOUNT.services.keyring.handler.Mnemonic.invalidSeedPhraseTryAgain'));
         mnemonicTypes = 'ton';
         pairTypes = ['ton-native'];
       }
@@ -78,7 +78,7 @@ export class AccountMnemonicHandler extends AccountBaseHandler {
       rs.addressMap[type] = keyring.createFromUri(getSuri(mnemonic, type), {}, type).address;
     });
     const exists = this.state.checkAddressExists(Object.values(rs.addressMap));
-    assert(!exists, t('Account already exists under the name {{name}}', {
+    assert(!exists, t('bg.ACCOUNT.services.keyring.handler.Mnemonic.accountAlreadyExistsWithName', {
       replace: {
         name: (exists === null || exists === void 0 ? void 0 : exists.name) || (exists === null || exists === void 0 ? void 0 : exists.address) || ''
       }
@@ -101,14 +101,14 @@ export class AccountMnemonicHandler extends AccountBaseHandler {
     const types = type ? [type] : ['sr25519', ...EthereumKeypairTypes, 'ton', ...CardanoKeypairTypes, ...BitcoinKeypairTypes];
     if (!hasMasterPassword) {
       if (!password) {
-        throw Error(t('The password of each account is needed to set up master password'));
+        throw Error(t('bg.ACCOUNT.services.keyring.handler.Mnemonic.eachAccountPasswordNeeded'));
       } else {
         keyring.changeMasterPassword(password);
         this.parentService.updateKeyringState();
       }
     }
     if (!types || !types.length) {
-      throw Error(t('Please choose at least one account type'));
+      throw Error(t('bg.ACCOUNT.services.keyring.handler.Mnemonic.chooseAtLeastOneAccountType'));
     }
     const nameExists = this.state.checkNameExists(name);
     if (nameExists) {
@@ -129,7 +129,7 @@ export class AccountMnemonicHandler extends AccountBaseHandler {
       addressDict[type] = address;
     });
     const exists = this.state.checkAddressExists(Object.values(addressDict));
-    assert(!exists, t('Account already exists under the name {{name}}', {
+    assert(!exists, t('bg.ACCOUNT.services.keyring.handler.Mnemonic.accountAlreadyExistsWithName', {
       replace: {
         name: (exists === null || exists === void 0 ? void 0 : exists.name) || (exists === null || exists === void 0 ? void 0 : exists.address) || ''
       }
@@ -180,7 +180,7 @@ export class AccountMnemonicHandler extends AccountBaseHandler {
     const isUnified = this.state.isUnifiedAccount(proxyId);
     if (!isUnified) {
       const pair = keyring.getPair(proxyId);
-      assert(pair, t('Unable to find account'));
+      assert(pair, t('bg.ACCOUNT.services.keyring.handler.Mnemonic.unableToFindAccount'));
       const result = pair.exportMnemonic(password);
       return {
         result
@@ -195,7 +195,7 @@ export class AccountMnemonicHandler extends AccountBaseHandler {
           break;
         }
       }
-      assert(pair, t('Unable to find account'));
+      assert(pair, t('bg.ACCOUNT.services.keyring.handler.Mnemonic.unableToFindAccount'));
       const result = pair.exportMnemonic(password) || '';
       return {
         result

package/services/keyring-service/context/handlers/Modify.js

@@ -88,7 +88,7 @@ export class AccountModifyHandler extends AccountBaseHandler {
     }
     if (!accountProxies[proxyId]) {
       const pair = keyring.getPair(proxyId);
-      assert(pair, t('Unable to find account'));
+      assert(pair, t('bg.ACCOUNT.services.keyring.handler.Modify.unableToFindAccount'));
       keyring.saveAccountMeta(pair, {
         ...pair.meta,
         name
@@ -100,7 +100,7 @@ export class AccountModifyHandler extends AccountBaseHandler {
       this.state.upsertAccountProxyByKey(accountProxy);
       for (const address of addresses) {
         const pair = keyring.getPair(address);
-        assert(pair, t('Unable to find account'));
+        assert(pair, t('bg.ACCOUNT.services.keyring.handler.Modify.unableToFindAccount'));
         keyring.saveAccountMeta(pair, {
           ...pair.meta,
           name
@@ -238,7 +238,7 @@ export class AccountModifyHandler extends AccountBaseHandler {
     const pairs = keyring.getPairs();
     const childPairs = pairs.filter(pair => pair.meta.parentAddress === oldAddress);
     for (const childPair of childPairs) {
-      assert(pair, t('Unable to find account'));
+      assert(pair, t('bg.ACCOUNT.services.keyring.handler.Modify.unableToFindAccount'));
       keyring.saveAccountMeta(childPair, {
         ...childPair.meta,
         parentAddress: newAddress

package/services/keyring-service/context/handlers/Secret.js

@@ -34,14 +34,14 @@ export class AccountSecretHandler extends AccountBaseHandler {
           if (exists.type === type) {
             return [{
               code: AccountExternalErrorCode.INVALID_ADDRESS,
-              message: t('Account exists')
+              message: t('bg.ACCOUNT.services.keyring.handler.Secret.accountExists')
             }];
           }
         }
       } catch (e) {}
       const nameExists = this.state.checkNameExists(name);
       if (nameExists) {
-        throw Error(t('Account name already exists'));
+        throw Error(t('bg.ACCOUNT.services.keyring.handler.Secret.accountNameAlreadyExists'));
       }
       const meta = {
         name,
@@ -116,10 +116,10 @@ export class AccountSecretHandler extends AccountBaseHandler {
       rs.keyTypes = types;
     } else {
       rs.autoAddPrefix = false;
-      assert(false, t('Invalid private key'));
+      assert(false, t('bg.ACCOUNT.services.keyring.handler.Secret.invalidPrivateKey'));
     }
     const exists = this.state.checkAddressExists(Object.values(rs.addressMap));
-    assert(!exists, t('Account already exists under the name {{name}}', {
+    assert(!exists, t('bg.ACCOUNT.services.keyring.handler.Secret.accountAlreadyExistsWithName', {
       replace: {
         name: (exists === null || exists === void 0 ? void 0 : exists.name) || (exists === null || exists === void 0 ? void 0 : exists.address) || ''
       }
@@ -180,13 +180,13 @@ export class AccountSecretHandler extends AccountBaseHandler {
           success: false,
           errors: [{
             code: AccountExternalErrorCode.KEYRING_ERROR,
-            message: t('Cannot create account')
+            message: t('bg.ACCOUNT.services.keyring.handler.Secret.cannotCreateAccount')
           }]
         };
       }
       const _address = keyringPair.address;
       const exists = this.state.checkAddressExists([_address]);
-      assert(!exists, t('Account already exists under the name {{name}}', {
+      assert(!exists, t('bg.ACCOUNT.services.keyring.handler.Secret.accountAlreadyExistsWithName', {
         replace: {
           name: (exists === null || exists === void 0 ? void 0 : exists.name) || (exists === null || exists === void 0 ? void 0 : exists.address) || ''
         }
@@ -274,7 +274,7 @@ export class AccountSecretHandler extends AccountBaseHandler {
     if (response.isValid) {
       const exists = this.state.checkAddressExists([response.address]);
       if (exists) {
-        response.errorMessage = t('Account already exists under the name {{name}}', {
+        response.errorMessage = t('bg.ACCOUNT.services.keyring.handler.Secret.accountAlreadyExistsWithName', {
           replace: {
             name: (exists === null || exists === void 0 ? void 0 : exists.name) || (exists === null || exists === void 0 ? void 0 : exists.address) || ''
           }

package/services/migration-service/scripts/DeleteEarningData.js

@@ -5,7 +5,7 @@ import BaseMigrationJob from '@subwallet/extension-base/services/migration-servi
 export default class DeleteEarningData extends BaseMigrationJob {
   async run() {
     try {
-      await this.state.dbService.deleteYieldPoolInfo(['LcDOT___acala_euphrates_liquid_staking', 'xcDOT___moonwell_lending']);
+      await this.state.dbService.deleteYieldPoolInfo(['KILT___native_staking___kilt', 'PILT___native_staking___kilt_peregrine']);
     } catch (e) {
       console.error(e);
     }

package/services/migration-service/scripts/MigrateTransactionHistoryBySymbol.js

@@ -7,12 +7,7 @@ export default class MigrateTransactionHistoryBySymbol extends BaseMigrationJob
     const state = this.state;
     try {
       const changeSlugsMap = {
-        'bifrost_testnet-NATIVE-BNC': 'bifrost_testnet-NATIVE-BFC',
-        'energy_web_x_rococo-NATIVE-VT': 'energy_web_x_rococo-NATIVE-EWT',
-        'chainflip_dot-NATIVE-DOT': 'chainflip_dot-NATIVE-Unit',
-        'autonomys_taurus-NATIVE-AI3': 'autonomys_taurus-NATIVE-tAI3',
-        'fraxtal-NATIVE-frxETH': 'fraxtal-ERC20-frxETH-0xFC00000000000000000000000000000000000006',
-        'arbitrum_one-ERC20-USDT-0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9': 'arbitrum_one-ERC20-USD₮0-0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9'
+        'polygon-ERC20-USDT-0xc2132D05D31c914a87C6611C10748AEb04B58e8F': 'polygon-ERC20-USD₮0-0xc2132D05D31c914a87C6611C10748AEb04B58e8F'
       };
       const allTxs = [];
       await Promise.all(Object.entries(changeSlugsMap).map(async ([oldSlug, newSlug], i) => {

package/services/migration-service/scripts/databases/MigrateAssetSetting.js

@@ -6,12 +6,7 @@ export default class MigrateAssetSetting extends BaseMigrationJob {
   async run() {
     try {
       const changeSlugsMap = {
-        'bifrost_testnet-NATIVE-BNC': 'bifrost_testnet-NATIVE-BFC',
-        'energy_web_x_rococo-NATIVE-VT': 'energy_web_x_rococo-NATIVE-EWT',
-        'chainflip_dot-NATIVE-DOT': 'chainflip_dot-NATIVE-Unit',
-        'autonomys_taurus-NATIVE-AI3': 'autonomys_taurus-NATIVE-tAI3',
-        'fraxtal-NATIVE-frxETH': 'fraxtal-ERC20-frxETH-0xFC00000000000000000000000000000000000006',
-        'arbitrum_one-ERC20-USDT-0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9': 'arbitrum_one-ERC20-USD₮0-0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9'
+        'polygon-ERC20-USDT-0xc2132D05D31c914a87C6611C10748AEb04B58e8F': 'polygon-ERC20-USD₮0-0xc2132D05D31c914a87C6611C10748AEb04B58e8F'
       };
       const assetSetting = await this.state.chainService.getAssetSettings();
       const migratedAssetSetting = {};