@subwallet/extension-base 0.8.4-0 → 1.0.2-1

package/cjs/services/migration-service/scripts/MigrateTransactionHistory.js

@@ -0,0 +1,72 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _Base = _interopRequireDefault(require("@subwallet/extension-base/services/migration-service/Base"));
+var _dexie = _interopRequireDefault(require("dexie"));
+var _utilCrypto = require("@polkadot/util-crypto");
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class MigrateTransactionHistory extends _Base.default {
+  async run() {
+    const state = this.state;
+    const chainInfoMap = state.getChainInfoMap();
+    const assetList = Object.values(state.getAssetRegistry());
+    try {
+      const db = new _dexie.default('SubWalletDB');
+      const dexieDB = await db.open();
+      const transactionTable = dexieDB.table('transactions');
+      const oldTransactionData = await transactionTable.toArray();
+      const newTransactionItems = [];
+      oldTransactionData.forEach(item => {
+        const chainInfo = chainInfoMap[item.networkKey];
+        if (!chainInfo) {
+          return;
+        }
+        const direction = item.action === 'send' ? _KoniTypes.TransactionDirection.SEND : _KoniTypes.TransactionDirection.RECEIVED;
+        const extrinsicType = item.changeSymbol === item.feeSymbol ? _KoniTypes.ExtrinsicType.TRANSFER_BALANCE : _KoniTypes.ExtrinsicType.TRANSFER_TOKEN;
+        const nativeAsset = (0, _utils._getChainNativeTokenBasicInfo)(chainInfo);
+        const transferAsset = assetList.find(a => a.originChain === item.networkKey && a.symbol === item.changeSymbol) || nativeAsset;
+        const newItem = {
+          chain: item.networkKey,
+          origin: 'migration',
+          type: extrinsicType,
+          address: item.address,
+          extrinsicHash: item.extrinsicHash,
+          time: item.time,
+          status: item.isSuccess ? _KoniTypes.ExtrinsicStatus.SUCCESS : _KoniTypes.ExtrinsicStatus.FAIL,
+          from: direction === _KoniTypes.TransactionDirection.SEND ? item.address : '',
+          to: direction === _KoniTypes.TransactionDirection.RECEIVED ? item.address : '',
+          amount: {
+            value: item.change,
+            decimals: transferAsset.decimals || 18,
+            symbol: transferAsset.symbol
+          },
+          fee: {
+            value: item.fee,
+            decimals: nativeAsset.decimals,
+            symbol: nativeAsset.symbol
+          },
+          direction: direction,
+          chainType: (0, _utilCrypto.isEthereumAddress)(item.address) ? _KoniTypes.ChainType.EVM : _KoniTypes.ChainType.SUBSTRATE,
+          chainName: chainInfo.name,
+          blockNumber: 0,
+          blockHash: '',
+          data: '',
+          signature: ''
+        };
+        newTransactionItems.push(newItem);
+      });
+      await state.historyService.addHistoryItems(newTransactionItems);
+    } catch (e) {
+      this.logger.error(e);
+    }
+  }
+}
+exports.default = MigrateTransactionHistory;

package/cjs/services/migration-service/scripts/index.js

