@subwallet/extension-base 0.8.1-wr → 0.8.1-wr3

package/cjs/utils/index.js

@@ -1,5 +1,6 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -9,4 +10,311 @@ Object.defineProperty(exports, "canDerive", {
     return _canDerive.canDerive;
   }
 });
-var _canDerive = require("./canDerive");
+exports.categoryAddresses = categoryAddresses;
+exports.categoryNetworks = categoryNetworks;
+exports.convertFundStatus = void 0;
+exports.convertToEvmAddress = convertToEvmAddress;
+exports.filterAddressByNetworkKey = filterAddressByNetworkKey;
+exports.getNftProvider = exports.getCurrentProvider = exports.filterAndSortingAccountByAuthType = void 0;
+exports.hexToStr = hexToStr;
+exports.hexToUTF16 = hexToUTF16;
+exports.inJestTest = inJestTest;
+exports.isAccountAll = isAccountAll;
+exports.isEmptyArray = exports.isDef = exports.isAddressesEqual = void 0;
+exports.isUrl = isUrl;
+exports.isValidSubstrateAddress = exports.isValidProvider = void 0;
+exports.mergeNetworkProviders = mergeNetworkProviders;
+exports.parseIpfsLink = exports.notDef = exports.nonEmptyArr = void 0;
+exports.parseNumberToDisplay = parseNumberToDisplay;
+exports.parseRawNumber = parseRawNumber;
+exports.reformatAddress = reformatAddress;
+exports.sumBN = sumBN;
+exports.toUnit = void 0;
+exports.utf16ToString = utf16ToString;
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _constants = require("@subwallet/extension-base/constants");
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+var _util = require("@polkadot/util");
+var _utilCrypto = require("@polkadot/util-crypto");
+var _canDerive = require("./canDerive");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const notDef = x => x === null || typeof x === 'undefined';
+exports.notDef = notDef;
+const isDef = x => !notDef(x);
+exports.isDef = isDef;
+const nonEmptyArr = x => Array.isArray(x) && x.length > 0;
+exports.nonEmptyArr = nonEmptyArr;
+const isEmptyArray = x => !Array.isArray(x) || Array.isArray(x) && x.length === 0;
+exports.isEmptyArray = isEmptyArray;
+function isAccountAll(address) {
+  return address === _constants.ALL_ACCOUNT_KEY;
+}
+function reformatAddress(address, networkPrefix) {
+  let isEthereum = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  if ((0, _utilCrypto.isEthereumAddress)(address)) {
+    return address;
+  }
+  if (isAccountAll(address)) {
+    return address;
+  }
+  const publicKey = (0, _utilCrypto.decodeAddress)(address);
+  if (isEthereum) {
+    return (0, _utilCrypto.ethereumEncode)(publicKey);
+  }
+  if (networkPrefix < 0) {
+    return address;
+  }
+  return (0, _utilCrypto.encodeAddress)(publicKey, networkPrefix);
+}
+function filterAddressByNetworkKey(addresses, networkKey, isEthereum) {
+  if (isEthereum) {
+    return addresses.filter(address => {
+      return (0, _utilCrypto.isEthereumAddress)(address);
+    });
+  } else {
+    return addresses.filter(address => {
+      return !(0, _utilCrypto.isEthereumAddress)(address);
+    });
+  }
+}
+function categoryAddresses(addresses) {
+  const substrateAddresses = [];
+  const evmAddresses = [];
+  addresses.forEach(address => {
+    if ((0, _utilCrypto.isEthereumAddress)(address)) {
+      evmAddresses.push(address);
+    } else {
+      substrateAddresses.push(address);
+    }
+  });
+  return [substrateAddresses, evmAddresses];
+}
+function categoryNetworks(networks) {
+  const substrateAddresses = [];
+  const evmAddresses = [];
+  return [substrateAddresses, evmAddresses];
+}
+function convertToEvmAddress(substrateAddress) {
+  const addressBytes = (0, _utilCrypto.decodeAddress)(substrateAddress);
+  return (0, _utilCrypto.ethereumEncode)('0x' + Buffer.from(addressBytes.subarray(0, 20)).toString('hex'));
+}
+function isUrl(targetString) {
+  let url;
+  try {
+    url = new URL(targetString);
+  } catch (_) {
+    return false;
+  }
+  return url.protocol === 'http:' || url.protocol === 'https:' || url.protocol === 'wss:';
+}
+function inJestTest() {
+  return process.env.JEST_WORKER_ID !== undefined;
+}
+const parseIpfsLink = ipfsLink => {
+  if (!ipfsLink.includes('ipfs://ipfs/')) {
+    return ipfsLink;
+  }
+  return ipfsLink.split('ipfs://ipfs/')[1];
+};
+exports.parseIpfsLink = parseIpfsLink;
+function hexToStr(buf) {
+  let str = '';
+  let hexStart = buf.indexOf('0x');
+  if (hexStart < 0) {
+    hexStart = 0;
+  } else {
+    hexStart = 2;
+  }
+  for (let i = hexStart, strLen = buf.length; i < strLen; i += 2) {
+    const ch = buf[i] + buf[i + 1];
+    const num = parseInt(ch, 16);
+
+    // eslint-disable-next-line eqeqeq
+    if (num != 0) {
+      str += String.fromCharCode(num);
+    } else {
+      break;
+    }
+  }
+  return str;
+}
+
+// eslint-disable-next-line camelcase
+function utf16ToString(uInt16Array) {
+  let str = '';
+
+  // eslint-disable-next-line camelcase
+  for (let i = 0; i < uInt16Array.length; i++) {
+    str += String.fromCharCode(uInt16Array[i]);
+  }
+  return str;
+}
+function hexToUTF16(hex) {
+  const buf = [];
+  let hexStart = hex.indexOf('0x');
+  if (hexStart < 0) {
+    hexStart = 0;
+  } else {
+    hexStart = 2;
+  }
+  for (let i = hexStart, strLen = hex.length; i < strLen; i += 2) {
+    const ch = hex[i] + hex[i + 1];
+    const num = parseInt(ch, 16);
+    buf.push(num);
+  }
+  return new Uint8Array(buf);
+}
+const isValidSubstrateAddress = address => {
+  try {
+    (0, _utilCrypto.encodeAddress)((0, _util.isHex)(address) ? (0, _util.hexToU8a)(address) : (0, _utilCrypto.decodeAddress)(address));
+    return true;
+  } catch (error) {
+    return false;
+  }
+};
+exports.isValidSubstrateAddress = isValidSubstrateAddress;
+const toUnit = (balance, decimals) => {
+  if (balance === 0) {
+    return 0;
+  }
+  return balance / 10 ** decimals;
+};
+exports.toUnit = toUnit;
+function sumBN(inputArr) {
+  let rs = new _util.BN(0);
+  inputArr.forEach(input => {
+    rs = rs.add(input);
+  });
+  return rs;
+}
+const convertFundStatus = status => {
+  if (status === 'Won' || status === 'Retiring') {
+    return _KoniTypes.CrowdloanParaState.COMPLETED;
+  } else if (status === 'Started') {
+    return _KoniTypes.CrowdloanParaState.ONGOING;
+  } else if (status === 'Dissolved') {
+    return _KoniTypes.CrowdloanParaState.FAILED;
+  } else {
+    return undefined;
+  }
+};
+exports.convertFundStatus = convertFundStatus;
+const isAddressesEqual = (addresses, prevAddresses) => {
+  if (addresses.length !== prevAddresses.length) {
+    return false;
+  }
+  for (const address of addresses) {
+    if (!prevAddresses.includes(address)) {
+      return false;
+    }
+  }
+  return true;
+};
+exports.isAddressesEqual = isAddressesEqual;
+const isValidProvider = provider => {
+  if (isUrl(provider)) {
+    return true;
+  } else if (provider.startsWith('wss://') || provider.startsWith('light://')) {
+    return true;
+  }
+  return false;
+};
+exports.isValidProvider = isValidProvider;
+const getCurrentProvider = data => {
+  if (!(data !== null && data !== void 0 && data.currentProvider)) {
+    return null;
+  }
+  if (data.currentProvider.startsWith('custom') && data.customProviders) {
+    return data.customProviders[data.currentProvider];
+  } else {
+    return data.providers[data.currentProvider];
+  }
+};
+exports.getCurrentProvider = getCurrentProvider;
+const getNftProvider = data => {
+  if (data.nftProvider) {
+    return data.providers[data.nftProvider];
+  }
+  return '';
+};
+exports.getNftProvider = getNftProvider;
+function mergeNetworkProviders(customNetwork, predefinedNetwork) {
+  // merge providers for 2 networks with the same genesisHash
+  if (customNetwork.customProviders) {
+    const parsedCustomProviders = {};
+    const currentProvider = customNetwork.customProviders[customNetwork.currentProvider || ''] || '';
+    const currentProviderMethod = currentProvider.startsWith('http') ? 'http' : 'ws';
+    let parsedProviderKey = '';
+    for (const customProvider of Object.values(customNetwork.customProviders)) {
+      let exist = false;
+      for (const [key, provider] of Object.entries(predefinedNetwork.providers)) {
+        if (currentProvider === provider) {
+          // point currentProvider to predefined
+          parsedProviderKey = key;
+        }
+        if (provider === customProvider) {
+          exist = true;
+          break;
+        }
+      }
+      if (!exist) {
+        const index = Object.values(parsedCustomProviders).length;
+        parsedCustomProviders[`custom_${index}`] = customProvider;
+      }
+    }
+    for (const [key, parsedProvider] of Object.entries(parsedCustomProviders)) {
+      if (currentProvider === parsedProvider) {
+        parsedProviderKey = key;
+      }
+    }
+    return {
+      currentProviderMethod,
+      parsedProviderKey,
+      parsedCustomProviders
+    };
+  } else {
+    return {
+      currentProviderMethod: '',
+      parsedProviderKey: '',
+      parsedCustomProviders: {}
+    };
+  }
+}
+const filterAndSortingAccountByAuthType = function (accounts, accountAuthType) {
+  let sorting = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  let rs = [...accounts];
+  rs = rs.filter(acc => acc.address !== 'ALL');
+  if (accountAuthType === 'substrate') {
+    rs = rs.filter(acc => acc.type !== 'ethereum');
+  } else if (accountAuthType === 'evm') {
+    rs = rs.filter(acc => acc.type === 'ethereum');
+  } else {
+    if (sorting) {
+      rs.sort((acc, acc2) => {
+        if (acc.type === 'ethereum' && acc2.type === 'ethereum' || acc.type !== 'ethereum' && acc2.type !== 'ethereum') {
+          return 0;
+        } else {
+          return acc.type === 'ethereum' ? 1 : -1;
+        }
+      });
+    }
+  }
+  return rs;
+};
+exports.filterAndSortingAccountByAuthType = filterAndSortingAccountByAuthType;
+function parseRawNumber(value) {
+  return parseFloat(value.replaceAll(',', ''));
+}
+function parseNumberToDisplay(amount, decimals) {
+  if (!decimals) {
+    return '0';
+  }
+  const parsedAmount = parseRawNumber(amount.toString());
+  const bigN = new _bignumber.default(parsedAmount / 10 ** decimals);
+  const roundedString = bigN.toFixed(9);
+  const formattedString = parseFloat(roundedString); // remove excess zeros at the end
+
+  return formattedString.toString();
+}

