@lifi/sdk 4.0.0-alpha.6 → 4.0.0-alpha.8

package/src/index.ts

@@ -1,8 +1,6 @@
 // biome-ignore lint/performance/noBarrelFile: module entrypoint
 // biome-ignore lint/performance/noReExportAll: types
 export * from '@lifi/types'
-export type { Client } from 'viem'
-export { formatUnits, isHex, parseUnits } from 'viem/utils'
 export { getChains } from './actions/getChains.js'
 export { getConnections } from './actions/getConnections.js'
 export { getContractCallsQuote } from './actions/getContractCallsQuote.js'
@@ -23,6 +21,7 @@ export { getTools } from './actions/getTools.js'
 export { getTransactionHistory } from './actions/getTransactionHistory.js'
 export { getWalletBalances } from './actions/getWalletBalances.js'
 export { actions } from './actions/index.js'
+export { patchContractCalls } from './actions/patchContractCalls.js'
 export { relayTransaction } from './actions/relayTransaction.js'
 export { createClient } from './client/createClient.js'
 export { BaseStepExecutor } from './core/BaseStepExecutor.js'
@@ -37,7 +36,6 @@ export {
 } from './core/execution.js'
 export { StatusManager } from './core/StatusManager.js'
 export { stepComparison } from './core/stepComparison.js'
-export { isTokenMessageSigningAllowed } from './core/utils.js'
 export { waitForDestinationChainTransaction } from './core/waitForDestinationChainTransaction.js'
 export { BaseError } from './errors/baseError.js'
 export type { ErrorCode } from './errors/constants.js'
