@lifi/sdk 4.8.2 → 4.10.0

package/dist/esm/utils/waitForResult.d.ts

@@ -1,12 +1,12 @@
 //#region src/utils/waitForResult.d.ts
 /**
- * Repeatedly calls a given asynchronous function until it resolves with a value
- * @param fn The function that should be repeated
+ * Repeatedly calls a given asynchronous function until it resolves with a truthy value
+ * @param fn The function that should be repeated. A falsy result means "no result yet" and polls again, with no limit on the number of polls
  * @param interval The timeout in milliseconds between retries, or a function that receives the current poll count and returns the interval. Defaults to 5000
- * @param maxRetries Maximum number of retries before throwing an error, defaults to 3
+ * @param maxRetries Maximum number of calls that throw before the error is rethrown, defaults to 3
  * @param shouldRetry Optional predicate to determine if an error should trigger a retry
  * @returns The result of the fn function
- * @throws Error if maximum retries is reached, if function keeps returning undefined, or if shouldRetry returns false
+ * @throws The error of fn if maximum retries is reached, or if shouldRetry returns false
  */
 export declare const waitForResult: <T>(fn: () => Promise<T | undefined>, interval?: number | ((poll: number) => number), maxRetries?: number, shouldRetry?: (count: number, error: unknown) => boolean) => Promise<T>;
 //#endregion

package/dist/esm/utils/waitForResult.js

@@ -1,13 +1,13 @@
 import { sleep } from "./sleep.js";
 //#region src/utils/waitForResult.ts
 /**
-* Repeatedly calls a given asynchronous function until it resolves with a value
-* @param fn The function that should be repeated
+* Repeatedly calls a given asynchronous function until it resolves with a truthy value
+* @param fn The function that should be repeated. A falsy result means "no result yet" and polls again, with no limit on the number of polls
 * @param interval The timeout in milliseconds between retries, or a function that receives the current poll count and returns the interval. Defaults to 5000
-* @param maxRetries Maximum number of retries before throwing an error, defaults to 3
+* @param maxRetries Maximum number of calls that throw before the error is rethrown, defaults to 3
 * @param shouldRetry Optional predicate to determine if an error should trigger a retry
 * @returns The result of the fn function
-* @throws Error if maximum retries is reached, if function keeps returning undefined, or if shouldRetry returns false
+* @throws The error of fn if maximum retries is reached, or if shouldRetry returns false
 */
 const waitForResult = async (fn, interval = 5e3, maxRetries = 3, shouldRetry = () => true) => {
 	let result;

package/dist/esm/utils/waitForResult.js.map

@@ -1 +1 @@
-{"version":3,"file":"waitForResult.js","names":[],"sources":["../../../src/utils/waitForResult.ts"],"sourcesContent":["import { sleep } from './sleep.js'\n\n/**\n * Repeatedly calls a given asynchronous function until it resolves with a value\n * @param fn The function that should be repeated\n * @param interval The timeout in milliseconds between retries, or a function that receives the current poll count and returns the interval. Defaults to 5000\n * @param maxRetries Maximum number of retries before throwing an error, defaults to 3\n * @param shouldRetry Optional predicate to determine if an error should trigger a retry\n * @returns The result of the fn function\n * @throws Error if maximum retries is reached, if function keeps returning undefined, or if shouldRetry returns false\n */\nexport const waitForResult = async <T>(\n  fn: () => Promise<T | undefined>,\n  interval: number | ((poll: number) => number) = 5000,\n  maxRetries = 3,\n  shouldRetry: (count: number, error: unknown) => boolean = () => true\n): Promise<T> => {\n  let result: T | undefined\n  let attempts = 0\n  let polls = 0\n\n  const getInterval = typeof interval === 'function' ? interval : () => interval\n\n  while (!result) {\n    try {\n      result = await fn()\n      if (!result) {\n        await sleep(getInterval(polls))\n        polls++\n      }\n    } catch (error) {\n      if (!shouldRetry(attempts, error)) {\n        throw error\n      }\n      attempts++\n      if (attempts === maxRetries) {\n        throw error\n      }\n      await sleep(getInterval(polls))\n      polls++\n    }\n  }\n\n  return result\n}\n"],"mappings":";;;;;;;;;;;AAWA,MAAa,gBAAgB,OAC3B,IACA,WAAgD,KAChD,aAAa,GACb,oBAAgE,SACjD;CACf,IAAI;CACJ,IAAI,WAAW;CACf,IAAI,QAAQ;CAEZ,MAAM,cAAc,OAAO,aAAa,aAAa,iBAAiB;CAEtE,OAAO,CAAC,QACN,IAAI;EACF,SAAS,MAAM,GAAG;EAClB,IAAI,CAAC,QAAQ;GACX,MAAM,MAAM,YAAY,KAAK,CAAC;GAC9B;EACF;CACF,SAAS,OAAO;EACd,IAAI,CAAC,YAAY,UAAU,KAAK,GAC9B,MAAM;EAER;EACA,IAAI,aAAa,YACf,MAAM;EAER,MAAM,MAAM,YAAY,KAAK,CAAC;EAC9B;CACF;CAGF,OAAO;AACT"}
+{"version":3,"file":"waitForResult.js","names":[],"sources":["../../../src/utils/waitForResult.ts"],"sourcesContent":["import { sleep } from './sleep.js'\n\n/**\n * Repeatedly calls a given asynchronous function until it resolves with a truthy value\n * @param fn The function that should be repeated. A falsy result means \"no result yet\" and polls again, with no limit on the number of polls\n * @param interval The timeout in milliseconds between retries, or a function that receives the current poll count and returns the interval. Defaults to 5000\n * @param maxRetries Maximum number of calls that throw before the error is rethrown, defaults to 3\n * @param shouldRetry Optional predicate to determine if an error should trigger a retry\n * @returns The result of the fn function\n * @throws The error of fn if maximum retries is reached, or if shouldRetry returns false\n */\nexport const waitForResult = async <T>(\n  fn: () => Promise<T | undefined>,\n  interval: number | ((poll: number) => number) = 5000,\n  maxRetries = 3,\n  shouldRetry: (count: number, error: unknown) => boolean = () => true\n): Promise<T> => {\n  let result: T | undefined\n  let attempts = 0\n  let polls = 0\n\n  const getInterval = typeof interval === 'function' ? interval : () => interval\n\n  while (!result) {\n    try {\n      result = await fn()\n      if (!result) {\n        await sleep(getInterval(polls))\n        polls++\n      }\n    } catch (error) {\n      if (!shouldRetry(attempts, error)) {\n        throw error\n      }\n      attempts++\n      if (attempts === maxRetries) {\n        throw error\n      }\n      await sleep(getInterval(polls))\n      polls++\n    }\n  }\n\n  return result\n}\n"],"mappings":";;;;;;;;;;;AAWA,MAAa,gBAAgB,OAC3B,IACA,WAAgD,KAChD,aAAa,GACb,oBAAgE,SACjD;CACf,IAAI;CACJ,IAAI,WAAW;CACf,IAAI,QAAQ;CAEZ,MAAM,cAAc,OAAO,aAAa,aAAa,iBAAiB;CAEtE,OAAO,CAAC,QACN,IAAI;EACF,SAAS,MAAM,GAAG;EAClB,IAAI,CAAC,QAAQ;GACX,MAAM,MAAM,YAAY,KAAK,CAAC;GAC9B;EACF;CACF,SAAS,OAAO;EACd,IAAI,CAAC,YAAY,UAAU,KAAK,GAC9B,MAAM;EAER;EACA,IAAI,aAAa,YACf,MAAM;EAER,MAAM,MAAM,YAAY,KAAK,CAAC;EAC9B;CACF;CAGF,OAAO;AACT"}

package/dist/esm/utils/withDedupe.d.ts

@@ -1,19 +1,22 @@
 //#region src/utils/withDedupe.d.ts
-/**
- * Map with a LRU (Least recently used) policy.
- *
- * https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU
- */
-export declare class LruMap<value = unknown> extends Map<string, value> {
-  maxSize: number;
-  constructor(size: number);
-  override set(key: string, value: value): this;
-}
 type WithDedupeOptions = {
   enabled?: boolean | undefined;
   id?: string | undefined;
+  /** Lets this caller leave a shared request without aborting it for others. */
+  signal?: AbortSignal | undefined;
 };
-/** Deduplicates in-flight promises. */
-export declare function withDedupe<T>(fn: () => Promise<T>, { enabled, id }: WithDedupeOptions): Promise<T>;
+/**
+ * Deduplicates in-flight promises.
+ *
+ * When the first caller passes a signal, `fn` receives the signal to hand on
+ * to its request. A caller that aborts leaves the shared request at once; the
+ * request itself is aborted only when every caller has aborted. The next
+ * caller then starts a new request, so `fn` should pass the signal on: a run
+ * that ignores it keeps going alongside the new one.
+ */
+export declare function withDedupe<T>(fn: (signal?: AbortSignal) => Promise<T>, options: WithDedupeOptions): Promise<T>;
+export declare function withDedupe<T>(fn: () => Promise<T>, options: WithDedupeOptions & {
+  signal?: undefined;
+}): Promise<T>;
 //#endregion
 //# sourceMappingURL=withDedupe.d.ts.map

package/dist/esm/utils/withDedupe.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"withDedupe.d.ts","names":[],"sources":["../../../src/utils/withDedupe.ts"],"mappings":";;;;;;qBAKa,OAAO,yBAAyB,YAAY;EACvD;EAEA,YAAY;WAKH,IAAI,aAAa,OAAO;;KAY9B;EACH;EACA;;;wBAIc,WAAW,GACzB,UAAU,QAAQ,MAChB,SAAgB,MAAM,oBACvB,QAAQ"}
+{"version":3,"file":"withDedupe.d.ts","names":[],"sources":["../../../src/utils/withDedupe.ts"],"mappings":";KAqBK;EACH;EACA;;EAEA,SAAS;;;;;;;;;;;wBAYK,WAAW,GACzB,KAAK,SAAS,gBAAgB,QAAQ,IACtC,SAAS,oBACR,QAAQ;wBACK,WAAW,GACzB,UAAU,QAAQ,IAClB,SAAS;EAAsB;IAC9B,QAAQ"}

