@subwallet/extension-base 1.1.9-0 → 1.1.11-0

package/koni/background/handlers/State.js

@@ -32,6 +32,7 @@ import { createPromiseHandler } from '@subwallet/extension-base/utils/promise';
 import { decodePair } from '@subwallet/keyring/pair/decode';
 import { keyring } from '@subwallet/ui-keyring';
 import SimpleKeyring from 'eth-simple-keyring';
+import { t } from 'i18next';
 import { Subject } from 'rxjs';
 import { assert, BN, hexStripPrefix, hexToU8a, isHex, logger as createLogger, u8aToHex } from '@polkadot/util';
 import { base64Decode, isEthereumAddress, keyExtractSuri } from '@polkadot/util-crypto';
@@ -138,7 +139,7 @@ export default class KoniState {
 
   // Start a provider, return its meta
   rpcStartProvider(key, port) {
-    assert(Object.keys(this.providers).includes(key), `Provider ${key} is not exposed by extension`);
+    assert(Object.keys(this.providers).includes(key), 'Provider cannot be found.');
     if (this.injectedProviders.get(port)) {
       return Promise.resolve(this.providers[key].meta);
     }
@@ -488,7 +489,7 @@ export default class KoniState {
   setAccountTie(address, genesisHash) {
     if (address !== ALL_ACCOUNT_KEY) {
       const pair = keyring.getPair(address);
-      assert(pair, 'Unable to find pair');
+      assert(pair, t('Unable to find account'));
       keyring.saveAccountMeta(pair, {
         ...pair.meta,
         genesisHash
@@ -512,7 +513,11 @@ export default class KoniState {
       authUrls[shortenUrl].currentEvmNetworkKey = networkKey;
       this.setAuthorize(authUrls);
     } else {
-      throw new EvmProviderError(EvmProviderErrorType.INTERNAL_ERROR, `Not found ${shortenUrl} in auth list`);
+      throw new EvmProviderError(EvmProviderErrorType.INTERNAL_ERROR, t('Not found {{shortenUrl}} in auth list', {
+        replace: {
+          shortenUrl
+        }
+      }));
     }
   }
   async switchNetworkAccount(id, url, networkKey, changeAddress) {
@@ -537,7 +542,7 @@ export default class KoniState {
         }
         if (useAddress !== ALL_ACCOUNT_KEY) {
           const pair = keyring.getPair(useAddress);
-          assert(pair, 'Unable to find pair');
+          assert(pair, t('Unable to find account'));
           keyring.saveAccountMeta(pair, {
             ...pair.meta,
             genesisHash: _getSubstrateGenesisHash(chainInfo)
@@ -1114,10 +1119,10 @@ export default class KoniState {
       payload = p1;
     }
     if (address === '' || !payload) {
-      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'Not found address or payload to sign');
+      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, t('Not found address or payload to sign'));
     }
     if (['eth_sign', 'personal_sign', 'eth_signTypedData', 'eth_signTypedData_v1', 'eth_signTypedData_v3', 'eth_signTypedData_v4'].indexOf(method) < 0) {
-      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'Not found sign method');
+      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, t('Unsupported action'));
     }
     if (['eth_signTypedData_v3', 'eth_signTypedData_v4'].indexOf(method) > -1) {
       // eslint-disable-next-line @typescript-eslint/no-unsafe-argument,@typescript-eslint/no-unsafe-assignment
@@ -1126,11 +1131,11 @@ export default class KoniState {
 
     // Check sign abiblity
     if (!allowedAccounts.find(acc => acc.toLowerCase() === address.toLowerCase())) {
-      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'Account ' + address + ' not in allowed list');
+      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, t('You have rescinded allowance for this account in wallet'));
     }
     const pair = keyring.getPair(address);
     if (!pair) {
-      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'Cannot find pair with address: ' + address);
+      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, t('Unable to find account'));
     }
     const account = {
       address: pair.address,
@@ -1153,7 +1158,7 @@ export default class KoniState {
         }
         break;
       default:
-        throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'Not found sign method');
+        throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, t('Unsupported action'));
     }
     const signPayload = {
       account: account,
@@ -1174,7 +1179,7 @@ export default class KoniState {
         if (payload) {
           return payload;
         } else {
-          throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'Not found signature');
+          throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, t('Not found signature'));
         }
       } else {
         throw new EvmProviderError(EvmProviderErrorType.USER_REJECTED_REQUEST);
@@ -1194,7 +1199,7 @@ export default class KoniState {
       return val;
     };
     if (transactionParams.from === transactionParams.to) {
-      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'From address and to address must not be the same');
+      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, t('Receiving address must be different from sending address'));
     }
     const transaction = {
       from: transactionParams.from,
@@ -1223,11 +1228,11 @@ export default class KoniState {
     // Address is validated in before step
     const fromAddress = allowedAccounts.find(account => account.toLowerCase() === transaction.from.toLowerCase());
     if (!fromAddress) {
-      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'From address is not in available for ' + url);
+      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, t('You have rescinded allowance for this account in wallet'));
     }
     const pair = keyring.getPair(fromAddress);
     if (!pair) {
-      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'Cannot find pair with address: ' + fromAddress);
+      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, t('Unable to find account'));
     }
     const account = {
       address: pair.address,
@@ -1237,7 +1242,7 @@ export default class KoniState {
     // Validate balance
     const balance = new BN((await web3.eth.getBalance(fromAddress)) || 0);
     if (balance.lt(new BN(gasPrice.toString()).mul(new BN(transaction.gas)).add(new BN(autoFormatNumber(transactionParams.value) || '0')))) {
-      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'Balance can be not enough to send transaction');
+      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, t('Insufficient balance'));
     }
     transaction.nonce = await web3.eth.getTransactionCount(fromAddress);
     const hashPayload = this.transactionService.generateHashPayload(networkKey, transaction);

