@talismn/util 1.0.1 → 2.0.0

package/dist/index.mjs

@@ -1,414 +1,853 @@
-// src/addTrailingSlash.ts
-var addTrailingSlash = (url) => {
-  if (url.endsWith("/")) {
-    return url;
-  }
-  return `${url}/`;
+import BigNumber from "bignumber.js";
+import { isEqual } from "lodash-es";
+import { BehaviorSubject, Observable, ReplaySubject, Subject, catchError, concat, concatMap, debounceTime, distinctUntilChanged, from, map, of, shareReplay, skip, startWith, switchMap, take, tap, timer } from "rxjs";
+//#region src/configureBigNumber.ts
+BigNumber.set({ STRICT: false });
+var configureBigNumber_default = BigNumber;
+//#endregion
+//#region src/addTrailingSlash.ts
+const addTrailingSlash = (url) => {
+	if (url.endsWith("/")) return url;
+	return `${url}/`;
 };
-
-// src/BigMath.ts
-var BigMath = {
-  abs(x) {
-    return x < 0n ? -x : x;
-  },
-  sign(x) {
-    if (x === 0n) return 0n;
-    return x < 0n ? -1n : 1n;
-  },
-  // TODO: Improve our babel/tsc config to let us use the `**` operator on bigint values.
-  // Error thrown: Exponentiation cannot be performed on 'bigint' values unless the 'target' option is set to 'es2016' or later. ts(2791)
-  // pow(base: bigint, exponent: bigint) {
-  //   return base ** exponent
-  // },
-  min(value, ...values) {
-    for (const v of values) if (v < value) value = v;
-    return value;
-  },
-  max(value, ...values) {
-    for (const v of values) if (v > value) value = v;
-    return value;
-  }
+//#endregion
+//#region src/assert.ts
+/**
+* @name assert
+* @description Throws an Error with the given message if the condition is falsy.
+* @example
+* assert(chain, "Chain not found")
+**/
+function assert(condition, message) {
+	if (condition) return;
+	throw new Error(typeof message === "function" ? message() : message);
+}
+//#endregion
+//#region src/BigMath.ts
+/**
+* Javascript's `Math` library for `BigInt`.
+* Taken from https://stackoverflow.com/questions/51867270/is-there-a-library-similar-to-math-that-supports-javascript-bigint/64953280#64953280
+*/
+const BigMath = {
+	abs(x) {
+		return x < 0n ? -x : x;
+	},
+	sign(x) {
+		if (x === 0n) return 0n;
+		return x < 0n ? -1n : 1n;
+	},
+	min(value, ...values) {
+		for (const v of values) if (v < value) value = v;
+		return value;
+	},
+	max(value, ...values) {
+		for (const v of values) if (v > value) value = v;
+		return value;
+	}
 };
-
-// src/deferred.ts
+//#endregion
+//#region src/isHexString.ts
+const REGEX_HEX_STRING = /^0x[0-9a-fA-F]*$/;
+const isHexString = (value) => {
+	return typeof value === "string" && REGEX_HEX_STRING.test(value);
+};
+//#endregion
+//#region src/bytes.ts
+/**
+* Byte / hex primitives, drop-in equivalents of the `@polkadot/util` helpers we used to depend on.
+* Semantics intentionally match polkadot-js for migration safety.
+*/
+const hexToU8a = (hex) => {
+	if (!hex) return /* @__PURE__ */ new Uint8Array();
+	const value = hex.startsWith("0x") ? hex.slice(2) : hex;
+	const padded = value.length % 2 ? `${value}0` : value;
+	const result = new Uint8Array(padded.length / 2);
+	for (let i = 0; i < result.length; i++) result[i] = parseInt(padded.substring(i * 2, i * 2 + 2), 16);
+	return result;
+};
+const u8aToHex = (value) => {
+	if (!value?.length) return "0x";
+	let hex = "";
+	for (const byte of value) hex += byte.toString(16).padStart(2, "0");
+	return `0x${hex}`;
+};
+const stringToU8a = (value) => value ? new TextEncoder().encode(value) : /* @__PURE__ */ new Uint8Array();
+const u8aToString = (value) => value?.length ? new TextDecoder("utf-8").decode(value) : "";
+const hexToString = (hex) => u8aToString(hexToU8a(hex));
+const hexToNumber = (hex) => hex ? parseInt(hex, 16) : NaN;
+const numberToU8a = (value) => {
+	let hex = (value ?? 0).toString(16);
+	if (hex.length % 2) hex = `0${hex}`;
+	return hexToU8a(hex);
+};
+/** Coerces hex strings, utf-8 strings, number arrays and buffers to Uint8Array (polkadot-js semantics) */
+const u8aToU8a = (value) => {
+	if (!value) return /* @__PURE__ */ new Uint8Array();
+	if (value instanceof Uint8Array) return value;
+	if (Array.isArray(value)) return new Uint8Array(value);
+	return isHexString(value) ? hexToU8a(value) : stringToU8a(value);
+};
+const u8aConcat = (...items) => {
+	const chunks = items.map((item) => u8aToU8a(item));
+	const result = new Uint8Array(chunks.reduce((total, chunk) => total + chunk.length, 0));
+	let offset = 0;
+	for (const chunk of chunks) {
+		result.set(chunk, offset);
+		offset += chunk.length;
+	}
+	return result;
+};
+const u8aEq = (a, b) => {
+	const u8aa = u8aToU8a(a);
+	const u8ab = u8aToU8a(b);
+	if (u8aa.length !== u8ab.length) return false;
+	return u8aa.every((byte, i) => byte === u8ab[i]);
+};
+const u8aCmp = (a, b) => {
+	const u8aa = u8aToU8a(a);
+	const u8ab = u8aToU8a(b);
+	for (let i = 0; i < Math.max(u8aa.length, u8ab.length); i++) {
+		const byteA = u8aa[i] ?? 0;
+		const byteB = u8ab[i] ?? 0;
+		if (byteA !== byteB) return byteA < byteB ? -1 : 1;
+	}
+	return u8aa.length === u8ab.length ? 0 : u8aa.length < u8ab.length ? -1 : 1;
+};
+/**
+* Tests if the input is printable ASCII (code points 32-126). Hex strings are decoded to bytes
+* first, other strings are checked character-wise (polkadot-js `isAscii` semantics).
+*/
+const isAsciiPrintable = (value) => {
+	if (value == null) return false;
+	return (typeof value === "string" && !isHexString(value) ? stringToU8a(value) : u8aToU8a(value)).every((b) => b >= 32 && b <= 126);
+};
+const U8A_WRAP_PREFIX = stringToU8a("<Bytes>");
+const U8A_WRAP_POSTFIX = stringToU8a("</Bytes>");
+const u8aIsWrapped = (value) => value.length >= U8A_WRAP_PREFIX.length + U8A_WRAP_POSTFIX.length && u8aEq(value.subarray(0, U8A_WRAP_PREFIX.length), U8A_WRAP_PREFIX) && u8aEq(value.subarray(value.length - U8A_WRAP_POSTFIX.length), U8A_WRAP_POSTFIX);
+/** Wraps bytes with `<Bytes>...</Bytes>` for raw-message signing, unless already wrapped */
+const u8aWrapBytes = (value) => {
+	const u8a = u8aToU8a(value);
+	return u8aIsWrapped(u8a) ? u8a : u8aConcat(U8A_WRAP_PREFIX, u8a, U8A_WRAP_POSTFIX);
+};
+const u8aUnwrapBytes = (value) => {
+	const u8a = u8aToU8a(value);
+	return u8aIsWrapped(u8a) ? u8a.subarray(U8A_WRAP_PREFIX.length, u8a.length - U8A_WRAP_POSTFIX.length) : u8a;
+};
+//#endregion
+//#region src/jsActivityHook.ts
+const reportJsActivity = (label, durationMs) => {
+	const record = globalThis.__recordJsActivity;
+	if (record) record(label, durationMs);
+};
+//#endregion
+//#region src/yieldToEventLoop.ts
+const yieldToEventLoop = () => {
+	if (typeof MessageChannel !== "undefined") return new Promise((resolve) => {
+		const channel = new MessageChannel();
+		const port1 = channel.port1;
+		const port2 = channel.port2;
+		port1.onmessage = () => {
+			port1.close();
+			port2.close();
+			resolve();
+		};
+		port2.postMessage(null);
+	});
+	return new Promise((resolve) => setTimeout(resolve, 0));
+};
+//#endregion
+//#region src/timeSlicer.ts
+/**
+* Default CPU budget for a single synchronous slice of chunked work.
+* ~50-60% of a 60fps frame, leaving the rest for the host (user interactions, rendering).
+*/
+const DEFAULT_TIME_SLICE_BUDGET_MS = 10;
+/**
+* Creates an AbortError-style error without relying on DOMException (not available on Hermes).
+* Recognized by `isAbortError` from this package.
+*/
+const newAbortError = () => Object.assign(/* @__PURE__ */ new Error("Aborted"), { name: "AbortError" });
+const defaultNow = typeof performance !== "undefined" ? () => performance.now() : () => Date.now();
+/**
+* Tracks a time budget for cooperative scheduling: run synchronous work until the budget
+* for the current slice is exhausted, then yield the thread back to the host event loop
+* before continuing.
+*
+* A single slicer can be shared across multiple phases of work so the budget spans them.
+*/
+const createTimeSlicer = ({ budgetMs = 10, signal, now = defaultNow, label } = {}) => {
+	let sliceStart = now();
+	const throwIfAborted = () => {
+		if (signal?.aborted) throw newAbortError();
+	};
+	const shouldYield = () => now() - sliceStart >= budgetMs;
+	const doYield = async () => {
+		const elapsed = now() - sliceStart;
+		if (elapsed >= budgetMs * 3) reportJsActivity(`timeSlicer over-budget slice${label ? ` (${label})` : ""}`, elapsed);
+		await yieldToEventLoop();
+		sliceStart = now();
+		throwIfAborted();
+	};
+	return {
+		signal,
+		shouldYield,
+		yield: doYield,
+		yieldIfNeeded: () => {
+			throwIfAborted();
+			return shouldYield() ? doYield() : void 0;
+		},
+		throwIfAborted
+	};
+};
+//#endregion
+//#region src/chunkedArray.ts
+const getSlicer = (options) => options?.slicer ?? createTimeSlicer({
+	budgetMs: options?.budgetMs,
+	signal: options?.signal,
+	label: options?.label
+});
+/**
+* `Array.prototype.forEach`, chunked: iterates synchronously until the time budget is
+* exhausted, then yields the thread to the host event loop before continuing.
+*
+* Errors thrown by `fn` reject the promise; aborting rejects with an AbortError at the
+* next between-items check point.
+*/
+const forEachWithYield = async (items, fn, options) => {
+	const slicer = getSlicer(options);
+	for (let i = 0; i < items.length; i++) {
+		const yielded = slicer.yieldIfNeeded();
+		if (yielded) await yielded;
+		fn(items[i], i);
+	}
+	const yielded = slicer.yieldIfNeeded();
+	if (yielded) await yielded;
+};
+/** `Array.prototype.map`, chunked (see forEachWithYield for semantics) */
+const mapWithYield = async (items, fn, options) => {
+	const results = new Array(items.length);
+	await forEachWithYield(items, (item, i) => results[i] = fn(item, i), options);
+	return results;
+};
+/** lodash `keyBy`, chunked (see forEachWithYield for semantics) */
+const keyByWithYield = async (items, keyFn, options) => {
+	const result = {};
+	await forEachWithYield(items, (item, i) => result[keyFn(item, i)] = item, options);
+	return result;
+};
+/**
+* Chunked equivalent of lodash `isEqual(a, b)` for arrays: `a === b` fast path, length
+* check, then per-item `a[i] === b[i] || isItemEqual(a[i], b[i])` within the time budget.
+* The result is identical to `isEqual(a, b)`.
+*/
+const arrayItemsEqualWithYield = async (a, b, options) => {
+	if (a === b) return true;
+	if (!a || !b) return false;
+	if (a.length !== b.length) return false;
+	const isItemEqual = options?.isItemEqual ?? isEqual;
+	const slicer = getSlicer(options);
+	for (let i = 0; i < a.length; i++) {
+		const yielded = slicer.yieldIfNeeded();
+		if (yielded) await yielded;
+		if (a[i] !== b[i] && !isItemEqual(a[i], b[i])) return false;
+	}
+	return true;
+};
+//#endregion
+//#region src/deferred.ts
+/**
+* In TypeScript, a deferred promise refers to a pattern that involves creating a promise that can be
+* resolved or rejected at a later point in time, typically by code outside of the current function scope.
+*
+* This pattern is often used when dealing with asynchronous operations that involve multiple steps or when
+* the result of an operation cannot be immediately determined.
+*/
 function Deferred() {
-  let resolve;
-  let reject;
-  let isPending = true;
-  let isResolved = false;
-  let isRejected = false;
-  const promise = new Promise((innerResolve, innerReject) => {
-    resolve = (value) => {
-      isPending = false;
-      isResolved = true;
-      innerResolve(value);
-    };
-    reject = (reason) => {
-      isPending = false;
-      isRejected = true;
-      innerReject(reason);
-    };
-  });
-  return {
-    promise,
-    resolve,
-    reject,
-    isPending: () => isPending,
-    isResolved: () => isResolved,
-    isRejected: () => isRejected
-  };
+	let resolve;
+	let reject;
+	let isPending = true;
+	let isResolved = false;
+	let isRejected = false;
+	return {
+		promise: new Promise((innerResolve, innerReject) => {
+			resolve = (value) => {
+				isPending = false;
+				isResolved = true;
+				innerResolve(value);
+			};
+			reject = (reason) => {
+				isPending = false;
+				isRejected = true;
+				innerReject(reason);
+			};
+		}),
+		resolve,
+		reject,
+		isPending: () => isPending,
+		isResolved: () => isResolved,
+		isRejected: () => isRejected
+	};
 }
-
-// src/firstThenDebounce.ts
-import { concat, debounceTime, skip, take } from "rxjs";
-var firstThenDebounce = (timeout) => (source) => concat(source.pipe(take(1)), source.pipe(skip(1)).pipe(debounceTime(timeout)));
-
-// src/formatDecimals.ts
-import BigNumber from "bignumber.js";
-var MIN_DIGITS = 4;
-var MAX_DECIMALS_FORMAT = 12;
-var formatDecimals = (num, digits = MIN_DIGITS, options = {}, locale = "en-US") => {
-  if (num === null || num === void 0) return "";
-  if (digits < MIN_DIGITS) digits = MIN_DIGITS;
-  const value = new BigNumber(num);
-  const minDisplayVal = 1 / 10 ** digits;
-  if (value.gt(0) && value.lt(minDisplayVal)) return `< ${formatDecimals(minDisplayVal)}`;
-  const flooredValue = value.integerValue();
-  const intDigits = flooredValue.isEqualTo(0) ? 0 : flooredValue.toString().length;
-  let truncatedValue = value;
-  const excessFractionDigitsPow10 = new BigNumber(10).pow(
-    digits > intDigits ? digits - intDigits : 0
-  );
-  truncatedValue = truncatedValue.multipliedBy(excessFractionDigitsPow10).integerValue().dividedBy(excessFractionDigitsPow10);
-  const excessIntegerDigits = new BigNumber(intDigits > digits ? intDigits - digits : 0);
-  const excessIntegerDigitsPow10 = new BigNumber(10).pow(excessIntegerDigits);
-  if (excessIntegerDigits.gt(0))
-    truncatedValue = truncatedValue.dividedBy(excessIntegerDigitsPow10).integerValue().multipliedBy(excessIntegerDigitsPow10);
-  return Intl.NumberFormat(locale, {
-    // compact notation (K, M, B) if above 9999
-    notation: truncatedValue.abs().gt(9999) ? "compact" : "standard",
-    // NOTE: possible values are from `0` to `21`
-    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/NumberFormat#maximumsignificantdigits
-    maximumSignificantDigits: Math.max(1, Math.min(digits + (truncatedValue.lt(1) ? 1 : 0), 21)),
-    ...options
-  }).format(truncatedValue.toNumber());
+//#endregion
+//#region src/firstThenDebounce.ts
+/**
+* An rxjs operator which:
+*
+* 1. Emits the first value it receives from the source observable, then:
+* 2. Debounces any future values by `timeout` ms.
+*/
+const firstThenDebounce = (timeout) => (source) => concat(source.pipe(take(1)), source.pipe(skip(1)).pipe(debounceTime(timeout)));
+//#endregion
+//#region src/formatDecimals.ts
+const MIN_DIGITS = 4;
+const MAX_DECIMALS_FORMAT = 12;
+/**
+* Custom decimal number formatting for Talisman
+* note that the NumberFormat().format() call is the ressource heavy part, it's not worth trying to optimize other parts
+* @param num input number
+* @param digits number of significant digits to display
+* @param locale locale used to format the number
+* @param options formatting options
+* @returns the formatted value
+*/
+const formatDecimals = (num, digits = MIN_DIGITS, options = {}, locale = "en-US") => {
+	if (num === null || num === void 0) return "";
+	if (digits < MIN_DIGITS) digits = MIN_DIGITS;
+	const value = new configureBigNumber_default(num);
+	const minDisplayVal = 1 / 10 ** digits;
+	if (value.gt(0) && value.lt(minDisplayVal)) return `< ${formatDecimals(minDisplayVal)}`;
+	const flooredValue = value.integerValue();
+	const intDigits = flooredValue.isEqualTo(0) ? 0 : flooredValue.toString().length;
+	let truncatedValue = value;
+	const excessFractionDigitsPow10 = new configureBigNumber_default(10).pow(digits > intDigits ? digits - intDigits : 0);
+	truncatedValue = truncatedValue.multipliedBy(excessFractionDigitsPow10).integerValue().dividedBy(excessFractionDigitsPow10);
+	const excessIntegerDigits = new configureBigNumber_default(intDigits > digits ? intDigits - digits : 0);
+	const excessIntegerDigitsPow10 = new configureBigNumber_default(10).pow(excessIntegerDigits);
+	if (excessIntegerDigits.gt(0)) truncatedValue = truncatedValue.dividedBy(excessIntegerDigitsPow10).integerValue().multipliedBy(excessIntegerDigitsPow10);
+	return Intl.NumberFormat(locale, {
+		notation: truncatedValue.abs().gt(9999) ? "compact" : "standard",
+		maximumSignificantDigits: Math.max(1, Math.min(digits + (truncatedValue.lt(1) ? 1 : 0), 21)),
+		...options
+	}).format(truncatedValue.toNumber());
 };
-
-// src/formatPrice.ts
-var formatPrice = (price, currency, compact) => {
-  return Intl.NumberFormat(void 0, {
-    style: "currency",
-    currency,
-    currencyDisplay: currency === "usd" ? "narrowSymbol" : "symbol",
-    minimumSignificantDigits: 3,
-    maximumSignificantDigits: compact ? price < 1 ? 3 : 4 : void 0,
-    roundingPriority: compact ? "auto" : "morePrecision",
-    notation: compact ? "compact" : "standard"
-  }).format(price);
+//#endregion
+//#region src/formatPrice.ts
+const formatPrice = (price, currency, compact) => {
+	return Intl.NumberFormat(void 0, {
+		style: "currency",
+		currency,
+		currencyDisplay: currency === "usd" ? "narrowSymbol" : "symbol",
+		minimumSignificantDigits: 3,
+		maximumSignificantDigits: compact ? price < 1 ? 3 : 4 : void 0,
+		roundingPriority: compact ? "auto" : "morePrecision",
+		notation: compact ? "compact" : "standard"
+	}).format(price);
 };
-
-// src/getLoadable.ts
-import { catchError, from, map, of, startWith, switchMap, timer } from "rxjs";
+//#endregion
+//#region src/getLoadable.ts
 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 { getError, refreshInterval } = options;
+	const createLoadableStream = () => from(factory()).pipe(map((data) => ({
+		status: "success",
+		data
+	})), catchError((error) => of({
+		status: "error",
+		error: getError ? getError(error) : getGenericError(error)
+	})));
+	return (refreshInterval ? timer(0, refreshInterval).pipe(switchMap(() => createLoadableStream())) : createLoadableStream()).pipe(startWith({ status: "loading" }));
 }
-var getGenericError = (error) => ({
-  name: "Error",
-  message: getGenericErrorMessage(error)
+const getGenericError = (error) => ({
+	name: "Error",
+	message: getGenericErrorMessage(error)
 });
-var 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 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";
 };
-
-// src/getLoadableQuery.ts
-import { map as map2, startWith as startWith2 } from "rxjs";
-
-// src/getQuery.ts
-import { isEqual } from "lodash-es";
-import { BehaviorSubject, distinctUntilChanged, Observable, shareReplay as shareReplay2 } from "rxjs";
-
-// src/getSharedObservable.ts
-import { shareReplay } from "rxjs";
-var CACHE = /* @__PURE__ */ new Map();
-var getSharedObservable = (namespace, args, createObservable, serializer = (args2) => JSON.stringify(args2)) => {
-  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;
+//#endregion
+//#region src/getSharedObservable.ts
+const CACHE = /* @__PURE__ */ new Map();
+/**
+* How long an entry survives with no subscribers before being dropped. Long enough
+* for quick unmount/remount cycles (navigation, react-rxjs Subscribe boundaries) to
+* reuse the entry, short enough that abandoned scopes (e.g. superseded balance
+* subscriptions after networks/accounts change) don't accumulate forever.
+*/
+const CLEANUP_DELAY_MS = 6e4;
+/**
+* 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
+*
+* Entries are reference-counted: an entry with no subscribers for CLEANUP_DELAY_MS is
+* removed from the cache (its shareReplay source is already torn down by refCount at
+* that point — only the replay buffer and the entry itself are dropped).
+*
+* @param namespace
+* @param args
+* @param createObservable
+* @param serializer
+* @returns
+*/
+const getSharedObservable = (namespace, args, createObservable, serializer = (args) => JSON.stringify(args)) => {
+	const cacheKey = `${namespace}:${serializer(args)}`;
+	const cached = CACHE.get(cacheKey);
+	if (cached) return cached.observable;
+	const sharedObs = createObservable(args).pipe(shareReplay({
+		bufferSize: 1,
+		refCount: true
+	}));
+	const scheduleCleanup = (entry) => {
+		if (entry.cleanupTimer) clearTimeout(entry.cleanupTimer);
+		entry.cleanupTimer = setTimeout(() => {
+			if (entry.refCount === 0 && CACHE.get(cacheKey) === entry) CACHE.delete(cacheKey);
+		}, CLEANUP_DELAY_MS);
+	};
+	const entry = {
+		observable: null,
+		refCount: 0,
+		cleanupTimer: null
+	};
+	entry.observable = new Observable((subscriber) => {
+		entry.refCount++;
+		if (entry.cleanupTimer) {
+			clearTimeout(entry.cleanupTimer);
+			entry.cleanupTimer = null;
+		}
+		const subscription = sharedObs.subscribe(subscriber);
+		return () => {
+			subscription.unsubscribe();
+			entry.refCount--;
+			if (entry.refCount === 0) scheduleCleanup(entry);
+		};
+	});
+	CACHE.set(cacheKey, entry);
+	scheduleCleanup(entry);
+	return entry.observable;
 };
-
-// src/getQuery.ts
-var getQuery$ = ({
-  namespace,
-  args,
-  queryFn,
-  defaultValue,
-  refreshInterval,
-  serializer = (args2) => JSON.stringify(args2)
-}) => {
-  return getSharedObservable(
-    namespace,
-    args,
-    () => new Observable((subscriber) => {
-      const controller = new AbortController();
-      const result = new BehaviorSubject({
-        status: "loading",
-        data: defaultValue,
-        error: void 0
-      });
-      const sub = result.pipe(distinctUntilChanged(isEqual)).subscribe(subscriber);
-      let timeout = null;
-      const run = () => {
-        if (controller.signal.aborted) return;
-        queryFn(args, controller.signal).then((data) => {
-          if (controller.signal.aborted) return;
-          result.next({ status: "loaded", data, error: void 0 });
-        }).catch((error) => {
-          if (controller.signal.aborted) return;
-          result.next({ status: "error", data: void 0, error });
-        }).finally(() => {
-          if (controller.signal.aborted) return;
-          if (refreshInterval) timeout = setTimeout(run, refreshInterval);
-        });
-      };
-      run();
-      return () => {
-        sub.unsubscribe();
-        if (timeout) clearTimeout(timeout);
-        controller.abort(new Error("getQuery$ unsubscribed"));
-      };
-    }).pipe(shareReplay2({ refCount: true, bufferSize: 1 })),
-    serializer
-  );
+//#endregion
+//#region src/getQuery.ts
+/**
+* Creates a shared observable for executing queries with caching, loading states, and automatic refresh capabilities.
+*
+* @example
+* ```typescript
+* const userQuery$ = getQuery$({
+*   namespace: 'users',
+*   args: { userId: 123 },
+*   queryFn: async ({ userId }) => fetchUser(userId),
+*   defaultValue: null,
+*   refreshInterval: 30000
+* });
+*
+* userQuery$.subscribe(result => {
+*   if (result.status === 'loaded') {
+*     console.log(result.data);
+*   }
+* });
+* ```
+*
+* @deprecated use getLoadableQuery$ instead
+*/
+const getQuery$ = ({ namespace, args, queryFn, defaultValue, refreshInterval, serializer = (args) => JSON.stringify(args) }) => {
+	return getSharedObservable(namespace, args, () => new Observable((subscriber) => {
+		const controller = new AbortController();
+		const result = new BehaviorSubject({
+			status: "loading",
+			data: defaultValue,
+			error: void 0
+		});
+		const sub = result.pipe(distinctUntilChanged(isEqual)).subscribe(subscriber);
+		let timeout = null;
+		const run = () => {
+			if (controller.signal.aborted) return;
+			queryFn(args, controller.signal).then((data) => {
+				if (controller.signal.aborted) return;
+				result.next({
+					status: "loaded",
+					data,
+					error: void 0
+				});
+			}).catch((error) => {
+				if (controller.signal.aborted) return;
+				result.next({
+					status: "error",
+					data: void 0,
+					error
+				});
+			}).finally(() => {
+				if (controller.signal.aborted) return;
+				if (refreshInterval) timeout = setTimeout(run, refreshInterval);
+			});
+		};
+		run();
+		return () => {
+			sub.unsubscribe();
+			if (timeout) clearTimeout(timeout);
+			controller.abort(/* @__PURE__ */ new Error("getQuery$ unsubscribed"));
+		};
+	}).pipe(shareReplay({
+		refCount: true,
+		bufferSize: 1
+	})), serializer);
 };
-
-// src/getLoadableQuery.ts
-var getLoadableQuery$ = (params) => {
-  const initial = params.defaultValue === void 0 ? [] : [{ status: "loading", data: params.defaultValue }];
-  return getQuery$(params).pipe(
-    map2((val) => {
-      switch (val.status) {
-        case "loading":
-          return { status: "loading", data: val.data };
-        case "loaded":
-          return { status: "success", data: val.data };
-        case "error": {
-          const err = val.error;
-          return {
-            status: "error",
-            error: {
-              name: err?.name ?? "QueryError",
-              message: err?.message ?? "Failed to execute query"
-            }
-          };
-        }
-      }
-    }),
-    startWith2(...initial)
-  );
+//#endregion
+//#region src/getLoadableQuery.ts
+/**
+* Thin wrapper around getQuery$ that returns Loadable<T> and optionally
+* primes the stream with a loading state using the provided default value.
+*
+* TODO: consolidate with getQuery$
+*/
+const getLoadableQuery$ = (params) => {
+	const initial = params.defaultValue === void 0 ? [] : [{
+		status: "loading",
+		data: params.defaultValue
+	}];
+	return getQuery$(params).pipe(map((val) => {
+		switch (val.status) {
+			case "loading": return {
+				status: "loading",
+				data: val.data
+			};
+			case "loaded": return {
+				status: "success",
+				data: val.data
+			};
+			case "error": {
+				const err = val.error;
+				return {
+					status: "error",
+					error: {
+						name: err?.name ?? "QueryError",
+						message: err?.message ?? "Failed to execute query"
+					}
+				};
+			}
+		}
+	}), startWith(...initial));
 };
-
-// src/hasOwnProperty.ts
+//#endregion
+//#region src/hasOwnProperty.ts
 function hasOwnProperty(obj, prop) {
-  if (typeof obj !== "object") return false;
-  if (obj === null) return false;
-  return prop in obj;
+	if (typeof obj !== "object") return false;
+	if (obj === null) return false;
+	return prop in obj;
 }
-
-// src/isAbortError.ts
-var isAbortError = (error) => {
-  return error instanceof Error && error.name === "AbortError";
+//#endregion
+//#region src/isAbortError.ts
+const isAbortError = (error) => {
+	return error instanceof Error && error.name === "AbortError";
 };
-
-// src/isArrayOf.ts
+//#endregion
+//#region src/isArrayOf.ts
 function isArrayOf(array, func) {
-  if (array.length > 0 && array[0] instanceof func) return true;
-  return false;
+	if (array.length > 0 && array[0] instanceof func) return true;
+	return false;
 }
-
-// src/isAscii.ts
-var isAscii = (str) => {
-  return [...str].every((char) => char.charCodeAt(0) <= 127);
+//#endregion
+//#region src/isAscii.ts
+const isAscii = (str) => {
+	return [...str].every((char) => char.charCodeAt(0) <= 127);
 };
-
-// src/isBigInt.ts
-var isBigInt = (value) => typeof value === "bigint";
-
-// src/isBooleanTrue.ts
-var isBooleanTrue = (x) => !!x;
-
-// src/isHexString.ts
-var REGEX_HEX_STRING = /^0x[0-9a-fA-F]*$/;
-var isHexString = (value) => {
-  return typeof value === "string" && REGEX_HEX_STRING.test(value);
-};
-
-// src/isNotNil.ts
-var isNotNil = (value) => value !== null && value !== void 0;
-
-// src/isPromise.ts
-var isPromise = (value) => !!value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
-
-// src/isSubject.ts
-import { Subject } from "rxjs";
+//#endregion
+//#region src/isBigInt.ts
+const isBigInt = (value) => typeof value === "bigint";
+//#endregion
+//#region src/isBooleanTrue.ts
+const isBooleanTrue = (x) => !!x;
+//#endregion
+//#region src/isErrorOfName.ts
+/**
+* Robust replacement for `error instanceof SomeErrorClass` when the class comes from a
+* package that gets bundled into multiple chunks/contexts (e.g. viem, @solana/web3.js).
+*
+* `instanceof` returns `false` whenever the error originates from a different bundled copy of
+* the module than the imported class reference — which silently broke Solana transfers (see
+* apps/extension/src/__tests__/no-instanceof-bundled-class.test.ts). An error's `.name` is
+* stable across copies, *provided the class sets it explicitly* (viem does:
+* `super({ name: 'ContractFunctionExecutionError' })`). For classes that don't set `.name`,
+* duck-type the shape instead.
+*/
+const isErrorOfName = (error, ...names) => error instanceof Error && names.includes(error.name);
+//#endregion
+//#region src/isNotNil.ts
+/**
+* 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 !== void 0;
+//#endregion
+//#region src/isPromise.ts
+const isPromise = (value) => !!value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+//#endregion
+//#region src/isSubject.ts
+/**
+* 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);
+	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";
+	return typeof value === "function";
 }
+/**
+* Returns `true` if `value` is a boolean.
+*/
 function isBool(value) {
-  return typeof value === "boolean";
+	return typeof value === "boolean";
 }
-
-// src/isTruthy.ts
-var isTruthy = (value) => Boolean(value);
-
-// src/keepAlive.ts
-import { shareReplay as shareReplay3, tap } from "rxjs";
-var keepAlive = (timeout) => {
-  let release;
-  return (source) => source.pipe(
-    tap({
-      subscribe: () => {
-        release = keepSourceSubscribed(source, timeout);
-      },
-      unsubscribe: () => {
-        release?.();
-      }
-    }),
-    shareReplay3({ refCount: true, bufferSize: 1 })
-  );
-};
-var keepSourceSubscribed = (observable, ms) => {
-  const sub = observable.subscribe();
-  return () => setTimeout(() => sub.unsubscribe(), ms);
+//#endregion
+//#region src/isTruthy.ts
+const isTruthy = (value) => Boolean(value);
+//#endregion
+//#region src/keepAlive.ts
+/**
+* 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
+	}));
 };
-
-// src/planckToTokens.ts
-import BigNumber2 from "bignumber.js";
+const keepSourceSubscribed = (observable, ms) => {
+	const sub = observable.subscribe();
+	return () => setTimeout(() => sub.unsubscribe(), ms);
+};
+//#endregion
+//#region src/lruMap.ts
+/**
+* A Map with a maximum size and least-recently-used eviction.
+*
+* Reads refresh recency; when an insert would exceed `maxSize`, the
+* least-recently-used entry is evicted. Intended for long-lived in-memory
+* caches that would otherwise grow without bound.
+*/
+var LruMap = class {
+	#map = /* @__PURE__ */ new Map();
+	#maxSize;
+	constructor(maxSize) {
+		if (maxSize < 1) throw new Error("LruMap maxSize must be >= 1");
+		this.#maxSize = maxSize;
+	}
+	get(key) {
+		if (!this.#map.has(key)) return void 0;
+		const value = this.#map.get(key);
+		this.#map.delete(key);
+		this.#map.set(key, value);
+		return value;
+	}
+	set(key, value) {
+		if (this.#map.has(key)) this.#map.delete(key);
+		else if (this.#map.size >= this.#maxSize) {
+			const oldest = this.#map.keys().next();
+			if (!oldest.done) this.#map.delete(oldest.value);
+		}
+		this.#map.set(key, value);
+		return this;
+	}
+	has(key) {
+		return this.#map.has(key);
+	}
+	delete(key) {
+		return this.#map.delete(key);
+	}
+	clear() {
+		this.#map.clear();
+	}
+	get size() {
+		return this.#map.size;
+	}
+};
+//#endregion
+//#region src/mapChunked.ts
+const runChunkedProject = (project, options, value, index) => new Observable((subscriber) => {
+	const controller = new AbortController();
+	project(value, {
+		slicer: createTimeSlicer({
+			budgetMs: options?.budgetMs,
+			signal: controller.signal,
+			label: options?.label
+		}),
+		signal: controller.signal
+	}, index).then((result) => {
+		if (!controller.signal.aborted) subscriber.next(result);
+		subscriber.complete();
+	}, (error) => {
+		if (isAbortError(error)) subscriber.complete();
+		else subscriber.error(error);
+	});
+	return () => controller.abort();
+});
+/**
+* `switchMap` for time-sliced (chunked) async work — latest-wins: a new upstream value or
+* an unsubscription aborts the in-flight `project` via `ctx.signal` / the shared slicer,
+* so cancelled work stops burning CPU at its next yield check point and its result is
+* never emitted.
+*
+* Non-abort errors thrown by `project` error the stream (same as a throwing sync `map`).
+*
+* Note: pipelines using this operator already emit asynchronously (macrotask), so adding
+* `observeOn(asyncScheduler)` downstream is redundant and only adds latency.
+*/
+const switchMapChunked = (project, options) => switchMap((value, index) => runChunkedProject(project, options, value, index));
+/**
+* `concatMap` variant of switchMapChunked — ordered: upstream values queue and are
+* processed one at a time; a new value does NOT cancel in-flight work (unsubscription
+* still aborts it).
+*/
+const concatMapChunked = (project, options) => concatMap((value, index) => runChunkedProject(project, options, value, index));
+//#endregion
+//#region src/planckToTokens.ts
 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 BigNumber2(planck).multipliedBy(multiplier).toString(10);
+	if (typeof planck !== "string" || typeof tokenDecimals !== "number") return;
+	const multiplier = 10 ** (-1 * tokenDecimals);
+	return new configureBigNumber_default(planck).multipliedBy(multiplier).toString(10);
 }
-
-// src/replaySubjectFrom.ts
-import { ReplaySubject } from "rxjs";
-var replaySubjectFrom = (initialValue) => {
-  if (initialValue instanceof ReplaySubject) return initialValue;
-  const subject = new ReplaySubject(1);
-  if (isPromise(initialValue)) {
-    initialValue.then(
-      (value) => subject.next(value),
-      (error) => subject.error(error)
-    );
-    return subject;
-  }
-  subject.next(initialValue);
-  return subject;
+//#endregion
+//#region src/replaySubjectFrom.ts
+/**
+* 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 (isPromise(initialValue)) {
+		initialValue.then((value) => subject.next(value), (error) => subject.error(error));
+		return subject;
+	}
+	subject.next(initialValue);
+	return subject;
 };
-
-// src/sleep.ts
-var sleep = (ms) => new Promise((resolve) => {
-  if (process.env.NODE_ENV === "test") resolve();
-  else setTimeout(resolve, ms);
+//#endregion
+//#region src/sleep.ts
+const sleep = (ms) => new Promise((resolve) => {
+	if (process.env.NODE_ENV === "test") resolve();
+	else setTimeout(resolve, ms);
 });
-
-// src/splitSubject.ts
+//#endregion
+//#region src/splitSubject.ts
+/**
+* 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 next = (value) => subject.next(value);
+	return [next, subject.asObservable()];
 }
-
-// src/throwAfter.ts
-var throwAfter = (ms, reason) => new Promise((_, reject) => setTimeout(() => reject(new Error(reason)), ms));
-
-// src/tokensToPlanck.ts
-import BigNumber3 from "bignumber.js";
+//#endregion
+//#region src/stripHexPrefix.ts
+/**
+* @name stripHexPrefix
+* @description Removes a leading `0x` prefix from a string, if present.
+* @param {string} str - string to strip
+* @returns {string} - the string without its leading `0x` prefix
+* @example
+* stripHexPrefix("0x1234") // "1234"
+* stripHexPrefix("1234") // "1234"
+**/
+const stripHexPrefix = (str) => str.startsWith("0x") ? str.slice(2) : str;
+//#endregion
+//#region src/throwAfter.ts
+const throwAfter = (ms, reason) => new Promise((_, reject) => setTimeout(() => reject(new Error(reason)), ms));
+//#endregion
+//#region src/tokensToPlanck.ts
 function tokensToPlanck(tokens, tokenDecimals) {
-  if (typeof tokens !== "string" || typeof tokenDecimals !== "number") return;
-  const base = 10;
-  const exponent = tokenDecimals;
-  const multiplier = base ** exponent;
-  return new BigNumber3(tokens).multipliedBy(multiplier).toString(10);
+	if (typeof tokens !== "string" || typeof tokenDecimals !== "number") return;
+	const multiplier = 10 ** tokenDecimals;
+	return new configureBigNumber_default(tokens).multipliedBy(multiplier).toString(10);
 }
-
-// src/validateHexString.ts
-var 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");
-};
-export {
-  BigMath,
-  Deferred,
-  MAX_DECIMALS_FORMAT,
-  REGEX_HEX_STRING,
-  addTrailingSlash,
-  firstThenDebounce,
-  formatDecimals,
-  formatPrice,
-  getLoadable$,
-  getLoadableQuery$,
-  getQuery$,
-  getSharedObservable,
-  hasOwnProperty,
-  isAbortError,
-  isArrayOf,
-  isAscii,
-  isBigInt,
-  isBooleanTrue,
-  isHexString,
-  isNotNil,
-  isPromise,
-  isSubject,
-  isTruthy,
-  keepAlive,
-  planckToTokens,
-  replaySubjectFrom,
-  sleep,
-  splitSubject,
-  throwAfter,
-  tokensToPlanck,
-  validateHexString
+//#endregion
+//#region src/validateArrayWithYield.ts
+/**
+* Validates every item of an array within a cooperative time budget, yielding the thread
+* to the host event loop whenever the budget for the current slice is exhausted.
+*
+* Like `z.array(schema).safeParse`, ALL items are validated and all failures collected
+* (no fail-fast) — pass e.g. `(item) => SomeSchema.safeParse(item)` as `parseItem`.
+* Zod-agnostic on purpose: this package has no zod dependency.
+*/
+const validateArrayWithYield = async (items, parseItem, options) => {
+	const data = new Array(items.length);
+	const errors = [];
+	await forEachWithYield(items, (item, index) => {
+		const result = parseItem(item, index);
+		if (result.success) data[index] = result.data;
+		else errors.push({
+			index,
+			error: result.error
+		});
+	}, options);
+	return errors.length ? {
+		success: false,
+		errors
+	} : {
+		success: true,
+		data
+	};
+};
+//#endregion
+//#region src/validateHexString.ts
+/**
+* @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");
 };
+//#endregion
+export { BigMath, DEFAULT_TIME_SLICE_BUDGET_MS, Deferred, LruMap, MAX_DECIMALS_FORMAT, REGEX_HEX_STRING, addTrailingSlash, arrayItemsEqualWithYield, assert, concatMapChunked, createTimeSlicer, firstThenDebounce, forEachWithYield, formatDecimals, formatPrice, getLoadable$, getLoadableQuery$, getQuery$, getSharedObservable, hasOwnProperty, hexToNumber, hexToString, hexToU8a, isAbortError, isArrayOf, isAscii, isAsciiPrintable, isBigInt, isBooleanTrue, isErrorOfName, isHexString, isNotNil, isPromise, isSubject, isTruthy, keepAlive, keyByWithYield, mapWithYield, newAbortError, numberToU8a, planckToTokens, replaySubjectFrom, reportJsActivity, sleep, splitSubject, stringToU8a, stripHexPrefix, switchMapChunked, throwAfter, tokensToPlanck, u8aCmp, u8aConcat, u8aEq, u8aToHex, u8aToString, u8aToU8a, u8aUnwrapBytes, u8aWrapBytes, validateArrayWithYield, validateHexString, yieldToEventLoop };
+
 //# sourceMappingURL=index.mjs.map