@@ -0,0 +1,26 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.EVERYTIME = void 0;
+var _AutoEnableChainsTokens = _interopRequireDefault(require("@subwallet/extension-base/services/migration-service/scripts/AutoEnableChainsTokens"));
+var _MigrateImportedToken = _interopRequireDefault(require("@subwallet/extension-base/services/migration-service/scripts/MigrateImportedToken"));
+var _MigrateNetworkSettings = _interopRequireDefault(require("@subwallet/extension-base/services/migration-service/scripts/MigrateNetworkSettings"));
+var _MigrateSettings = _interopRequireDefault(require("@subwallet/extension-base/services/migration-service/scripts/MigrateSettings"));
+var _MigrateTransactionHistory = _interopRequireDefault(require("@subwallet/extension-base/services/migration-service/scripts/MigrateTransactionHistory"));
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const EVERYTIME = '__everytime__';
+exports.EVERYTIME = EVERYTIME;
+var _default = {
+  '1.0.1-11': _MigrateNetworkSettings.default,
+  '1.0.1-20': _MigrateImportedToken.default,
+  '1.0.1-30': _MigrateTransactionHistory.default,
+  '1.0.1-40': _AutoEnableChainsTokens.default,
+  '1.0.1-50': _MigrateSettings.default
+  // [`${EVERYTIME}-1`]: AutoEnableChainsTokens
+};
+exports.default = _default;

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

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _rxjs = require("rxjs");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class NotificationService {
+  notificationSubject = new _rxjs.BehaviorSubject([]);
+  getNotificationSubject() {
+    return this.notificationSubject;
+  }
+  notify(notification) {
+    const now = new Date().getTime();
+    // Get values in last 30 seconds only
+    const notifications = this.notificationSubject.value.filter(n => n.id < now - 30000);
+
+    // Push notification
+    notifications.push({
+      ...notification,
+      id: now
+    });
+    this.notificationSubject.next(notifications);
+    if (notification.notifyViaBrowser) {
+      var _notification$action;
+      NotificationService.createBrowserNotification(notification.title, notification.message, notification === null || notification === void 0 ? void 0 : (_notification$action = notification.action) === null || _notification$action === void 0 ? void 0 : _notification$action.url);
+    }
+  }
+
+  // Create a new chrome notification with link
+  static createBrowserNotification(title, message, link) {
+    chrome.notifications.create({
+      type: 'basic',
+      title,
+      message,
+      iconUrl: 'https://subwallet.app/assets/images/favicon/favicon-192x192.png',
+      priority: 2,
+      isClickable: !!link
+    }, notificationId => {
+      if (link) {
+        chrome.notifications.onClicked.addListener(nId => {
+          if (nId === notificationId) {
+            window.open(link);
+          }
+        });
+      }
+    });
+  }
+}
+exports.default = NotificationService;

package/cjs/services/price-service/coingecko.js

@@ -0,0 +1,53 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getTokenPrice = void 0;
+var _axios = _interopRequireDefault(require("axios"));
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+let useBackupApi = false;
+const getTokenPrice = async function (priceIds) {
+  let currency = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'usd';
+  try {
+    var _res;
+    const idStr = Array.from(priceIds).join(',');
+    let res;
+    if (!useBackupApi) {
+      try {
+        res = await _axios.default.get(`https://api.coingecko.com/api/v3/coins/markets?vs_currency=${currency}&per_page=250&ids=${idStr}`);
+      } catch (err) {
+        useBackupApi = true;
+      }
+    }
+    if (useBackupApi || ((_res = res) === null || _res === void 0 ? void 0 : _res.status) !== 200) {
+      console.log('Use backup api for price');
+      useBackupApi = true;
+      res = await _axios.default.get(`https://chain-data.subwallet.app/api/price/get?ids=${idStr}`);
+    }
+    if (res.status !== 200) {
+      console.warn('Failed to get token price');
+    }
+    const responseData = res.data || [];
+    const priceMap = {};
+    const price24hMap = {};
+    responseData.forEach(val => {
+      const currentPrice = val.current_price || 0;
+      const price24h = currentPrice - (val.price_change_24h || 0);
+      priceMap[val.id] = currentPrice;
+      price24hMap[val.id] = price24h;
+    });
+    return {
+      currency,
+      priceMap,
+      price24hMap
+    };
+  } catch (err) {
+    console.error('Failed to get token price', err);
+    throw err;
+  }
+};
+exports.getTokenPrice = getTokenPrice;

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

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PriceService = void 0;
+var _constants = require("@subwallet/extension-base/constants");
+var _coingecko = require("@subwallet/extension-base/services/price-service/coingecko");
+var _rxjs = require("rxjs");
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const DEFAULT_PRICE_SUBJECT = {
+  ready: false,
+  currency: 'usd',
+  priceMap: {},
+  price24hMap: {}
+};
+class PriceService {
+  priceSubject = new _rxjs.BehaviorSubject(DEFAULT_PRICE_SUBJECT);
+  priceIds = new Set();
+  constructor(dbService, eventService, chainService) {
+    this.dbService = dbService;
+    this.eventService = eventService;
+    this.chainService = chainService;
+
+    // Fetch data from storage
+    this.getPrice().catch(console.error);
+    const eventHandler = () => {
+      const newPriceIds = this.getPriceIds();
+
+      // Compare two set newPriceIds and this.priceIds
+      if (newPriceIds.size !== this.priceIds.size || !Array.from(newPriceIds).every(v => this.priceIds.has(v))) {
+        this.priceIds = newPriceIds;
+        this.refreshPriceData(this.priceIds);
+      }
+    };
+    this.eventService.waitAssetReady.then(() => {
+      this.refreshPriceData();
+      this.eventService.on('asset.enable', eventHandler);
+      this.eventService.on('asset.update', eventHandler);
+    }).catch(console.error);
+  }
+  async getPrice() {
+    const isReady = this.priceSubject.value.ready;
+    if (!isReady) {
+      const data = await this.dbService.getPriceStore();
+      this.priceSubject.next(data || DEFAULT_PRICE_SUBJECT);
+    }
+    return this.priceSubject.value;
+  }
+  getPriceSubject() {
+    return this.priceSubject;
+  }
+  getPriceIds() {
+    const priceIdList = Object.values(this.chainService.getAssetRegistry()).map(a => a.priceId).filter(a => a);
+    return new Set(priceIdList);
+  }
+  refreshPriceData(priceIds) {
+    clearTimeout(this.refreshTimeout);
+    console.log('Refresh Price Data');
+    this.priceIds = priceIds || this.getPriceIds();
+
+    // Update for tokens price
+    (0, _coingecko.getTokenPrice)(this.priceIds).then(rs => {
+      this.priceSubject.next({
+        ...rs,
+        ready: true
+      });
+      this.dbService.updatePriceStore(rs).catch(console.error);
+      console.log('Get Token Price From CoinGecko');
+    }).catch(console.error);
+    this.refreshTimeout = setTimeout(this.refreshPriceData.bind(this), _constants.CRON_REFRESH_PRICE_INTERVAL);
+  }
+}
+exports.PriceService = PriceService;

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

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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
+
+const EXTENSION_REQUEST_URL = 'extension';
+exports.EXTENSION_REQUEST_URL = EXTENSION_REQUEST_URL;
+const PREDEFINED_CHAIN_DAPP_CHAIN_MAP = {
+  'portal.astar.network': ['astar', 'astarEvm'],
+  'apps.moonbeam.network': ['moonbeam', 'moonriver'],
+  'app.stellaswap.com': ['moonbeam']
+};
+exports.PREDEFINED_CHAIN_DAPP_CHAIN_MAP = PREDEFINED_CHAIN_DAPP_CHAIN_MAP;

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

