@lifi/sdk 4.8.2 → 4.10.0

package/src/utils/parseUnits.ts

@@ -2,49 +2,82 @@
  * Multiplies a string representation of a number by a given exponent of base 10 (10exponent).
  */
 export function parseUnits(value: string, decimals: number): bigint {
-  if (!/^(-?)([0-9]*)\.?([0-9]*)$/.test(value)) {
+  if (!Number.isInteger(decimals) || decimals < 0) {
+    throw new Error(
+      `\`decimals\` must be a non-negative integer. Got \`${decimals}\`.`
+    )
+  }
+
+  // An input with no digit is 0n: the widget parses an empty amount field.
+  if (/^-?\.?$/.test(value)) {
+    return 0n
+  }
+
+  if (!/^-?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)$/.test(value)) {
     throw new Error(`Number \`${value}\` is not a valid decimal number.`)
   }
 
-  let [integer, fraction = '0'] = value.split('.')
+  let [integer = '', fraction = '0'] = value.split('.')
 
   const negative = integer.startsWith('-')
   if (negative) {
     integer = integer.slice(1)
   }
+  if (integer === '') {
+    integer = '0'
+  }
 
   // trim trailing zeros.
   fraction = fraction.replace(/(0+)$/, '')
 
   // round off if the fraction is larger than the number of decimals.
   if (decimals === 0) {
-    if (Math.round(Number(`.${fraction}`)) === 1) {
+    // Round half away from zero by the first fractional digit.
+    if (fraction.length > 0 && Number.parseInt(fraction[0], 10) >= 5) {
       integer = `${BigInt(integer) + 1n}`
     }
     fraction = ''
   } else if (fraction.length > decimals) {
-    const [left, unit, right] = [
-      fraction.slice(0, decimals - 1),
-      fraction.slice(decimals - 1, decimals),
-      fraction.slice(decimals),
-    ]
-
-    const rounded = Math.round(Number(`${unit}.${right}`))
-    if (rounded > 9) {
-      fraction = `${BigInt(left) + BigInt(1)}0`.padStart(left.length + 1, '0')
-    } else {
-      fraction = `${left}${rounded}`
-    }
+    const left = fraction.slice(0, decimals)
+    const roundDigit = Number.parseInt(
+      fraction.slice(decimals, decimals + 1),
+      10
+    )
 
-    if (fraction.length > decimals) {
-      fraction = fraction.slice(1)
-      integer = `${BigInt(integer) + 1n}`
+    if (roundDigit >= 5) {
+      // Carry in decimal space, not through a JS number: a float loses
+      // precision on long fractions and can round the wrong way.
+      const carried = carry(left)
+      if (carried.length > decimals) {
+        // The carry overflowed into the integer part.
+        fraction = carried.slice(1)
+        integer = `${BigInt(integer) + 1n}`
+      } else {
+        fraction = carried
+      }
+    } else {
+      fraction = left
     }
-
-    fraction = fraction.slice(0, decimals)
   } else {
     fraction = fraction.padEnd(decimals, '0')
   }
 
   return BigInt(`${negative ? '-' : ''}${integer}${fraction}`)
 }
+
+/**
+ * Adds 1 to a digit string. The result has the same length, unless the carry
+ * passes the most significant digit: then it is one digit longer.
+ */
+function carry(digits: string): string {
+  const out = digits.split('')
+  for (let i = out.length - 1; i >= 0; i--) {
+    const digit = Number.parseInt(out[i], 10) + 1
+    if (digit < 10) {
+      out[i] = String(digit)
+      return out.join('')
+    }
+    out[i] = '0'
+  }
+  return `1${out.join('')}`
+}

package/src/utils/sleep.ts

@@ -1,5 +1,29 @@
-export function sleep(ms: number): Promise<null> {
-  return new Promise((resolve) => {
-    setTimeout(() => resolve(null), ms)
+import { getAbortError } from './abort.js'
+
+/**
+ * Resolves with `null` after `ms`. With a `signal`, it rejects with the abort
+ * reason as soon as the signal aborts, and clears its timer.
+ */
+export function sleep(
+  ms: number,
+  { signal }: { signal?: AbortSignal | undefined } = {}
+): Promise<null> {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(getAbortError(signal))
+      return
+    }
+
+    const cleanup = (): void => signal?.removeEventListener('abort', onAbort)
+    const timer = setTimeout(() => {
+      cleanup()
+      resolve(null)
+    }, ms)
+    const onAbort = (): void => {
+      clearTimeout(timer)
+      cleanup()
+      reject(getAbortError(signal!))
+    }
+    signal?.addEventListener('abort', onAbort, { once: true })
   })
 }

package/src/utils/waitForResult.ts

@@ -1,13 +1,13 @@
 import { sleep } from './sleep.js'
 
 /**
- * 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 const waitForResult = async <T>(
   fn: () => Promise<T | undefined>,

package/src/utils/withDedupe.ts

@@ -1,45 +1,139 @@
-/**
- * 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
+import { getAbortError } from './abort.js'
+import { LruMap } from './lru.js'
 
-  constructor(size: number) {
-    super()
-    this.maxSize = size
-  }
+type Caller = {
+  resolve: (value: any) => void
+  reject: (error: unknown) => void
+}
 
-  override set(key: string, value: value): this {
-    super.set(key, value)
-    if (this.maxSize && this.size > this.maxSize) {
-      this.delete(this.keys().next().value!)
-    }
-    return this
-  }
+type InFlight = {
+  promise: Promise<any>
+  /** Absent when the first caller had no signal: then nothing can abort it. */
+  controller?: AbortController | undefined
+  /** Callers with a signal that are still waiting, once the first one joins. */
+  callers?: Set<Caller> | undefined
+  /** A caller without a signal joined, so the request must run to the end. */
+  pinned: boolean
 }
 
 /** @internal */
-const promiseCache = /*#__PURE__*/ new LruMap<Promise<any>>(8192)
+const promiseCache = /*#__PURE__*/ new LruMap<InFlight>(8192)
 
 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. */
+/**
+ * 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 function withDedupe<T>(
+  fn: (signal?: AbortSignal) => Promise<T>,
+  options: WithDedupeOptions
+): Promise<T>
 export function withDedupe<T>(
   fn: () => Promise<T>,
-  { enabled = true, id }: WithDedupeOptions
+  options: WithDedupeOptions & { signal?: undefined }
+): Promise<T>
+export function withDedupe<T>(
+  fn: (signal?: AbortSignal) => Promise<T>,
+  { enabled = true, id, signal }: WithDedupeOptions
 ): Promise<T> {
   if (!enabled || !id) {
-    return fn()
+    return fn(signal)
+  }
+  if (signal?.aborted) {
+    return Promise.reject(getAbortError(signal))
+  }
+  let inFlight = promiseCache.get(id)
+  if (!inFlight) {
+    const controller = signal ? new AbortController() : undefined
+    const promise = fn(controller?.signal).finally(() => evict(id, promise))
+    inFlight = { promise, controller, pinned: false }
+    promiseCache.set(id, inFlight)
   }
-  if (promiseCache.get(id)) {
-    return promiseCache.get(id)!
+  return join<T>(id, inFlight, signal)
+}
+
+function join<T>(
+  id: string,
+  inFlight: InFlight,
+  signal: AbortSignal | undefined
+): Promise<T> {
+  if (!signal) {
+    inFlight.pinned = true
+    return inFlight.promise
+  }
+  const callers = inFlight.callers ?? subscribe(inFlight)
+  return new Promise<T>((resolve, reject) => {
+    // Stop listening before settling, so a later abort cannot reach the request.
+    const caller: Caller = {
+      resolve: (value) => {
+        signal.removeEventListener('abort', leave)
+        resolve(value)
+      },
+      reject: (error) => {
+        signal.removeEventListener('abort', leave)
+        reject(error)
+      },
+    }
+    const leave = () => {
+      // `leave` can run without the event, so the listener is not always gone.
+      signal.removeEventListener('abort', leave)
+      callers.delete(caller)
+      const reason = getAbortError(signal)
+      reject(reason)
+      if (!inFlight.pinned && callers.size === 0) {
+        // A caller arriving now must start a new request, not join this one.
+        evict(id, inFlight.promise)
+        inFlight.controller?.abort(reason)
+      }
+    }
+    callers.add(caller)
+    signal.addEventListener('abort', leave, { once: true })
+    // `fn` runs before this listener exists and may have aborted the signal.
+    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: InFlight): Set<Caller> {
+  const callers = new Set<Caller>()
+  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: string, promise: Promise<unknown>): void {
+  if (promiseCache.get(id)?.promise === promise) {
+    promiseCache.delete(id)
   }
-  const promise = fn().finally(() => promiseCache.delete(id))
-  promiseCache.set(id, promise)
-  return promise
 }

package/src/utils/withTimeout.ts

@@ -1,3 +1,5 @@
+import { isAbortError } from './abort.js'
+
 /**
  * Wraps a function in a timeout.
  * Based on viem's withTimeout implementation.
@@ -25,8 +27,8 @@ export function withTimeout<T>(
   return new Promise((resolve, reject) => {
     ;(async () => {
       let timeoutId!: NodeJS.Timeout
+      const controller = new AbortController()
       try {
-        const controller = new AbortController()
         if (timeout > 0) {
           timeoutId = setTimeout(() => {
             if (signal) {
@@ -38,8 +40,11 @@ export function withTimeout<T>(
         }
         resolve(await fn({ signal: controller?.signal || null }))
       } catch (err) {
-        if ((err as Error)?.name === 'AbortError') {
+        // Only an abort from our own timeout is a timeout. Any other
+        // AbortError belongs to the caller and passes through.
+        if (controller.signal.aborted && isAbortError(err)) {
           reject(errorInstance)
+          return
         }
         reject(err)
       } finally {

package/src/version.ts

@@ -1,2 +1,2 @@
 export const name = '@lifi/sdk'
-export const version = '4.8.2'
+export const version = '4.10.0'