@subwallet/extension-base 1.2.32-0 → 1.2.33-0

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

@@ -5,11 +5,13 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+var _constants = require("@subwallet/extension-base/constants");
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
-var _constants = require("@subwallet/extension-base/services/request-service/constants");
+var _constants2 = require("@subwallet/extension-base/services/request-service/constants");
 var _Authorize = _interopRequireDefault(require("@subwallet/extension-base/stores/Authorize"));
 var _utils2 = require("@subwallet/extension-base/utils");
 var _getId = require("@subwallet/extension-base/utils/getId");
+var _keyring = require("@subwallet/keyring");
 var _rxjs = require("rxjs");
 var _utilCrypto = require("@polkadot/util-crypto");
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
@@ -29,29 +31,51 @@ class AuthRequestHandler {
     this.keyringService = keyringService;
     this.#requestService = requestService;
     this.#chainService = chainService;
-    this.init().catch(console.error);
+    this.migrateAuthUrlInfoToUnified().then(() => {
+      this.init().catch(console.error);
+    }).catch(console.error);
   }
   async init() {
     const authList = await this.getAuthList();
     let needUpdateAuthList = false;
-    Object.entries(authList).forEach(_ref => {
+    const updatedAuthList = Object.entries(authList).reduce((acc, _ref) => {
       let [key, value] = _ref;
-      const existKeyAllBothConnect = _constants.DAPP_CONNECT_ALL_TYPE_ACCOUNT_URL.find(url_ => url_.includes(key));
-      if (existKeyAllBothConnect && value.accountAuthType !== 'both') {
+      const existKeyBothConnectAuthType = _constants2.DAPP_CONNECT_BOTH_TYPE_ACCOUNT_URL.some(url_ => url_.includes(key));
+      if (existKeyBothConnectAuthType && (!value.accountAuthTypes || value.accountAuthTypes.length < 2)) {
+        value.accountAuthTypes = ['evm', 'substrate'];
         needUpdateAuthList = true;
-        authList[key] = {
-          ...value,
-          accountAuthType: 'both'
-        };
       }
-    });
+      acc[key] = {
+        ...value
+      };
+      return acc;
+    }, {});
     if (needUpdateAuthList) {
-      this.setAuthorize(authList);
+      this.setAuthorize(updatedAuthList);
+    }
+  }
+  async migrateAuthUrlInfoToUnified() {
+    const authList = await this.getAuthList();
+    let needUpdateAuthList = false;
+    const updatedAuthList = Object.entries(authList).reduce((acc, _ref2) => {
+      let [key, value] = _ref2;
+      if ('accountAuthType' in value) {
+        const oldValueStructure = value;
+        needUpdateAuthList = true;
+        value.accountAuthTypes = oldValueStructure.accountAuthType === 'both' ? ['substrate', 'evm'] : [oldValueStructure.accountAuthType || 'substrate'];
+      }
+      acc[key] = {
+        ...value
+      };
+      return acc;
+    }, {});
+    if (needUpdateAuthList) {
+      this.setAuthorize(updatedAuthList);
     }
   }
   getAddressList() {
     let value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-    const addressList = Object.keys(this.keyringService.accounts);
+    const addressList = Object.keys(this.keyringService.context.pairs);
     return addressList.reduce((addressList, v) => ({
       ...addressList,
       [v]: value
@@ -61,12 +85,12 @@ class AuthRequestHandler {
     return Object.keys(this.#authRequestsV2).length;
   }
   get allAuthRequestsV2() {
-    return Object.values(this.#authRequestsV2).map(_ref2 => {
+    return Object.values(this.#authRequestsV2).map(_ref3 => {
       let {
         id,
         request,
         url
-      } = _ref2;
+      } = _ref3;
       return {
         id,
         request,
@@ -113,14 +137,14 @@ class AuthRequestHandler {
     let needEnableChains = [];
     if (options.url) {
       const domain = (0, _utils2.getDomainFromUrl)(options.url);
-      const predefinedSupportChains = _constants.PREDEFINED_CHAIN_DAPP_CHAIN_MAP[domain];
+      const predefinedSupportChains = _constants2.PREDEFINED_CHAIN_DAPP_CHAIN_MAP[domain];
       if (!defaultChain && predefinedSupportChains) {
         defaultChain = predefinedSupportChains[0];
         options.autoActive && needEnableChains.push(...predefinedSupportChains);
       }
     }
     let chainInfo;
-    if (['both', 'evm'].includes(options.accessType)) {
+    if (options.accessType === 'evm') {
       const evmChains = Object.values(chainInfoMaps).filter(_utils._isChainEvmCompatible);
       chainInfo = (defaultChain ? chainInfoMaps[defaultChain] : evmChains.find(chain => {
         var _chainStateMap$chain$;
@@ -144,7 +168,6 @@ class AuthRequestHandler {
   authCompleteV2 = (id, url, resolve, reject) => {
     const isAllowedMap = this.getAddressList();
     const complete = (result, cb, accounts) => {
-      var _this$getDAppChainInf;
       const isAllowed = result === true;
       let isCancelled = false;
       if (!isAllowed && typeof result === 'object' && result.message === 'Cancelled') {
@@ -155,11 +178,12 @@ class AuthRequestHandler {
           isAllowedMap[acc] = true;
         });
       } else {
-        // eslint-disable-next-line no-return-assign
-        Object.keys(isAllowedMap).forEach(address => isAllowedMap[address] = false);
+        Object.keys(isAllowedMap).forEach(address => {
+          isAllowedMap[address] = false;
+        });
       }
       const {
-        accountAuthType,
+        accountAuthTypes,
         idStr,
         request: {
           allowedAccounts,
@@ -167,21 +191,36 @@ class AuthRequestHandler {
         },
         url
       } = this.#authRequestsV2[id];
-      if (accountAuthType !== 'both') {
-        const isEvmType = accountAuthType === 'evm';
-        const backupAllowed = [...(allowedAccounts || [])].filter(a => {
-          const isEth = (0, _utilCrypto.isEthereumAddress)(a);
-          return isEvmType ? !isEth : isEth;
+
+      // Note: accountAuthTypes represents the accountAuthType of this request
+      //       allowedAccounts is a list of connected accounts that exist for this origin during this request.
+
+      if (accountAuthTypes.length !== _constants.ALL_ACCOUNT_AUTH_TYPES.length) {
+        const backupAllowed = (allowedAccounts || []).filter(a => {
+          if ((0, _utilCrypto.isEthereumAddress)(a) && !accountAuthTypes.includes('evm')) {
+            return true;
+          }
+          if ((0, _keyring.isSubstrateAddress)(a) && !accountAuthTypes.includes('substrate')) {
+            return true;
+          }
+          if ((0, _keyring.isTonAddress)(a) && !accountAuthTypes.includes('ton')) {
+            return true;
+          }
+          return false;
         });
         backupAllowed.forEach(acc => {
           isAllowedMap[acc] = true;
         });
       }
-      const defaultEvmNetworkKey = (_this$getDAppChainInf = this.getDAppChainInfo({
-        accessType: accountAuthType,
-        url,
-        autoActive: !isCancelled && isAllowed
-      })) === null || _this$getDAppChainInf === void 0 ? void 0 : _this$getDAppChainInf.slug;
+      let defaultEvmNetworkKey;
+      if (accountAuthTypes.includes('evm')) {
+        const chainInfo = this.getDAppChainInfo({
+          accessType: 'evm',
+          autoActive: true,
+          url
+        });
+        defaultEvmNetworkKey = chainInfo === null || chainInfo === void 0 ? void 0 : chainInfo.slug;
+      }
       this.getAuthorize(value => {
         let authorizeList = {};
         if (value) {
@@ -203,7 +242,7 @@ class AuthRequestHandler {
           isAllowedMap,
           origin,
           url,
-          accountAuthType: existed && existed.accountAuthType !== accountAuthType ? 'both' : accountAuthType,
+          accountAuthTypes: [...new Set([...accountAuthTypes, ...((existed === null || existed === void 0 ? void 0 : existed.accountAuthTypes) || [])])],
           currentEvmNetworkKey: existed ? existed.currentEvmNetworkKey : defaultEvmNetworkKey
         };
         this.setAuthorize(authorizeList, () => {
@@ -219,11 +258,11 @@ class AuthRequestHandler {
           reject(error);
         });
       },
-      resolve: _ref3 => {
+      resolve: _ref4 => {
         let {
           accounts,
           result
-        } = _ref3;
+        } = _ref4;
         complete(result, () => {
           resolve(result);
         }, accounts);
@@ -234,9 +273,8 @@ class AuthRequestHandler {
   async authorizeUrlV2(url, request) {
     let authList = await this.getAuthList();
     const idStr = (0, _utils2.stripUrl)(url);
-    const isAllowedDappConnectAllType = !!_constants.DAPP_CONNECT_ALL_TYPE_ACCOUNT_URL.find(url_ => url.includes(url_));
-    let accountAuthType = isAllowedDappConnectAllType ? 'both' : request.accountAuthType || 'substrate';
-    request.accountAuthType = accountAuthType;
+    const isAllowedDappConnectBothType = !!_constants2.DAPP_CONNECT_BOTH_TYPE_ACCOUNT_URL.find(url_ => url.includes(url_));
+    let accountAuthTypes = [...new Set(isAllowedDappConnectBothType ? ['evm', 'substrate'] : request.accountAuthTypes || ['substrate'])];
     if (!authList) {
       authList = {};
     }
@@ -247,9 +285,10 @@ class AuthRequestHandler {
       reject,
       resolve
     } = promiseHandler;
-    const isExistedAuthBothBefore = Object.entries(this.authorizeUrlSubject.value).find(_ref4 => {
-      let [key, data] = _ref4;
-      return key === idStr && data.accountAuthType === 'both';
+    const isExistedAuthBothBefore = Object.entries(this.authorizeUrlSubject.value).find(_ref5 => {
+      var _data$accountAuthType;
+      let [key, data] = _ref5;
+      return key === idStr && ((_data$accountAuthType = data.accountAuthTypes) === null || _data$accountAuthType === void 0 ? void 0 : _data$accountAuthType.length) === _constants.ALL_ACCOUNT_AUTH_TYPES.length;
     });
     if (isExistedAuthBothBefore) {
       return true;
@@ -264,12 +303,12 @@ class AuthRequestHandler {
 
     // Do not enqueue duplicate authorization requests.
     const mergeKeys = [];
-    Object.entries(this.#authRequestsV2).forEach(_ref5 => {
-      let [key, _request] = _ref5;
+    Object.entries(this.#authRequestsV2).forEach(_ref6 => {
+      let [key, _request] = _ref6;
       if (_request.idStr === idStr) {
-        if (_request.accountAuthType !== request.accountAuthType) {
-          request.accountAuthType = 'both';
-          accountAuthType = 'both';
+        if (accountAuthTypes && _request.accountAuthTypes) {
+          const filteredAccountAuthTypes = new Set([..._request.accountAuthTypes, ...accountAuthTypes]);
+          accountAuthTypes = [...filteredAccountAuthTypes];
         }
         mergeKeys.push(key);
       }
@@ -284,8 +323,8 @@ class AuthRequestHandler {
       });
     }
     const existedAuth = authList[idStr];
-    const existedAccountAuthType = existedAuth === null || existedAuth === void 0 ? void 0 : existedAuth.accountAuthType;
-    const confirmAnotherType = existedAccountAuthType !== 'both' && existedAccountAuthType !== request.accountAuthType;
+    const existedAccountAuthType = existedAuth === null || existedAuth === void 0 ? void 0 : existedAuth.accountAuthTypes;
+    const confirmAnotherType = !existedAccountAuthType || accountAuthTypes.some(type => !existedAccountAuthType.includes(type));
     if (request.reConfirm && existedAuth) {
       request.origin = existedAuth.origin;
     }
@@ -296,16 +335,21 @@ class AuthRequestHandler {
       if (inBlackList) {
         throw new Error('The source {{url}} is not allowed to interact with this extension'.replace('{{url}}', url));
       }
-      request.allowedAccounts = Object.entries(existedAuth.isAllowedMap).map(_ref6 => {
-        let [address, allowed] = _ref6;
+      request.allowedAccounts = Object.entries(existedAuth.isAllowedMap).map(_ref7 => {
+        let [address, allowed] = _ref7;
         return allowed ? address : '';
       }).filter(item => item !== '');
       let allowedListByRequestType = [...request.allowedAccounts];
-      if (accountAuthType === 'evm') {
-        allowedListByRequestType = allowedListByRequestType.filter(a => (0, _utilCrypto.isEthereumAddress)(a));
-      } else if (accountAuthType === 'substrate') {
-        allowedListByRequestType = allowedListByRequestType.filter(a => !(0, _utilCrypto.isEthereumAddress)(a));
-      }
+      allowedListByRequestType = accountAuthTypes.reduce((list, accountAuthType) => {
+        if (accountAuthType === 'evm') {
+          list.push(...allowedListByRequestType.filter(a => (0, _utilCrypto.isEthereumAddress)(a)));
+        } else if (accountAuthType === 'substrate') {
+          list.push(...allowedListByRequestType.filter(a => (0, _keyring.isSubstrateAddress)(a)));
+        } else if (accountAuthType === 'ton') {
+          list.push(...allowedListByRequestType.filter(a => (0, _keyring.isTonAddress)(a)));
+        }
+        return list;
+      }, []);
       if (!confirmAnotherType && !request.reConfirm && allowedListByRequestType.length !== 0) {
         // Prevent appear confirmation popup
         return false;
@@ -314,7 +358,7 @@ class AuthRequestHandler {
       // Auto auth for web app
 
       // Ignore white list
-      const isWhiteList = _constants.WEB_APP_URL.some(url => idStr.includes(url)) && false;
+      const isWhiteList = _constants2.WEB_APP_URL.some(url => idStr.includes(url)) && false;
       if (isWhiteList) {
         const isAllowedMap = this.getAddressList(true);
         authList[(0, _utils2.stripUrl)(url)] = {
@@ -324,7 +368,7 @@ class AuthRequestHandler {
           isAllowedMap,
           origin,
           url,
-          accountAuthType: 'both'
+          accountAuthTypes: _constants.ALL_ACCOUNT_AUTH_TYPES
         };
         this.setAuthorize(authList);
         return true;
@@ -334,9 +378,12 @@ class AuthRequestHandler {
       ...this.authCompleteV2(id, url, resolve, reject),
       id,
       idStr,
-      request,
+      request: {
+        ...request,
+        accountAuthTypes
+      },
       url,
-      accountAuthType: accountAuthType
+      accountAuthTypes: accountAuthTypes || ['substrate']
     };
     this.updateIconAuthV2();
     if (Object.keys(this.#authRequestsV2).length < 2 && !(mergeKeys.length > 0 && mergeKeys[mergeKeys.length - 1] !== id)) {

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

@@ -114,11 +114,10 @@ class EvmRequestHandler {
   }
   async signMessage(confirmation) {
     const {
-      account,
+      address,
       payload,
       type
     } = confirmation.payload;
-    const address = account.address;
     const pair = _uiKeyring.default.getPair(address);
     if (pair.isLocked) {
       _uiKeyring.default.unlockPair(pair.address);
@@ -130,7 +129,7 @@ class EvmRequestHandler {
       case 'eth_signTypedData_v1':
       case 'eth_signTypedData_v3':
       case 'eth_signTypedData_v4':
-        return await pair.evmSigner.signMessage(payload, type);
+        return await pair.evm.signMessage(payload, type);
       default:
         throw new _EvmProviderError.EvmProviderError(_KoniTypes.EvmProviderErrorType.INVALID_PARAMS, (0, _i18next.t)('Unsupported action'));
     }
@@ -208,7 +207,7 @@ class EvmRequestHandler {
     if (pair.isLocked) {
       _uiKeyring.default.unlockPair(pair.address);
     }
-    return pair.evmSigner.signTransaction(tx);
+    return pair.evm.signTransaction(tx);
   }
   async decorateResult(t, request, result) {
     if (result.payload === '') {

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

@@ -8,7 +8,6 @@ exports.default = void 0;
 var _RequestExtrinsicSign = _interopRequireDefault(require("@subwallet/extension-base/background/RequestExtrinsicSign"));
 var _getId = require("@subwallet/extension-base/utils/getId");
 var _request = require("@subwallet/extension-base/utils/request");
-var _uiKeyring = _interopRequireDefault(require("@subwallet/ui-keyring"));
 var _rxjs = require("rxjs");
 var _logger = require("@polkadot/util/logger");
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
@@ -29,13 +28,13 @@ class SubstrateRequestHandler {
   get allSubstrateRequests() {
     return Object.values(this.#substrateRequests).map(_ref => {
       let {
-        account,
+        address,
         id,
         request,
         url
       } = _ref;
       return {
-        account,
+        address,
         id,
         request,
         url,
@@ -67,7 +66,7 @@ class SubstrateRequestHandler {
   get numSubstrateRequests() {
     return Object.keys(this.#substrateRequests).length;
   }
-  async sign(url, request, account, _id) {
+  async sign(url, request, _id) {
     const id = _id || (0, _getId.getId)();
     const isAlwaysRequired = await this.#requestService.settingService.isAlwaysRequired;
     if (isAlwaysRequired) {
@@ -76,7 +75,7 @@ class SubstrateRequestHandler {
     return new Promise((resolve, reject) => {
       this.#substrateRequests[id] = {
         ...this.signComplete(id, resolve, reject),
-        account,
+        address: request.payload.address,
         id,
         request,
         url
@@ -91,14 +90,9 @@ class SubstrateRequestHandler {
       this.#requestService.keyringService.lock();
     }
     return new Promise((resolve, reject) => {
-      const pair = _uiKeyring.default.getPair(address);
-      const account = {
-        address: pair.address,
-        ...pair.meta
-      };
       this.#substrateRequests[id] = {
         ...this.signComplete(id, resolve, reject),
-        account,
+        address,
         id,
         request: new _RequestExtrinsicSign.default(payload),
         url: url

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

@@ -0,0 +1,175 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _request = require("@subwallet/extension-base/utils/request");
+var _uiKeyring = require("@subwallet/ui-keyring");
+var _core = require("@ton/core");
+var _i18next = require("i18next");
+var _rxjs = require("rxjs");
+var _util = require("@polkadot/util");
+var _logger = require("@polkadot/util/logger");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class TonRequestHandler {
+  #requestService;
+  #logger;
+  confirmationsQueueSubjectTon = new _rxjs.BehaviorSubject({
+    tonSignatureRequest: {},
+    tonSendTransactionRequest: {},
+    tonWatchTransactionRequest: {}
+  });
+  confirmationsPromiseMap = {};
+  constructor(requestService) {
+    this.#requestService = requestService;
+    this.#logger = (0, _logger.logger)('TonRequestHandler');
+  }
+  get numTonRequests() {
+    let count = 0;
+    Object.values(this.confirmationsQueueSubjectTon.getValue()).forEach(x => {
+      count += Object.keys(x).length;
+    });
+    return count;
+  }
+  getConfirmationsQueueSubjectTon() {
+    return this.confirmationsQueueSubjectTon;
+  }
+  async addConfirmationTon(id, url, type, payload) {
+    let options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+    let validator = arguments.length > 5 ? arguments[5] : undefined;
+    const confirmations = this.confirmationsQueueSubjectTon.getValue();
+    const confirmationType = confirmations[type];
+    const payloadJson = JSON.stringify({});
+    const isInternal = (0, _request.isInternalRequest)(url);
+    if (['tonSendTransactionRequest', 'tonSignatureRequest'].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 Error('Ton duplicate request'); // update this message.
+    }
+
+    confirmationType[id] = {
+      id,
+      url,
+      isInternal,
+      payload,
+      payloadJson,
+      ...options
+    };
+    const promise = new Promise((resolve, reject) => {
+      this.confirmationsPromiseMap[id] = {
+        validator: validator,
+        resolver: {
+          resolve: resolve,
+          reject: reject
+        }
+      };
+    });
+    this.confirmationsQueueSubjectTon.next(confirmations);
+    if (!isInternal) {
+      this.#requestService.popupOpen();
+    }
+    this.#requestService.updateIconV2();
+    return promise;
+  }
+  async completeConfirmationTon(request) {
+    const confirmations = this.confirmationsQueueSubjectTon.getValue();
+    for (const ct in request) {
+      const type = ct;
+      const result = request[type];
+      const {
+        id
+      } = result;
+      const {
+        resolver,
+        validator
+      } = this.confirmationsPromiseMap[id];
+      const confirmation = confirmations[type][id];
+      if (!resolver || !confirmation) {
+        this.#logger.error((0, _i18next.t)('Unable to proceed. Please try again'), type, id);
+        throw new Error((0, _i18next.t)('Unable to proceed. Please try again'));
+      }
+
+      // Fill signature for some special type
+      await this.decorateResult(type, confirmation, result);
+
+      // Validate response from confirmation popup some info like password, response format....
+      const error = validator && validator(result);
+      if (error) {
+        resolver.reject(error);
+      }
+
+      // Delete confirmations from queue
+      delete this.confirmationsPromiseMap[id];
+      delete confirmations[type][id];
+      this.confirmationsQueueSubjectTon.next(confirmations);
+
+      // Update icon, and close queue
+      this.#requestService.updateIconV2(this.#requestService.numAllRequests === 0);
+      resolver.resolve(result);
+    }
+
+    // TODO: Review later
+    return true;
+  }
+  async decorateResult(t, request, result) {
+    if (result.payload === '') {
+      if (t === 'tonSignatureRequest') {
+        // result.payload = await this.signMessage(request as ConfirmationDefinitions['evmSignatureRequest'][0]);
+      } else if (t === 'tonSendTransactionRequest') {
+        result.payload = this.signTransactionTon(request);
+      }
+      if (t === 'tonSignatureRequest' || t === 'tonSendTransactionRequest') {
+        const isAlwaysRequired = await this.#requestService.settingService.isAlwaysRequired;
+        if (isAlwaysRequired) {
+          this.#requestService.keyringService.lock();
+        }
+      }
+    }
+  }
+  signTransactionTon(confirmation) {
+    const transaction = confirmation.payload;
+    const {
+      from,
+      messagePayload
+    } = transaction;
+    const pair = _uiKeyring.keyring.getPair(from);
+    if (pair.isLocked) {
+      _uiKeyring.keyring.unlockPair(pair.address);
+    }
+    const messages = _core.Cell.fromBase64(messagePayload);
+    const signedTransaction = pair.ton.sign(messages);
+    return (0, _util.u8aToHex)(Uint8Array.from(signedTransaction));
+  }
+  resetWallet() {
+    const confirmations = this.confirmationsQueueSubjectTon.getValue();
+    for (const [type, requests] of Object.entries(confirmations)) {
+      for (const confirmation of Object.values(requests)) {
+        const {
+          id
+        } = confirmation;
+        const {
+          resolver
+        } = this.confirmationsPromiseMap[id];
+        if (!resolver || !confirmation) {
+          console.error('Not found confirmation', type, id);
+        } else {
+          resolver.reject(new Error('Reset wallet'));
+        }
+        delete this.confirmationsPromiseMap[id];
+        delete confirmations[type][id];
+      }
+    }
+    this.confirmationsQueueSubjectTon.next(confirmations);
+  }
+}
+exports.default = TonRequestHandler;