package/koni/background/handlers/Tabs.js

@@ -15,6 +15,7 @@ import { _generateCustomProviderKey } from '@subwallet/extension-base/services/c
 import { DEFAULT_CHAIN_PATROL_ENABLE } from '@subwallet/extension-base/services/setting-service/constants';
 import { canDerive, stripUrl } from '@subwallet/extension-base/utils';
 import keyring from '@subwallet/ui-keyring';
+import { t } from 'i18next';
 import Web3 from 'web3';
 import { checkIfDenied } from '@polkadot/phishing';
 import { assert, isNumber } from '@polkadot/util';
@@ -103,7 +104,7 @@ export default class KoniTabs {
   /// Clone from Polkadot.js
   getSigningPair(address) {
     const pair = keyring.getPair(address);
-    assert(pair, 'Unable to find keypair');
+    assert(pair, t('Unable to find account'));
     return pair;
   }
   async bytesSign(url, request) {
@@ -327,13 +328,13 @@ export default class KoniTabs {
       const web3 = evmApi === null || evmApi === void 0 ? void 0 : evmApi.api;
       if ((web3 === null || web3 === void 0 ? void 0 : web3.currentProvider) instanceof Web3.providers.WebsocketProvider) {
         if (!web3.currentProvider.connected) {
-          console.log(`[Web3] ${slug} is disconnected, trying to connect...`);
+          console.log(`${slug} is disconnected, trying to connect...`);
           this.#koniState.refreshWeb3Api(slug);
           let checkingNum = 0;
           const poll = resolve => {
             checkingNum += 1;
             if (web3.currentProvider.connected) {
-              console.log(`Network [${slug}] is connected.`);
+              console.log(`${slug} is connected.`);
               resolve(true);
             } else {
               console.log(`Connecting to network [${slug}]`);
@@ -383,7 +384,7 @@ export default class KoniTabs {
     if (networkKey) {
       await this.#koniState.switchEvmNetworkByUrl(stripUrl(url), networkKey);
     } else {
-      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, `Not found chainId ${chainId} in wallet`);
+      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'This network is currently not supported');
     }
     return null;
   }
@@ -394,15 +395,15 @@ export default class KoniTabs {
     const input = params;
     const _tokenType = (input === null || input === void 0 ? void 0 : (_input$type = input.type) === null || _input$type === void 0 ? void 0 : _input$type.toLowerCase()) || '';
     if (_tokenType !== 'erc20' && _tokenType !== 'erc721') {
-      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, `Assets type ${_tokenType} is not supported`);
+      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'Assets type {{tokenType}} is not supported'.replace('{{tokenType}}', _tokenType));
     }
     if (!(input !== null && input !== void 0 && (_input$options = input.options) !== null && _input$options !== void 0 && _input$options.address) || !(input !== null && input !== void 0 && (_input$options2 = input.options) !== null && _input$options2 !== void 0 && _input$options2.symbol)) {
-      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'Assets params require address and symbol');
+      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'Unable to get contract address and token symbol');
     }
     const evmState = await this.getEvmState(url);
     const chain = evmState.networkKey;
     if (!chain) {
-      throw new EvmProviderError(EvmProviderErrorType.INTERNAL_ERROR, 'Current chain is not available');
+      throw new EvmProviderError(EvmProviderErrorType.INTERNAL_ERROR, 'The network on dApp is not supported in wallet. Please manually add the network to wallet');
     }
     const tokenType = _tokenType === 'erc20' ? _AssetType.ERC20 : _AssetType.ERC721;
     const tokenInfo = {
@@ -503,7 +504,7 @@ export default class KoniTabs {
             return url.protocol === 'http:' || url.protocol === 'https:';
           });
           if (!filteredUrls.length) {
-            throw new EvmProviderError(EvmProviderErrorType.INTERNAL_ERROR, 'Currently HTTP provider for EVM network');
+            throw new EvmProviderError(EvmProviderErrorType.INTERNAL_ERROR, 'Currently support WSS provider for Substrate networks and HTTP provider for EVM network');
           }
           const provider = filteredUrls[0];
           const chainInfo = {
@@ -746,7 +747,7 @@ export default class KoniTabs {
     if (signResult) {
       return signResult;
     } else {
-      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'Have something wrong to sign message');
+      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'Failed to sign message');
     }
   }
   async evmSendTransaction(id, url, {
@@ -757,10 +758,10 @@ export default class KoniTabs {
     const evmState = await this.getEvmState(url);
     const networkKey = evmState.networkKey;
     if (!canUseAccount) {
-      throw new Error('Account ' + transactionParams.from + ' not in allowed list');
+      throw new Error(t('You have rescinded allowance for this account in wallet'));
     }
     if (!networkKey) {
-      throw new Error('Empty current network key');
+      throw new Error('Network unavailable. Please switch network or manually add network to wallet');
     }
     const allowedAccounts = await this.getEvmCurrentAccount(url, true);
     const transactionHash = await this.#koniState.evmSendTransaction(id, url, networkKey, allowedAccounts, transactionParams);
@@ -851,14 +852,14 @@ export default class KoniTabs {
   }) {
     const _tokenType = input.type;
     if (_tokenType !== 'psp22' && _tokenType !== 'psp34') {
-      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, `Assets type ${_tokenType} is not supported`);
+      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'Assets type {{tokenType}} is not supported'.replace('{{tokenType}}', _tokenType));
     }
     if (!input.address || !input.symbol) {
-      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'Assets params require address and symbol');
+      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'Unable to get contract address and token symbol');
     }
     const [chain] = this.#koniState.findNetworkKeyByGenesisHash(genesisHash);
     if (!chain) {
-      throw new EvmProviderError(EvmProviderErrorType.INTERNAL_ERROR, 'Current chain is not available');
+      throw new EvmProviderError(EvmProviderErrorType.INTERNAL_ERROR, 'The network on dApp is not supported in wallet. Please manually add the network to wallet');
     }
     const state = this.#koniState.getChainStateByKey(chain);
     if (!state.active) {

package/package.json

@@ -17,7 +17,7 @@
     "./cjs/detectPackage.js"
   ],
   "type": "module",
