@talismn/util 0.5.0 → 0.5.1

package/dist/talismn-util.esm.js

@@ -1,8 +1,5 @@
-import { u8aToHex, u8aConcat, u8aToU8a, hexToU8a } from '@polkadot/util';
-import { blake2AsU8a, isEthereumAddress as isEthereumAddress$1, ethereumEncode, decodeAddress as decodeAddress$1, base58Decode, checkAddressChecksum, xxhashAsU8a } from '@polkadot/util-crypto';
 import { twMerge } from 'tailwind-merge';
-import { encodeAddress, decodeAddress } from '@polkadot/keyring';
-import { concat, take, skip, debounceTime, shareReplay, tap } from 'rxjs';
+import { concat, take, skip, debounceTime, shareReplay, Subject, tap, ReplaySubject, timer, switchMap, from, startWith, map, catchError, of } from 'rxjs';
 import BigNumber from 'bignumber.js';
 
 const addTrailingSlash = url => {
@@ -39,54 +36,8 @@ const BigMath = {
   }
 };
 
-const bitLength$1 = 128;
-function blake2Concat(input) {
-  return u8aToHex(u8aConcat(blake2AsU8a(input, bitLength$1), u8aToU8a(input)));
-}
-
 const classNames = twMerge;
-
-function encodeAnyAddress(key, ss58Format) {
-  try {
-    return encodeAddress(key, ss58Format);
-  } catch (error) {
-    if (typeof key !== "string") throw error;
-    if (!isEthereumAddress$1(key)) throw error;
-    return ethereumEncode(key);
-  }
-}
-
-/**
- *
- * @param address substrate SS58 address
- * @param prefix prefix used to format the address
- * @returns address encoded with supplied prefix
- */
-const convertAddress = (address, prefix) => {
-  return encodeAnyAddress(address, prefix ?? undefined);
-};
-
-function decodeAnyAddress(encoded, ignoreChecksum, ss58Format) {
-  try {
-    return decodeAddress(encoded, ignoreChecksum, ss58Format);
-  } catch (error) {
-    if (typeof encoded !== "string") throw error;
-    if (!isEthereumAddress$1(encoded)) throw error;
-    return hexToU8a(encoded.slice("0x".length));
-  }
-}
-
-const decodeSs58Format = address => {
-  if (!address) return;
-  try {
-    decodeAddress$1(address);
-    const decoded = base58Decode(address);
-    const [,,, ss58Format] = checkAddressChecksum(decoded);
-    return ss58Format;
-  } catch {
-    return; // invalid address
-  }
-};
+const cn = twMerge;
 
 /**
  * In TypeScript, a deferred promise refers to a pattern that involves creating a promise that can be
@@ -189,113 +140,57 @@ const formatPrice = (price, currency, compact) => {
   }).format(price);
 };
 
+const CACHE = new Map();
+
+/**
+ * When using react-rxjs hooks and state observables, the options are used as weak map keys.
+ * This means that if the options object is recreated on each render, the observable will be recreated as well.
+ * This utility function allows you to create a shared observable based on a namespace and arguments that, so react-rxjs can reuse the same observables
+ *
+ * @param namespace
+ * @param args
+ * @param createObservable
+ * @param serializer
+ * @returns
+ */
+const getSharedObservable = (namespace, args, createObservable, serializer = args => JSON.stringify(args)) => {
+  const cacheKey = `${namespace}:${serializer(args)}`;
+  if (CACHE.has(cacheKey)) return CACHE.get(cacheKey);
+  const obs = createObservable(args);
+  const sharedObs = obs.pipe(shareReplay({
+    bufferSize: 1,
+    refCount: true
+  }));
+  CACHE.set(cacheKey, sharedObs);
+  return sharedObs;
+};
+
 function hasOwnProperty(obj, prop) {
   if (typeof obj !== "object") return false;
   if (obj === null) return false;
   return prop in obj;
 }
 
+const isAbortError = error => {
+  return error instanceof Error && error.name === "AbortError";
+};
+
 function isArrayOf(array, func) {
   if (array.length > 0 && array[0] instanceof func) return true;
   return false;
 }
 
