@lifi/sdk 3.0.0-alpha.9 → 3.0.0-beta.1

package/src/core/types.ts

@@ -0,0 +1,118 @@
+import type {
+  ChainType,
+  Execution,
+  LiFiStep,
+  Route,
+  Step,
+  Token,
+  TokenAmount,
+} from '@lifi/types'
+import type { WalletClient } from 'viem'
+
+export interface SDKProvider {
+  readonly type: ChainType
+  isAddress(address: string): boolean
+  resolveAddress(name: string): Promise<string | undefined>
+  getStepExecutor(options: StepExecutorOptions): Promise<StepExecutor>
+  getBalance(walletAddress: string, tokens: Token[]): Promise<TokenAmount[]>
+}
+
+export interface StepExecutorOptions {
+  routeId: string
+  executionOptions?: ExecutionOptions
+}
+
+export interface InteractionSettings {
+  allowInteraction?: boolean
+  allowUpdates?: boolean
+  allowExecution?: boolean
+}
+
+export interface StepExecutor {
+  allowUserInteraction: boolean
+  allowExecution: boolean
+  setInteraction(settings?: InteractionSettings): void
+  executeStep(step: LiFiStepExtended): Promise<LiFiStepExtended>
+}
+
+export interface RouteExtended extends Omit<Route, 'steps'> {
+  steps: LiFiStepExtended[]
+}
+
+export interface LiFiStepExtended extends LiFiStep {
+  execution?: Execution
+}
+
+export type StepExtended = Step & {
+  execution?: Execution
+}
+
+export type TransactionParameters = {
+  chainId?: number
+  to?: string
+  from?: string
+  nonce?: number
+  data?: string
+  value?: bigint
+  gas?: bigint
+  gasPrice?: bigint
+  maxFeePerGas?: bigint
+  maxPriorityFeePerGas?: bigint
+}
+
+export interface RouteExecutionData {
+  route: Route
+  executors: StepExecutor[]
+  executionOptions?: ExecutionOptions
+}
+
+export type RouteExecutionDataDictionary = Partial<
+  Record<string, RouteExecutionData>
+>
+
+export type RouteExecutionDictionary = Partial<Record<string, Promise<Route>>>
+
+export type UpdateRouteHook = (updatedRoute: RouteExtended) => void
+
+export interface TransactionRequestParameters extends TransactionParameters {
+  requestType: 'approve' | 'transaction'
+}
+
+export type TransactionRequestUpdateHook = (
+  updatedTxRequest: TransactionRequestParameters
+) => Promise<TransactionParameters>
+
+export type SwitchChainHook = (
+  chainId: number
+) => Promise<WalletClient | undefined>
+
+export interface AcceptSlippageUpdateHookParams {
+  toToken: Token
+  oldToAmount: string
+  newToAmount: string
+  oldSlippage: number
+  newSlippage: number
+}
+
+export type AcceptSlippageUpdateHook = (
+  params: AcceptSlippageUpdateHookParams
+) => Promise<boolean | undefined>
+
+export interface ExchangeRateUpdateParams {
+  toToken: Token
+  oldToAmount: string
+  newToAmount: string
+}
+
+export type AcceptExchangeRateUpdateHook = (
+  params: ExchangeRateUpdateParams
+) => Promise<boolean | undefined>
+
+export interface ExecutionOptions {
+  acceptExchangeRateUpdateHook?: AcceptExchangeRateUpdateHook
+  switchChainHook?: SwitchChainHook
+  updateRouteHook?: UpdateRouteHook
+  updateTransactionRequestHook?: TransactionRequestUpdateHook
+  executeInBackground?: boolean
+  infiniteApproval?: boolean
+}

package/src/core/utils.ts

