@subwallet/extension-base 0.8.3-2 → 1.0.1

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

@@ -0,0 +1,269 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _Authorize = _interopRequireDefault(require("@subwallet/extension-base/stores/Authorize"));
+var _getId = require("@subwallet/extension-base/utils/getId");
+var _accounts = require("@subwallet/ui-keyring/observable/accounts");
+var _rxjs = require("rxjs");
+var _util = require("@polkadot/util");
+var _utilCrypto = require("@polkadot/util-crypto");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const AUTH_URLS_KEY = 'authUrls';
+class AuthRequestHandler {
+  #requestService;
+  #chainService;
+  authorizeStore = new _Authorize.default();
+  #authRequestsV2 = {};
+  authorizeCached = undefined;
+  authorizeUrlSubject = new _rxjs.Subject();
+  evmChainSubject = new _rxjs.Subject();
+  authSubjectV2 = new _rxjs.BehaviorSubject([]);
+  constructor(requestService, chainService) {
+    this.#requestService = requestService;
+    this.#chainService = chainService;
+  }
+  stripUrl(url) {
+    (0, _util.assert)(url && (url.startsWith('http:') || url.startsWith('https:') || url.startsWith('ipfs:') || url.startsWith('ipns:')), `Invalid url ${url}, expected to start with http: or https: or ipfs: or ipns:`);
+    const parts = url.split('/');
+    return parts[2];
+  }
+  getAddressList() {
+    let value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    const addressList = Object.keys(_accounts.accounts.subject.value);
+    return addressList.reduce((addressList, v) => ({
+      ...addressList,
+      [v]: value
+    }), {});
+  }
+  get numAuthRequestsV2() {
+    return Object.keys(this.#authRequestsV2).length;
+  }
+  get allAuthRequestsV2() {
+    return Object.values(this.#authRequestsV2).map(_ref => {
+      let {
+        id,
+        request,
+        url
+      } = _ref;
+      return {
+        id,
+        request,
+        url
+      };
+    });
+  }
+  updateIconAuthV2(shouldClose) {
+    this.authSubjectV2.next(this.allAuthRequestsV2);
+    this.#requestService.updateIconV2(shouldClose);
+  }
+  setAuthorize(data, callback) {
+    this.authorizeStore.set(AUTH_URLS_KEY, data, () => {
+      this.authorizeCached = data;
+      this.evmChainSubject.next(this.authorizeCached);
+      this.authorizeUrlSubject.next(this.authorizeCached);
+      callback && callback();
+    });
+  }
+  getAuthorize(update) {
+    // This action can be use many by DApp interaction => caching it in memory
+    if (this.authorizeCached) {
+      update(this.authorizeCached);
+    } else {
+      this.authorizeStore.get('authUrls', data => {
+        this.authorizeCached = data;
+        update(this.authorizeCached);
+      });
+    }
+  }
+  getAuthList() {
+    return new Promise((resolve, reject) => {
+      this.getAuthorize(rs => {
+        resolve(rs);
+      });
+    });
+  }
+  authCompleteV2 = (id, resolve, reject) => {
+    const isAllowedMap = this.getAddressList();
+    const complete = (result, cb, accounts) => {
+      const isAllowed = result === true;
+      let isCancelled = false;
+      if (!isAllowed && typeof result === 'object' && result.message === 'Cancelled') {
+        isCancelled = true;
+      }
+      if (accounts && accounts.length) {
+        accounts.forEach(acc => {
+          isAllowedMap[acc] = true;
+        });
+      } else {
+        // eslint-disable-next-line no-return-assign
+        Object.keys(isAllowedMap).forEach(address => isAllowedMap[address] = false);
+      }
+      const {
+        accountAuthType,
+        idStr,
+        request: {
+          allowedAccounts,
+          origin
+        },
+        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;
+        });
+        backupAllowed.forEach(acc => {
+          isAllowedMap[acc] = true;
+        });
+      }
+      let defaultEvmNetworkKey;
+      if (accountAuthType === 'both' || accountAuthType === 'evm') {
+        const defaultChain = Object.values(this.#chainService.getChainInfoMap()).find(chainInfo => {
+          const chainState = this.#chainService.getChainStateByKey(chainInfo.slug);
+          return (0, _utils._isChainEvmCompatible)(chainInfo) && (0, _utils._isChainEnabled)(chainState);
+        });
+        if (defaultChain) {
+          defaultEvmNetworkKey = defaultChain.slug;
+        }
+      }
+      this.getAuthorize(value => {
+        let authorizeList = {};
+        if (value) {
+          authorizeList = value;
+        }
+        const existed = authorizeList[this.stripUrl(url)];
+
+        // On cancel don't save anything
+        if (isCancelled) {
+          delete this.#authRequestsV2[id];
+          this.updateIconAuthV2(true);
+          cb();
+          return;
+        }
+        authorizeList[this.stripUrl(url)] = {
+          count: 0,
+          id: idStr,
+          isAllowed,
+          isAllowedMap,
+          origin,
+          url,
+          accountAuthType: existed && existed.accountAuthType !== accountAuthType ? 'both' : accountAuthType,
+          currentEvmNetworkKey: existed ? existed.currentEvmNetworkKey : defaultEvmNetworkKey
+        };
+        this.setAuthorize(authorizeList, () => {
+          cb();
+          delete this.#authRequestsV2[id];
+          this.updateIconAuthV2(true);
+        });
+      });
+    };
+    return {
+      reject: error => {
+        complete(error, () => {
+          reject(error);
+        });
+      },
+      resolve: _ref2 => {
+        let {
+          accounts,
+          result
+        } = _ref2;
+        complete(result, () => {
+          resolve(result);
+        }, accounts);
+      }
+    };
+  };
+  async authorizeUrlV2(url, request) {
+    let authList = await this.getAuthList();
+    const accountAuthType = request.accountAuthType || 'substrate';
+    request.accountAuthType = accountAuthType;
+    if (!authList) {
+      authList = {};
+    }
+    const idStr = this.stripUrl(url);
+    // Do not enqueue duplicate authorization requests.
+    const isDuplicate = Object.values(this.#authRequestsV2).some(request => request.idStr === idStr);
+    (0, _util.assert)(!isDuplicate, `The source ${url} has a pending authorization request`);
+    const existedAuth = authList[idStr];
+    const existedAccountAuthType = existedAuth === null || existedAuth === void 0 ? void 0 : existedAuth.accountAuthType;
+    const confirmAnotherType = existedAccountAuthType !== 'both' && existedAccountAuthType !== request.accountAuthType;
+    if (request.reConfirm && existedAuth) {
+      request.origin = existedAuth.origin;
+    }
+
+    // Reconfirm if check auth for empty list
+    if (existedAuth) {
+      const inBlackList = existedAuth && !existedAuth.isAllowed;
+      if (inBlackList) {
+        throw new Error(`The source ${url} is not allowed to interact with this extension`);
+      }
+      request.allowedAccounts = Object.entries(existedAuth.isAllowedMap).map(_ref3 => {
+        let [address, allowed] = _ref3;
+        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));
+      }
+      if (!confirmAnotherType && !request.reConfirm && allowedListByRequestType.length !== 0) {
+        // Prevent appear confirmation popup
+        return false;
+      }
+    }
+    return new Promise((resolve, reject) => {
+      const id = (0, _getId.getId)();
+      this.#authRequestsV2[id] = {
+        ...this.authCompleteV2(id, resolve, reject),
+        id,
+        idStr,
+        request,
+        url,
+        accountAuthType: accountAuthType
+      };
+      this.updateIconAuthV2();
+      if (Object.keys(this.#authRequestsV2).length < 2) {
+        this.#requestService.popupOpen();
+      }
+    });
+  }
+  getAuthRequestV2(id) {
+    return this.#authRequestsV2[id];
+  }
+  get subscribeEvmChainChange() {
+    return this.evmChainSubject;
+  }
+  get subscribeAuthorizeUrlSubject() {
+    return this.authorizeUrlSubject;
+  }
+  ensureUrlAuthorizedV2(url) {
+    const idStr = this.stripUrl(url);
+    return new Promise((resolve, reject) => {
+      this.getAuthorize(value => {
+        if (!value) {
+          value = {};
+        }
+        const entry = Object.keys(value).includes(idStr);
+        if (!entry) {
+          reject(new Error(`The source ${url} has not been enabled yet`));
+        }
+        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`));
+        }
+        resolve(true);
+      });
+    });
+  }
+}
+exports.default = AuthRequestHandler;

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

@@ -0,0 +1,217 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _common = _interopRequireDefault(require("@ethereumjs/common"));
+var _EvmProviderError = require("@subwallet/extension-base/background/errors/EvmProviderError");
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _eth = require("@subwallet/extension-base/utils/eth");
+var _request = require("@subwallet/extension-base/utils/request");
+var _uiKeyring = _interopRequireDefault(require("@subwallet/ui-keyring"));
+var _bn = _interopRequireDefault(require("bn.js"));
+var _ethereumjsTx = require("ethereumjs-tx");
+var _ethereumjsUtil = require("ethereumjs-util");
+var _rxjs = require("rxjs");
+var _util = require("@polkadot/util");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class EvmRequestHandler {
+  #requestService;
+  #logger;
+  confirmationsQueueSubject = new _rxjs.BehaviorSubject({
+    addNetworkRequest: {},
+    addTokenRequest: {},
+    switchNetworkRequest: {},
+    evmSignatureRequest: {},
+    evmSendTransactionRequest: {}
+  });
+  confirmationsPromiseMap = {};
+  constructor(requestService) {
+    this.#requestService = requestService;
+    this.#logger = (0, _util.logger)('EvmRequestHandler');
+  }
+  get numEvmRequests() {
+    let count = 0;
+    Object.values(this.confirmationsQueueSubject.getValue()).forEach(x => {
+      count += Object.keys(x).length;
+    });
+    return count;
+  }
+  getConfirmationsQueueSubject() {
+    return this.confirmationsQueueSubject;
+  }
+  addConfirmation(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.confirmationsQueueSubject.getValue();
+    const confirmationType = confirmations[type];
+    const payloadJson = JSON.stringify(payload);
+    const isInternal = (0, _request.isInternalRequest)(url);
+
+    // Check duplicate request
+    const duplicated = Object.values(confirmationType).find(c => c.url === url && c.payloadJson === payloadJson);
+    if (duplicated) {
+      throw new _EvmProviderError.EvmProviderError(_KoniTypes.EvmProviderErrorType.INVALID_PARAMS, 'Duplicate request information');
+    }
+    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.confirmationsQueueSubject.next(confirmations);
+    if (!isInternal) {
+      // Not open new popup and use existed
+      const popupList = this.#requestService.popup;
+      if (this.#requestService.popup.length > 0) {
+        // eslint-disable-next-line no-void
+        void chrome.windows.update(popupList[0], {
+          focused: true
+        });
+      } else {
+        this.#requestService.popupOpen();
+      }
+    }
+    this.#requestService.updateIconV2();
+    return promise;
+  }
+  async signMessage(confirmation) {
+    const {
+      account,
+      payload,
+      type
+    } = confirmation.payload;
+    const address = account.address;
+    const pair = _uiKeyring.default.getPair(address);
+    if (pair.isLocked) {
+      _uiKeyring.default.unlockPair(pair.address);
+    }
+    switch (type) {
+      case 'eth_sign':
+      case 'personal_sign':
+      case 'eth_signTypedData':
+      case 'eth_signTypedData_v1':
+      case 'eth_signTypedData_v3':
+      case 'eth_signTypedData_v4':
+        return await pair.evmSigner.signMessage(payload, type);
+      default:
+        throw new _EvmProviderError.EvmProviderError(_KoniTypes.EvmProviderErrorType.INVALID_PARAMS, 'Not found sign method');
+    }
+  }
+  configToTransaction(config) {
+    function formatField(input) {
+      if (typeof input === 'string') {
+        if (input.startsWith('0x')) {
+          return input;
+        } else {
+          return new _bn.default(input);
+        }
+      }
+      return input;
+    }
+
+    // Convert any string, number to number with BigN exclude hex string
+    const txData = {
+      from: config.from,
+      nonce: formatField(config.nonce),
+      gasPrice: formatField(config.gasPrice),
+      gasLimit: formatField(config.gas),
+      to: config.to,
+      value: formatField(config.value),
+      data: (0, _ethereumjsUtil.toBuffer)(config.data)
+    };
+    const common = _common.default.custom({
+      chainId: config.chainId
+    });
+
+    // @ts-ignore
+    return new _ethereumjsTx.Transaction(txData, {
+      common
+    });
+  }
+  async signTransaction(confirmation) {
+    const transaction = confirmation.payload;
+    const {
+      estimateGas,
+      from,
+      gasPrice
+    } = transaction;
+    const pair = _uiKeyring.default.getPair(from);
+    const params = {
+      ...transaction,
+      gasPrice: (0, _eth.anyNumberToBN)(gasPrice).toNumber(),
+      gasLimit: (0, _eth.anyNumberToBN)(estimateGas).toNumber()
+      // nonce: await web3.eth.getTransactionCount(from) // Todo: fill this value from transaction service
+    };
+
+    const tx = this.configToTransaction(params);
+    await Promise.resolve();
+    if (pair.isLocked) {
+      _uiKeyring.default.unlockPair(pair.address);
+    }
+    return pair.evmSigner.signTransaction(tx);
+  }
+  async decorateResult(t, request, result) {
+    if (result.payload === '') {
+      if (t === 'evmSignatureRequest') {
+        result.payload = await this.signMessage(request);
+      } else if (t === 'evmSendTransactionRequest') {
+        result.payload = await this.signTransaction(request);
+      }
+    }
+  }
+  async completeConfirmation(request) {
+    const confirmations = this.confirmationsQueueSubject.getValue();
+    for (const ct in request) {
+      const t = ct;
+      const result = request[t];
+      const {
+        id
+      } = result;
+      const {
+        resolver,
+        validator
+      } = this.confirmationsPromiseMap[id];
+      const confirmation = confirmations[t][id];
+      if (!resolver || !confirmation) {
+        this.#logger.error('Not found confirmation', t, id);
+        throw new Error('Not found promise for confirmation');
+      }
+
+      // Fill signature for some special type
+      await this.decorateResult(t, 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[t][id];
+      this.confirmationsQueueSubject.next(confirmations);
+
+      // Update icon, and close queue
+      this.#requestService.updateIconV2(this.#requestService.numAllRequests === 0);
+      resolver.resolve(result);
+    }
+    return true;
+  }
+}
+exports.default = EvmRequestHandler;

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

@@ -0,0 +1,85 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _helper = require("@subwallet/extension-base/services/request-service/helper");
+var _stores = require("@subwallet/extension-base/stores");
+var _getId = require("@subwallet/extension-base/utils/getId");
+var _extensionChains = require("@subwallet/extension-chains");
+var _rxjs = require("rxjs");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class MetadataRequestHandler {
+  #requestService;
+  #metaStore = new _stores.MetadataStore();
+  #metaRequests = {};
+  metaSubject = new _rxjs.BehaviorSubject([]);
+  constructor(requestService) {
+    this.#requestService = requestService;
+    (0, _helper.extractMetadata)(this.#metaStore);
+  }
+  get knownMetadata() {
+    return (0, _extensionChains.knownMetadata)();
+  }
+  get allMetaRequests() {
+    return Object.values(this.#metaRequests).map(_ref => {
+      let {
+        id,
+        request,
+        url
+      } = _ref;
+      return {
+        id,
+        request,
+        url
+      };
+    });
+  }
+  get numMetaRequests() {
+    return Object.keys(this.#metaRequests).length;
+  }
+  getMetaRequest(id) {
+    return this.#metaRequests[id];
+  }
+  saveMetadata(meta) {
+    this.#metaStore.set(meta.genesisHash, meta);
+    (0, _extensionChains.addMetadata)(meta);
+  }
+  updateIconMeta(shouldClose) {
+    this.metaSubject.next(this.allMetaRequests);
+    this.#requestService.updateIconV2(shouldClose);
+  }
+  metaComplete = (id, resolve, reject) => {
+    const complete = () => {
+      delete this.#metaRequests[id];
+      this.updateIconMeta(true);
+    };
+    return {
+      reject: error => {
+        complete();
+        reject(error);
+      },
+      resolve: result => {
+        complete();
+        resolve(result);
+      }
+    };
+  };
+  injectMetadata(url, request) {
+    return new Promise((resolve, reject) => {
+      const id = (0, _getId.getId)();
+      this.#metaRequests[id] = {
+        ...this.metaComplete(id, resolve, reject),
+        id,
+        request,
+        url
+      };
+      this.updateIconMeta();
+      this.#requestService.popupOpen();
+    });
+  }
+}
+exports.default = MetadataRequestHandler;

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

@@ -0,0 +1,86 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _helpers = require("@subwallet/extension-base/background/handlers/helpers");
+var _helper = require("@subwallet/extension-base/services/request-service/helper");
+var _constants = require("@subwallet/extension-base/services/setting-service/constants");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const NOTIFICATION_URL = chrome.extension.getURL('notification.html');
+const OS = (0, _helper.getOS)();
+const extraHeight = OS === 'Linux' ? 0 : 28;
+const extraWidth = OS === 'Windows' ? 16 : 0;
+const POPUP_WINDOW_OPTS = {
+  focused: true,
+  height: 600 + extraHeight,
+  type: 'popup',
+  url: NOTIFICATION_URL,
+  width: 390 + extraWidth
+};
+const NORMAL_WINDOW_OPTS = {
+  focused: true,
+  type: 'normal',
+  url: NOTIFICATION_URL
+};
+class PopupHandler {
+  #requestService;
+  #notification = _constants.DEFAULT_NOTIFICATION_TYPE;
+  #windows = [];
+  constructor(requestService) {
+    this.#requestService = requestService;
+    const updateNotification = rs => {
+      this.#notification = rs.browserConfirmationType;
+    };
+    requestService.settingService.getSettings(updateNotification);
+    requestService.settingService.getSubject().subscribe({
+      next: updateNotification
+    });
+  }
+  updateIconV2(shouldClose) {
+    const numRequests = this.#requestService.numRequests;
+    const text = numRequests > 0 ? numRequests.toString() : '';
+    (0, _helpers.withErrorLog)(() => {
+      var _chrome$browserAction;
+      return (_chrome$browserAction = chrome.browserAction) === null || _chrome$browserAction === void 0 ? void 0 : _chrome$browserAction.setBadgeText({
+        text
+      });
+    });
+    if (shouldClose && text === '') {
+      this.popupClose();
+    }
+  }
+  get popup() {
+    return this.#windows;
+  }
+  popupClose() {
+    this.#windows.forEach(id => (0, _helpers.withErrorLog)(() => chrome.windows.remove(id)));
+    this.#windows = [];
+  }
+  popupOpen() {
+    if (this.#notification !== 'extension') {
+      chrome.windows.getCurrent(win => {
+        const popupOptions = {
+          ...(this.#notification === 'window' ? {
+            ...NORMAL_WINDOW_OPTS,
+            width: win.width,
+            height: win.height
+          } : POPUP_WINDOW_OPTS)
+        };
+        if (win) {
+          popupOptions.left = (win.left || 0) + (win.width || 0) - (popupOptions.width || 0) - 20;
+          popupOptions.top = (win.top || 0) + 80;
+        }
+        chrome.windows.create(popupOptions, window => {
+          if (window) {
+            this.#windows.push(window.id || 0);
+          }
+        });
+      });
+    }
+  }
+}
+exports.default = PopupHandler;