@@ -57,15 +55,20 @@ export type {
   AcceptExchangeRateUpdateHook,
   AcceptSlippageUpdateHook,
   AcceptSlippageUpdateHookParams,
+  ContractCallParams,
+  ContractTool,
   ExchangeRateUpdateParams,
   Execution,
   ExecutionOptions,
   ExecutionStatus,
+  GetContractCallsHook,
+  GetContractCallsResult,
   InteractionSettings,
   LiFiStepExtended,
   Process,
   ProcessStatus,
   ProcessType,
+  RequestInterceptor,
   RouteExecutionData,
   RouteExecutionDataDictionary,
   RouteExecutionDictionary,
@@ -78,7 +81,6 @@ export type {
   StepExecutor,
   StepExecutorOptions,
   StepExtended,
-  SwitchChainHook,
   TransactionMethodType,
   TransactionParameters,
   TransactionRequestParameters,
@@ -88,6 +90,9 @@ export type {
 export { checkPackageUpdates } from './utils/checkPackageUpdates.js'
 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 { parseUnits } from './utils/parseUnits.js'
 export { sleep } from './utils/sleep.js'
 export { waitForResult } from './utils/waitForResult.js'
 export { withDedupe } from './utils/withDedupe.js'

package/src/types/core.ts

@@ -2,6 +2,7 @@ import type {
   ChainId,
   ChainType,
   CoinKey,
+  ContractCall,
   ExtendedChain,
   FeeCost,
   GasCost,
@@ -13,7 +14,11 @@ import type {
   Token,
   TokenAmount,
 } from '@lifi/types'
-import type { Client } from 'viem'
+import type { ExtendedRequestInit } from './request.js'
+
+export type RequestInterceptor = (
+  request: ExtendedRequestInit
+) => ExtendedRequestInit | Promise<ExtendedRequestInit>
 
 export interface SDKBaseConfig {
   apiKey?: string
@@ -27,6 +32,8 @@ export interface SDKBaseConfig {
   widgetVersion?: string
   debug: boolean
   preloadChains?: boolean
+  chainsRefetchInterval?: number
+  requestInterceptor?: RequestInterceptor
 }
 
 export interface SDKConfig extends Partial<Omit<SDKBaseConfig, 'integrator'>> {
@@ -132,8 +139,6 @@ export type TransactionRequestUpdateHook = (
   updatedTxRequest: TransactionRequestParameters
 ) => Promise<TransactionParameters>
 
-export type SwitchChainHook = (chainId: number) => Promise<Client | undefined>
-
 export interface AcceptSlippageUpdateHookParams {
   toToken: Token
   oldToAmount: string
@@ -156,11 +161,39 @@ export type AcceptExchangeRateUpdateHook = (
   params: ExchangeRateUpdateParams
 ) => Promise<boolean | undefined>
 
+export interface ContractCallParams {
+  fromChainId: number
+  toChainId: number
+  fromTokenAddress: string
+  toTokenAddress: string
+  fromAddress: string
+  toAddress?: string
+  fromAmount: bigint
+  toAmount: bigint
+  slippage?: number
+}
+
+export interface ContractTool {
+  name: string
+  logoURI: string
+}
+
+export interface GetContractCallsResult {
+  contractCalls: ContractCall[]
+  patcher?: boolean
+  contractTool?: ContractTool
+}
+
+export type GetContractCallsHook = (
+  params: ContractCallParams
+) => Promise<GetContractCallsResult>
+
 export interface ExecutionOptions {
   acceptExchangeRateUpdateHook?: AcceptExchangeRateUpdateHook
-  switchChainHook?: SwitchChainHook
   updateRouteHook?: UpdateRouteHook
   updateTransactionRequestHook?: TransactionRequestUpdateHook
+  getContractCalls?: GetContractCallsHook
+  adjustZeroOutputFromPreviousStep?: boolean
   executeInBackground?: boolean
   disableMessageSigning?: boolean
   /**

package/src/utils/convertQuoteToRoute.ts

@@ -1,23 +1,132 @@
-import type { LiFiStep, Route } from '@lifi/types'
+import type { LiFiStep, Route, Step } from '@lifi/types'
 import { ValidationError } from '../errors/errors.js'
 import { SDKError } from '../errors/SDKError.js'
+import { formatUnits } from './formatUnits.js'
+
+interface ConvertQuoteToRouteOptions {
+  /**
+   * When true, if the quote has zero output values (toAmount, toAmountMin, toAmountUSD),
+   * use the values from the previous included step that has non-zero output.
+   */
+  adjustZeroOutputFromPreviousStep?: boolean
+}
+
+const parseBigInt = (value: string | undefined): bigint => {
+  if (!value) {
+    return 0n
+  }
+  try {
+    return BigInt(value)
+  } catch {
+    return 0n
+  }
+}
+
+const parseNumber = (value: string | undefined): number => {
+  if (!value) {
+    return 0
+  }
+  const parsed = Number(value)
+  return Number.isNaN(parsed) ? 0 : parsed
+}
+
+const isZeroOutput = (
+  toAmount: string,
+  toAmountMin: string,
+  toAmountUSD?: string
+): boolean => {
+  return (
+    !parseBigInt(toAmount) &&
+    !parseBigInt(toAmountMin) &&
+    !parseNumber(toAmountUSD)
+  )
+}
+
+const hasNonZeroOutput = (step: Step): boolean => {
+  return (
+    !!parseBigInt(step.estimate.toAmount) ||
+    !!parseBigInt(step.estimate.toAmountMin)
+  )
+}
+
+const findPreviousNonZeroStep = (steps: Step[]): Step | undefined => {
+  // Find the last step that has non-zero output (the step before the zero output step)
+  for (let i = steps.length - 1; i >= 0; i--) {
+    const step = steps[i]
+    if (hasNonZeroOutput(step)) {
+      return step
+    }
+  }
+  return undefined
+}
+
+export function formatTokenPrice(
+  amount?: string | bigint,
+  price?: string,
+  decimals?: number
+) {
+  if (!amount || !price) {
+    return 0
+  }
+
+  const formattedAmount =
+    typeof amount === 'bigint' && decimals !== undefined
+      ? formatUnits(amount, decimals)
+      : amount.toString()
+
+  if (Number.isNaN(Number(formattedAmount)) || Number.isNaN(Number(price))) {
+    return 0
+  }
+  return Number.parseFloat(formattedAmount) * Number.parseFloat(price)
+}
 
 /**
  * Converts a quote to Route
  * @param quote - Step returned from the quote endpoint.
- * @param txHash
- * @param chainId
+ * @param options - Optional configuration for handling edge cases.
  * @returns - The route to be executed.
  * @throws {BaseError} Throws a ValidationError if the step has missing values.
  */
-export const convertQuoteToRoute = (quote: LiFiStep): Route => {
+export const convertQuoteToRoute = (
+  quote: LiFiStep,
+  options?: ConvertQuoteToRouteOptions
+): Route => {
+  let toAmount = quote.estimate.toAmount
+  let toAmountMin = quote.estimate.toAmountMin
+  let toAmountUSD = quote.estimate.toAmountUSD
+
+  // Handle zero output values by looking at previous included step
+  if (
+    options?.adjustZeroOutputFromPreviousStep &&
+    quote.includedSteps?.length &&
+    isZeroOutput(toAmount, toAmountMin, toAmountUSD)
+  ) {
+    const previousStep = findPreviousNonZeroStep(quote.includedSteps)
+    if (previousStep) {
+      toAmount = previousStep.estimate.toAmount
+      toAmountMin = previousStep.estimate.toAmountMin
+      toAmountUSD = formatTokenPrice(
+        parseBigInt(toAmount),
+        previousStep.action.toToken.priceUSD,
+        previousStep.action.toToken.decimals
+      ).toFixed(2)
+
+      // Update the last included step's estimate with the adjusted values
+      const lastStep = quote.includedSteps[quote.includedSteps.length - 1]
+      if (lastStep && !hasNonZeroOutput(lastStep)) {
+        lastStep.estimate.toAmount = toAmount
+        lastStep.estimate.toAmountMin = toAmountMin
+      }
+    }
+  }
+
   if (!quote.estimate.fromAmountUSD) {
     throw new SDKError(
       new ValidationError("Missing 'fromAmountUSD' in step estimate.")
     )
   }
 
-  if (!quote.estimate.toAmountUSD) {
+  if (!toAmountUSD) {
     throw new SDKError(
       new ValidationError("Missing 'toAmountUSD' in step estimate.")
     )
@@ -32,9 +141,9 @@ export const convertQuoteToRoute = (quote: LiFiStep): Route => {
     fromAddress: quote.action.fromAddress,
     toChainId: quote.action.toToken.chainId,
     toToken: quote.action.toToken,
-    toAmount: quote.estimate.toAmount,
-    toAmountMin: quote.estimate.toAmountMin,
-    toAmountUSD: quote.estimate.toAmountUSD,
+    toAmount,
+    toAmountMin,
+    toAmountUSD,
     toAddress: quote.action.toAddress || quote.action.fromAddress,
     gasCostUSD: quote.estimate.gasCosts?.[0]?.amountUSD || '0',
     steps: [quote],

package/src/utils/formatUnits.ts

@@ -0,0 +1,22 @@
+/**
+ *  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) {
+  let display = value.toString()
+
+  const negative = display.startsWith('-')
+  if (negative) {
+    display = display.slice(1)
+  }
+
+  display = display.padStart(decimals, '0')
+
+  let [integer, fraction] = [
+    display.slice(0, display.length - decimals),
+    display.slice(display.length - decimals),
+  ]
+  fraction = fraction.replace(/(0+)$/, '')
+  return `${negative ? '-' : ''}${integer || '0'}${
+    fraction ? `.${fraction}` : ''
+  }`
+}

package/src/utils/isHex.ts

@@ -0,0 +1,14 @@
+export type Hex = `0x${string}`
+
+export function isHex(
+  value: unknown,
+  { strict = true }: { strict?: boolean | undefined } = {}
+): value is Hex {
+  if (!value) {
+    return false
+  }
+  if (typeof value !== 'string') {
+    return false
+  }
+  return strict ? /^0x[0-9a-fA-F]*$/.test(value) : value.startsWith('0x')
+}

package/src/utils/parseUnits.ts

@@ -0,0 +1,50 @@
+/**
+ * Multiplies a string representation of a number by a given exponent of base 10 (10exponent).
+ */
+export function parseUnits(value: string, decimals: number) {
+  if (!/^(-?)([0-9]*)\.?([0-9]*)$/.test(value)) {
+    throw new Error(`Number \`${value}\` is not a valid decimal number.`)
+  }
+
+  let [integer, fraction = '0'] = value.split('.')
+
+  const negative = integer.startsWith('-')
+  if (negative) {
+    integer = integer.slice(1)
+  }
+
+  // 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) {
+      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}`
+    }
+
+    if (fraction.length > decimals) {
+      fraction = fraction.slice(1)
+      integer = `${BigInt(integer) + 1n}`
+    }
+
+    fraction = fraction.slice(0, decimals)
+  } else {
+    fraction = fraction.padEnd(decimals, '0')
+  }
+
+  return BigInt(`${negative ? '-' : ''}${integer}${fraction}`)
+}

package/src/utils/request.ts

@@ -24,7 +24,8 @@ export const request = async <T = Response>(
     retries: requestSettings.retries,
   }
 ): Promise<T> => {
-  const { userId, integrator, widgetVersion, apiKey } = config
+  const { userId, integrator, widgetVersion, apiKey, requestInterceptor } =
+    config
 
   if (!integrator) {
     throw new SDKError(
@@ -71,6 +72,10 @@ export const request = async <T = Response>(
       'x-lifi-integrator': integrator,
     }
 
+    if (requestInterceptor) {
+      options = await requestInterceptor(options)
+    }
+
     const response: Response = await fetch(
       url,
       stripExtendRequestInitProperties(options)
@@ -82,12 +87,10 @@ export const request = async <T = Response>(
 
     return await response.json()
   } catch (error) {
-    if (options.retries > 0 && (error as HTTPError).status === 500) {
+    const retries = options.retries ?? 0
+    if (retries > 0 && (error as HTTPError).status === 500) {
       await sleep(500)
-      return request<T>(config, url, {
-        ...options,
-        retries: options.retries - 1,
-      })
+      return request<T>(config, url, { ...options, retries: retries - 1 })
     }
 
     await (error as HTTPError).buildAdditionalDetails?.()

package/src/version.ts

@@ -1,2 +1,2 @@
 export const name = '@lifi/sdk'
-export const version = '4.0.0-alpha.6'
+export const version = '4.0.0-alpha.8'