package/cjs/utils/keyring.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.extractPrivateKey = extractPrivateKey;
+exports.unlockAccount = exports.lockAccount = void 0;
+var _uiKeyring = require("@subwallet/ui-keyring");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+// import _decode from '@polkadot/keyring/pair/decode';
+
+function extract(address) {
+  // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+  const rs = this.getPair(address);
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  console.log(rs.publicKey);
+}
+function extractPrivateKey(keyring, address, password) {
+  extract.call(keyring, address);
+}
+const unlockAccount = signAddress => {
+  let publicKey;
+  try {
+    publicKey = _uiKeyring.keyring.decodeAddress(signAddress);
+  } catch (error) {
+    console.error(error);
+    return 'Unable to decode address';
+  }
+  const pair = _uiKeyring.keyring.getPair(publicKey);
+  if (!pair) {
+    return 'Unable to find pair';
+  }
+  if (pair.isLocked) {
+    try {
+      _uiKeyring.keyring.unlockPair(pair.address);
+    } catch (e) {
+      return e.message;
+    }
+  }
+  return null;
+};
+exports.unlockAccount = unlockAccount;
+const lockAccount = address => {
+  try {
+    const pair = _uiKeyring.keyring.getPair(address);
+    if (pair) {
+      pair.lock();
+    }
+  } catch (error) {
+    console.error('Unable to lock account', error);
+  }
+};
+exports.lockAccount = lockAccount;

