@lifi/sdk 3.0.0-alpha.4 → 3.0.0-alpha.41

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({
+          bridge: step.tool,
+          fromChain: step.action.fromChainId,
+          toChain: step.action.toChainId,
+          txHash,
+        })
+      } 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 (!status.receiving) {
+    throw new ServerError("Status doesn't contain receiving information.")
+  }
+
+  return status
+}

package/src/createConfig.ts

@@ -0,0 +1,33 @@
+/* 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 { SDKOptions } from './types/index.js'
+import { name, version } from './version.js'
+
+function createBaseConfig(options: SDKOptions) {
+  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)
+  checkPackageUpdates(name, version, options.disableVersionCheck)
+  return _config
+}
+
+export async function createChainsConfig() {
+  config.loading = getChains({ chainTypes: Object.values(ChainType) })
+    .then((chains) => config.setChains(chains))
+    .catch()
+  await config.loading
+}
+
+export function createConfig(options: SDKOptions) {
+  const _config = createBaseConfig(options)
+  if (_config.preloadChains) {
+    createChainsConfig()
+  }
+  return _config
+}

package/src/helpers.ts

@@ -0,0 +1,83 @@
+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'
+
+/**
+ * Returns a random number between min (inclusive) and max (inclusive)
+ * @param min - minimum number.
+ * @param max - maximum number.
+ * @returns - random number.
+ */
+export const getRandomNumber = (min: number, max: number): number => {
+  return Math.floor(Math.random() * (max - min + 1) + min)
+}
+
+export const checkPackageUpdates = async (
+  packageName?: string,
+  packageVersion?: string,
+  disableCheck?: boolean
+) => {
+  if (disableCheck || process.env.NODE_ENV !== 'development') {
+    return
+  }
+  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,12 @@
+export * from '@lifi/types'
+export { config } from './config.js'
+export { EVM } from './core/EVM/EVM.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 './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
+  }
+}