npm - @lifi/sdk - Versions diffs - 3.2.0 → 3.3.0-alpha.1 - Mend

@lifi/sdk 3.2.0 → 3.3.0-alpha.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (344) hide show

package/src/core/UTXO/utxo-stack/transports/utxo/getHttpRpcClient.ts ADDED Viewed

@@ -0,0 +1,122 @@
+import { HttpRequestError, stringify, TimeoutError, withTimeout } from 'viem'
+import type { HttpRequestReturnType, HttpRpcClientOptions } from 'viem/utils'
+export type RpcRequest = {
+  jsonrpc?: '2.0'
+  method: string
+  params?: any
+  id?: number
+}
+export type HttpRequestParameters<
+  body extends RpcRequest | RpcRequest[] = RpcRequest,
+> = {
+  url?: string
+  /** The RPC request body. */
+  body?: body
+  /** Request configuration to pass to `fetch`. */
+  fetchOptions?: HttpRpcClientOptions['fetchOptions'] | undefined
+  /** A callback to handle the response. */
+  onRequest?: ((request: Request) => Promise<void> | void) | undefined
+  /** A callback to handle the response. */
+  onResponse?: ((response: Response) => Promise<void> | void) | undefined
+  /** The timeout (in ms) for the request. */
+  timeout?: HttpRpcClientOptions['timeout'] | undefined
+}
+export type HttpRpcClient = {
+  request<body extends RpcRequest | RpcRequest[]>(
+    params: HttpRequestParameters<body>
+  ): Promise<HttpRequestReturnType<body>>
+}
+export function getHttpRpcClient(
+  url: string,
+  options: HttpRpcClientOptions = {}
+): HttpRpcClient {
+  return {
+    async request(params) {
+      const {
+        body,
+        onRequest = options.onRequest,
+        onResponse = options.onResponse,
+        timeout = options.timeout ?? 10_000,
+      } = params
+      const fetchOptions = {
+        ...(options.fetchOptions ?? {}),
+        ...(params.fetchOptions ?? {}),
+      }
+      const { headers, method, signal: signal_ } = fetchOptions
+      try {
+        const response = await withTimeout(
+          async ({ signal }) => {
+            const init: RequestInit = {
+              ...fetchOptions,
+              body: body ? stringify(body) : undefined,
+              headers: {
+                ...(method !== 'GET'
+                  ? { 'Content-Type': 'application/json' }
+                  : undefined),
+                ...headers,
+              },
+              method: method,
+              signal: signal_ || (timeout > 0 ? signal : null),
+            }
+            const request = new Request(params.url ?? url, init)
+            if (onRequest) {
+              await onRequest(request)
+            }
+            const response = await fetch(params.url ?? url, init)
+            return response
+          },
+          {
+            errorInstance: new TimeoutError({ body: body ?? {}, url }),
+            timeout,
+            signal: true,
+          }
+        )
+        if (onResponse) {
+          await onResponse(response)
+        }
+        let data: any
+        if (
+          response.headers.get('Content-Type')?.startsWith('application/json')
+        ) {
+          data = await response.json()
+        } else {
+          data = await response.text()
+          data = JSON.parse(data || '{}')
+        }
+        if (!response.ok) {
+          throw new HttpRequestError({
+            body,
+            details: stringify(data.error) || response.statusText,
+            headers: response.headers,
+            status: response.status,
+            url,
+          })
+        }
+        return data
+      } catch (err) {
+        if (err instanceof HttpRequestError) {
+          throw err
+        }
+        if (err instanceof TimeoutError) {
+          throw err
+        }
+        throw new HttpRequestError({
+          body,
+          cause: err as Error,
+          url,
+        })
+      }
+    },
+  }
+}

package/src/core/UTXO/utxo-stack/transports/utxo/getRpcProviderMethods.ts ADDED Viewed

@@ -0,0 +1,22 @@
+import { ankrMethods } from './ankr.js'
+import { blockchairMethods } from './blockchair.js'
+import { blockcypherMethods } from './blockcypher.js'
+import { mempoolMethods } from './mempool.js'
+import type { RpcMethods } from './types.js'
+export function getRpcProviderMethods(
+  key: 'blockchair' | 'ankr' | 'blockcypher' | 'mempool' | string
+): RpcMethods | null {
+  switch (key) {
+    case 'blockchair':
+      return blockchairMethods
+    case 'ankr':
+      return ankrMethods
+    case 'blockcypher':
+      return blockcypherMethods
+    case 'mempool':
+      return mempoolMethods
+    default:
+      return null
+  }
+}