@@ -0,0 +1,108 @@
+import {
+  type LiFiStep,
+  type ProcessStatus,
+  type ProcessType,
+  type StatusMessage,
+  type Substatus,
+} from '@lifi/types'
+
+const processMessages: Record<
+  ProcessType,
+  Partial<Record<ProcessStatus, string>>
+> = {
+  TOKEN_ALLOWANCE: {
+    STARTED: 'Setting token allowance.',
+    PENDING: 'Waiting for token allowance.',
+    DONE: 'Token allowance set.',
+  },
+  SWITCH_CHAIN: {
+    PENDING: 'Chain switch required.',
+    DONE: 'Chain switched successfully.',
+  },
+  SWAP: {
+    STARTED: 'Preparing swap transaction.',
+    ACTION_REQUIRED: 'Please sign the transaction.',
+    PENDING: 'Waiting for swap transaction.',
+    DONE: 'Swap completed.',
+  },
+  CROSS_CHAIN: {
+    STARTED: 'Preparing bridge transaction.',
+    ACTION_REQUIRED: 'Please sign the transaction.',
+    PENDING: 'Waiting for bridge transaction.',
+    DONE: 'Bridge transaction confirmed.',
+  },
+  RECEIVING_CHAIN: {
+    PENDING: 'Waiting for destination chain.',
+    DONE: 'Bridge completed.',
+  },
+  TRANSACTION: {},
+}
+const substatusMessages: Record<
+  StatusMessage,
+  Partial<Record<Substatus, string>>
+> = {
+  PENDING: {
+    BRIDGE_NOT_AVAILABLE: 'Bridge communication is temporarily unavailable.',
+    CHAIN_NOT_AVAILABLE: 'RPC communication is temporarily unavailable.',
+    UNKNOWN_ERROR:
+      'An unexpected error occurred. Please seek assistance in the LI.FI discord server.',
+    WAIT_SOURCE_CONFIRMATIONS:
+      'The bridge deposit has been received. The bridge is waiting for more confirmations to start the off-chain logic.',
+    WAIT_DESTINATION_TRANSACTION:
+      'The bridge off-chain logic is being executed. Wait for the transaction to appear on the destination chain.',
+  },
+  DONE: {
+    PARTIAL:
+      'Some of the received tokens are not the requested destination tokens.',
+    REFUNDED: 'The tokens were refunded to the sender address.',
+    COMPLETED: 'The transfer is complete.',
+  },
+  FAILED: {},
+  INVALID: {},
+  NOT_FOUND: {},
+}
+
+export function getProcessMessage(
+  type: ProcessType,
+  status: ProcessStatus
+): string | undefined {
+  const processMessage = processMessages[type][status]
+  return processMessage
+}
+
+export function getSubstatusMessage(
+  status: StatusMessage,
+  substatus?: Substatus
+): string | undefined {
+  if (!substatus) {
+    return
+  }
+  const message = substatusMessages[status][substatus]
+  return message
+}
+
+/**
+ * Used to check if changed exchange rate is in the range of slippage threshold.
+ * We use a slippage value as a threshold to trigger the rate change hook.
+ * This can result in almost doubled slippage for the user and need to be revisited.
+ * @param oldStep
+ * @param newStep
+ * @returns Boolean
+ */
+export function checkStepSlippageThreshold(
+  oldStep: LiFiStep,
+  newStep: LiFiStep
+): boolean {
+  const setSlippage = oldStep.action.slippage
+  const oldEstimatedToAmount = BigInt(oldStep.estimate.toAmountMin)
+  const newEstimatedToAmount = BigInt(newStep.estimate.toAmountMin)
+  const amountDifference = oldEstimatedToAmount - newEstimatedToAmount
+  // oldEstimatedToAmount can be 0 when we use contract calls
+  let actualSlippage = 0
+  if (oldEstimatedToAmount > 0) {
+    actualSlippage =
+      Number((amountDifference * 1_000_000_000n) / oldEstimatedToAmount) /
+      1_000_000_000
+  }
+  return actualSlippage <= setSlippage
+}

package/src/core/waitForReceivingTransaction.ts