package/cjs/utils/request.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isInternalRequest = isInternalRequest;
+var _constants = require("@subwallet/extension-base/services/request-service/constants");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+function isInternalRequest(url) {
+  return url === _constants.EXTENSION_REQUEST_URL;
+}

package/constants/i18n.d.ts

@@ -0,0 +1,2 @@
+import { LanguageOptionType } from '@subwallet/extension-base/background/KoniTypes';
+export declare const languageOptions: LanguageOptionType[];

package/constants/i18n.js

@@ -0,0 +1,25 @@
+// Copyright 2019-2022 @polkadot/extension-ui authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export const languageOptions = [{
+  text: 'English',
+  value: 'en'
+}, {
+  text: '汉语',
+  value: 'zh'
+}, {
+  text: 'Français',
+  value: 'fr'
+}, {
+  text: 'Türkce',
+  value: 'tr'
+}, {
+  text: 'Polski',
+  value: 'pl'
+}, {
+  text: 'ภาษาไทย',
+  value: 'th'
+}, {
+  text: 'اردو',
+  value: 'ur'
+}];

package/constants/index.d.ts

@@ -0,0 +1,25 @@
+export declare const CRON_REFRESH_PRICE_INTERVAL = 30000;
+export declare const DOTSAMA_API_TIMEOUT = 30000;
+export declare const DOTSAMA_AUTO_CONNECT_MS = 3000;
+export declare const DOTSAMA_MAX_CONTINUE_RETRY = 2;
+export declare const CRON_AUTO_RECOVER_DOTSAMA_INTERVAL = 60000;
+export declare const CRON_AUTO_RECOVER_WEB3_INTERVAL = 90000;
+export declare const ACALA_REFRESH_CROWDLOAN_INTERVAL = 300000;
+export declare const ACALA_REFRESH_BALANCE_INTERVAL = 30000;
+export declare const ASTAR_REFRESH_BALANCE_INTERVAL = 30000;
+export declare const SUB_TOKEN_REFRESH_BALANCE_INTERVAL = 30000;
+export declare const SUBSCRIBE_BALANCE_FAST_INTERVAL = 9000;
+export declare const CRON_REFRESH_NFT_INTERVAL = 900000;
+export declare const CRON_REFRESH_STAKING_REWARD_INTERVAL = 900000;
+export declare const CRON_REFRESH_STAKING_REWARD_FAST_INTERVAL = 10000;
+export declare const CRON_REFRESH_HISTORY_INTERVAL = 90000;
+export declare const CRON_GET_API_MAP_STATUS = 5000;
+export declare const CRON_REFRESH_STAKING_DATA = 30000;
+export declare const CRON_REFRESH_CHAIN_STAKING_METADATA = 900000;
+export declare const CRON_REFRESH_CHAIN_NOMINATOR_METADATA = 900000;
+export declare const ALL_ACCOUNT_KEY = "ALL";
+export declare const ALL_NETWORK_KEY = "all";
+export declare const ALL_GENESIS_HASH: null;
+export declare const IGNORE_GET_SUBSTRATE_FEATURES_LIST: string[];
+export declare const IGNORE_QR_SIGNER: string[];
+export declare const DEFAULT_THEME = "dark";