-  "version": "1.1.9-0",
+  "version": "1.1.11-0",
   "main": "./cjs/index.js",
   "module": "./index.js",
   "types": "./index.d.ts",
@@ -134,6 +134,11 @@
       "require": "./cjs/constants/staking.js",
       "default": "./constants/staking.js"
     },
+    "./constants/storage": {
+      "types": "./constants/storage.d.ts",
+      "require": "./cjs/constants/storage.js",
+      "default": "./constants/storage.js"
+    },
     "./defaults": {
       "types": "./defaults.d.ts",
       "require": "./cjs/defaults.js",
@@ -792,6 +797,26 @@
       "require": "./cjs/services/setting-service/constants.js",
       "default": "./services/setting-service/constants.js"
     },
+    "./services/setting-service/i18n/Backend": {
+      "types": "./services/setting-service/i18n/Backend.d.ts",
+      "require": "./cjs/services/setting-service/i18n/Backend.js",
+      "default": "./services/setting-service/i18n/Backend.js"
+    },
+    "./services/setting-service/i18n/cache": {
+      "types": "./services/setting-service/i18n/cache.d.ts",
+      "require": "./cjs/services/setting-service/i18n/cache.js",
+      "default": "./services/setting-service/i18n/cache.js"
+    },
+    "./services/setting-service/i18n/extend": {
+      "types": "./services/setting-service/i18n/extend.d.ts",
+      "require": "./cjs/services/setting-service/i18n/extend.js",
+      "default": "./services/setting-service/i18n/extend.js"
+    },
+    "./services/setting-service/i18n/i18n": {
+      "types": "./services/setting-service/i18n/i18n.d.ts",
+      "require": "./cjs/services/setting-service/i18n/i18n.js",
+      "default": "./services/setting-service/i18n/i18n.js"
+    },
     "./services/setting-service/SettingService": {
       "types": "./services/setting-service/SettingService.d.ts",
       "require": "./cjs/services/setting-service/SettingService.js",
@@ -1137,11 +1162,6 @@
       "require": "./cjs/utils/getId.js",
       "default": "./utils/getId.js"
     },