@@ -0,0 +1,74 @@
+import type {
+  FullStatusData,
+  LiFiStep,
+  ProcessType,
+  StatusResponse,
+} from '@lifi/types'
+import { getStatus } from '../services/api.js'
+import { ServerError } from '../utils/errors.js'
+import { repeatUntilDone } from '../utils/utils.js'
+import type { StatusManager } from './StatusManager.js'
+import { getSubstatusMessage } from './utils.js'
+
+const TRANSACTION_HASH_OBSERVERS: Record<string, Promise<StatusResponse>> = {}
+
+export async function waitForReceivingTransaction(
+  txHash: string,
+  statusManager: StatusManager,
+  processType: ProcessType,
+  step: LiFiStep
+): Promise<StatusResponse> {
+  const _getStatus = (): Promise<StatusResponse | undefined> =>
+    new Promise(async (resolve, reject) => {
+      let statusResponse: StatusResponse
+      try {
+        statusResponse = await getStatus({
+          fromChain: step.action.fromChainId,
+          toChain: step.action.toChainId,
+          txHash,
+          ...(step.tool !== 'custom' && { bridge: step.tool }),
+        })
+      } catch (e: any) {
+        console.debug('Fetching status from backend failed.', e)
+        return resolve(undefined)
+      }
+
+      switch (statusResponse.status) {
+        case 'DONE':
+          return resolve(statusResponse)
+        case 'PENDING':
+          statusManager?.updateProcess(step, processType, 'PENDING', {
+            substatus: statusResponse.substatus,
+            substatusMessage:
+              statusResponse.substatusMessage ||
+              getSubstatusMessage(
+                statusResponse.status,
+                statusResponse.substatus
+              ),
+            txLink: (statusResponse as FullStatusData).bridgeExplorerLink,
+          })
+          return resolve(undefined)
+        case 'NOT_FOUND':
+          return resolve(undefined)
+        case 'INVALID':
+        case 'FAILED':
+        default:
+          return reject()
+      }
+    })
+
+  let status
+
+  if (txHash in TRANSACTION_HASH_OBSERVERS) {
+    status = await TRANSACTION_HASH_OBSERVERS[txHash]
+  } else {
+    TRANSACTION_HASH_OBSERVERS[txHash] = repeatUntilDone(_getStatus, 5_000)
+    status = await TRANSACTION_HASH_OBSERVERS[txHash]
+  }
+
+  if (!('receiving' in status)) {
+    throw new ServerError("Status doesn't contain receiving information.")
+  }
+
+  return status
+}

package/src/createConfig.ts

@@ -0,0 +1,35 @@
+/* eslint-disable @typescript-eslint/no-empty-function */
+import { ChainType } from '@lifi/types'
+import { config } from './config.js'
+import { checkPackageUpdates } from './helpers.js'
+import { getChains } from './services/api.js'
+import type { SDKConfig } from './types/index.js'
+import { name, version } from './version.js'
+
+function createBaseConfig(options: SDKConfig) {
+  if (!options.integrator) {
+    throw new Error(
+      'Integrator not found. Please see documentation https://docs.li.fi/integrate-li.fi-js-sdk/set-up-the-sdk'
+    )
+  }
+  const _config = config.set(options)
+  if (!options.disableVersionCheck && process.env.NODE_ENV === 'development') {
+    checkPackageUpdates(name, version)
+  }
+  return _config
+}
+
+export async function createChainsConfig() {
+  config.loading = getChains({ chainTypes: [ChainType.EVM, ChainType.SVM] })
+    .then((chains) => config.setChains(chains))
+    .catch()
+  await config.loading
+}
+
+export function createConfig(options: SDKConfig) {
+  const _config = createBaseConfig(options)
+  if (_config.preloadChains) {
+    createChainsConfig()
+  }
+  return _config
+}

package/src/helpers.ts