package/src/core/UTXO/utxo-stack/transports/utxo/mempool.ts ADDED Viewed

@@ -0,0 +1,34 @@
+import type { RpcMethods } from './types.js'
+type MempoolBalanceResponse = {
+  address: string
+  chain_stats: {
+    funded_txo_count: number
+    funded_txo_sum: number
+    spent_txo_count: number
+    spent_txo_sum: number
+    tx_count: number
+  }
+  mempool_stats: {
+    funded_txo_count: number
+    funded_txo_sum: number
+    spent_txo_count: number
+    spent_txo_sum: number
+    tx_count: number
+  }
+}
+export const mempoolMethods: RpcMethods = {
+  getBalance: async (client, baseUrl, { address }) => {
+    const apiUrl = `${baseUrl}/address/${address}`
+    const response = (await client.request({
+      url: apiUrl,
+      fetchOptions: { method: 'GET' },
+    })) as unknown as MempoolBalanceResponse
+    const balance =
+      response.chain_stats.funded_txo_sum - response.chain_stats.spent_txo_sum
+    return {
+      result: BigInt(balance),
+    }
+  },
+}

package/src/core/UTXO/utxo-stack/transports/utxo/types.ts ADDED Viewed

@@ -0,0 +1,55 @@
+import type { UTXOTransaction } from '../../types/transaction.js'
+import type { HttpRpcClient } from './getHttpRpcClient.js'
+export type UTXOSchema = [
+  {
+    Method: 'getblockcount'
+    Parameters: []
+    ReturnType: number
+  },
+  {
+    Method: 'sendrawtransaction'
+    Parameters: [string, number?]
+    ReturnType: string
+  },
+  {
+    Method: 'getrawtransaction'
+    Parameters: [string, boolean, string?]
+    ReturnType: UTXOTransaction
+  },
+]
+export type UTXOAPISchema = [
+  {
+    Method: 'getBalance'
+    Parameters: { address: string }
+    ReturnType: bigint
+  },
+]
+export type UTXOAPIMethod = UTXOAPISchema[number]['Method']
+export type SuccessResult<result> = {
+  method?: undefined
+  result: result
+  error?: undefined
+}
+export type ErrorResult<error> = {
+  method?: undefined
+  result?: undefined
+  error: error
+}
+export type RpcResponse<result = any, error = any> =
+  | SuccessResult<result>
+  | ErrorResult<error>
+export type RpcMethodHandler = (
+  client: HttpRpcClient,
+  baseUrl: string,
+  params: any
+) => Promise<RpcResponse>
+export type RpcMethods = {
+  [key in UTXOAPIMethod]: RpcMethodHandler
+}

package/src/core/UTXO/utxo-stack/transports/utxo/utxo.ts ADDED Viewed

@@ -0,0 +1,84 @@
+import {
+  createTransport,
+  RpcRequestError,
+  UrlRequiredError,
+  type HttpTransport,
+  type HttpTransportConfig,
+} from 'viem'
+import { getHttpRpcClient } from './getHttpRpcClient.js'
+import { getRpcProviderMethods } from './getRpcProviderMethods.js'
+import type { UTXOAPIMethod } from './types.js'
+type UTXOHttpTransportConfig = HttpTransportConfig & {
+  includeChainToURL?: boolean
+}
+export function utxo(
+  url?: string,
+  config: UTXOHttpTransportConfig = {}
+): HttpTransport {
+  const {
+    fetchOptions,
+    key = 'utxo',
+    name = 'UTXO HTTP API',
+    onFetchRequest,
+    onFetchResponse,
+    retryDelay,
+  } = config
+  return ({ chain, retryCount: retryCount_, timeout: timeout_ }) => {
+    const retryCount = config.retryCount ?? retryCount_
+    const timeout = timeout_ ?? config.timeout ?? 10_000
+    let url_ = url
+    if (config.includeChainToURL) {
+      const chainName = chain?.name.replace(' ', '-').toLowerCase()
+      url_ = `${url}${chainName ? `/${chainName}` : ''}`
+    }
+    if (!url_) {
+      throw new UrlRequiredError()
+    }
+    const client = getHttpRpcClient(url_, {
+      fetchOptions,
+      onRequest: onFetchRequest,
+      onResponse: onFetchResponse,
+      timeout,
+    })
+    const rpcMethods = getRpcProviderMethods(key)
+    return createTransport(
+      {
+        key,
+        name,
+        async request({ method, params }) {
+          const body = { method, params }
+          const methodHandler = rpcMethods?.[method as UTXOAPIMethod]
+          const { error, result } = await (methodHandler?.(
+            client,
+            url_,
+            params
+          ) ??
+            client.request({
+              body,
+            }))
+          if (error) {
+            throw new RpcRequestError({
+              body,
+              error,
+              url: url_,
+            })
+          }
+          return result
+        },
+        retryCount,
+        retryDelay,
+        timeout,
+        type: 'http',
+      },
+      {
+        fetchOptions,
+        url: url_,
+      }
+    )
+  }
+}