-    "./utils/keyring": {
-      "types": "./utils/keyring.d.ts",
-      "require": "./cjs/utils/keyring.js",
-      "default": "./utils/keyring.js"
-    },
     "./utils/lazy": {
       "types": "./utils/lazy.d.ts",
       "require": "./cjs/utils/lazy.js",
@@ -1201,11 +1221,11 @@
     "@reduxjs/toolkit": "^1.9.1",
     "@sora-substrate/type-definitions": "^1.17.7",
     "@substrate/connect": "^0.7.26",
-    "@subwallet/chain-list": "0.2.11-beta.0",
-    "@subwallet/extension-base": "^1.1.9-0",
-    "@subwallet/extension-chains": "^1.1.9-0",
-    "@subwallet/extension-dapp": "^1.1.9-0",
-    "@subwallet/extension-inject": "^1.1.9-0",
+    "@subwallet/chain-list": "0.2.13",
+    "@subwallet/extension-base": "^1.1.11-0",
+    "@subwallet/extension-chains": "^1.1.11-0",
+    "@subwallet/extension-dapp": "^1.1.11-0",
+    "@subwallet/extension-inject": "^1.1.11-0",
     "@subwallet/keyring": "^0.0.10",
     "@subwallet/ui-keyring": "^0.0.10",
     "@walletconnect/sign-client": "^2.8.4",

package/packageInfo.js

@@ -7,5 +7,5 @@ export const packageInfo = {
   name: '@subwallet/extension-base',
   path: (import.meta && import.meta.url) ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf('/') + 1) : 'auto',
   type: 'esm',
-  version: '1.1.9-0'
+  version: '1.1.11-0'
 };

package/services/balance-service/index.js

@@ -8,6 +8,7 @@ import { state } from '@subwallet/extension-base/koni/background/handlers';
 import { _PURE_EVM_CHAINS } from '@subwallet/extension-base/services/chain-service/constants';
 import { _getChainNativeTokenSlug, _isChainEvmCompatible, _isPureEvmChain } from '@subwallet/extension-base/services/chain-service/utils';
 import { categoryAddresses } from '@subwallet/extension-base/utils';
