@subwallet/extension-base 0.8.3-2 → 1.0.1

package/utils/index.js

@@ -1,4 +1,275 @@
-// Copyright 2019-2022 @polkadot/extension authors & contributors
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-export { canDerive } from "./canDerive.js";
+import { CrowdloanParaState } from '@subwallet/extension-base/background/KoniTypes';
+import { ALL_ACCOUNT_KEY } from '@subwallet/extension-base/constants';
+import BigNumber from 'bignumber.js';
+import { BN, hexToU8a, isHex } from '@polkadot/util';
+import { decodeAddress, encodeAddress, ethereumEncode, isEthereumAddress } from '@polkadot/util-crypto';
+export { canDerive } from "./canDerive.js";
+export const notDef = x => x === null || typeof x === 'undefined';
+export const isDef = x => !notDef(x);
+export const nonEmptyArr = x => Array.isArray(x) && x.length > 0;
+export const isEmptyArray = x => !Array.isArray(x) || Array.isArray(x) && x.length === 0;
+export function isAccountAll(address) {
+  return address === ALL_ACCOUNT_KEY;
+}
+export function reformatAddress(address, networkPrefix, isEthereum = false) {
+  if (isEthereumAddress(address)) {
+    return address;
+  }
+  if (isAccountAll(address)) {
+    return address;
+  }
+  const publicKey = decodeAddress(address);
+  if (isEthereum) {
+    return ethereumEncode(publicKey);
+  }
+  if (networkPrefix < 0) {
+    return address;
+  }
+  return encodeAddress(publicKey, networkPrefix);
+}
+export function filterAddressByNetworkKey(addresses, networkKey, isEthereum) {
+  if (isEthereum) {
+    return addresses.filter(address => {
+      return isEthereumAddress(address);
+    });
+  } else {
+    return addresses.filter(address => {
+      return !isEthereumAddress(address);
+    });
+  }
+}
+export function categoryAddresses(addresses) {
+  const substrateAddresses = [];
+  const evmAddresses = [];
+  addresses.forEach(address => {
+    if (isEthereumAddress(address)) {
+      evmAddresses.push(address);
+    } else {
+      substrateAddresses.push(address);
+    }
+  });
+  return [substrateAddresses, evmAddresses];
+}
+export function categoryNetworks(networks) {
+  const substrateAddresses = [];
+  const evmAddresses = [];
+  return [substrateAddresses, evmAddresses];
+}
+export function convertToEvmAddress(substrateAddress) {
+  const addressBytes = decodeAddress(substrateAddress);
+  return ethereumEncode('0x' + Buffer.from(addressBytes.subarray(0, 20)).toString('hex'));
+}
+export function isUrl(targetString) {
+  let url;
+  try {
+    url = new URL(targetString);
+  } catch (_) {
+    return false;
+  }
+  return url.protocol === 'http:' || url.protocol === 'https:' || url.protocol === 'wss:';
+}
+export function inJestTest() {
+  return process.env.JEST_WORKER_ID !== undefined;
+}
+export const parseIpfsLink = ipfsLink => {
+  if (!ipfsLink.includes('ipfs://ipfs/')) {
+    return ipfsLink;
+  }
+  return ipfsLink.split('ipfs://ipfs/')[1];
+};
+export 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
+export 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;
+}
+export 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);
+}
+export const isValidSubstrateAddress = address => {
+  try {
+    encodeAddress(isHex(address) ? hexToU8a(address) : decodeAddress(address));
+    return true;
+  } catch (error) {
+    return false;
+  }
+};
+export const toUnit = (balance, decimals) => {
+  if (balance === 0) {
+    return 0;
+  }
+  return balance / 10 ** decimals;
+};
+export function sumBN(inputArr) {
+  let rs = new BN(0);
+  inputArr.forEach(input => {
+    rs = rs.add(input);
+  });
+  return rs;
+}
+export const convertFundStatus = status => {
+  if (status === 'Won' || status === 'Retiring') {
+    return CrowdloanParaState.COMPLETED;
+  } else if (status === 'Started') {
+    return CrowdloanParaState.ONGOING;
+  } else if (status === 'Dissolved') {
+    return CrowdloanParaState.FAILED;
+  } else {
+    return undefined;
+  }
+};
+export const isAddressesEqual = (addresses, prevAddresses) => {
+  if (addresses.length !== prevAddresses.length) {
+    return false;
+  }
+  for (const address of addresses) {
+    if (!prevAddresses.includes(address)) {
+      return false;
+    }
+  }
+  return true;
+};
+export const isValidProvider = provider => {
+  if (isUrl(provider)) {
+    return true;
+  } else if (provider.startsWith('wss://') || provider.startsWith('light://')) {
+    return true;
+  }
+  return false;
+};
+export 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];
+  }
+};
+export const getNftProvider = data => {
+  if (data.nftProvider) {
+    return data.providers[data.nftProvider];
+  }
+  return '';
+};
+export 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: {}
+    };
+  }
+}
+export const filterAndSortingAccountByAuthType = (accounts, accountAuthType, sorting = 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;
+};
+export function parseRawNumber(value) {
+  return parseFloat(value.replaceAll(',', ''));
+}
+export function parseNumberToDisplay(amount, decimals) {
+  if (!decimals) {
+    return '0';
+  }
+  const parsedAmount = parseRawNumber(amount.toString());
+  const bigN = new BigNumber(parsedAmount / 10 ** decimals);
+  const roundedString = bigN.toFixed(9);
+  const formattedString = parseFloat(roundedString); // remove excess zeros at the end
+
+  return formattedString.toString();
+}
+export function isSameAddress(address1, address2) {
+  return reformatAddress(address1, 0) === reformatAddress(address2, 0); // TODO: maybe there's a better way
+}