package/constants/index.js

@@ -0,0 +1,28 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export const CRON_REFRESH_PRICE_INTERVAL = 30000;
+export const DOTSAMA_API_TIMEOUT = 30000;
+export const DOTSAMA_AUTO_CONNECT_MS = 3000;
+export const DOTSAMA_MAX_CONTINUE_RETRY = 2;
+export const CRON_AUTO_RECOVER_DOTSAMA_INTERVAL = 60000;
+export const CRON_AUTO_RECOVER_WEB3_INTERVAL = 90000;
+export const ACALA_REFRESH_CROWDLOAN_INTERVAL = 300000;
+export const ACALA_REFRESH_BALANCE_INTERVAL = 30000;
+export const ASTAR_REFRESH_BALANCE_INTERVAL = 30000;
+export const SUB_TOKEN_REFRESH_BALANCE_INTERVAL = 30000;
+export const SUBSCRIBE_BALANCE_FAST_INTERVAL = 9000;
+export const CRON_REFRESH_NFT_INTERVAL = 900000;
+export const CRON_REFRESH_STAKING_REWARD_INTERVAL = 900000;
+export const CRON_REFRESH_STAKING_REWARD_FAST_INTERVAL = 10000;
+export const CRON_REFRESH_HISTORY_INTERVAL = 90000;
+export const CRON_GET_API_MAP_STATUS = 5000;
+export const CRON_REFRESH_STAKING_DATA = 30000;
+export const CRON_REFRESH_CHAIN_STAKING_METADATA = 900000;
+export const CRON_REFRESH_CHAIN_NOMINATOR_METADATA = 900000;
+export const ALL_ACCOUNT_KEY = 'ALL';
+export const ALL_NETWORK_KEY = 'all';
+export const ALL_GENESIS_HASH = null;
+export const IGNORE_GET_SUBSTRATE_FEATURES_LIST = ['astarEvm', 'ethereum', 'ethereum_goerli', 'binance', 'binance_test', 'boba_rinkeby', 'boba', 'bobabase', 'bobabeam'];
+export const IGNORE_QR_SIGNER = [];
+export const DEFAULT_THEME = 'dark';