+import { t } from 'i18next';
 export class BalanceService {
   constructor(chainService) {
     this.chainService = chainService;
@@ -26,12 +27,20 @@ export class BalanceService {
     const chainInfo = this.chainService.getChainInfoByKey(chain);
     const chainState = this.chainService.getChainStateByKey(chain);
     if (!chainInfo || !chainState || !chainState.active) {
-      return Promise.reject(new BalanceError(BalanceErrorType.NETWORK_ERROR, `Chain ${chain} is not active`));
+      return Promise.reject(new BalanceError(BalanceErrorType.NETWORK_ERROR, t('{{chain}} is inactive. Please enable network', {
+        replace: {
+          chain
+        }
+      })));
     }
     const tSlug = tokenSlug || _getChainNativeTokenSlug(chainInfo);
     const tokenInfo = this.chainService.getAssetBySlug(tSlug);
     if (!tokenInfo) {
-      return Promise.reject(new BalanceError(BalanceErrorType.TOKEN_ERROR, `Token ${tSlug} is not supported`));
+      return Promise.reject(new BalanceError(BalanceErrorType.TOKEN_ERROR, t('Transfer is currently not available for this token: {{tSlug}}', {
+        replace: {
+          slug: tSlug
+        }
+      })));
     }
     return new Promise((resolve, reject) => {
       let hasError = true;
@@ -55,7 +64,7 @@ export class BalanceService {
       setTimeout(() => {
         if (hasError) {
           unsub();
-          reject(new Error('Get Balance Timeout'));
+          reject(new Error(t('Failed to get balance. Please check your internet connection or change your network endpoint')));
         }
       }, 9999);
     });

package/services/chain-service/constants.js

@@ -49,7 +49,7 @@ export const _NFT_CHAIN_GROUP = {
 // Staking--------------------------------------------------------------------------------------------------------------
 
 export const _STAKING_CHAIN_GROUP = {
-  relay: ['polkadot', 'kusama', 'aleph', 'polkadex', 'ternoa', 'ternoa_alphanet', 'alephTest', 'polkadexTest', 'westend', 'kate', 'edgeware'],
+  relay: ['polkadot', 'kusama', 'aleph', 'polkadex', 'ternoa', 'ternoa_alphanet', 'alephTest', 'polkadexTest', 'westend', 'kate', 'edgeware', 'creditcoin'],
   para: ['moonbeam', 'moonriver', 'moonbase', 'turing', 'turingStaging', 'bifrost', 'bifrost_testnet', 'calamari_test', 'calamari'],
   astar: ['astar', 'shiden', 'shibuya'],
   amplitude: ['amplitude', 'amplitude_test', 'kilt', 'kilt_peregrine', 'pendulum'],
@@ -89,7 +89,8 @@ export const _STAKING_ERA_LENGTH_MAP = {
   kilt: 2,
   kilt_peregrine: 2,
   edgeware: 6,
-  kate: 6
+  kate: 6,
+  creditcoin: 24
 };
 export const _PARACHAIN_INFLATION_DISTRIBUTION = {
   moonbeam: {

package/services/keyring-service/index.d.ts

@@ -18,5 +18,6 @@ export declare class KeyringService {
     get addresses(): SubjectInfo;
     get currentAccount(): CurrentAccountInfo;
     setCurrentAccount(currentAccountData: CurrentAccountInfo): void;
+    lock(): void;
     resetWallet(resetAll: boolean): void;
 }

package/services/keyring-service/index.js

@@ -87,6 +87,10 @@ export class KeyringService {
     this.eventService.emit('account.updateCurrent', currentAccountData);
     this.currentAccountStore.set('CurrentAccountInfo', currentAccountData);
   }
+  lock() {
+    keyring.lockAll();
+    this.updateKeyringState();
+  }
   resetWallet(resetAll) {
     keyring.resetWallet(resetAll);
     this.updateKeyringState();

package/services/request-service/handler/AuthRequestHandler.js

@@ -210,7 +210,7 @@ export default class AuthRequestHandler {
     const idStr = stripUrl(url);
     // Do not enqueue duplicate authorization requests.
     const isDuplicate = Object.values(this.#authRequestsV2).some(request => request.idStr === idStr);
-    assert(!isDuplicate, `The source ${url} has a pending authorization request`);
+    assert(!isDuplicate, 'The source {{url}} has a pending authorization request'.replace('{{url}}', url));
     const existedAuth = authList[idStr];
     const existedAccountAuthType = existedAuth === null || existedAuth === void 0 ? void 0 : existedAuth.accountAuthType;
     const confirmAnotherType = existedAccountAuthType !== 'both' && existedAccountAuthType !== request.accountAuthType;
@@ -222,7 +222,7 @@ export default class AuthRequestHandler {
     if (existedAuth) {
       const inBlackList = existedAuth && !existedAuth.isAllowed;
       if (inBlackList) {
-        throw new Error(`The source ${url} is not allowed to interact with this extension`);
+        throw new Error('The source {{url}} is not allowed to interact with this extension'.replace('{{url}}', url));
       }
       request.allowedAccounts = Object.entries(existedAuth.isAllowedMap).map(([address, allowed]) => allowed ? address : '').filter(item => item !== '');
       let allowedListByRequestType = [...request.allowedAccounts];
@@ -270,11 +270,11 @@ export default class AuthRequestHandler {
         }
         const entry = Object.keys(value).includes(idStr);
         if (!entry) {
-          reject(new Error(`The source ${url} has not been enabled yet`));
+          reject(new Error('The source {{url}} has not been authorized yet'.replace('{{url}}', url)));
         }
         const isConnected = value[idStr] && Object.keys(value[idStr].isAllowedMap).some(address => value[idStr].isAllowedMap[address]);
         if (!isConnected) {
-          reject(new Error(`The source ${url} is not allowed to interact with this extension`));
+          reject(new Error('The source {{url}} is not allowed to interact with this extension'.replace('{{url}}', url)));
         }
         resolve(true);
       });

package/services/request-service/handler/EvmRequestHandler.js

@@ -10,6 +10,7 @@ import keyring from '@subwallet/ui-keyring';
 import BN from 'bn.js';
 import { Transaction } from 'ethereumjs-tx';
 import { toBuffer } from 'ethereumjs-util';
+import { t } from 'i18next';
 import { BehaviorSubject } from 'rxjs';
 import { logger as createLogger } from '@polkadot/util';
 export default class EvmRequestHandler {
@@ -37,16 +38,22 @@ export default class EvmRequestHandler {
   getConfirmationsQueueSubject() {
     return this.confirmationsQueueSubject;
   }
-  addConfirmation(id, url, type, payload, options = {}, validator) {
+  async addConfirmation(id, url, type, payload, options = {}, validator) {
     const confirmations = this.confirmationsQueueSubject.getValue();
     const confirmationType = confirmations[type];
     const payloadJson = JSON.stringify(payload);
     const isInternal = isInternalRequest(url);
+    if (['evmSignatureRequest', 'evmSendTransactionRequest'].includes(type)) {
+      const isAlwaysRequired = await this.#requestService.settingService.isAlwaysRequired;
+      if (isAlwaysRequired) {
+        this.#requestService.keyringService.lock();
+      }
+    }
 
     // Check duplicate request
     const duplicated = Object.values(confirmationType).find(c => c.url === url && c.payloadJson === payloadJson);
     if (duplicated) {
-      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'Duplicate request information');
+      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, t('Duplicate request'));
     }
     confirmationType[id] = {
       id,
@@ -79,7 +86,7 @@ export default class EvmRequestHandler {
     // Check duplicate request
     const exists = confirmationType[id];
     if (!exists) {
-      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'Request does not exist');
+      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, t('Request does not exist'));
     }
     const payloadJson = JSON.stringify(payload);
     confirmationType[id] = {
@@ -113,7 +120,7 @@ export default class EvmRequestHandler {
       case 'eth_signTypedData_v4':
         return await pair.evmSigner.signMessage(payload, type);
       default:
-        throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'Not found sign method');
+        throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, t('Unsupported action'));
     }
   }
   configToTransaction(config) {
@@ -181,13 +188,19 @@ export default class EvmRequestHandler {
       } else if (t === 'evmSendTransactionRequest') {
         result.payload = await this.signTransaction(request);
       }
+      if (t === 'evmSignatureRequest' || t === 'evmSendTransactionRequest') {
+        const isAlwaysRequired = await this.#requestService.settingService.isAlwaysRequired;
+        if (isAlwaysRequired) {
+          this.#requestService.keyringService.lock();
+        }
+      }
     }
   }
   async completeConfirmation(request) {
     const confirmations = this.confirmationsQueueSubject.getValue();
     for (const ct in request) {
-      const t = ct;
-      const result = request[t];
+      const type = ct;
+      const result = request[type];
       const {
         id
       } = result;
@@ -195,14 +208,14 @@ export default class EvmRequestHandler {
         resolver,
         validator
       } = this.confirmationsPromiseMap[id];
-      const confirmation = confirmations[t][id];
+      const confirmation = confirmations[type][id];
       if (!resolver || !confirmation) {
-        this.#logger.error('Not found confirmation', t, id);
-        throw new Error('Not found promise for confirmation');
+        this.#logger.error(t('Unable to proceed. Please try again'), type, id);
+        throw new Error(t('Unable to proceed. Please try again'));
       }
 
       // Fill signature for some special type
-      await this.decorateResult(t, confirmation, result);
+      await this.decorateResult(type, confirmation, result);
 
       // Validate response from confirmation popup some info like password, response format....
       const error = validator && validator(result);
@@ -212,7 +225,7 @@ export default class EvmRequestHandler {
 
       // Delete confirmations from queue
       delete this.confirmationsPromiseMap[id];
-      delete confirmations[t][id];
+      delete confirmations[type][id];
       this.confirmationsQueueSubject.next(confirmations);
 
       // Update icon, and close queue

package/services/request-service/handler/SubstrateRequestHandler.js

@@ -57,8 +57,12 @@ export default class SubstrateRequestHandler {
   get numSubstrateRequests() {
     return Object.keys(this.#substrateRequests).length;
   }
-  sign(url, request, account, _id) {
+  async sign(url, request, account, _id) {
     const id = _id || getId();
+    const isAlwaysRequired = await this.#requestService.settingService.isAlwaysRequired;
+    if (isAlwaysRequired) {
+      this.#requestService.keyringService.lock();
+    }
     return new Promise((resolve, reject) => {
       this.#substrateRequests[id] = {
         ...this.signComplete(id, resolve, reject),
@@ -71,7 +75,11 @@ export default class SubstrateRequestHandler {
       this.#requestService.popupOpen();
     });
   }
-  signTransaction(id, address, url, payload) {
+  async signTransaction(id, address, url, payload) {
+    const isAlwaysRequired = await this.#requestService.settingService.isAlwaysRequired;
+    if (isAlwaysRequired) {
+      this.#requestService.keyringService.lock();
+    }
     return new Promise((resolve, reject) => {
       const pair = keyring.getPair(address);
       const account = {

package/services/request-service/index.d.ts

@@ -10,8 +10,8 @@ import { SignerPayloadJSON } from '@polkadot/types/types/extrinsic';
 import { AuthUrls, MetaRequest } from './types';
 export default class RequestService {
     #private;
-    private keyringService;
     readonly settingService: SettingService;
+    readonly keyringService: KeyringService;
     constructor(chainService: ChainService, settingService: SettingService, keyringService: KeyringService);
     get numAllRequests(): number;
     updateIconV2(shouldClose?: boolean): void;

package/services/request-service/index.js

@@ -15,9 +15,9 @@ export default class RequestService {
 
   // Common
   constructor(chainService, settingService, keyringService) {
-    this.keyringService = keyringService;
     this.#chainService = chainService;
     this.settingService = settingService;
+    this.keyringService = keyringService;
     this.#popupHandler = new PopupHandler(this);
     this.#metadataRequestHandler = new MetadataRequestHandler(this);
     this.#authRequestHandler = new AuthRequestHandler(this, this.#chainService, this.keyringService);

package/services/setting-service/SettingService.d.ts

@@ -3,11 +3,13 @@ import { Subject } from 'rxjs';
 export default class SettingService {
     private readonly settingsStore;
     private readonly passPhishingStore;
+    constructor();
     getSubject(): Subject<RequestSettingsType>;
     getSettings(update: (value: RequestSettingsType) => void): void;
     setSettings(data: RequestSettingsType, callback?: () => void): void;
     passPhishingSubject(): Subject<Record<string, PassPhishing>>;
     getPassPhishingList(update: (value: Record<string, PassPhishing>) => void): void;
     setPassPhishing(data: Record<string, PassPhishing>, callback?: () => void): void;
+    get isAlwaysRequired(): Promise<boolean>;
     resetWallet(): void;
 }