@subwallet/extension-base 1.1.11-1 → 1.1.12-1

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/setting-service/SettingService.js

@@ -11,13 +11,17 @@ export default class SettingService {
   passPhishingStore = new PassPhishingStore();
   constructor() {
     let old = localStorage.getItem(LANGUAGE) || 'en';
-    this.settingsStore.getSubject().subscribe(({
+    const updateLanguage = ({
       language
     }) => {
       if (language !== old) {
         old = language;
         i18n.changeLanguage(language).catch(console.error);
       }
+    };
+    this.getSettings(updateLanguage);
+    this.settingsStore.getSubject().subscribe({
+      next: updateLanguage
     });
   }
   getSubject() {

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);
+    }
   }
 }