@lifi/sdk 4.9.0 → 4.10.0

package/dist/esm/version.js

@@ -1,6 +1,6 @@
 //#region src/version.ts
 const name = "@lifi/sdk";
-const version = "4.9.0";
+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.9.0'\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.9.0",
+  "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/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

@@ -123,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/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
+  }
+}

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,24 +1,5 @@
-/**
- * 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 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
-  }
-}
+import { getAbortError } from './abort.js'
+import { LruMap } from './lru.js'
 
 type Caller = {
   resolve: (value: any) => void
@@ -70,7 +51,7 @@ export function withDedupe<T>(
     return fn(signal)
   }
   if (signal?.aborted) {
-    return Promise.reject(abortReason(signal))
+    return Promise.reject(getAbortError(signal))
   }
   let inFlight = promiseCache.get(id)
   if (!inFlight) {
@@ -108,7 +89,7 @@ function join<T>(
       // `leave` can run without the event, so the listener is not always gone.
       signal.removeEventListener('abort', leave)
       callers.delete(caller)
-      const reason = abortReason(signal)
+      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.
@@ -156,8 +137,3 @@ function evict(id: string, promise: Promise<unknown>): void {
     promiseCache.delete(id)
   }
 }
-
-/** Older runtimes and polyfills can abort a signal without a `reason`. */
-const abortReason = (signal: AbortSignal): unknown =>
-  signal.reason ??
-  Object.assign(new Error('This operation was aborted'), { name: 'AbortError' })

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.9.0'
+export const version = '4.10.0'