package/src/core/UTXO/utxo-stack/types/transaction.ts ADDED Viewed

@@ -0,0 +1,43 @@
+export type UTXOTransaction = {
+  blockhash?: string
+  blocktime?: number
+  confirmations?: number
+  hash: string
+  hex: string
+  in_active_chain?: boolean
+  locktime: number
+  size: number
+  time?: number
+  txid: string
+  version: number
+  vsize: number
+  weight: number
+  vin: {
+    scriptSig: {
+      asm: string
+      hex: string
+    }
+    sequence: number
+    txid: string
+    txinwitness: string[]
+    vout: number
+  }[]
+  vout: {
+    n: 0
+    scriptPubKey:
+      | {
+          address: string
+          asm: string
+          desc: string
+          hex: string
+          type: string
+        }
+      | {
+          asm: string
+          desc: string
+          hex: string
+          type: string
+        }
+    value: number
+  }[]
+}

package/src/core/checkBalance.ts CHANGED Viewed

@@ -1,8 +1,8 @@
 import type { LiFiStep } from '@lifi/types'
 import { formatUnits } from 'viem'
-import { getTokenBalance } from '../services/balance.js'
 import { BalanceError } from '../errors/errors.js'
-import { sleep } from './utils.js'
+import { getTokenBalance } from '../services/balance.js'
+import { sleep } from '../utils/sleep.js'
 export const checkBalance = async (
   walletAddress: string,

package/src/core/utils.ts CHANGED Viewed

@@ -25,9 +25,3 @@ export function checkStepSlippageThreshold(
   }
   return actualSlippage <= setSlippage
 }
-export function sleep(ms: number): Promise<null> {
-  return new Promise((resolve) => {
-    setTimeout(() => resolve(null), ms)
-  })
-}

package/src/core/waitForReceivingTransaction.ts CHANGED Viewed

@@ -4,9 +4,9 @@ import type {
   ProcessType,
   StatusResponse,
 } from '@lifi/types'
-import { getStatus } from '../services/api.js'
 import { ServerError } from '../errors/errors.js'
-import { repeatUntilDone } from '../utils/utils.js'
+import { getStatus } from '../services/api.js'
+import { waitForResult } from '../utils/waitForResult.js'
 import type { StatusManager } from './StatusManager.js'
 import { getSubstatusMessage } from './processMessages.js'