package/utils/keyring.d.ts

@@ -0,0 +1,4 @@
+import { Keyring } from '@subwallet/keyring';
+export declare function extractPrivateKey(keyring: Keyring, address: string, password: string): void;
+export declare const unlockAccount: (signAddress: string) => string | null;
+export declare const lockAccount: (address: string) => void;

package/utils/keyring.js

@@ -0,0 +1,49 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { keyring } from '@subwallet/ui-keyring';
+
+// 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);
+}
+export function extractPrivateKey(keyring, address, password) {
+  extract.call(keyring, address);
+}
+export const unlockAccount = signAddress => {
+  let publicKey;
+  try {
+    publicKey = keyring.decodeAddress(signAddress);
+  } catch (error) {
+    console.error(error);
+    return 'Unable to decode address';
+  }
+  const pair = keyring.getPair(publicKey);
+  if (!pair) {
+    return 'Unable to find pair';
+  }
+  if (pair.isLocked) {
+    try {
+      keyring.unlockPair(pair.address);
+    } catch (e) {
+      return e.message;
+    }
+  }
+  return null;
+};
+export const lockAccount = address => {
+  try {
+    const pair = keyring.getPair(address);
+    if (pair) {
+      pair.lock();
+    }
+  } catch (error) {
+    console.error('Unable to lock account', error);
+  }
+};

package/utils/request.d.ts

@@ -0,0 +1 @@
+export declare function isInternalRequest(url: string): boolean;

package/utils/request.js

@@ -0,0 +1,7 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { EXTENSION_REQUEST_URL } from '@subwallet/extension-base/services/request-service/constants';
+export function isInternalRequest(url) {
+  return url === EXTENSION_REQUEST_URL;
+}

package/errors/SubWalletProviderError.d.ts

@@ -1,6 +0,0 @@
-import { SubWalletProviderErrorInterface } from '@subwallet/extension-base/background/KoniTypes';
-export declare class SubWalletProviderError extends Error implements SubWalletProviderErrorInterface {
-    code: number | undefined;
-    data: unknown | undefined;
-    constructor(message: string, code?: number, data?: unknown);
-}