package/dist/esm/utils/withDedupe.js

@@ -1,32 +1,78 @@
+import { getAbortError } from "./abort.js";
+import { LruMap } from "./lru.js";
 //#region src/utils/withDedupe.ts
-/**
-* Map with a LRU (Least recently used) policy.
-*
-* https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU
-*/
-var LruMap = class extends Map {
-	maxSize;
-	constructor(size) {
-		super();
-		this.maxSize = size;
-	}
-	set(key, value) {
-		super.set(key, value);
-		if (this.maxSize && this.size > this.maxSize) this.delete(this.keys().next().value);
-		return this;
-	}
-};
 /** @internal */
 const promiseCache = /*#__PURE__*/ new LruMap(8192);
-/** Deduplicates in-flight promises. */
-function withDedupe(fn, { enabled = true, id }) {
-	if (!enabled || !id) return fn();
-	if (promiseCache.get(id)) return promiseCache.get(id);
-	const promise = fn().finally(() => promiseCache.delete(id));
-	promiseCache.set(id, promise);
-	return promise;
+function withDedupe(fn, { enabled = true, id, signal }) {
+	if (!enabled || !id) return fn(signal);
+	if (signal?.aborted) return Promise.reject(getAbortError(signal));
+	let inFlight = promiseCache.get(id);
+	if (!inFlight) {
+		const controller = signal ? new AbortController() : void 0;
+		const promise = fn(controller?.signal).finally(() => evict(id, promise));
+		inFlight = {
+			promise,
+			controller,
+			pinned: false
+		};
+		promiseCache.set(id, inFlight);
+	}
+	return join(id, inFlight, signal);
+}
+function join(id, inFlight, signal) {
+	if (!signal) {
+		inFlight.pinned = true;
+		return inFlight.promise;
+	}
+	const callers = inFlight.callers ?? subscribe(inFlight);
+	return new Promise((resolve, reject) => {
+		const caller = {
+			resolve: (value) => {
+				signal.removeEventListener("abort", leave);
+				resolve(value);
+			},
+			reject: (error) => {
+				signal.removeEventListener("abort", leave);
+				reject(error);
+			}
+		};
+		const leave = () => {
+			signal.removeEventListener("abort", leave);
+			callers.delete(caller);
+			const reason = getAbortError(signal);
+			reject(reason);
+			if (!inFlight.pinned && callers.size === 0) {
+				evict(id, inFlight.promise);
+				inFlight.controller?.abort(reason);
+			}
+		};
+		callers.add(caller);
+		signal.addEventListener("abort", leave, { once: true });
+		if (signal.aborted) leave();
+	});
+}
+/**
+* Hands the result to the callers with a signal, through one reaction per
+* request, so a caller that leaves holds nothing here. It is added only when
+* the first such caller joins: a request shared only by callers without a
+* signal gets no handler of ours, and a failure they all ignore is still
+* reported as an unhandled rejection.
+*/
+function subscribe(inFlight) {
+	const callers = /* @__PURE__ */ new Set();
+	inFlight.callers = callers;
+	inFlight.promise.then((value) => {
+		for (const caller of callers) caller.resolve(value);
+	}, (error) => {
+		for (const caller of callers) caller.reject(error);
+	});
+	return callers;
+}
+/** Drops the entry for `id` only while it still holds this request. */
+function evict(id, promise) {
+	if (promiseCache.get(id)?.promise === promise) promiseCache.delete(id);
 }
 //#endregion
-export { LruMap, withDedupe };
+export { withDedupe };
 
 //# sourceMappingURL=withDedupe.js.map

package/dist/esm/utils/withDedupe.js.map

@@ -1 +1 @@
-{"version":3,"file":"withDedupe.js","names":[],"sources":["../../../src/utils/withDedupe.ts"],"sourcesContent":["/**\n * Map with a LRU (Least recently used) policy.\n *\n * https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU\n */\nexport class LruMap<value = unknown> extends Map<string, value> {\n  maxSize: number\n\n  constructor(size: number) {\n    super()\n    this.maxSize = size\n  }\n\n  override set(key: string, value: value): this {\n    super.set(key, value)\n    if (this.maxSize && this.size > this.maxSize) {\n      this.delete(this.keys().next().value!)\n    }\n    return this\n  }\n}\n\n/** @internal */\nconst promiseCache = /*#__PURE__*/ new LruMap<Promise<any>>(8192)\n\ntype WithDedupeOptions = {\n  enabled?: boolean | undefined\n  id?: string | undefined\n}\n\n/** Deduplicates in-flight promises. */\nexport function withDedupe<T>(\n  fn: () => Promise<T>,\n  { enabled = true, id }: WithDedupeOptions\n): Promise<T> {\n  if (!enabled || !id) {\n    return fn()\n  }\n  if (promiseCache.get(id)) {\n    return promiseCache.get(id)!\n  }\n  const promise = fn().finally(() => promiseCache.delete(id))\n  promiseCache.set(id, promise)\n  return promise\n}\n"],"mappings":";;;;;;AAKA,IAAa,SAAb,cAA6C,IAAmB;CAC9D;CAEA,YAAY,MAAc;EACxB,MAAM;EACN,KAAK,UAAU;CACjB;CAEA,IAAa,KAAa,OAAoB;EAC5C,MAAM,IAAI,KAAK,KAAK;EACpB,IAAI,KAAK,WAAW,KAAK,OAAO,KAAK,SACnC,KAAK,OAAO,KAAK,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,KAAM;EAEvC,OAAO;CACT;AACF;;AAGA,MAAM,6BAA6B,IAAI,OAAqB,IAAI;;AAQhE,SAAgB,WACd,IACA,EAAE,UAAU,MAAM,MACN;CACZ,IAAI,CAAC,WAAW,CAAC,IACf,OAAO,GAAG;CAEZ,IAAI,aAAa,IAAI,EAAE,GACrB,OAAO,aAAa,IAAI,EAAE;CAE5B,MAAM,UAAU,GAAG,CAAC,CAAC,cAAc,aAAa,OAAO,EAAE,CAAC;CAC1D,aAAa,IAAI,IAAI,OAAO;CAC5B,OAAO;AACT"}
+{"version":3,"file":"withDedupe.js","names":[],"sources":["../../../src/utils/withDedupe.ts"],"sourcesContent":["import { getAbortError } from './abort.js'\nimport { LruMap } from './lru.js'\n\ntype Caller = {\n  resolve: (value: any) => void\n  reject: (error: unknown) => void\n}\n\ntype InFlight = {\n  promise: Promise<any>\n  /** Absent when the first caller had no signal: then nothing can abort it. */\n  controller?: AbortController | undefined\n  /** Callers with a signal that are still waiting, once the first one joins. */\n  callers?: Set<Caller> | undefined\n  /** A caller without a signal joined, so the request must run to the end. */\n  pinned: boolean\n}\n\n/** @internal */\nconst promiseCache = /*#__PURE__*/ new LruMap<InFlight>(8192)\n\ntype WithDedupeOptions = {\n  enabled?: boolean | undefined\n  id?: string | undefined\n  /** Lets this caller leave a shared request without aborting it for others. */\n  signal?: AbortSignal | undefined\n}\n\n/**\n * Deduplicates in-flight promises.\n *\n * When the first caller passes a signal, `fn` receives the signal to hand on\n * to its request. A caller that aborts leaves the shared request at once; the\n * request itself is aborted only when every caller has aborted. The next\n * caller then starts a new request, so `fn` should pass the signal on: a run\n * that ignores it keeps going alongside the new one.\n */\nexport function withDedupe<T>(\n  fn: (signal?: AbortSignal) => Promise<T>,\n  options: WithDedupeOptions\n): Promise<T>\nexport function withDedupe<T>(\n  fn: () => Promise<T>,\n  options: WithDedupeOptions & { signal?: undefined }\n): Promise<T>\nexport function withDedupe<T>(\n  fn: (signal?: AbortSignal) => Promise<T>,\n  { enabled = true, id, signal }: WithDedupeOptions\n): Promise<T> {\n  if (!enabled || !id) {\n    return fn(signal)\n  }\n  if (signal?.aborted) {\n    return Promise.reject(getAbortError(signal))\n  }\n  let inFlight = promiseCache.get(id)\n  if (!inFlight) {\n    const controller = signal ? new AbortController() : undefined\n    const promise = fn(controller?.signal).finally(() => evict(id, promise))\n    inFlight = { promise, controller, pinned: false }\n    promiseCache.set(id, inFlight)\n  }\n  return join<T>(id, inFlight, signal)\n}\n\nfunction join<T>(\n  id: string,\n  inFlight: InFlight,\n  signal: AbortSignal | undefined\n): Promise<T> {\n  if (!signal) {\n    inFlight.pinned = true\n    return inFlight.promise\n  }\n  const callers = inFlight.callers ?? subscribe(inFlight)\n  return new Promise<T>((resolve, reject) => {\n    // Stop listening before settling, so a later abort cannot reach the request.\n    const caller: Caller = {\n      resolve: (value) => {\n        signal.removeEventListener('abort', leave)\n        resolve(value)\n      },\n      reject: (error) => {\n        signal.removeEventListener('abort', leave)\n        reject(error)\n      },\n    }\n    const leave = () => {\n      // `leave` can run without the event, so the listener is not always gone.\n      signal.removeEventListener('abort', leave)\n      callers.delete(caller)\n      const reason = getAbortError(signal)\n      reject(reason)\n      if (!inFlight.pinned && callers.size === 0) {\n        // A caller arriving now must start a new request, not join this one.\n        evict(id, inFlight.promise)\n        inFlight.controller?.abort(reason)\n      }\n    }\n    callers.add(caller)\n    signal.addEventListener('abort', leave, { once: true })\n    // `fn` runs before this listener exists and may have aborted the signal.\n    if (signal.aborted) {\n      leave()\n    }\n  })\n}\n\n/**\n * Hands the result to the callers with a signal, through one reaction per\n * request, so a caller that leaves holds nothing here. It is added only when\n * the first such caller joins: a request shared only by callers without a\n * signal gets no handler of ours, and a failure they all ignore is still\n * reported as an unhandled rejection.\n */\nfunction subscribe(inFlight: InFlight): Set<Caller> {\n  const callers = new Set<Caller>()\n  inFlight.callers = callers\n  inFlight.promise.then(\n    (value) => {\n      for (const caller of callers) {\n        caller.resolve(value)\n      }\n    },\n    (error) => {\n      for (const caller of callers) {\n        caller.reject(error)\n      }\n    }\n  )\n  return callers\n}\n\n/** Drops the entry for `id` only while it still holds this request. */\nfunction evict(id: string, promise: Promise<unknown>): void {\n  if (promiseCache.get(id)?.promise === promise) {\n    promiseCache.delete(id)\n  }\n}\n"],"mappings":";;;;AAmBA,MAAM,6BAA6B,IAAI,OAAiB,IAAI;AA0B5D,SAAgB,WACd,IACA,EAAE,UAAU,MAAM,IAAI,UACV;CACZ,IAAI,CAAC,WAAW,CAAC,IACf,OAAO,GAAG,MAAM;CAElB,IAAI,QAAQ,SACV,OAAO,QAAQ,OAAO,cAAc,MAAM,CAAC;CAE7C,IAAI,WAAW,aAAa,IAAI,EAAE;CAClC,IAAI,CAAC,UAAU;EACb,MAAM,aAAa,SAAS,IAAI,gBAAgB,IAAI,KAAA;EACpD,MAAM,UAAU,GAAG,YAAY,MAAM,CAAC,CAAC,cAAc,MAAM,IAAI,OAAO,CAAC;EACvE,WAAW;GAAE;GAAS;GAAY,QAAQ;EAAM;EAChD,aAAa,IAAI,IAAI,QAAQ;CAC/B;CACA,OAAO,KAAQ,IAAI,UAAU,MAAM;AACrC;AAEA,SAAS,KACP,IACA,UACA,QACY;CACZ,IAAI,CAAC,QAAQ;EACX,SAAS,SAAS;EAClB,OAAO,SAAS;CAClB;CACA,MAAM,UAAU,SAAS,WAAW,UAAU,QAAQ;CACtD,OAAO,IAAI,SAAY,SAAS,WAAW;EAEzC,MAAM,SAAiB;GACrB,UAAU,UAAU;IAClB,OAAO,oBAAoB,SAAS,KAAK;IACzC,QAAQ,KAAK;GACf;GACA,SAAS,UAAU;IACjB,OAAO,oBAAoB,SAAS,KAAK;IACzC,OAAO,KAAK;GACd;EACF;EACA,MAAM,cAAc;GAElB,OAAO,oBAAoB,SAAS,KAAK;GACzC,QAAQ,OAAO,MAAM;GACrB,MAAM,SAAS,cAAc,MAAM;GACnC,OAAO,MAAM;GACb,IAAI,CAAC,SAAS,UAAU,QAAQ,SAAS,GAAG;IAE1C,MAAM,IAAI,SAAS,OAAO;IAC1B,SAAS,YAAY,MAAM,MAAM;GACnC;EACF;EACA,QAAQ,IAAI,MAAM;EAClB,OAAO,iBAAiB,SAAS,OAAO,EAAE,MAAM,KAAK,CAAC;EAEtD,IAAI,OAAO,SACT,MAAM;CAEV,CAAC;AACH;;;;;;;;AASA,SAAS,UAAU,UAAiC;CAClD,MAAM,0BAAU,IAAI,IAAY;CAChC,SAAS,UAAU;CACnB,SAAS,QAAQ,MACd,UAAU;EACT,KAAK,MAAM,UAAU,SACnB,OAAO,QAAQ,KAAK;CAExB,IACC,UAAU;EACT,KAAK,MAAM,UAAU,SACnB,OAAO,OAAO,KAAK;CAEvB,CACF;CACA,OAAO;AACT;;AAGA,SAAS,MAAM,IAAY,SAAiC;CAC1D,IAAI,aAAa,IAAI,EAAE,CAAC,EAAE,YAAY,SACpC,aAAa,OAAO,EAAE;AAE1B"}

package/dist/esm/utils/withTimeout.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"withTimeout.d.ts","names":[],"sources":["../../../src/utils/withTimeout.ts"],"mappings":";;;;;;;;;;wBASgB,YAAY,GAC1B,OAAO;EAAY,QAAQ;MAAuC,QAAQ,MAExE,eACA,SACA;EAGA,gBAAgB;EAEhB;EAEA;IAED,QAAQ"}
+{"version":3,"file":"withTimeout.d.ts","names":[],"sources":["../../../src/utils/withTimeout.ts"],"mappings":";;;;;;;;;;wBAWgB,YAAY,GAC1B,OAAO;EAAY,QAAQ;MAAuC,QAAQ,MAExE,eACA,SACA;EAGA,gBAAgB;EAEhB;EAEA;IAED,QAAQ"}