@@ -0,0 +1,69 @@
+import type { LiFiStep, Route } from '@lifi/types'
+import { request } from './request.js'
+import type { TenderlyResponse } from './types/index.js'
+import { ValidationError } from './utils/errors.js'
+import { name, version } from './version.js'
+
+export const checkPackageUpdates = async (
+  packageName?: string,
+  packageVersion?: string
+) => {
+  try {
+    const pkgName = packageName ?? name
+    const response = await request<{ version: string }>(
+      `https://registry.npmjs.org/${pkgName}/latest`,
+      { skipTrackingHeaders: true }
+    )
+    const latestVersion = response.version
+    const currentVersion = packageVersion ?? version
+    if (latestVersion > currentVersion) {
+      console.warn(
+        // eslint-disable-next-line max-len
+        `${pkgName}: new package version is available. Please update as soon as possible to enjoy the newest features. Current version: ${currentVersion}. Latest version: ${latestVersion}.`
+      )
+    }
+  } catch (error) {
+    // Cannot verify version, might be network error etc. We don't bother showing anything in that case
+  }
+}
+
+/**
+ * Converts a quote to Route
+ * @param step - Step returned from the quote endpoint.
+ * @returns - The route to be executed.
+ * @throws {ValidationError} Throws a ValidationError if the step has missing values.
+ */
+export const convertQuoteToRoute = (step: LiFiStep): Route => {
+  if (!step.estimate.fromAmountUSD) {
+    throw new ValidationError("Missing 'fromAmountUSD' in step estimate.")
+  }
+
+  if (!step.estimate.toAmountUSD) {
+    throw new ValidationError("Missing 'toAmountUSD' in step estimate.")
+  }
+
+  const route: Route = {
+    fromToken: step.action.fromToken,
+    toToken: step.action.toToken,
+    fromAmount: step.action.fromAmount,
+    toAmount: step.estimate.toAmount,
+    id: step.id,
+    fromChainId: step.action.fromToken.chainId,
+    toChainId: step.action.toToken.chainId,
+    fromAmountUSD: step.estimate.fromAmountUSD,
+    toAmountUSD: step.estimate.toAmountUSD,
+    steps: [step],
+    toAmountMin: step.estimate.toAmountMin,
+    insurance: { state: 'NOT_INSURABLE', feeAmountUsd: '0' },
+  }
+
+  return route
+}
+
+export const fetchTxErrorDetails = async (txHash: string, chainId: number) => {
+  const response = await request<TenderlyResponse>(
+    `https://api.tenderly.co/api/v1/public-contract/${chainId}/tx/${txHash}`
+  )
+
+  return response
+}

package/src/index.ts

@@ -0,0 +1,24 @@
+export * from '@lifi/types'
+export { config } from './config.js'
+export { EVM } from './core/EVM/EVM.js'
+export { getTokenAllowance } from './core/EVM/getAllowance.js'
+export { setTokenAllowance } from './core/EVM/setAllowance.js'
+export type {
+  MultisigConfig,
+  MultisigTransaction,
+  MultisigTxDetails,
+} from './core/EVM/types.js'
+export {
+  KeypairWalletAdapter,
+  KeypairWalletName,
+} from './core/Solana/KeypairWalletAdapter.js'
+export { Solana } from './core/Solana/Solana.js'
+export * from './core/index.js'
+export { createConfig } from './createConfig.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 './utils/errors.js'
+export { LiFiError, type ErrorCode } from './utils/errors.js'

package/src/request.ts

@@ -0,0 +1,79 @@
+import { config } from './config.js'
+import { HTTPError } from './utils/errors.js'
+import { wait } from './utils/utils.js'
+import { version } from './version.js'
+
+export const requestSettings = {
+  retries: 1,
+}
+
+interface ExtendedRequestInit extends RequestInit {
+  retries?: number
+  skipTrackingHeaders?: boolean
+}
+
+export const request = async <T = Response>(
+  url: RequestInfo | URL,
+  options: ExtendedRequestInit = {
+    retries: requestSettings.retries,
+  }
+): Promise<T> => {
+  const { userId, integrator, widgetVersion, apiKey } = config.get()
+  if (!integrator) {
+    throw new Error(
+      'Integrator not found. Please see documentation https://docs.li.fi/integrate-li.fi-js-sdk/set-up-the-sdk'
+    )
+  }
+  options.retries = options.retries ?? requestSettings.retries
+  try {
+    if (!options.skipTrackingHeaders) {
+      if (apiKey) {
+        options.headers = {
+          ...options.headers,
+          'x-lifi-api-key': apiKey,
+        }
+      }
+
+      if (userId) {
+        options.headers = {
+          ...options.headers,
+          'x-lifi-userid': userId,
+        }
+      }
+
+      if (widgetVersion) {
+        options.headers = {
+          ...options.headers,
+          'x-lifi-widget': widgetVersion,
+        }
+      }
+
+      if (version) {
+        options.headers = {
+          ...options.headers,
+          'x-lifi-sdk': version,
+        }
+      }
+
+      // integrator is mandatory during SDK initialization
+      options.headers = {
+        ...options.headers,
+        'x-lifi-integrator': integrator,
+      }
+    }
+
+    const response: Response = await fetch(url, options)
+    if (!response.ok) {
+      throw new HTTPError(response)
+    }
+
+    const data: T = await response.json()
+    return data
+  } catch (error) {
+    if (options.retries > 0 && (error as HTTPError)?.status === 500) {
+      await wait(500)
+      return request<T>(url, { ...options, retries: options.retries - 1 })
+    }
+    throw error
+  }
+}