@@ -0,0 +1,296 @@
+"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 _constants = 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 _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);
+      });
+    });
+  }
+  getDAppChainInfo(options) {
+    const chainInfoMaps = this.#chainService.getChainInfoMap();
+    const chainStateMap = this.#chainService.getChainStateMap();
+    let defaultChain = options.defaultChain;
+    const needEnableChains = [];
+    if (options.url) {
+      const domain = (0, _utils2.getDomainFromUrl)(options.url);
+      const predefinedSupportChains = _constants.PREDEFINED_CHAIN_DAPP_CHAIN_MAP[domain];
+      if (predefinedSupportChains) {
+        defaultChain = predefinedSupportChains[0];
+        options.autoActive && needEnableChains.push(...predefinedSupportChains);
+      }
+    }
+    let chainInfo;
+    if (['both', 'evm'].includes(options.accessType)) {
+      const evmChains = Object.values(chainInfoMaps).filter(_utils._isChainEvmCompatible);
+      chainInfo = (defaultChain ? chainInfoMaps[defaultChain] : evmChains.find(chain => {
+        var _chainStateMap$chain$;
+        return (_chainStateMap$chain$ = chainStateMap[chain.slug]) === null || _chainStateMap$chain$ === void 0 ? void 0 : _chainStateMap$chain$.active;
+      })) || evmChains[0];
+      if (options.autoActive) {
+        if (!needEnableChains.includes(chainInfo.slug)) {
+          needEnableChains.push(chainInfo.slug);
+        }
+      }
+    }
+    needEnableChains.length > 0 && this.#chainService.enableChains(needEnableChains);
+    return chainInfo;
+  }
+  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') {
+        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;
+        });
+      }
+      const defaultEvmNetworkKey = (_this$getDAppChainInf = this.getDAppChainInfo({
+        accessType: accountAuthType,
+        url,
+        autoActive: !isCancelled && isAllowed
+      })) === null || _this$getDAppChainInf === void 0 ? void 0 : _this$getDAppChainInf.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, url, 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;