@lifi/sdk 3.13.5 → 4.0.0-alpha.1

package/src/core/types.ts

@@ -1,188 +0,0 @@
-import type {
-  ChainId,
-  ChainType,
-  CoinKey,
-  FeeCost,
-  GasCost,
-  LiFiStep,
-  Route,
-  Step,
-  Substatus,
-  Token,
-  TokenAmount,
-} from '@lifi/types'
-import type { Client } from 'viem'
-
-export interface SDKProvider {
-  readonly type: ChainType
-  isAddress(address: string): boolean
-  resolveAddress(
-    name: string,
-    chainId?: ChainId,
-    token?: CoinKey
-  ): 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<Client | 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
-  disableMessageSigning?: boolean
-  /**
-   * @deprecated
-   */
-  infiniteApproval?: boolean
-}
-
-export type ExecutionStatus = 'ACTION_REQUIRED' | 'PENDING' | 'FAILED' | 'DONE'
-
-export type ProcessStatus =
-  | 'STARTED'
-  | 'ACTION_REQUIRED'
-  | 'MESSAGE_REQUIRED'
-  | 'RESET_REQUIRED'
-  | 'PENDING'
-  | 'FAILED'
-  | 'DONE'
-  | 'CANCELLED'
-
-export type ProcessType =
-  | 'TOKEN_ALLOWANCE'
-  | 'PERMIT'
-  | 'SWAP'
-  | 'CROSS_CHAIN'
-  | 'RECEIVING_CHAIN'
-
-export type Process = {
-  type: ProcessType
-  status: ProcessStatus
-  substatus?: Substatus
-  chainId?: number
-  txHash?: string
-  taskId?: string
-  txLink?: string
-  txType?: TransactionMethodType
-  actionRequiredAt?: number
-  doneAt?: number
-  failedAt?: number
-  pendingAt?: number
-  startedAt: number
-  message?: string
-  error?: {
-    code: string | number
-    message: string
-    htmlMessage?: string
-  }
-
-  // additional information
-  [key: string]: any
-}
-
-export interface Execution {
-  startedAt: number
-  doneAt?: number
-  status: ExecutionStatus
-  process: Array<Process>
-  fromAmount?: string
-  toAmount?: string
-  toToken?: Token
-  feeCosts?: FeeCost[]
-  gasCosts?: GasCost[]
-  internalTxLink?: string
-  externalTxLink?: string
-}
-
-export type TransactionMethodType = 'standard' | 'relayed' | 'batched'

package/src/createConfig.ts

@@ -1,36 +0,0 @@
-import { ChainType } from '@lifi/types'
-import { config } from './config.js'
-import { getChains } from './services/api.js'
-import type { SDKConfig } from './types/internal.js'
-import { checkPackageUpdates } from './utils/checkPackageUpdates.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
-}
-
-async function createChainsConfig() {
-  config.loading = getChains({
-    chainTypes: [ChainType.EVM, ChainType.SVM, ChainType.UTXO, ChainType.MVM],
-  })
-    .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/request.ts

@@ -1,93 +0,0 @@
-import { config } from './config.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 = {
-  retries: 1,
-}
-
-const stripExtendRequestInitProperties = ({
-  retries,
-  ...rest
-}: ExtendedRequestInit): RequestInit => ({
-  ...rest,
-})
-
-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 SDKError(
-      new ValidationError(
-        'You need to provide the Integrator property. Please see documentation https://docs.li.fi/integrate-li.fi-js-sdk/set-up-the-sdk'
-      )
-    )
-  }
-
-  options.retries = options.retries ?? requestSettings.retries
-
-  try {
-    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,
-      stripExtendRequestInitProperties(options)
-    )
-
-    if (!response.ok) {
-      throw new HTTPError(response, url, options)
-    }
-
-    return await response.json()
-  } catch (error) {
-    if (options.retries > 0 && (error as HTTPError).status === 500) {
-      await sleep(500)
-      return request<T>(url, { ...options, retries: options.retries - 1 })
-    }
-
-    await (error as HTTPError).buildAdditionalDetails?.()
-
-    throw new SDKError(error as HTTPError)
-  }
-}