@@ -16,7 +16,8 @@ export async function waitForReceivingTransaction(
   txHash: string,
   statusManager: StatusManager,
   processType: ProcessType,
-  step: LiFiStep
+  step: LiFiStep,
+  interval: number = 5_000
 ): Promise<StatusResponse> {
   const _getStatus = (): Promise<StatusResponse | undefined> =>
     new Promise(async (resolve, reject) => {
@@ -62,7 +63,7 @@ export async function waitForReceivingTransaction(
   if (txHash in TRANSACTION_HASH_OBSERVERS) {
     status = await TRANSACTION_HASH_OBSERVERS[txHash]
   } else {
-    TRANSACTION_HASH_OBSERVERS[txHash] = repeatUntilDone(_getStatus, 5_000)
+    TRANSACTION_HASH_OBSERVERS[txHash] = waitForResult(_getStatus, interval)
     status = await TRANSACTION_HASH_OBSERVERS[txHash]
   }

package/src/createConfig.ts CHANGED Viewed

@@ -20,7 +20,9 @@ function createBaseConfig(options: SDKConfig) {
 }
 export async function createChainsConfig() {
-  config.loading = getChains({ chainTypes: [ChainType.EVM, ChainType.SVM] })
+  config.loading = getChains({
+    chainTypes: [ChainType.EVM, ChainType.SVM, ChainType.UTXO],
+  })
     .then((chains) => config.setChains(chains))
     .catch()
   await config.loading

package/src/index.ts CHANGED Viewed

@@ -14,17 +14,21 @@ export type {
   MultisigTransaction,
   MultisigTxDetails,
 } from './core/EVM/types.js'
+export * from './core/index.js'
+export { isSVMAddress } from './core/Solana/isSVMAddress.js'
 export {
   KeypairWalletAdapter,
   KeypairWalletName,
 } from './core/Solana/KeypairWalletAdapter.js'
 export { Solana } from './core/Solana/Solana.js'
-export * from './core/index.js'
+export { isUTXOAddress } from './core/UTXO/isUTXOAddress.js'
+export * from './core/UTXO/utxo-stack/clients/types.js'
+export { UTXO } from './core/UTXO/UTXO.js'
 export { createConfig } from './createConfig.js'
+export * from './errors/index.js'
+export { type ErrorCode } from './errors/index.js'
 export * from './helpers.js'
 export * from './services/api.js'
 export * from './services/balance.js'
 export * from './services/getNameServiceAddress.js'
 export * from './types/index.js'
-export * from './errors/index.js'
-export { type ErrorCode } from './errors/index.js'

package/src/request.ts CHANGED Viewed

@@ -1,9 +1,9 @@
 import { config } from './config.js'
-import { HTTPError } from './errors/httpError.js'
-import { wait } from './utils/utils.js'
 import { ValidationError } from './errors/errors.js'
+import { HTTPError } from './errors/httpError.js'
 import { SDKError } from './errors/SDKError.js'
 import type { ExtendedRequestInit } from './types/request.js'
+import { sleep } from './utils/sleep.js'
 import { version } from './version.js'
 export const requestSettings = {
@@ -82,7 +82,7 @@ export const request = async <T = Response>(
     return await response.json()
   } catch (error) {
     if (options.retries > 0 && (error as HTTPError).status === 500) {
-      await wait(500)
+      await sleep(500)
       return request<T>(url, { ...options, retries: options.retries - 1 })
     }

package/src/services/api.ts CHANGED Viewed

@@ -31,6 +31,7 @@ import { ValidationError } from '../errors/errors.js'
 import { SDKError } from '../errors/SDKError.js'
 import { request } from '../request.js'
 import { isRoutesRequest, isStep } from '../typeguards.js'
+import { withDedupe } from '../utils/withDedupe.js'
 /**
  * Fetch information about a Token
  * @param chain - Id or key of the chain that contains the token
@@ -231,14 +232,18 @@ export const getChains = async (
         delete params[key as keyof ChainsRequest]
     )
   }
-  const response = await request<ChainsResponse>(
-    `${config.get().apiUrl}/chains?${new URLSearchParams(
-      params as Record<string, string>
-    )}`,
-    {
-      signal: options?.signal,
-    }
+  const urlSearchParams = new URLSearchParams(
+    params as Record<string, string>
+  ).toString()
+  const response = await withDedupe(
+    () =>
+      request<ChainsResponse>(
+        `${config.get().apiUrl}/chains?${urlSearchParams}`,
+        {
+          signal: options?.signal,
+        }
+      ),
+    { id: `${getChains.name}.${urlSearchParams}` }
   )
   return response.chains
 }
@@ -349,15 +354,20 @@ export const getTokens = async (
         delete params[key as keyof TokensRequest]
     )
   }
-  return await request<TokensResponse>(
-    `${config.get().apiUrl}/tokens?${new URLSearchParams(
-      params as Record<string, string>
-    )}`,
-    {
-      signal: options?.signal,
-    }
+  const urlSearchParams = new URLSearchParams(
+    params as Record<string, string>
+  ).toString()
+  const response = await withDedupe(
+    () =>
+      request<TokensResponse>(
+        `${config.get().apiUrl}/tokens?${urlSearchParams}`,
+        {
+          signal: options?.signal,
+        }
+      ),
+    { id: `${getTokens.name}.${urlSearchParams}` }
   )
+  return response
 }
 /**

package/src/services/balance.ts CHANGED Viewed

@@ -1,7 +1,7 @@
-import type { Token, TokenAmount } from '@lifi/types'
+import { ChainType, type Token, type TokenAmount } from '@lifi/types'
 import { config } from '../config.js'
-import { isToken } from '../typeguards.js'
 import { ValidationError } from '../errors/errors.js'
+import { isToken } from '../typeguards.js'
 /**
  * Returns the balances of a specific token a wallet holds across all aggregated chains.
@@ -50,8 +50,8 @@ export const getTokenBalances = async (
 /**
  * This method queries the balances of tokens for a specific list of chains for a given wallet.
- * @param walletAddress - A walletaddress.
- * @param tokensByChain - A list of Token objects organized by chain ids.
+ * @param walletAddress - A wallet address.
+ * @param tokensByChain - A list of token objects organized by chain ids.
  * @returns A list of objects containing the tokens and the amounts on different chains organized by the chosen chains.
  * @throws {BaseError} Throws a ValidationError if parameters are invalid.
  */
@@ -73,10 +73,15 @@ export const getTokenBalancesByChain = async (
   await Promise.allSettled(
     Object.keys(tokensByChain).map(async (chainIdStr) => {
       const chainId = parseInt(chainIdStr)
-      const baseTokenAddress = tokensByChain[chainId][0].address
+      const chain = await config.getChainById(chainId)
+      const tokenAddress = tokensByChain[chainId][0].address
       const provider = config
         .get()
-        .providers.find((provider) => provider.isAddress(baseTokenAddress))
+        .providers.find((provider) =>
+          chain.chainType === ChainType.UTXO
+            ? provider.isAddress(walletAddress)
+            : provider.isAddress(tokenAddress)
+        )
       if (!provider) {
         throw new Error('SDK Token Provider not found.')
       }

package/src/utils/index.ts CHANGED Viewed

@@ -1,4 +1,4 @@
 export * from '../errors/index.js'
 export * from './getTransactionMessage.js'
 export * from './median.js'
-export * from './utils.js'
+export * from './waitForResult.js'

package/src/utils/isZeroAddress.ts ADDED Viewed

@@ -0,0 +1,20 @@
+import { AddressZero, AlternativeAddressZero } from '../constants.js'
+export const isZeroAddress = (address: string): boolean => {
+  if (address === AddressZero || address === AlternativeAddressZero) {
+    return true
+  }
+  return false
+}
+export const isNativeTokenAddress = (address: string): boolean => {
+  if (
+    address === AddressZero ||
+    address === AlternativeAddressZero ||
+    // CELO native token
+    address === '0x471ece3750da237f93b8e339c536989b8978a438'
+  ) {
+    return true
+  }
+  return false
+}

package/src/utils/sleep.ts ADDED Viewed

@@ -0,0 +1,5 @@
+export function sleep(ms: number): Promise<null> {
+  return new Promise((resolve) => {
+    setTimeout(() => resolve(null), ms)
+  })
+}

package/src/utils/waitForResult.ts ADDED Viewed

@@ -0,0 +1,21 @@
+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
+ * @param interval The timeout in milliseconds between retries, defaults to 5000
+ * @returns The result of the fn function
+ */
+export const waitForResult = async <T>(
+  fn: () => Promise<T | undefined>,
+  interval = 5000
+): Promise<T> => {
+  let result: T | undefined
+  while (!result) {
+    result = await fn()
+    if (!result) {
+      await sleep(interval)
+    }
+  }
+  return result
+}

package/src/utils/withDedupe.ts ADDED Viewed

@@ -0,0 +1,46 @@
+/**
+ * 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) {
+    super.set(key, value)
+    if (this.maxSize && this.size > this.maxSize) {
+      this.delete(this.keys().next().value!)
+    }
+    return this
+  }
+}
+/** @internal */
+export const promiseCache = /*#__PURE__*/ new LruMap<Promise<any>>(8192)
+type WithDedupeOptions = {
+  enabled?: boolean | undefined
+  id?: string | undefined
+}
+// eslint-disable-next-line jsdoc/require-param, jsdoc/require-returns
+/** Deduplicates in-flight promises. */
+export function withDedupe<data>(
+  fn: () => Promise<data>,
+  { enabled = true, id }: WithDedupeOptions
+): Promise<data> {
+  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
+}