@lifi/sdk 3.3.0-alpha.3 → 3.3.0-beta.0

package/src/core/UTXO/utxo-stack/utils/observe.ts

@@ -0,0 +1,81 @@
+import type { MaybePromise } from 'viem'
+
+type Callback = ((...args: any[]) => any) | undefined
+type Callbacks = Record<string, Callback>
+
+/** @internal */
+export const listenersCache = /*#__PURE__*/ new Map<
+  string,
+  { id: number; fns: Callbacks }[]
+>()
+/** @internal */
+export const cleanupCache = /*#__PURE__*/ new Map<string, () => void>()
+
+type EmitFunction<callbacks extends Callbacks> = (
+  emit: callbacks
+) => MaybePromise<void | (() => void)>
+
+let callbackCount = 0
+
+/**
+ * @description Sets up an observer for a given function. If another function
+ * is set up under the same observer id, the function will only be called once
+ * for both instances of the observer.
+ */
+export function observe<callbacks extends Callbacks>(
+  observerId: string,
+  callbacks: callbacks,
+  fn: EmitFunction<callbacks>
+) {
+  const callbackId = ++callbackCount
+
+  const getListeners = () => listenersCache.get(observerId) || []
+
+  const unsubscribe = () => {
+    const listeners = getListeners()
+    listenersCache.set(
+      observerId,
+      listeners.filter((cb: any) => cb.id !== callbackId)
+    )
+  }
+
+  const unwatch = () => {
+    const cleanup = cleanupCache.get(observerId)
+    if (getListeners().length === 1 && cleanup) {
+      cleanup()
+    }
+    unsubscribe()
+  }
+
+  const listeners = getListeners()
+  listenersCache.set(observerId, [
+    ...listeners,
+    { id: callbackId, fns: callbacks },
+  ])
+
+  if (listeners && listeners.length > 0) {
+    return unwatch
+  }
+
+  const emit: callbacks = {} as callbacks
+  for (const key in callbacks) {
+    emit[key] = ((
+      ...args: Parameters<NonNullable<callbacks[keyof callbacks]>>
+    ) => {
+      const listeners = getListeners()
+      if (listeners.length === 0) {
+        return
+      }
+      for (const listener of listeners) {
+        listener.fns[key]?.(...args)
+      }
+    }) as callbacks[Extract<keyof callbacks, string>]
+  }
+
+  const cleanup = fn(emit)
+  if (typeof cleanup === 'function') {
+    cleanupCache.set(observerId, cleanup)
+  }
+
+  return unwatch
+}

package/src/core/UTXO/utxo-stack/utils/poll.ts

@@ -0,0 +1,46 @@
+import { sleep } from '../../../../utils/sleep.js'
+
+type PollOptions<T> = {
+  // Whether or not to emit when the polling starts.
+  emitOnBegin?: boolean | undefined
+  // The initial wait time (in ms) before polling.
+  initialWaitTime?: ((data: T | void) => Promise<number>) | undefined
+  // The interval (in ms).
+  interval: number
+}
+
+/**
+ * @description Polls a function at a specified interval.
+ */
+export function poll<T>(
+  fn: ({ unpoll }: { unpoll: () => void }) => Promise<T | void>,
+  { emitOnBegin, initialWaitTime, interval }: PollOptions<T>
+) {
+  let active = true
+
+  const unwatch = () => (active = false)
+
+  const watch = async () => {
+    let data: T | void = undefined
+    if (emitOnBegin) {
+      data = await fn({ unpoll: unwatch })
+    }
+
+    const initialWait = (await initialWaitTime?.(data)) ?? interval
+    await sleep(initialWait)
+
+    const poll = async () => {
+      if (!active) {
+        return
+      }
+      await fn({ unpoll: unwatch })
+      await sleep(interval)
+      poll()
+    }
+
+    poll()
+  }
+  watch()
+
+  return unwatch
+}

package/src/errors/constants.ts

@@ -34,6 +34,7 @@ export enum LiFiErrorCode {
   WalletChangedDuringExecution = 1017,
   TransactionExpired = 1018,
   TransactionSimulationFailed = 1019,
+  TransactionConflict = 1020,
 }
 
 export enum ErrorMessage {

package/src/services/api.ts

@@ -154,7 +154,7 @@ export const getContractCallsQuote = async (
     }
   })
   if (
-    !isContractCallsRequestWithFromAmount(params) ||
+    !isContractCallsRequestWithFromAmount(params) &&
     !isContractCallsRequestWithToAmount(params)
   ) {
     throw new SDKError(

package/src/services/balance.ts

@@ -70,7 +70,7 @@ export const getTokenBalancesByChain = async (
   }
 
   const tokenAmountsByChain: { [chainId: number]: TokenAmount[] } = {}
-  await Promise.allSettled(
+  const tokenAmountsSettled = await Promise.allSettled(
     Object.keys(tokensByChain).map(async (chainIdStr) => {
       const chainId = parseInt(chainIdStr)
       const chain = await config.getChainById(chainId)
@@ -83,7 +83,9 @@ export const getTokenBalancesByChain = async (
             : provider.isAddress(tokenAddress)
         )
       if (!provider) {
-        throw new Error('SDK Token Provider not found.')
+        throw new Error(
+          `SDK Token Provider for ${chain.chainType} is not found.`
+        )
       }
       const tokenAmounts = await provider.getBalance(
         walletAddress,
@@ -92,5 +94,12 @@ export const getTokenBalancesByChain = async (
       tokenAmountsByChain[chainId] = tokenAmounts
     })
   )
+  if (config.get().debug) {
+    tokenAmountsSettled.forEach((promise) => {
+      if (promise.status === 'rejected') {
+        console.log("Couldn't fetch token balance.", promise.reason)
+      }
+    })
+  }
   return tokenAmountsByChain
 }

package/src/types/internal.ts

@@ -13,6 +13,7 @@ export interface SDKBaseConfig {
   disableVersionCheck?: boolean
   widgetVersion?: string
   preloadChains: boolean
+  debug: boolean
 }
 
 export interface SDKConfig extends Partial<Omit<SDKBaseConfig, 'integrator'>> {

package/src/version.ts

@@ -1,2 +1,2 @@
 export const name = '@lifi/sdk'
-export const version = '3.3.0-alpha.3'
+export const version = '3.3.0-beta.0'