package/dist/esm/utils/withTimeout.js

@@ -1,3 +1,4 @@
+import { isAbortError } from "./abort.js";
 //#region src/utils/withTimeout.ts
 /**
 * Wraps a function in a timeout.
@@ -12,15 +13,18 @@ function withTimeout(fn, { errorInstance = /* @__PURE__ */ new Error("Timed out
 	return new Promise((resolve, reject) => {
 		(async () => {
 			let timeoutId;
+			const controller = new AbortController();
 			try {
-				const controller = new AbortController();
 				if (timeout > 0) timeoutId = setTimeout(() => {
 					if (signal) controller.abort();
 					else reject(errorInstance);
 				}, timeout);
 				resolve(await fn({ signal: controller?.signal || null }));
 			} catch (err) {
-				if (err?.name === "AbortError") reject(errorInstance);
+				if (controller.signal.aborted && isAbortError(err)) {
+					reject(errorInstance);
+					return;
+				}
 				reject(err);
 			} finally {
 				clearTimeout(timeoutId);

package/dist/esm/utils/withTimeout.js.map

@@ -1 +1 @@
-{"version":3,"file":"withTimeout.js","names":[],"sources":["../../../src/utils/withTimeout.ts"],"sourcesContent":["/**\n * Wraps a function in a timeout.\n * Based on viem's withTimeout implementation.\n * @param fn - The function to wrap.\n * @param timeout - The timeout in milliseconds.\n * @param errorInstance - The error instance to throw when the timeout is reached.\n * @param signal - Whether or not the timeout should use an abort signal.\n * @returns The result of the function.\n */\nexport function withTimeout<T>(\n  fn: ({ signal }: { signal: AbortController['signal'] | null }) => Promise<T>,\n  {\n    errorInstance = new Error('Timed out after waiting for too long.'),\n    timeout,\n    signal,\n  }: {\n    // The error instance to throw when the timeout is reached.\n    errorInstance?: Error | undefined\n    // The timeout (in ms).\n    timeout: number\n    // Whether or not the timeout should use an abort signal.\n    signal?: boolean | undefined\n  }\n): Promise<T> {\n  return new Promise((resolve, reject) => {\n    ;(async () => {\n      let timeoutId!: NodeJS.Timeout\n      try {\n        const controller = new AbortController()\n        if (timeout > 0) {\n          timeoutId = setTimeout(() => {\n            if (signal) {\n              controller.abort()\n            } else {\n              reject(errorInstance)\n            }\n          }, timeout) as NodeJS.Timeout // need to cast because bun globals.d.ts overrides @types/node\n        }\n        resolve(await fn({ signal: controller?.signal || null }))\n      } catch (err) {\n        if ((err as Error)?.name === 'AbortError') {\n          reject(errorInstance)\n        }\n        reject(err)\n      } finally {\n        clearTimeout(timeoutId)\n      }\n    })()\n  })\n}\n"],"mappings":";;;;;;;;;;AASA,SAAgB,YACd,IACA,EACE,gCAAgB,IAAI,MAAM,uCAAuC,GACjE,SACA,UASU;CACZ,OAAO,IAAI,SAAS,SAAS,WAAW;EACrC,CAAC,YAAY;GACZ,IAAI;GACJ,IAAI;IACF,MAAM,aAAa,IAAI,gBAAgB;IACvC,IAAI,UAAU,GACZ,YAAY,iBAAiB;KAC3B,IAAI,QACF,WAAW,MAAM;UAEjB,OAAO,aAAa;IAExB,GAAG,OAAO;IAEZ,QAAQ,MAAM,GAAG,EAAE,QAAQ,YAAY,UAAU,KAAK,CAAC,CAAC;GAC1D,SAAS,KAAK;IACZ,IAAK,KAAe,SAAS,cAC3B,OAAO,aAAa;IAEtB,OAAO,GAAG;GACZ,UAAU;IACR,aAAa,SAAS;GACxB;EACF,EAAA,CAAG;CACL,CAAC;AACH"}
+{"version":3,"file":"withTimeout.js","names":[],"sources":["../../../src/utils/withTimeout.ts"],"sourcesContent":["import { isAbortError } from './abort.js'\n\n/**\n * Wraps a function in a timeout.\n * Based on viem's withTimeout implementation.\n * @param fn - The function to wrap.\n * @param timeout - The timeout in milliseconds.\n * @param errorInstance - The error instance to throw when the timeout is reached.\n * @param signal - Whether or not the timeout should use an abort signal.\n * @returns The result of the function.\n */\nexport function withTimeout<T>(\n  fn: ({ signal }: { signal: AbortController['signal'] | null }) => Promise<T>,\n  {\n    errorInstance = new Error('Timed out after waiting for too long.'),\n    timeout,\n    signal,\n  }: {\n    // The error instance to throw when the timeout is reached.\n    errorInstance?: Error | undefined\n    // The timeout (in ms).\n    timeout: number\n    // Whether or not the timeout should use an abort signal.\n    signal?: boolean | undefined\n  }\n): Promise<T> {\n  return new Promise((resolve, reject) => {\n    ;(async () => {\n      let timeoutId!: NodeJS.Timeout\n      const controller = new AbortController()\n      try {\n        if (timeout > 0) {\n          timeoutId = setTimeout(() => {\n            if (signal) {\n              controller.abort()\n            } else {\n              reject(errorInstance)\n            }\n          }, timeout) as NodeJS.Timeout // need to cast because bun globals.d.ts overrides @types/node\n        }\n        resolve(await fn({ signal: controller?.signal || null }))\n      } catch (err) {\n        // Only an abort from our own timeout is a timeout. Any other\n        // AbortError belongs to the caller and passes through.\n        if (controller.signal.aborted && isAbortError(err)) {\n          reject(errorInstance)\n          return\n        }\n        reject(err)\n      } finally {\n        clearTimeout(timeoutId)\n      }\n    })()\n  })\n}\n"],"mappings":";;;;;;;;;;;AAWA,SAAgB,YACd,IACA,EACE,gCAAgB,IAAI,MAAM,uCAAuC,GACjE,SACA,UASU;CACZ,OAAO,IAAI,SAAS,SAAS,WAAW;EACrC,CAAC,YAAY;GACZ,IAAI;GACJ,MAAM,aAAa,IAAI,gBAAgB;GACvC,IAAI;IACF,IAAI,UAAU,GACZ,YAAY,iBAAiB;KAC3B,IAAI,QACF,WAAW,MAAM;UAEjB,OAAO,aAAa;IAExB,GAAG,OAAO;IAEZ,QAAQ,MAAM,GAAG,EAAE,QAAQ,YAAY,UAAU,KAAK,CAAC,CAAC;GAC1D,SAAS,KAAK;IAGZ,IAAI,WAAW,OAAO,WAAW,aAAa,GAAG,GAAG;KAClD,OAAO,aAAa;KACpB;IACF;IACA,OAAO,GAAG;GACZ,UAAU;IACR,aAAa,SAAS;GACxB;EACF,EAAA,CAAG;CACL,CAAC;AACH"}

package/dist/esm/version.d.ts

@@ -1,5 +1,5 @@
 //#region src/version.d.ts
 export declare const name = "@lifi/sdk";
-export declare const version = "4.8.2";
+export declare const version = "4.10.0";
 //#endregion
 //# sourceMappingURL=version.d.ts.map

package/dist/esm/version.js

@@ -1,6 +1,6 @@
 //#region src/version.ts
 const name = "@lifi/sdk";
-const version = "4.8.2";
+const version = "4.10.0";
 //#endregion
 export { name, version };
 

package/dist/esm/version.js.map

@@ -1 +1 @@
-{"version":3,"file":"version.js","names":[],"sources":["../../src/version.ts"],"sourcesContent":["export const name = '@lifi/sdk'\nexport const version = '4.8.2'\n"],"mappings":";AAAA,MAAa,OAAO;AACpB,MAAa,UAAU"}
+{"version":3,"file":"version.js","names":[],"sources":["../../src/version.ts"],"sourcesContent":["export const name = '@lifi/sdk'\nexport const version = '4.10.0'\n"],"mappings":";AAAA,MAAa,OAAO;AACpB,MAAa,UAAU"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lifi/sdk",
-  "version": "4.8.2",
+  "version": "4.10.0",
   "description": "LI.FI SDK for Any-to-Any Cross-Chain-Swap",
   "homepage": "https://github.com/lifinance/sdk",
   "bugs": {
@@ -28,7 +28,7 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@lifi/types": "^18.10.0"
+    "@lifi/types": "^18.12.1"
   },
   "publishConfig": {
     "access": "public"

package/src/actions/getChains.ts

@@ -4,6 +4,7 @@ import type {
   ExtendedChain,
   RequestOptions,
 } from '@lifi/types'
+import { SDKError } from '../errors/SDKError.js'
 import type { SDKBaseConfig, SDKClient } from '../types/core.js'
 import { request } from '../utils/request.js'
 import { withDedupe } from '../utils/withDedupe.js'
@@ -41,15 +42,22 @@ export const _getChains = async (
     params as Record<string, string>
   ).toString()
   const response = await withDedupe(
-    () =>
+    (signal) =>
       request<ChainsResponse>(
         config,
         `${config.apiUrl}/chains?${urlSearchParams}`,
         {
-          signal: options?.signal,
+          signal,
         }
       ),
-    { id: `${getChains.name}.${config.apiUrl}.${urlSearchParams}` }
-  )
+    {
+      id: `${getChains.name}.${config.apiUrl}.${urlSearchParams}`,
+      signal: options?.signal,
+    }
+  ).catch((error) => {
+    // A caller that aborts leaves before the request settles; keep its error
+    // shaped like one from `request`.
+    throw error instanceof SDKError ? error : new SDKError(error)
+  })
   return response.chains
 }

package/src/actions/getTokens.ts

@@ -4,6 +4,7 @@ import type {
   TokensRequest,
   TokensResponse,
 } from '@lifi/types'
+import { SDKError } from '../errors/SDKError.js'
 import type { SDKClient } from '../types/core.js'
 import { request } from '../utils/request.js'
 import { withDedupe } from '../utils/withDedupe.js'
@@ -43,15 +44,22 @@ export async function getTokens(
   ).toString()
   const _isExtended = params?.extended === true
   const response = await withDedupe(
-    () =>
+    (signal) =>
       request<
         typeof _isExtended extends true
           ? TokensExtendedResponse
           : TokensResponse
       >(client.config, `${client.config.apiUrl}/tokens?${urlSearchParams}`, {
-        signal: options?.signal,
+        signal,
       }),
-    { id: `${getTokens.name}.${client.config.apiUrl}.${urlSearchParams}` }
-  )
+    {
+      id: `${getTokens.name}.${client.config.apiUrl}.${urlSearchParams}`,
+      signal: options?.signal,
+    }
+  ).catch((error) => {
+    // A caller that aborts leaves before the request settles; keep its error
+    // shaped like one from `request`.
+    throw error instanceof SDKError ? error : new SDKError(error)
+  })
   return response
 }

package/src/client/createClient.ts

@@ -1,5 +1,6 @@
 import type { ChainId, ChainType, ExtendedChain } from '@lifi/types'
 import type {
+  RPCUrls,
   SDKBaseConfig,
   SDKClient,
   SDKConfig,
@@ -20,12 +21,38 @@ export function createClient(options: SDKConfig): SDKClient {
     checkPackageUpdates(name, version)
   }
 
-  const { providers, ...configOptions } = options
+  const { providers, rpcUrls, ...configOptions } = options
+
+  // Role entries split once, here: the config keeps plain read lists, so
+  // everything that reads `config.rpcUrls` sees `string[]` as before.
+  const readRpcUrls: RPCUrls = {}
+  const writeRpcUrls: RPCUrls = {}
+  const bundleRpcUrls: RPCUrls = {}
+  let hasRoles = false
+  for (const key in rpcUrls) {
+    const chainId = Number(key) as ChainId
+    const entry = rpcUrls[chainId]
+    if (Array.isArray(entry)) {
+      readRpcUrls[chainId] = entry
+    } else if (entry) {
+      hasRoles = true
+      if (entry.read) {
+        readRpcUrls[chainId] = entry.read
+      }
+      if (entry.write?.length) {
+        writeRpcUrls[chainId] = entry.write
+      }
+      if (entry.bundle?.length) {
+        bundleRpcUrls[chainId] = entry.bundle
+      }
+    }
+  }
 
   const _config: SDKBaseConfig = {
     ...configOptions,
     apiUrl: configOptions?.apiUrl ?? 'https://li.quest/v1',
-    rpcUrls: configOptions?.rpcUrls ?? {},
+    // Plain lists only: the caller's own object, exactly as before.
+    rpcUrls: hasRoles ? readRpcUrls : ((rpcUrls ?? {}) as RPCUrls),
     debug: configOptions?.debug ?? false,
     preloadChains: configOptions?.preloadChains ?? true,
     integrator: configOptions?.integrator ?? 'lifi-sdk',
@@ -78,6 +105,12 @@ export function createClient(options: SDKConfig): SDKClient {
       }
       return chainRpcUrls
     },
+    async getWriteRpcUrlsByChainId(chainId: ChainId) {
+      return writeRpcUrls[chainId] ?? []
+    },
+    async getBundleRpcUrlsByChainId(chainId: ChainId) {
+      return bundleRpcUrls[chainId] ?? []
+    },
   }
 
   function extend<TClient extends SDKClient>(

package/src/core/tasks/helpers/checkBalance.ts

@@ -118,6 +118,11 @@ export const checkBalance = async (
     Math.floor((1 - slippage) * Number(SLIPPAGE_PRECISION))
   )
 
+  // Aborted once `withTimeout` settles. A timeout rejects at once, but the
+  // loop keeps running; the signal stops it before it can change `step`.
+  const controller = new AbortController()
+  const { signal } = controller
+
   await withTimeout(
     async () => {
       for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
@@ -133,9 +138,12 @@ export const checkBalance = async (
               error as Error
             )
           }
-          await sleep(BACKOFF_BASE_MS * 2 ** attempt)
+          await sleep(BACKOFF_BASE_MS * 2 ** attempt, { signal })
           continue
         }
+        if (signal.aborted) {
+          return
+        }
 
         const balanceByAddress = new Map(
           balances.map((b) => [b.address.toLowerCase(), b.amount] as const)
@@ -207,12 +215,12 @@ export const checkBalance = async (
           )
         }
 
-        await sleep(BACKOFF_BASE_MS * 2 ** attempt)
+        await sleep(BACKOFF_BASE_MS * 2 ** attempt, { signal })
       }
     },
     {
       timeout: OVERALL_TIMEOUT_MS,
       errorInstance: new BalanceError('Could not read wallet balance.'),
     }
-  )
+  ).finally(() => controller.abort())
 }