-const isBigInt = value => typeof value === "bigint";
-
-const isBooleanTrue = x => !!x;
-
-const isEthereumAddress = address => !!address && address.startsWith("0x") && address.length === 42;
-
-/**
- * Similar to isValidAddress but will not call isEthereumAddress under the hood
- * @param address
- * @param prefix if supplied, the method will also check the prefix
- * @returns true if valid substrate (SS58) address, false otherwise
- */
-const isValidSubstrateAddress = (address, prefix) => {
-  try {
-    // attempt to encode, it will throw an error if address is invalid
-    const encoded = encodeAddress(address, prefix ?? undefined);
-
-    //if a prefix is supplied, check that reencoding using this prefix matches the input address
-    if (prefix !== undefined) return address === encoded;
-
-    //if no prefix supplied, the fact that decoding + encoding succeded indicates that the address is valid
-    return true;
-  } catch (error) {
-    // input is not a substrate (SS58) address
-    return false;
-  }
-};
-
-function planckToTokens(planck, tokenDecimals) {
-  if (typeof planck !== "string" || typeof tokenDecimals !== "number") return;
-  const base = 10;
-  const exponent = -1 * tokenDecimals;
-  const multiplier = base ** exponent;
-  return new BigNumber(planck).multipliedBy(multiplier).toString(10);
-}
-
-const sleep = ms => new Promise(resolve => {
-  if (process.env.NODE_ENV === "test") resolve();else setTimeout(resolve, ms);
-});
-
-const throwAfter = (ms, reason) => new Promise((_, reject) => setTimeout(() => reject(new Error(reason)), ms));
-
-function tokensToPlanck(tokens, tokenDecimals) {
-  if (typeof tokens !== "string" || typeof tokenDecimals !== "number") return;
-  const base = 10;
-  const exponent = tokenDecimals;
-  const multiplier = base ** exponent;
-  return new BigNumber(tokens).multipliedBy(multiplier).toString(10);
-}
-
-const bitLength = 64;
-function twox64Concat(input) {
-  const inputAsU8a = typeof input === "string" ? input : new Uint8Array(input);
-  return u8aToHex(u8aConcat(xxhashAsU8a(inputAsU8a, bitLength), u8aToU8a(inputAsU8a)));
-}
-
-/**
- * @name validateHexString
- * @description Checks if a string is a hex string. Required to account for type differences between different polkadot libraries
- * @param {string} str - string to check
- * @returns {HexString} - boolean
- * @example
- * validateHexString("0x1234") // "0x1234"
- * validateHexString("1234") // Error: Expected a hex string
- * validateHexString(1234) // Error: Expected a string
- **/
-const validateHexString = str => {
-  if (typeof str !== "string") {
-    throw new Error("Expected a string");
-  }
-  if (str.startsWith("0x")) {
-    return str;
-  }
-  throw new Error("Expected a hex string");
+const isAscii = str => {
+  return [...str].every(char => char.charCodeAt(0) <= 127);
 };
 
-const CACHE$1 = new Map();
-
-// Normalize an address in a way that it can be compared to other addresses that have also been normalized
-const normalizeAddress = address => {
-  try {
-    if (!CACHE$1.has(address)) CACHE$1.set(address, encodeAnyAddress(address));
-    return CACHE$1.get(address);
-  } catch (cause) {
-    throw new Error(`Unable to normalize address: ${address}`, {
-      cause
-    });
-  }
-};
+const isBigInt = value => typeof value === "bigint";
 
-const isAddressEqual = (address1, address2) => {
-  return normalizeAddress(address1) === normalizeAddress(address2);
-};
+const isBooleanTrue = x => !!x;
 
-const isAscii = str => {
-  return [...str].every(char => char.charCodeAt(0) <= 127);
+const REGEX_HEX_STRING = /^0x[0-9a-fA-F]*$/;
+const isHexString = value => {
+  return typeof value === "string" && REGEX_HEX_STRING.test(value);
 };
 
 /**
@@ -308,36 +203,33 @@ const isAscii = str => {
  */
 const isNotNil = value => value !== null && value !== undefined;
 
-const isTruthy = value => Boolean(value);
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const isPromise = value => !!value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
 
-const isAbortError = error => {
-  return error instanceof Error && error.name === "AbortError";
-};
+/**
+ * Tests to see if an object is an RxJS {@link Subject}.
+ */
+function isSubject(object) {
+  if (!object) return false;
+  if (object instanceof Subject) return true;
+  return "asObservable" in object && isFn(object.asObservable) && "complete" in object && isFn(object.complete) && "error" in object && isFn(object.error) && "forEach" in object && isFn(object.forEach) && "next" in object && isFn(object.next) && "pipe" in object && isFn(object.pipe) && "subscribe" in object && isFn(object.subscribe) && "unsubscribe" in object && isFn(object.unsubscribe) && "closed" in object && isBool(object.closed) && "observed" in object && isBool(object.observed);
+}
 
-const CACHE = new Map();
+/**
+ * Returns `true` if `value` is a function.
+ */
+function isFn(value) {
+  return typeof value === "function";
+}
 
 /**
- * When using react-rxjs hooks and state observables, the options are used as weak map keys.
- * This means that if the options object is recreated on each render, the observable will be recreated as well.
- * This utility function allows you to create a shared observable based on a namespace and arguments that, so react-rxjs can reuse the same observables
- *
- * @param namespace
- * @param args
- * @param createObservable
- * @param serializer
- * @returns
+ * Returns `true` if `value` is a boolean.
  */
-const getSharedObservable = (namespace, args, createObservable, serializer = args => JSON.stringify(args)) => {
-  const cacheKey = `${namespace}:${serializer(args)}`;
-  if (CACHE.has(cacheKey)) return CACHE.get(cacheKey);
-  const obs = createObservable(args);
-  const sharedObs = obs.pipe(shareReplay({
-    bufferSize: 1,
-    refCount: true
-  }));
-  CACHE.set(cacheKey, sharedObs);
-  return sharedObs;
-};
+function isBool(value) {
+  return typeof value === "boolean";
+}
+
+const isTruthy = value => Boolean(value);
 
 /**
  * An RxJS operator that keeps the source observable alive for a specified duration
@@ -373,9 +265,120 @@ const keepSourceSubscribed = (observable, ms) => {
   return () => setTimeout(() => sub.unsubscribe(), ms);
 };
 
-const REGEX_HEX_STRING = /^0x[0-9a-fA-F]*$/;
-const isHexString = value => {
-  return typeof value === "string" && REGEX_HEX_STRING.test(value);
+function planckToTokens(planck, tokenDecimals) {
+  if (typeof planck !== "string" || typeof tokenDecimals !== "number") return;
+  const base = 10;
+  const exponent = -1 * tokenDecimals;
+  const multiplier = base ** exponent;
+  return new BigNumber(planck).multipliedBy(multiplier).toString(10);
+}
+
+/**
+ * Turns a value into a {@link ReplaySubject} of size 1.
+ *
+ * If the value is already a {@link ReplaySubject}, it will be returned as-is.
+ *
+ * If the value is a {@link Promise}, it will be awaited,
+ * and the awaited value will be published into the {@link ReplaySubject} when it becomes available.
+ *
+ * For any other type of value, it will be immediately published into the {@link ReplaySubject}.
+ */
+const replaySubjectFrom = initialValue => {
+  if (initialValue instanceof ReplaySubject) return initialValue;
+  const subject = new ReplaySubject(1);
+
+  // if initialValue is a promise, await it and then call `subject.next()` with the awaited value
+  if (isPromise(initialValue)) {
+    initialValue.then(value => subject.next(value), error => subject.error(error));
+    return subject;
+  }
+
+  // if initialValue is not a promise, immediately call `subject.next()` with the value
+  subject.next(initialValue);
+  return subject;
+};
+
+const sleep = ms => new Promise(resolve => {
+  if (process.env.NODE_ENV === "test") resolve();else setTimeout(resolve, ms);
+});
+
+/**
+ * Takes a subject and splits it into two parts:
+ *
+ * 1. A function to submit new values into the subject.
+ * 2. An observable for subscribing to new values from the subject.
+ *
+ * This can be helpful when, to avoid bugs, you want to expose only one
+ * of these parts to external code and keep the other part private.
+ */
+function splitSubject(subject) {
+  const next = value => subject.next(value);
+  const observable = subject.asObservable();
+  return [next, observable];
+}
+
+const throwAfter = (ms, reason) => new Promise((_, reject) => setTimeout(() => reject(new Error(reason)), ms));
+
+function tokensToPlanck(tokens, tokenDecimals) {
+  if (typeof tokens !== "string" || typeof tokenDecimals !== "number") return;
+  const base = 10;
+  const exponent = tokenDecimals;
+  const multiplier = base ** exponent;
+  return new BigNumber(tokens).multipliedBy(multiplier).toString(10);
+}
+
+/**
+ * @name validateHexString
+ * @description Checks if a string is a hex string. Required to account for type differences between different polkadot libraries
+ * @param {string} str - string to check
+ * @returns {`0x${string}`} - boolean
+ * @example
+ * validateHexString("0x1234") // "0x1234"
+ * validateHexString("1234") // Error: Expected a hex string
+ * validateHexString(1234) // Error: Expected a string
+ **/
+const validateHexString = str => {
+  if (typeof str !== "string") {
+    throw new Error("Expected a string");
+  }
+  if (str.startsWith("0x")) {
+    return str;
+  }
+  throw new Error("Expected a hex string");
+};
+
+// Designed to be serializable as it can be sent to the frontend
+
+function getLoadable$(factory, options = {}) {
+  const {
+    getError,
+    refreshInterval
+  } = options;
+  const createLoadableStream = () => from(factory()).pipe(map(data => ({
+    status: "success",
+    data
+  })), catchError(error => of({
+    status: "error",
+    error: getError ? getError(error) : getGenericError(error)
+  })));
+  const source$ = refreshInterval ? timer(0, refreshInterval).pipe(switchMap(() => createLoadableStream())) : createLoadableStream();
+  return source$.pipe(startWith({
+    status: "loading"
+  }));
+}
+const getGenericError = error => ({
+  name: "Error",
+  message: getGenericErrorMessage(error)
+});
+const getGenericErrorMessage = error => {
+  if (typeof error === "string") {
+    return error;
+  } else if (error instanceof Error) {
+    return error.message;
+  } else if (error && typeof error === "object" && "message" in error) {
+    return error.message;
+  }
+  return String(error) || "Unknown error";
 };
 
-export { BigMath, Deferred, MAX_DECIMALS_FORMAT, REGEX_HEX_STRING, addTrailingSlash, blake2Concat, classNames, convertAddress, decodeAnyAddress, decodeSs58Format, encodeAnyAddress, firstThenDebounce, formatDecimals, formatPrice, getSharedObservable, hasOwnProperty, isAbortError, isAddressEqual, isArrayOf, isAscii, isBigInt, isBooleanTrue, isEthereumAddress, isHexString, isNotNil, isTruthy, isValidSubstrateAddress, keepAlive, normalizeAddress, planckToTokens, sleep, throwAfter, tokensToPlanck, twox64Concat, validateHexString };
+export { BigMath, Deferred, MAX_DECIMALS_FORMAT, REGEX_HEX_STRING, addTrailingSlash, classNames, cn, firstThenDebounce, formatDecimals, formatPrice, getLoadable$, getSharedObservable, hasOwnProperty, isAbortError, isArrayOf, isAscii, isBigInt, isBooleanTrue, isHexString, isNotNil, isPromise, isSubject, isTruthy, keepAlive, planckToTokens, replaySubjectFrom, sleep, splitSubject, throwAfter, tokensToPlanck, validateHexString };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@talismn/util",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "author": "Talisman",
   "homepage": "https://talisman.xyz",
   "license": "GPL-3.0-or-later",
@@ -26,9 +26,6 @@
     "tailwind-merge": "^2.5.4"
   },
   "devDependencies": {
-    "@polkadot/keyring": "13.5.1",
-    "@polkadot/util": "13.5.1",
-    "@polkadot/util-crypto": "13.5.1",
     "@types/jest": "^29.5.14",
     "eslint": "^8.57.1",
     "jest": "^29.7.0",
@@ -38,9 +35,6 @@
     "@talismn/eslint-config": "0.0.3"
   },
   "peerDependencies": {
-    "@polkadot/keyring": "*",
-    "@polkadot/util": "*",
-    "@polkadot/util-crypto": "*",
     "rxjs": ">= 7.8.1"
   },
   "eslintConfig": {

package/dist/declarations/src/blake2Concat.d.ts

@@ -1 +0,0 @@
-export declare function blake2Concat(input: Uint8Array): `0x${string}`;

package/dist/declarations/src/convertAddress.d.ts

@@ -1,7 +0,0 @@
-/**
- *
- * @param address substrate SS58 address
- * @param prefix prefix used to format the address
- * @returns address encoded with supplied prefix
- */
-export declare const convertAddress: (address: string, prefix: number | null) => string;

package/dist/declarations/src/decodeAnyAddress.d.ts

@@ -1 +0,0 @@
-export declare function decodeAnyAddress(encoded?: string | Uint8Array | null | undefined, ignoreChecksum?: boolean | undefined, ss58Format?: number | undefined): Uint8Array;

package/dist/declarations/src/decodeSs58Format.d.ts

@@ -1 +0,0 @@
-export declare const decodeSs58Format: (address?: string) => number | undefined;

package/dist/declarations/src/encodeAnyAddress.d.ts

@@ -1 +0,0 @@
-export declare function encodeAnyAddress(key: string | Uint8Array, ss58Format?: number | undefined): string;

package/dist/declarations/src/isAddressEqual.d.ts

@@ -1 +0,0 @@
-export declare const isAddressEqual: (address1: string, address2: string) => boolean;

package/dist/declarations/src/isEthereumAddress.d.ts

@@ -1 +0,0 @@
-export declare const isEthereumAddress: (address: string | undefined | null) => address is `0x${string}`;

package/dist/declarations/src/isValidSubstrateAddress.d.ts

@@ -1,7 +0,0 @@
-/**
- * Similar to isValidAddress but will not call isEthereumAddress under the hood
- * @param address
- * @param prefix if supplied, the method will also check the prefix
- * @returns true if valid substrate (SS58) address, false otherwise
- */
-export declare const isValidSubstrateAddress: (address: string, prefix?: number | null) => boolean;

package/dist/declarations/src/normalizeAddress.d.ts

@@ -1 +0,0 @@
-export declare const normalizeAddress: (address: string) => string;

package/dist/declarations/src/twox64Concat.d.ts

@@ -1 +0,0 @@
-export declare function twox64Concat(input: string | Buffer | Uint8Array): `0x${string}`;