package/defaults.d.ts

@@ -1,4 +1,4 @@
-declare const ALLOWED_PATH: readonly ["/", "/account/import-ledger", "/account/restore-json", "/account/create", "/account/settings"];
+declare const ALLOWED_PATH: readonly ["/", "/settings/security", "/accounts/connect-ledger"];
 declare const PHISHING_PAGE_REDIRECT = "/phishing-page-detected";
 declare const EXTENSION_PREFIX: string;
 declare const PORT_MOBILE: string;

package/defaults.js

@@ -1,7 +1,7 @@
 // Copyright 2019-2022 @polkadot/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-const ALLOWED_PATH = ['/', '/account/import-ledger', '/account/restore-json', '/account/create', '/account/settings'];
+const ALLOWED_PATH = ['/', '/settings/security', '/accounts/connect-ledger'];
 const PHISHING_PAGE_REDIRECT = '/phishing-page-detected';
 const EXTENSION_PREFIX = process.env.EXTENSION_PREFIX || '';
 const PORT_MOBILE = `${EXTENSION_PREFIX}mobile`;

package/koni/api/coingecko.d.ts

@@ -0,0 +1,2 @@
+import { PriceJson } from '@subwallet/extension-base/background/KoniTypes';
+export declare const getTokenPrice: (priceIds: Array<string>, currency?: string) => Promise<PriceJson>;

package/koni/api/coingecko.js

@@ -0,0 +1,37 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import axios from 'axios';
+export const getTokenPrice = async (priceIds, currency = 'usd') => {
+  try {
+    // const inverseMap: Record<string, string> = {};
+    const idStr = priceIds.join(',');
+    const res = await axios.get(`https://api.coingecko.com/api/v3/coins/markets?vs_currency=${currency}&per_page=1000&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;
+
+      // if (inverseMap[val.id]) {
+      //   priceMap[inverseMap[val.id]] = currentPrice;
+      //   price24hMap[inverseMap[val.id]] = price24h;
+      // }
+    });
+
+    return {
+      currency,
+      priceMap,
+      price24hMap
+    };
+  } catch (err) {
+    console.error('Failed to get token price', err);
+    throw err;
+  }
+};

package/koni/api/donate.d.ts

@@ -0,0 +1,3 @@
+import { DonateInfo } from '@subwallet/extension-base/background/KoniTypes';
+declare const DONATEINFOS: Record<string, DonateInfo>;
+export default DONATEINFOS;

package/koni/api/donate.js

@@ -0,0 +1,13 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const DONATEINFOS = {
+  ukraine: {
+    key: '1x8aa2N2Ar9SQweJv9vsuZn3WYDHu7gMQu1RePjZuBe33Hv',
+    name: 'Ukraine / Україна',
+    value: '5D1qSEmJAPafzsw8MH6vjkjdBtYZbbZYGvAXGMQP1pA7rMXk',
+    icon: 'ukraine',
+    link: 'https://twitter.com/Ukraine/status/1498547710697345027'
+  }
+};
+export default DONATEINFOS;

package/koni/api/dotsama/balance.d.ts

@@ -0,0 +1,8 @@
+import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
+import { BalanceItem } from '@subwallet/extension-base/background/KoniTypes';
+import { _EvmApi, _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+export declare function subscribeBalance(addresses: string[], chainInfoMap: Record<string, _ChainInfo>, substrateApiMap: Record<string, _SubstrateApi>, evmApiMap: Record<string, _EvmApi>, callback: (rs: BalanceItem) => void): () => void;
+export declare function subscribeSubstrateBalance(addresses: string[], chainInfo: _ChainInfo, chain: string, networkAPI: _SubstrateApi, evmApiMap: Record<string, _EvmApi>, callBack: (rs: BalanceItem) => void): Promise<() => void>;
+export declare function subscribeEVMBalance(chain: string, addresses: string[], evmApiMap: Record<string, _EvmApi>, callback: (rs: BalanceItem) => void, tokenInfo: _ChainAsset): () => void;
+export declare function getFreeBalance(chain: string, address: string, substrateApiMap: Record<string, _SubstrateApi>, evmApiMap: Record<string, _EvmApi>, tokenSlug?: string): Promise<string>;
+export declare function subscribeFreeBalance(chain: string, address: string, substrateApiMap: Record<string, _SubstrateApi>, evmApiMap: Record<string, _EvmApi>, token: string | undefined, update: (balance: string) => void): Promise<() => void>;