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

package/background/KoniTypes.d.ts

@@ -7,7 +7,7 @@ import { _CHAIN_VALIDATION_ERROR } from '@subwallet/extension-base/services/chai
 import { _ChainState, _EvmApi, _NetworkUpsertParams, _SubstrateApi, _ValidateCustomAssetRequest, _ValidateCustomAssetResponse, EnableChainParams, EnableMultiChainParams } from '@subwallet/extension-base/services/chain-service/types';
 import { SWTransactionResponse, SWTransactionResult } from '@subwallet/extension-base/services/transaction-service/types';
 import { WalletConnectNotSupportRequest, WalletConnectSessionRequest } from '@subwallet/extension-base/services/wallet-connect-service/types';
-import { InjectedAccount, MetadataDefBase } from '@subwallet/extension-inject/types';
+import { InjectedAccount, InjectedAccountWithMeta, MetadataDefBase } from '@subwallet/extension-inject/types';
 import { KeyringPair$Json, KeyringPair$Meta } from '@subwallet/keyring/types';
 import { KeyringOptions } from '@subwallet/ui-keyring/options/types';
 import { KeyringAddress, KeyringPairs$Json } from '@subwallet/ui-keyring/types';
@@ -701,6 +701,12 @@ export interface RequestEditContactAccount {
 export interface RequestDeleteContactAccount {
     address: string;
 }
+export interface RequestAddInjectedAccounts {
+    accounts: InjectedAccountWithMeta[];
+}
+export interface RequestRemoveInjectedAccounts {
+    addresses: string[];
+}
 export declare enum ExternalRequestPromiseStatus {
     PENDING = 0,
     REJECTED = 1,
@@ -924,6 +930,7 @@ export interface EvmSendTransactionRequest extends TransactionConfig, EvmSignReq
     parseData: EvmTransactionData;
     isToContract: boolean;
 }
+export declare type EvmWatchTransactionRequest = EvmSendTransactionRequest;
 export interface ConfirmationsQueueItemOptions {
     requiredPassword?: boolean;
     address?: string;
@@ -981,6 +988,7 @@ export interface ConfirmationDefinitions {
     switchNetworkRequest: [ConfirmationsQueueItem<SwitchNetworkRequest>, ConfirmationResult<boolean>];
     evmSignatureRequest: [ConfirmationsQueueItem<EvmSignatureRequest>, ConfirmationResult<string>];
     evmSendTransactionRequest: [ConfirmationsQueueItem<EvmSendTransactionRequest>, ConfirmationResult<string>];
+    evmWatchTransactionRequest: [ConfirmationsQueueItem<EvmWatchTransactionRequest>, ConfirmationResult<string>];
 }
 export declare type ConfirmationType = keyof ConfirmationDefinitions;
 export declare type ConfirmationsQueue = {
@@ -1603,30 +1611,32 @@ export interface KoniRequestSignatures {
     'pri(authorize.forgetAllSite)': [null, boolean, AuthUrls];
     'pri(authorize.rejectV2)': [RequestAuthorizeReject, boolean];
     'pri(authorize.cancelV2)': [RequestAuthorizeCancel, boolean];
-    'pri(seed.createV2)': [RequestSeedCreateV2, ResponseSeedCreateV2];
     'pri(seed.validateV2)': [RequestSeedValidateV2, ResponseSeedValidateV2];
     'pri(privateKey.validateV2)': [RequestSeedValidateV2, ResponsePrivateKeyValidateV2];
+    'pri(accounts.checkPublicAndSecretKey)': [RequestCheckPublicAndSecretKey, ResponseCheckPublicAndSecretKey];
+    'pri(seed.createV2)': [RequestSeedCreateV2, ResponseSeedCreateV2];
     'pri(accounts.create.suriV2)': [RequestAccountCreateSuriV2, ResponseAccountCreateSuriV2];
     'pri(accounts.create.externalV2)': [RequestAccountCreateExternalV2, AccountExternalError[]];
     'pri(accounts.create.hardwareV2)': [RequestAccountCreateHardwareV2, boolean];
     'pri(accounts.create.hardwareMultiple)': [RequestAccountCreateHardwareMultiple, boolean];
     'pri(accounts.create.withSecret)': [RequestAccountCreateWithSecretKey, ResponseAccountCreateWithSecretKey];
+    'pri(accounts.inject.add)': [RequestAddInjectedAccounts, boolean];
+    'pri(accounts.inject.remove)': [RequestRemoveInjectedAccounts, boolean];
     'pri(derivation.createV2)': [RequestDeriveCreateV2, boolean];
     'pri(json.restoreV2)': [RequestJsonRestoreV2, void];
     'pri(json.batchRestoreV2)': [RequestBatchRestoreV2, void];
     'pri(accounts.exportPrivateKey)': [RequestAccountExportPrivateKey, ResponseAccountExportPrivateKey];
-    'pri(accounts.checkPublicAndSecretKey)': [RequestCheckPublicAndSecretKey, ResponseCheckPublicAndSecretKey];
     'pri(accounts.subscribeWithCurrentAddress)': [RequestAccountSubscribe, AccountsWithCurrentAddress, AccountsWithCurrentAddress];
-    'pri(accounts.subscribeAccountsInputAddress)': [RequestAccountSubscribe, string, OptionInputAddress];
-    'pri(accounts.saveRecent)': [RequestSaveRecentAccount, KeyringAddress];
-    'pri(accounts.get.meta)': [RequestAccountMeta, ResponseAccountMeta];
     'pri(accounts.updateCurrentAddress)': [string, boolean];
     'pri(currentAccount.saveAddress)': [RequestCurrentAccountAddress, CurrentAccountInfo];
+    'pri(accounts.get.meta)': [RequestAccountMeta, ResponseAccountMeta];
+    'pri(accounts.saveRecent)': [RequestSaveRecentAccount, KeyringAddress];
     'pri(accounts.subscribeAddresses)': [null, AddressBookInfo, AddressBookInfo];
     'pri(accounts.editContact)': [RequestEditContactAccount, boolean];
     'pri(accounts.deleteContact)': [RequestDeleteContactAccount, boolean];
     'pri(accounts.resolveDomainToAddress)': [ResolveDomainRequest, string | undefined];
     'pri(accounts.resolveAddressToDomain)': [ResolveAddressToDomainRequest, string | undefined];
+    'pri(accounts.subscribeAccountsInputAddress)': [RequestAccountSubscribe, string, OptionInputAddress];
     'pri(settings.changeBalancesVisibility)': [null, boolean];
     'pri(settings.subscribe)': [null, UiSettings, UiSettings];
     'pri(settings.getLogoMaps)': [null, AllLogoMap];

package/background/types.d.ts

@@ -31,17 +31,19 @@ export interface AbstractAddressJson extends KeyringPair$Meta {
 export interface AccountJson extends AbstractAddressJson {
     accountIndex?: number;
     addressOffset?: number;
+    availableGenesisHashes?: string[];
     genesisHash?: string | null;
     isExternal?: boolean;
     isHardware?: boolean;
     isHidden?: boolean;
+    isInjected?: boolean;
     isMasterAccount?: boolean;
     isMasterPassword?: boolean;
     isReadOnly?: boolean;
+    originGenesisHash?: string | null;
     parentAddress?: string;
+    source?: string;
     suri?: string;
-    originGenesisHash?: string | null;
-    availableGenesisHashes?: string[];
 }
 export interface AddressJson extends AbstractAddressJson {
     isRecent?: boolean;

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

@@ -33,6 +33,7 @@ var _astar = require("@subwallet/extension-base/koni/api/staking/bonding/astar")
 var _constants = require("@subwallet/extension-base/services/chain-service/constants");
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
 var _utils2 = require("@subwallet/extension-base/utils");
+var _number = require("@subwallet/extension-base/utils/number");
 var _i18next = require("i18next");
 var _util = require("@polkadot/util");
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
@@ -285,7 +286,7 @@ function getValidatorLabel(chain) {
 }
 const getMinStakeErrorMessage = (chainInfo, bnMinStake) => {
   const tokenInfo = (0, _utils._getChainNativeTokenBasicInfo)(chainInfo);
-  const number = bnMinStake.div(new _util.BN(10).pow(new _util.BN(tokenInfo.decimals))).toString();
+  const number = (0, _number.formatNumber)(bnMinStake.toString(), tokenInfo.decimals || 0, _number.balanceFormatter);
   return (0, _i18next.t)('Insufficient stake. Please stake at least {{number}} {{tokenSymbol}} to get rewards', {
     replace: {
       tokenSymbol: tokenInfo.symbol,

package/cjs/koni/background/handlers/Extension.js

@@ -2775,15 +2775,19 @@ class KoniExtension {
       if (createNew) {
         const pairs = _uiKeyring.keyring.getPairs();
         for (const pair of pairs) {
-          const meta = {
-            ...pair.meta,
-            isMasterPassword: false
-          };
-          if (!meta.originGenesisHash) {
-            meta.genesisHash = '';
+          if (pair.meta.isInjected) {
+            // Empty
+          } else {
+            const meta = {
+              ...pair.meta,
+              isMasterPassword: false
+            };
+            if (!meta.originGenesisHash) {
+              meta.genesisHash = '';
+            }
+            pair.setMeta(meta);
+            _uiKeyring.keyring.saveAccountMeta(pair, pair.meta);
           }
-          pair.setMeta(meta);
-          _uiKeyring.keyring.saveAccountMeta(pair, pair.meta);
         }
       }
       _uiKeyring.keyring.changeMasterPassword(newPassword, oldPassword);
@@ -2889,7 +2893,7 @@ class KoniExtension {
     }
   }
 
-  /// Signing external request
+  /// Signing substrate request
   signingApprovePasswordV2(_ref70) {
     let {
       id
@@ -3573,6 +3577,16 @@ class KoniExtension {
     return await (0, _domain.resolveAzeroAddressToDomain)(request.address, request.chain, chainApi.api);
   }
 
+  /// Inject account
+  addInjects(request) {
+    this.#koniState.keyringService.addInjectAccounts(request.accounts);
+    return true;
+  }
+  removeInjects(request) {
+    this.#koniState.keyringService.removeInjectAccounts(request.addresses);
+    return true;
+  }
+
   // --------------------------------------------------------------
   // eslint-disable-next-line @typescript-eslint/require-await
   async handle(id, type, request, port) {
@@ -3725,7 +3739,7 @@ class KoniExtension {
       case 'pri(transaction.history.getSubscription)':
         return await this.subscribeHistory(id, port);
 
-      /// Account management
+      /* Account management */
       // Add account
       case 'pri(accounts.create.suriV2)':
         return await this.accountsCreateSuriV2(request);
@@ -3788,6 +3802,14 @@ class KoniExtension {
       case 'pri(accounts.resolveAddressToDomain)':
         return await this.resolveAddressByDomain(request);
 
+      // Inject account
+      case 'pri(accounts.inject.add)':
+        return this.addInjects(request);
+      case 'pri(accounts.inject.remove)':
+        return this.removeInjects(request);
+
+      /* Account management */
+
       // ChainService
       case 'pri(chainService.subscribeChainInfoMap)':
         return this.subscribeChainInfoMap(id, port);

package/cjs/koni/background/handlers/State.js

@@ -1565,7 +1565,7 @@ class KoniState {
     });
   }
   async resetWallet(resetAll) {
-    this.keyringService.resetWallet(resetAll);
+    await this.keyringService.resetWallet(resetAll);
     this.requestService.resetWallet();
     this.transactionService.resetWallet();
     await this.dbService.resetWallet(resetAll);

package/cjs/packageInfo.js

@@ -13,6 +13,6 @@ const packageInfo = {
   name: '@subwallet/extension-base',
   path: typeof __dirname === 'string' ? __dirname : 'auto',
   type: 'cjs',
-  version: '1.1.11-0'
+  version: '1.1.11-2'
 };
 exports.packageInfo = packageInfo;

package/cjs/services/keyring-service/index.js

@@ -8,6 +8,7 @@ var _constants = require("@subwallet/extension-base/constants");
 var _stores = require("@subwallet/extension-base/stores");
 var _uiKeyring = require("@subwallet/ui-keyring");
 var _rxjs = require("rxjs");
+var _util = require("@polkadot/util");
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
@@ -98,8 +99,39 @@ class KeyringService {
     _uiKeyring.keyring.lockAll();
     this.updateKeyringState();
   }
-  resetWallet(resetAll) {
+
+  /* Inject */
+
+  addInjectAccounts(accounts) {
+    _uiKeyring.keyring.addInjects(accounts.map(account => {
+      const name = account.meta.name || (0, _util.stringShorten)(account.address);
+
+      // TODO: Add if need
+      // name = name.concat(' (', account.meta.source, ')');
+
+      return {
+        ...account,
+        meta: {
+          ...account.meta,
+          name: name
+        }
+      };
+    }));
+  }
+  removeInjectAccounts(addresses) {
+    _uiKeyring.keyring.removeInjects(addresses);
+  }
+
+  /* Inject */
+
+  /* Reset */
+  async resetWallet(resetAll) {
     _uiKeyring.keyring.resetWallet(resetAll);
+    await new Promise(resolve => {
+      setTimeout(() => {
+        resolve();
+      }, 500);
+    });
     this.updateKeyringState();
     this.currentAccountSubject.next({
       address: _constants.ALL_ACCOUNT_KEY,

package/cjs/services/notification-service/NotificationService.js

@@ -32,7 +32,8 @@ class NotificationService {
 
   // Create a new chrome notification with link
   static createBrowserNotification(title, message, link) {
-    chrome.notifications.create({
+    var _chrome, _chrome$notifications;
+    (_chrome = chrome) === null || _chrome === void 0 ? void 0 : (_chrome$notifications = _chrome.notifications) === null || _chrome$notifications === void 0 ? void 0 : _chrome$notifications.create({
       type: 'basic',
       title,
       message,

package/cjs/services/request-service/constants.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.PREDEFINED_CHAIN_DAPP_CHAIN_MAP = exports.EXTENSION_REQUEST_URL = void 0;
+exports.WEB_APP_URL = exports.PREDEFINED_CHAIN_DAPP_CHAIN_MAP = exports.EXTENSION_REQUEST_URL = void 0;
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
@@ -14,4 +14,13 @@ const PREDEFINED_CHAIN_DAPP_CHAIN_MAP = {
   'apps.moonbeam.network': ['moonbeam', 'moonriver'],
   'app.stellaswap.com': ['moonbeam']
 };
-exports.PREDEFINED_CHAIN_DAPP_CHAIN_MAP = PREDEFINED_CHAIN_DAPP_CHAIN_MAP;
+exports.PREDEFINED_CHAIN_DAPP_CHAIN_MAP = PREDEFINED_CHAIN_DAPP_CHAIN_MAP;
+const WEB_APP_URL = [
+/// Web app
+'localhost:9000',
+// Local
+'subwallet-webapp.pages.dev',
+// Pull request build
+'web.subwallet.app' // Production
+];
+exports.WEB_APP_URL = WEB_APP_URL;

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

@@ -221,7 +221,7 @@ class AuthRequestHandler {
     }
     const idStr = (0, _utils2.stripUrl)(url);
     // Do not enqueue duplicate authorization requests.
-    const isDuplicate = Object.values(this.#authRequestsV2).some(request => request.idStr === idStr);
+    const isDuplicate = Object.values(this.#authRequestsV2).some(_request => _request.idStr === idStr && _request.accountAuthType === request.accountAuthType);
     (0, _util.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;
@@ -250,6 +250,25 @@ class AuthRequestHandler {
         // Prevent appear confirmation popup
         return false;
       }
+    } else {
+      // Auto auth for web app
+
+      // Ignore white list
+      const isWhiteList = _constants.WEB_APP_URL.some(url => idStr.includes(url)) && false;
+      if (isWhiteList) {
+        const isAllowedMap = this.getAddressList(true);
+        authList[(0, _utils2.stripUrl)(url)] = {
+          count: 0,
+          id: idStr,
+          isAllowed: true,
+          isAllowedMap,
+          origin,
+          url,
+          accountAuthType: 'both'
+        };
+        this.setAuthorize(authList);
+        return true;
+      }
     }
     return new Promise((resolve, reject) => {
       const id = (0, _getId.getId)();

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

@@ -28,7 +28,8 @@ class EvmRequestHandler {
     addTokenRequest: {},
     switchNetworkRequest: {},
     evmSignatureRequest: {},
-    evmSendTransactionRequest: {}
+    evmSendTransactionRequest: {},
+    evmWatchTransactionRequest: {}
   });
   confirmationsPromiseMap = {};
   constructor(requestService) {

package/cjs/services/transaction-service/index.js

@@ -34,6 +34,7 @@ var _util = require("@polkadot/util");
 
 class TransactionService {
   transactionSubject = new _rxjs.BehaviorSubject({});
+  watchTransactionSubscribes = {};
   get transactions() {
     return this.transactionSubject.getValue();
   }
@@ -716,6 +717,7 @@ class TransactionService {
       payload.from = address;
     }
     const isExternal = !!account.isExternal;
+    const isInjected = !!account.isInjected;
 
     // generate hashPayload for EVM transaction
     payload.hashPayload = this.generateHashPayload(chain, payload);
@@ -736,73 +738,140 @@ class TransactionService {
       warnings: [],
       extrinsicHash: id
     };
-    this.requestService.addConfirmation(id, url || _constants3.EXTENSION_REQUEST_URL, 'evmSendTransactionRequest', payload, {}).then(async _ref7 => {
-      let {
-        isApproved,
-        payload
-      } = _ref7;
-      if (isApproved) {
-        let signedTransaction;
-        if (!payload) {
-          throw new _EvmProviderError.EvmProviderError(_KoniTypes.EvmProviderErrorType.UNAUTHORIZED, (0, _i18next.t)('Failed to sign'));
-        }
-        const web3Api = this.chainService.getEvmApi(chain).api;
-        if (!isExternal) {
-          signedTransaction = payload;
-        } else {
-          const signed = (0, _mergeTransactionAndSignature.mergeTransactionAndSignature)(txObject, payload);
-          const recover = web3Api.eth.accounts.recoverTransaction(signed);
-          if (recover.toLowerCase() !== account.address.toLowerCase()) {
-            throw new _EvmProviderError.EvmProviderError(_KoniTypes.EvmProviderErrorType.UNAUTHORIZED, (0, _i18next.t)('Wrong signature. Please sign with the account you use in dApp'));
+    if (isInjected) {
+      this.requestService.addConfirmation(id, url || _constants3.EXTENSION_REQUEST_URL, 'evmWatchTransactionRequest', payload, {}).then(async _ref7 => {
+        let {
+          isApproved,
+          payload
+        } = _ref7;
+        if (isApproved) {
+          if (!payload) {
+            throw new _EvmProviderError.EvmProviderError(_KoniTypes.EvmProviderErrorType.UNAUTHORIZED, 'Bad signature');
           }
-          signedTransaction = signed;
-        }
+          const web3Api = this.chainService.getEvmApi(chain).api;
 
-        // Emit signed event
-        emitter.emit('signed', eventData);
+          // Emit signed event
+          emitter.emit('signed', eventData);
+          eventData.nonce = txObject.nonce;
+          eventData.startBlock = (await web3Api.eth.getBlockNumber()) - 3;
+          // Add start info
+          emitter.emit('send', eventData); // This event is needed after sending transaction with queue
 
-        // Send transaction
-        this.handleTransactionTimeout(emitter, eventData);
-
-        // Add start info
-        eventData.nonce = txObject.nonce;
-        eventData.startBlock = await web3Api.eth.getBlockNumber();
-        emitter.emit('send', eventData); // This event is needed after sending transaction with queue
-        signedTransaction && web3Api.eth.sendSignedTransaction(signedTransaction).once('transactionHash', hash => {
-          eventData.extrinsicHash = hash;
+          const txHash = payload;
+          eventData.extrinsicHash = txHash;
           emitter.emit('extrinsicHash', eventData);
-        }).once('receipt', rs => {
-          eventData.extrinsicHash = rs.transactionHash;
-          eventData.blockHash = rs.blockHash;
-          eventData.blockNumber = rs.blockNumber;
-          emitter.emit('success', eventData);
-        }).once('error', e => {
-          eventData.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.SEND_TRANSACTION_FAILED, (0, _i18next.t)(e.message)));
+          this.watchTransactionSubscribes[id] = new Promise((resolve, reject) => {
+            // eslint-disable-next-line prefer-const
+            let subscribe;
+            const onComplete = () => {
+              var _subscribe, _subscribe$unsubscrib, _subscribe$unsubscrib2;
+              (_subscribe = subscribe) === null || _subscribe === void 0 ? void 0 : (_subscribe$unsubscrib = _subscribe.unsubscribe) === null || _subscribe$unsubscrib === void 0 ? void 0 : (_subscribe$unsubscrib2 = _subscribe$unsubscrib.call(_subscribe)) === null || _subscribe$unsubscrib2 === void 0 ? void 0 : _subscribe$unsubscrib2.then(console.debug).catch(console.debug);
+              delete this.watchTransactionSubscribes[id];
+            };
+            const onSuccess = rs => {
+              if (rs) {
+                eventData.extrinsicHash = rs.transactionHash;
+                eventData.blockHash = rs.blockHash;
+                eventData.blockNumber = rs.blockNumber;
+                emitter.emit('success', eventData);
+                onComplete();
+                resolve();
+              }
+            };
+            const onError = error => {
+              if (error) {
+                // TODO: Change type and message
+                eventData.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNABLE_TO_SEND, error.message));
+                emitter.emit('error', eventData);
+                onComplete();
+                reject(error);
+              }
+            };
+            const onCheck = () => {
+              web3Api.eth.getTransactionReceipt(txHash).then(onSuccess).catch(onError);
+            };
+            subscribe = web3Api.eth.subscribe('newBlockHeaders', onCheck);
+          });
+        } else {
+          this.removeTransaction(id);
+          eventData.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.USER_REJECT_REQUEST));
           emitter.emit('error', eventData);
-        }).catch(e => {
-          eventData.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNABLE_TO_SEND, (0, _i18next.t)(e.message)));
+        }
+      }).catch(e => {
+        this.removeTransaction(id);
+        // TODO: Change type
+        eventData.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNABLE_TO_SIGN, e.message));
+        emitter.emit('error', eventData);
+      });
+    } else {
+      this.requestService.addConfirmation(id, url || _constants3.EXTENSION_REQUEST_URL, 'evmSendTransactionRequest', payload, {}).then(async _ref8 => {
+        let {
+          isApproved,
+          payload
+        } = _ref8;
+        if (isApproved) {
+          let signedTransaction;
+          if (!payload) {
+            throw new _EvmProviderError.EvmProviderError(_KoniTypes.EvmProviderErrorType.UNAUTHORIZED, (0, _i18next.t)('Failed to sign'));
+          }
+          const web3Api = this.chainService.getEvmApi(chain).api;
+          if (!isExternal) {
+            signedTransaction = payload;
+          } else {
+            const signed = (0, _mergeTransactionAndSignature.mergeTransactionAndSignature)(txObject, payload);
+            const recover = web3Api.eth.accounts.recoverTransaction(signed);
+            if (recover.toLowerCase() !== account.address.toLowerCase()) {
+              throw new _EvmProviderError.EvmProviderError(_KoniTypes.EvmProviderErrorType.UNAUTHORIZED, (0, _i18next.t)('Wrong signature. Please sign with the account you use in dApp'));
+            }
+            signedTransaction = signed;
+          }
+
+          // Emit signed event
+          emitter.emit('signed', eventData);
+
+          // Send transaction
+          this.handleTransactionTimeout(emitter, eventData);
+
+          // Add start info
+          eventData.nonce = txObject.nonce;
+          eventData.startBlock = await web3Api.eth.getBlockNumber();
+          emitter.emit('send', eventData); // This event is needed after sending transaction with queue
+          signedTransaction && web3Api.eth.sendSignedTransaction(signedTransaction).once('transactionHash', hash => {
+            eventData.extrinsicHash = hash;
+            emitter.emit('extrinsicHash', eventData);
+          }).once('receipt', rs => {
+            eventData.extrinsicHash = rs.transactionHash;
+            eventData.blockHash = rs.blockHash;
+            eventData.blockNumber = rs.blockNumber;
+            emitter.emit('success', eventData);
+          }).once('error', e => {
+            eventData.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.SEND_TRANSACTION_FAILED, (0, _i18next.t)(e.message)));
+            emitter.emit('error', eventData);
+          }).catch(e => {
+            eventData.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNABLE_TO_SEND, (0, _i18next.t)(e.message)));
+            emitter.emit('error', eventData);
+          });
+        } else {
+          this.removeTransaction(id);
+          eventData.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.USER_REJECT_REQUEST));
           emitter.emit('error', eventData);
-        });
-      } else {
+        }
+      }).catch(e => {
         this.removeTransaction(id);
-        eventData.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.USER_REJECT_REQUEST));
+        eventData.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNABLE_TO_SIGN, (0, _i18next.t)(e.message)));
         emitter.emit('error', eventData);
-      }
-    }).catch(e => {
-      this.removeTransaction(id);
-      eventData.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNABLE_TO_SIGN, (0, _i18next.t)(e.message)));
-      emitter.emit('error', eventData);
-    });
+      });
+    }
     return emitter;
   }
-  signAndSendSubstrateTransaction(_ref8) {
+  signAndSendSubstrateTransaction(_ref9) {
     let {
       address,
       chain,
       id,
       transaction,
       url
-    } = _ref8;
+    } = _ref9;
     const emitter = new _eventemitter.default();
     const eventData = {
       id,
@@ -848,20 +917,20 @@ class TransactionService {
           eventData.extrinsicHash = txState.txHash.toHex();
           eventData.eventLogs = txState.events;
           // TODO: push block hash and block number into eventData
-          txState.events.filter(_ref9 => {
+          txState.events.filter(_ref10 => {
             let {
               event: {
                 section
               }
-            } = _ref9;
+            } = _ref10;
             return section === 'system';
-          }).forEach(_ref10 => {
+          }).forEach(_ref11 => {
             let {
               event: {
                 method,
                 data: [error]
               }
-            } = _ref10;
+            } = _ref11;
             if (method === 'ExtrinsicFailed') {
               eventData.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.SEND_TRANSACTION_FAILED, error.toString()));
               emitter.emit('error', eventData);

package/cjs/utils/lazy.js

@@ -20,6 +20,7 @@ function removeLazy(key) {
 function addLazy(key, callback) {
   let lazyTime = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 300;
   let maxLazyTime = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 3000;
+  let fireOnFirst = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : true;
   const existed = lazyMap[key];
   const now = new Date().getTime();
   if (existed) {
@@ -42,11 +43,24 @@ function addLazy(key, callback) {
       }, lazyTime);
     }
   } else {
-    // Fire callback immediately in the first time
-    callback();
-    lazyMap[key] = {
-      callback,
-      lastFire: now
-    };
+    if (fireOnFirst) {
+      // Fire callback immediately in the first time
+      callback();
+      lazyMap[key] = {
+        callback,
+        lastFire: now
+      };
+    } else {
+      lazyMap[key] = {
+        callback,
+        lastFire: now
+      };
+      lazyMap[key].timeout = setTimeout(() => {
+        // This will be fire in the last call of lazy thread
+        callback();
+        lazyMap[key].lastFire = new Date().getTime();
+        removeLazy(key);
+      }, lazyTime);
+    }
   }
 }

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

@@ -6,6 +6,7 @@ import { getAstarWithdrawable } from '@subwallet/extension-base/koni/api/staking
 import { _KNOWN_CHAIN_INFLATION_PARAMS, _STAKING_CHAIN_GROUP, _SUBSTRATE_DEFAULT_INFLATION_PARAMS } from '@subwallet/extension-base/services/chain-service/constants';
 import { _getChainNativeTokenBasicInfo } from '@subwallet/extension-base/services/chain-service/utils';
 import { detectTranslate, parseRawNumber, reformatAddress } from '@subwallet/extension-base/utils';
+import { balanceFormatter, formatNumber } from '@subwallet/extension-base/utils/number';
 import { t } from 'i18next';
 import { BN, BN_BILLION, BN_HUNDRED, BN_MILLION, BN_THOUSAND, BN_ZERO, bnToU8a, stringToU8a, u8aConcat } from '@polkadot/util';
 export let PalletParachainStakingRequestType;
@@ -254,7 +255,7 @@ export function getValidatorLabel(chain) {
 }
 export const getMinStakeErrorMessage = (chainInfo, bnMinStake) => {
   const tokenInfo = _getChainNativeTokenBasicInfo(chainInfo);
-  const number = bnMinStake.div(new BN(10).pow(new BN(tokenInfo.decimals))).toString();
+  const number = formatNumber(bnMinStake.toString(), tokenInfo.decimals || 0, balanceFormatter);
   return t('Insufficient stake. Please stake at least {{number}} {{tokenSymbol}} to get rewards', {
     replace: {
       tokenSymbol: tokenInfo.symbol,

package/koni/background/handlers/Extension.d.ts

@@ -210,5 +210,7 @@ export default class KoniExtension {
     private findRawMetadata;
     private resolveDomainByAddress;
     private resolveAddressByDomain;
+    private addInjects;
+    private removeInjects;
     handle<TMessageType extends MessageTypes>(id: string, type: TMessageType, request: RequestTypes[TMessageType], port: chrome.runtime.Port): Promise<ResponseType<TMessageType>>;
 }

package/koni/background/handlers/Extension.js

@@ -2700,15 +2700,19 @@ export default class KoniExtension {
       if (createNew) {
         const pairs = keyring.getPairs();
         for (const pair of pairs) {
-          const meta = {
-            ...pair.meta,
-            isMasterPassword: false
-          };
-          if (!meta.originGenesisHash) {
-            meta.genesisHash = '';
+          if (pair.meta.isInjected) {
+            // Empty
+          } else {
+            const meta = {
+              ...pair.meta,
+              isMasterPassword: false
+            };
+            if (!meta.originGenesisHash) {
+              meta.genesisHash = '';
+            }
+            pair.setMeta(meta);
+            keyring.saveAccountMeta(pair, pair.meta);
           }
-          pair.setMeta(meta);
-          keyring.saveAccountMeta(pair, pair.meta);
         }
       }
       keyring.changeMasterPassword(newPassword, oldPassword);
@@ -2810,7 +2814,7 @@ export default class KoniExtension {
     }
   }
 
-  /// Signing external request
+  /// Signing substrate request
   signingApprovePasswordV2({
     id
   }) {
@@ -3473,6 +3477,16 @@ export default class KoniExtension {
     return await resolveAzeroAddressToDomain(request.address, request.chain, chainApi.api);
   }
 
+  /// Inject account
+  addInjects(request) {
+    this.#koniState.keyringService.addInjectAccounts(request.accounts);
+    return true;
+  }
+  removeInjects(request) {
+    this.#koniState.keyringService.removeInjectAccounts(request.addresses);
+    return true;
+  }
+
   // --------------------------------------------------------------
   // eslint-disable-next-line @typescript-eslint/require-await
   async handle(id, type, request, port) {
@@ -3625,7 +3639,7 @@ export default class KoniExtension {
       case 'pri(transaction.history.getSubscription)':
         return await this.subscribeHistory(id, port);
 
-      /// Account management
+      /* Account management */
       // Add account
       case 'pri(accounts.create.suriV2)':
         return await this.accountsCreateSuriV2(request);
@@ -3688,6 +3702,14 @@ export default class KoniExtension {
       case 'pri(accounts.resolveAddressToDomain)':
         return await this.resolveAddressByDomain(request);
 
+      // Inject account
+      case 'pri(accounts.inject.add)':
+        return this.addInjects(request);
+      case 'pri(accounts.inject.remove)':
+        return this.removeInjects(request);
+
+      /* Account management */
+
       // ChainService
       case 'pri(chainService.subscribeChainInfoMap)':
         return this.subscribeChainInfoMap(id, port);

package/koni/background/handlers/State.js

@@ -1539,7 +1539,7 @@ export default class KoniState {
     });
   }
   async resetWallet(resetAll) {
-    this.keyringService.resetWallet(resetAll);
+    await this.keyringService.resetWallet(resetAll);
     this.requestService.resetWallet();
     this.transactionService.resetWallet();
     await this.dbService.resetWallet(resetAll);

package/package.json

@@ -17,7 +17,7 @@
     "./cjs/detectPackage.js"
   ],
   "type": "module",
-  "version": "1.1.11-0",
+  "version": "1.1.11-2",
   "main": "./cjs/index.js",
   "module": "./index.js",
   "types": "./index.d.ts",
@@ -1222,12 +1222,12 @@
     "@sora-substrate/type-definitions": "^1.17.7",
     "@substrate/connect": "^0.7.26",
     "@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",
+    "@subwallet/extension-base": "^1.1.11-2",
+    "@subwallet/extension-chains": "^1.1.11-2",
+    "@subwallet/extension-dapp": "^1.1.11-2",
+    "@subwallet/extension-inject": "^1.1.11-2",
+    "@subwallet/keyring": "^0.1.1",
+    "@subwallet/ui-keyring": "^0.1.1",
     "@walletconnect/sign-client": "^2.8.4",
     "@walletconnect/types": "^2.8.4",
     "@walletconnect/utils": "^2.8.4",
@@ -1256,6 +1256,8 @@
     "web3": "^1.10.0",
     "web3-core": "^1.10.0",
     "web3-core-helpers": "^1.10.0",
+    "web3-core-subscriptions": "1.10.0",
+    "web3-eth": "1.10.0",
     "web3-eth-contract": "^1.10.0",
     "web3-utils": "^1.10.0"
   }

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.11-0'
+  version: '1.1.11-2'
 };

package/page/SubWalleEvmProvider.d.ts

@@ -16,7 +16,7 @@ export declare class SubWalletEvmProvider extends SafeEventEmitter implements Ev
     get connected(): boolean;
     isConnected(): boolean;
     protected subscribeExtensionEvents(): void;
-    enable(): Promise<unknown>;
+    enable(): Promise<string[]>;
     on(eventName: string | symbol, listener: (...args: any[]) => void): this;
     once(eventName: string | symbol, listener: (...args: any[]) => void): this;
     request<T>({ method, params }: RequestArguments): Promise<T>;

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

@@ -1,5 +1,6 @@
 import { CurrentAccountInfo, KeyringState } from '@subwallet/extension-base/background/KoniTypes';
 import { EventService } from '@subwallet/extension-base/services/event-service';
+import { InjectedAccountWithMeta } from '@subwallet/extension-inject/types';
 import { SubjectInfo } from '@subwallet/ui-keyring/observable/types';
 import { BehaviorSubject } from 'rxjs';
 export declare class KeyringService {
@@ -19,5 +20,7 @@ export declare class KeyringService {
     get currentAccount(): CurrentAccountInfo;
     setCurrentAccount(currentAccountData: CurrentAccountInfo): void;
     lock(): void;
-    resetWallet(resetAll: boolean): void;
+    addInjectAccounts(accounts: InjectedAccountWithMeta[]): void;
+    removeInjectAccounts(addresses: string[]): void;
+    resetWallet(resetAll: boolean): Promise<void>;
 }

package/services/keyring-service/index.js

@@ -5,6 +5,7 @@ import { ALL_ACCOUNT_KEY } from '@subwallet/extension-base/constants';
 import { CurrentAccountStore } from '@subwallet/extension-base/stores';
 import { keyring } from '@subwallet/ui-keyring';
 import { BehaviorSubject } from 'rxjs';
+import { stringShorten } from '@polkadot/util';
 export class KeyringService {
   currentAccountStore = new CurrentAccountStore();
   currentAccountSubject = new BehaviorSubject({
@@ -91,8 +92,39 @@ export class KeyringService {
     keyring.lockAll();
     this.updateKeyringState();
   }
-  resetWallet(resetAll) {
+
+  /* Inject */
+
+  addInjectAccounts(accounts) {
+    keyring.addInjects(accounts.map(account => {
+      const name = account.meta.name || stringShorten(account.address);
+
+      // TODO: Add if need
+      // name = name.concat(' (', account.meta.source, ')');
+
+      return {
+        ...account,
+        meta: {
+          ...account.meta,
+          name: name
+        }
+      };
+    }));
+  }
+  removeInjectAccounts(addresses) {
+    keyring.removeInjects(addresses);
+  }
+
+  /* Inject */
+
+  /* Reset */
+  async resetWallet(resetAll) {
     keyring.resetWallet(resetAll);
+    await new Promise(resolve => {
+      setTimeout(() => {
+        resolve();
+      }, 500);
+    });
     this.updateKeyringState();
     this.currentAccountSubject.next({
       address: ALL_ACCOUNT_KEY,

package/services/notification-service/NotificationService.js

@@ -26,7 +26,8 @@ export default class NotificationService {
 
   // Create a new chrome notification with link
   static createBrowserNotification(title, message, link) {
-    chrome.notifications.create({
+    var _chrome, _chrome$notifications;
+    (_chrome = chrome) === null || _chrome === void 0 ? void 0 : (_chrome$notifications = _chrome.notifications) === null || _chrome$notifications === void 0 ? void 0 : _chrome$notifications.create({
       type: 'basic',
       title,
       message,

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

@@ -1,2 +1,3 @@
 export declare const EXTENSION_REQUEST_URL = "extension";
 export declare const PREDEFINED_CHAIN_DAPP_CHAIN_MAP: Record<string, string[]>;
+export declare const WEB_APP_URL: string[];

package/services/request-service/constants.js

@@ -6,4 +6,12 @@ export const PREDEFINED_CHAIN_DAPP_CHAIN_MAP = {
   'portal.astar.network': ['astar', 'astarEvm'],
   'apps.moonbeam.network': ['moonbeam', 'moonriver'],
   'app.stellaswap.com': ['moonbeam']
-};
+};
+export const WEB_APP_URL = [
+/// Web app
+'localhost:9000',
+// Local
+'subwallet-webapp.pages.dev',
+// Pull request build
+'web.subwallet.app' // Production
+];

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

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { _isChainEvmCompatible } from '@subwallet/extension-base/services/chain-service/utils';
-import { PREDEFINED_CHAIN_DAPP_CHAIN_MAP } from '@subwallet/extension-base/services/request-service/constants';
+import { PREDEFINED_CHAIN_DAPP_CHAIN_MAP, WEB_APP_URL } from '@subwallet/extension-base/services/request-service/constants';
 import AuthorizeStore from '@subwallet/extension-base/stores/Authorize';
 import { getDomainFromUrl, stripUrl } from '@subwallet/extension-base/utils';
 import { getId } from '@subwallet/extension-base/utils/getId';
@@ -209,7 +209,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);
+    const isDuplicate = Object.values(this.#authRequestsV2).some(_request => _request.idStr === idStr && _request.accountAuthType === request.accountAuthType);
     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;
@@ -235,6 +235,25 @@ export default class AuthRequestHandler {
         // Prevent appear confirmation popup
         return false;
       }
+    } else {
+      // Auto auth for web app
+
+      // Ignore white list
+      const isWhiteList = WEB_APP_URL.some(url => idStr.includes(url)) && false;
+      if (isWhiteList) {
+        const isAllowedMap = this.getAddressList(true);
+        authList[stripUrl(url)] = {
+          count: 0,
+          id: idStr,
+          isAllowed: true,
+          isAllowedMap,
+          origin,
+          url,
+          accountAuthType: 'both'
+        };
+        this.setAuthorize(authList);
+        return true;
+      }
     }
     return new Promise((resolve, reject) => {
       const id = getId();

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

@@ -21,7 +21,8 @@ export default class EvmRequestHandler {
     addTokenRequest: {},
     switchNetworkRequest: {},
     evmSignatureRequest: {},
-    evmSendTransactionRequest: {}
+    evmSendTransactionRequest: {},
+    evmWatchTransactionRequest: {}
   });
   confirmationsPromiseMap = {};
   constructor(requestService) {

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

@@ -19,6 +19,7 @@ export default class TransactionService {
     private readonly notificationService;
     private readonly requestService;
     private readonly transactionSubject;
+    private readonly watchTransactionSubscribes;
     private get transactions();
     constructor(chainService: ChainService, eventService: EventService, requestService: RequestService, balanceService: BalanceService, historyService: HistoryService, notificationService: NotificationService, databaseService: DatabaseService);
     private get allTransactions();

package/services/transaction-service/index.js

@@ -27,6 +27,7 @@ import { BehaviorSubject } from 'rxjs';
 import { isHex } from '@polkadot/util';
 export default class TransactionService {
   transactionSubject = new BehaviorSubject({});
+  watchTransactionSubscribes = {};
   get transactions() {
     return this.transactionSubject.getValue();
   }
@@ -703,6 +704,7 @@ export default class TransactionService {
       payload.from = address;
     }
     const isExternal = !!account.isExternal;
+    const isInjected = !!account.isInjected;
 
     // generate hashPayload for EVM transaction
     payload.hashPayload = this.generateHashPayload(chain, payload);
@@ -723,62 +725,128 @@ export default class TransactionService {
       warnings: [],
       extrinsicHash: id
     };
-    this.requestService.addConfirmation(id, url || EXTENSION_REQUEST_URL, 'evmSendTransactionRequest', payload, {}).then(async ({
-      isApproved,
-      payload
-    }) => {
-      if (isApproved) {
-        let signedTransaction;
-        if (!payload) {
-          throw new EvmProviderError(EvmProviderErrorType.UNAUTHORIZED, t('Failed to sign'));
-        }
-        const web3Api = this.chainService.getEvmApi(chain).api;
-        if (!isExternal) {
-          signedTransaction = payload;
-        } else {
-          const signed = mergeTransactionAndSignature(txObject, payload);
-          const recover = web3Api.eth.accounts.recoverTransaction(signed);
-          if (recover.toLowerCase() !== account.address.toLowerCase()) {
-            throw new EvmProviderError(EvmProviderErrorType.UNAUTHORIZED, t('Wrong signature. Please sign with the account you use in dApp'));
+    if (isInjected) {
+      this.requestService.addConfirmation(id, url || EXTENSION_REQUEST_URL, 'evmWatchTransactionRequest', payload, {}).then(async ({
+        isApproved,
+        payload
+      }) => {
+        if (isApproved) {
+          if (!payload) {
+            throw new EvmProviderError(EvmProviderErrorType.UNAUTHORIZED, 'Bad signature');
           }
-          signedTransaction = signed;
-        }
-
-        // Emit signed event
-        emitter.emit('signed', eventData);
+          const web3Api = this.chainService.getEvmApi(chain).api;
 
-        // Send transaction
-        this.handleTransactionTimeout(emitter, eventData);
+          // Emit signed event
+          emitter.emit('signed', eventData);
+          eventData.nonce = txObject.nonce;
+          eventData.startBlock = (await web3Api.eth.getBlockNumber()) - 3;
+          // Add start info
+          emitter.emit('send', eventData); // This event is needed after sending transaction with queue
 
-        // Add start info
-        eventData.nonce = txObject.nonce;
-        eventData.startBlock = await web3Api.eth.getBlockNumber();
-        emitter.emit('send', eventData); // This event is needed after sending transaction with queue
-        signedTransaction && web3Api.eth.sendSignedTransaction(signedTransaction).once('transactionHash', hash => {
-          eventData.extrinsicHash = hash;
+          const txHash = payload;
+          eventData.extrinsicHash = txHash;
           emitter.emit('extrinsicHash', eventData);
-        }).once('receipt', rs => {
-          eventData.extrinsicHash = rs.transactionHash;
-          eventData.blockHash = rs.blockHash;
-          eventData.blockNumber = rs.blockNumber;
-          emitter.emit('success', eventData);
-        }).once('error', e => {
-          eventData.errors.push(new TransactionError(BasicTxErrorType.SEND_TRANSACTION_FAILED, t(e.message)));
+          this.watchTransactionSubscribes[id] = new Promise((resolve, reject) => {
+            // eslint-disable-next-line prefer-const
+            let subscribe;
+            const onComplete = () => {
+              var _subscribe, _subscribe$unsubscrib, _subscribe$unsubscrib2;
+              (_subscribe = subscribe) === null || _subscribe === void 0 ? void 0 : (_subscribe$unsubscrib = _subscribe.unsubscribe) === null || _subscribe$unsubscrib === void 0 ? void 0 : (_subscribe$unsubscrib2 = _subscribe$unsubscrib.call(_subscribe)) === null || _subscribe$unsubscrib2 === void 0 ? void 0 : _subscribe$unsubscrib2.then(console.debug).catch(console.debug);
+              delete this.watchTransactionSubscribes[id];
+            };
+            const onSuccess = rs => {
+              if (rs) {
+                eventData.extrinsicHash = rs.transactionHash;
+                eventData.blockHash = rs.blockHash;
+                eventData.blockNumber = rs.blockNumber;
+                emitter.emit('success', eventData);
+                onComplete();
+                resolve();
+              }
+            };
+            const onError = error => {
+              if (error) {
+                // TODO: Change type and message
+                eventData.errors.push(new TransactionError(BasicTxErrorType.UNABLE_TO_SEND, error.message));
+                emitter.emit('error', eventData);
+                onComplete();
+                reject(error);
+              }
+            };
+            const onCheck = () => {
+              web3Api.eth.getTransactionReceipt(txHash).then(onSuccess).catch(onError);
+            };
+            subscribe = web3Api.eth.subscribe('newBlockHeaders', onCheck);
+          });
+        } else {
+          this.removeTransaction(id);
+          eventData.errors.push(new TransactionError(BasicTxErrorType.USER_REJECT_REQUEST));
           emitter.emit('error', eventData);
-        }).catch(e => {
-          eventData.errors.push(new TransactionError(BasicTxErrorType.UNABLE_TO_SEND, t(e.message)));
+        }
+      }).catch(e => {
+        this.removeTransaction(id);
+        // TODO: Change type
+        eventData.errors.push(new TransactionError(BasicTxErrorType.UNABLE_TO_SIGN, e.message));
+        emitter.emit('error', eventData);
+      });
+    } else {
+      this.requestService.addConfirmation(id, url || EXTENSION_REQUEST_URL, 'evmSendTransactionRequest', payload, {}).then(async ({
+        isApproved,
+        payload
+      }) => {
+        if (isApproved) {
+          let signedTransaction;
+          if (!payload) {
+            throw new EvmProviderError(EvmProviderErrorType.UNAUTHORIZED, t('Failed to sign'));
+          }
+          const web3Api = this.chainService.getEvmApi(chain).api;
+          if (!isExternal) {
+            signedTransaction = payload;
+          } else {
+            const signed = mergeTransactionAndSignature(txObject, payload);
+            const recover = web3Api.eth.accounts.recoverTransaction(signed);
+            if (recover.toLowerCase() !== account.address.toLowerCase()) {
+              throw new EvmProviderError(EvmProviderErrorType.UNAUTHORIZED, t('Wrong signature. Please sign with the account you use in dApp'));
+            }
+            signedTransaction = signed;
+          }
+
+          // Emit signed event
+          emitter.emit('signed', eventData);
+
+          // Send transaction
+          this.handleTransactionTimeout(emitter, eventData);
+
+          // Add start info
+          eventData.nonce = txObject.nonce;
+          eventData.startBlock = await web3Api.eth.getBlockNumber();
+          emitter.emit('send', eventData); // This event is needed after sending transaction with queue
+          signedTransaction && web3Api.eth.sendSignedTransaction(signedTransaction).once('transactionHash', hash => {
+            eventData.extrinsicHash = hash;
+            emitter.emit('extrinsicHash', eventData);
+          }).once('receipt', rs => {
+            eventData.extrinsicHash = rs.transactionHash;
+            eventData.blockHash = rs.blockHash;
+            eventData.blockNumber = rs.blockNumber;
+            emitter.emit('success', eventData);
+          }).once('error', e => {
+            eventData.errors.push(new TransactionError(BasicTxErrorType.SEND_TRANSACTION_FAILED, t(e.message)));
+            emitter.emit('error', eventData);
+          }).catch(e => {
+            eventData.errors.push(new TransactionError(BasicTxErrorType.UNABLE_TO_SEND, t(e.message)));
+            emitter.emit('error', eventData);
+          });
+        } else {
+          this.removeTransaction(id);
+          eventData.errors.push(new TransactionError(BasicTxErrorType.USER_REJECT_REQUEST));
           emitter.emit('error', eventData);
-        });
-      } else {
+        }
+      }).catch(e => {
         this.removeTransaction(id);
-        eventData.errors.push(new TransactionError(BasicTxErrorType.USER_REJECT_REQUEST));
+        eventData.errors.push(new TransactionError(BasicTxErrorType.UNABLE_TO_SIGN, t(e.message)));
         emitter.emit('error', eventData);
-      }
-    }).catch(e => {
-      this.removeTransaction(id);
-      eventData.errors.push(new TransactionError(BasicTxErrorType.UNABLE_TO_SIGN, t(e.message)));
-      emitter.emit('error', eventData);
-    });
+      });
+    }
     return emitter;
   }
   signAndSendSubstrateTransaction({

package/utils/lazy.d.ts

@@ -1,2 +1,2 @@
 export declare function removeLazy(key: string): void;
-export declare function addLazy(key: string, callback: () => void, lazyTime?: number, maxLazyTime?: number): void;
+export declare function addLazy(key: string, callback: () => void, lazyTime?: number, maxLazyTime?: number, fireOnFirst?: boolean): void;

package/utils/lazy.js

@@ -10,7 +10,7 @@ export function removeLazy(key) {
 }
 
 // Add or update new lazy thread
-export function addLazy(key, callback, lazyTime = 300, maxLazyTime = 3000) {
+export function addLazy(key, callback, lazyTime = 300, maxLazyTime = 3000, fireOnFirst = true) {
   const existed = lazyMap[key];
   const now = new Date().getTime();
   if (existed) {
@@ -33,11 +33,24 @@ export function addLazy(key, callback, lazyTime = 300, maxLazyTime = 3000) {
       }, lazyTime);
     }
   } else {
-    // Fire callback immediately in the first time
-    callback();
-    lazyMap[key] = {
-      callback,
-      lastFire: now
-    };
+    if (fireOnFirst) {
+      // Fire callback immediately in the first time
+      callback();
+      lazyMap[key] = {
+        callback,
+        lastFire: now
+      };
+    } else {
+      lazyMap[key] = {
+        callback,
+        lastFire: now
+      };
+      lazyMap[key].timeout = setTimeout(() => {
+        // This will be fire in the last call of lazy thread
+        callback();
+        lazyMap[key].lastFire = new Date().getTime();
+        removeLazy(key);
+      }, lazyTime);
+    }
   }
 }