package/src/index.ts

@@ -97,6 +97,8 @@ export type {
   RouteExecutionDictionary,
   RouteExtended,
   RPCUrls,
+  RPCUrlsByRole,
+  RPCUrlsConfig,
   SDKBaseConfig,
   SDKClient,
   SDKConfig,
@@ -121,9 +123,10 @@ export { convertQuoteToRoute } from './utils/convertQuoteToRoute.js'
 export { fetchTxErrorDetails } from './utils/fetchTxErrorDetails.js'
 export { formatUnits } from './utils/formatUnits.js'
 export { isHex } from './utils/isHex.js'
+export { LruMap } from './utils/lru.js'
 export { parseUnits } from './utils/parseUnits.js'
 export { sleep } from './utils/sleep.js'
 export { waitForResult } from './utils/waitForResult.js'
-export { LruMap, withDedupe } from './utils/withDedupe.js'
+export { withDedupe } from './utils/withDedupe.js'
 export { withTimeout } from './utils/withTimeout.js'
 export { name, version } from './version.js'

package/src/types/core.ts

@@ -38,11 +38,55 @@ export interface SDKBaseConfig {
   storage?: SDKStorage
 }
 
-export interface SDKConfig extends Partial<Omit<SDKBaseConfig, 'integrator'>> {
+export interface SDKConfig
+  extends Partial<Omit<SDKBaseConfig, 'integrator' | 'rpcUrls'>> {
   integrator: string
+  /**
+   * Per chain, one list for reads and sends, or lists by role. The client
+   * keeps the read lists in `config.rpcUrls` and serves the write and bundle
+   * lists through `getWriteRpcUrlsByChainId` and `getBundleRpcUrlsByChainId`.
+   */
+  rpcUrls?: RPCUrlsConfig
   providers?: SDKProvider[]
 }
 
+/**
+ * RPC URLs for one chain, split by what they are used for.
+ */
+export interface RPCUrlsByRole {
+  /**
+   * Reads: balances, simulation and confirmation. Unset, the chain's own RPC
+   * URLs serve reads, as for a chain with no `rpcUrls` entry.
+   */
+  read?: string[]
+  /**
+   * Sends. Unset or empty, the read URLs send as well. While `write` is set,
+   * nothing is sent through the read URLs: when `bundle` is unset, the write
+   * URLs that support bundles also submit bundles, and with none of them, a
+   * route that needs a bundle fails.
+   *
+   * Only `@lifi/sdk-provider-solana` uses this today; other providers ignore
+   * it.
+   */
+  write?: string[]
+  /**
+   * Bundle submissions (Jito `sendBundle`). Unset, empty, or with no URL that
+   * supports bundles, the write URLs that do submit them. While `bundle` or
+   * `write` is set, bundles never go to the read URLs.
+   *
+   * Only `@lifi/sdk-provider-solana` uses this today; other providers ignore
+   * it.
+   */
+  bundle?: string[]
+}
+
+/**
+ * The `rpcUrls` option of `createClient`: per chain, either one list for reads
+ * and sends, or lists by role.
+ */
+export type RPCUrlsConfig = Partial<Record<ChainId, string[] | RPCUrlsByRole>>
+
+/** RPC URL lists per chain. `client.config.rpcUrls` holds the read lists. */
 export type RPCUrls = Partial<Record<ChainId, string[]>>
 
 export interface SDKProvider {
@@ -78,6 +122,20 @@ export interface SDKClient {
   getChainById(chainId: ChainId): Promise<ExtendedChain>
   getRpcUrls(): Promise<RPCUrls>
   getRpcUrlsByChainId(chainId: ChainId): Promise<string[]>
+  /**
+   * The chain's dedicated write RPC URLs (`rpcUrls[chainId].write`). Empty
+   * when the chain has none.
+   *
+   * Optional so clients from other SDK versions, and hand-written ones, still
+   * satisfy `SDKClient`. Providers treat a missing method as no write list.
+   */
+  getWriteRpcUrlsByChainId?(chainId: ChainId): Promise<string[]>
+  /**
+   * The chain's dedicated bundle RPC URLs (`rpcUrls[chainId].bundle`). Empty
+   * when the chain has none. Optional for the same reason as
+   * `getWriteRpcUrlsByChainId`.
+   */
+  getBundleRpcUrlsByChainId?(chainId: ChainId): Promise<string[]>
 }
 
 export interface StepExecutorOptions {

package/src/utils/abort.ts

@@ -0,0 +1,10 @@
+/** Older runtimes and polyfills can abort a signal without a `reason`. */
+export const getAbortError = (signal: AbortSignal): unknown =>
+  signal.reason ??
+  Object.assign(new Error('This operation was aborted'), { name: 'AbortError' })
+
+export const isAbortError = (error: unknown): boolean =>
+  typeof error === 'object' &&
+  error !== null &&
+  'name' in error &&
+  error.name === 'AbortError'

package/src/utils/formatUnits.ts

@@ -2,6 +2,12 @@
  *  Divides a number by a given exponent of base 10 (10exponent), and formats it into a string representation of the number.
  */
 export function formatUnits(value: bigint, decimals: number): string {
+  if (!Number.isInteger(decimals) || decimals < 0) {
+    throw new Error(
+      `\`decimals\` must be a non-negative integer. Got \`${decimals}\`.`
+    )
+  }
+
   let display = value.toString()
 
   const negative = display.startsWith('-')

package/src/utils/lru.ts

@@ -0,0 +1,38 @@
+/**
+ * Map with a LRU (Least recently used) policy.
+ *
+ * https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU
+ */
+export class LruMap<value = unknown> extends Map<string, value> {
+  maxSize: number
+
+  constructor(size: number) {
+    super()
+    this.maxSize = size
+  }
+
+  override get(key: string): value | undefined {
+    const value = super.get(key)
+    if (super.has(key)) {
+      super.delete(key)
+      super.set(key, value as value)
+    }
+    return value
+  }
+
+  override set(key: string, value: value): this {
+    if (super.has(key)) {
+      super.delete(key)
+    }
+    super.set(key, value)
+    if (this.maxSize && this.size > this.maxSize) {
+      // `super.keys()`, not `this.keys()`: on iOS 18 the subclass iterator
+      // can yield `undefined`, and the map then grows without limit.
+      const firstKey = super.keys().next().value
+      if (firstKey !== undefined) {
+        super.delete(firstKey)
+      }
+    }
+    return this
+  }
+}