@talismn/util 0.4.2 → 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 } 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,43 +140,129 @@ 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 isAscii = str => {
+  return [...str].every(char => char.charCodeAt(0) <= 127);
+};
+
 const isBigInt = value => typeof value === "bigint";
 
 const isBooleanTrue = x => !!x;
 
-const isEthereumAddress = address => !!address && address.startsWith("0x") && address.length === 42;
+const REGEX_HEX_STRING = /^0x[0-9a-fA-F]*$/;
+const isHexString = value => {
+  return typeof value === "string" && REGEX_HEX_STRING.test(value);
+};
 
 /**
- * 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
+ * WARNING: This function only checks against null or undefined, it does not coerce the value.
+ * ie: false and 0 are considered not nil
+ * Use isTruthy instead for a regular coercion check.
+ *
+ * @param value
+ * @returns whether the value is neither null nor undefined
  */
-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;
-  }
+const isNotNil = value => value !== null && value !== undefined;
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const isPromise = value => !!value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+
+/**
+ * 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);
+}
+
+/**
+ * Returns `true` if `value` is a function.
+ */
+function isFn(value) {
+  return typeof value === "function";
+}
+
+/**
+ * Returns `true` if `value` is a boolean.
+ */
+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
+ * after all subscribers have unsubscribed. This prevents expensive re-subscriptions
+ * when subscribers come and go frequently.
+ *
+ * @param keepAliveMs - Duration in milliseconds to keep the source alive after last unsubscription
+ * @returns MonoTypeOperatorFunction that can be used in pipe()
+ *
+ * @example
+ * ```typescript
+ * const data$ = expensive_api_call$.pipe(
+ *   keepAlive(3000) // Keep alive for 3 seconds
+ * );
+ * ```
+ */
+const keepAlive = timeout => {
+  let release;
+  return source => source.pipe(tap({
+    subscribe: () => {
+      release = keepSourceSubscribed(source, timeout);
+    },
+    unsubscribe: () => {
+      release?.();
+    }
+  }), shareReplay({
+    refCount: true,
+    bufferSize: 1
+  }));
+};
+const keepSourceSubscribed = (observable, ms) => {
+  const sub = observable.subscribe();
+  return () => setTimeout(() => sub.unsubscribe(), ms);
 };
 
 function planckToTokens(planck, tokenDecimals) {
@@ -236,10 +273,50 @@ function planckToTokens(planck, tokenDecimals) {
   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) {
@@ -250,17 +327,11 @@ function tokensToPlanck(tokens, tokenDecimals) {
   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
+ * @returns {`0x${string}`} - boolean
  * @example
  * validateHexString("0x1234") // "0x1234"
  * validateHexString("1234") // Error: Expected a hex string
@@ -276,38 +347,38 @@ const validateHexString = str => {
   throw new Error("Expected a hex string");
 };
 
-const CACHE = 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.has(address)) CACHE.set(address, encodeAnyAddress(address));
-    return CACHE.get(address);
-  } catch (cause) {
-    throw new Error(`Unable to normalize address: ${address}`, {
-      cause
-    });
+// 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";
 };
 
-const isAddressEqual = (address1, address2) => {
-  return normalizeAddress(address1) === normalizeAddress(address2);
-};
-
-const isAscii = str => {
-  return [...str].every(char => char.charCodeAt(0) <= 127);
-};
-
-/**
- * WARNING: This function only checks against null or undefined, it does not coerce the value.
- * ie: false and 0 are considered not nil
- * Use isTruthy instead for a regular coercion check.
- *
- * @param value
- * @returns whether the value is neither null nor undefined
- */
-const isNotNil = value => value !== null && value !== undefined;
-
-const isTruthy = value => Boolean(value);
-
-export { BigMath, Deferred, MAX_DECIMALS_FORMAT, addTrailingSlash, blake2Concat, classNames, convertAddress, decodeAnyAddress, decodeSs58Format, encodeAnyAddress, firstThenDebounce, formatDecimals, formatPrice, hasOwnProperty, isAddressEqual, isArrayOf, isAscii, isBigInt, isBooleanTrue, isEthereumAddress, isNotNil, isTruthy, isValidSubstrateAddress, 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.4.2",
+  "version": "0.5.1",
   "author": "Talisman",
   "homepage": "https://talisman.xyz",
   "license": "GPL-3.0-or-later",
@@ -26,21 +26,15 @@
     "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",
     "ts-jest": "^29.2.5",
     "typescript": "^5.6.3",
-    "@talismn/eslint-config": "0.0.3",
-    "@talismn/tsconfig": "0.0.2"
+    "@talismn/tsconfig": "0.0.2",
+    "@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}`;