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

package/src/typeguards.ts

@@ -0,0 +1,89 @@
+import type {
+  Action,
+  Estimate,
+  LiFiStep,
+  RouteOptions,
+  RoutesRequest,
+  StaticToken,
+} from '@lifi/types'
+
+export const isRoutesRequest = (
+  routesRequest: RoutesRequest
+): routesRequest is RoutesRequest => {
+  const {
+    fromChainId,
+    fromAmount,
+    fromTokenAddress,
+    toChainId,
+    toTokenAddress,
+    options,
+  } = routesRequest
+
+  return (
+    typeof fromChainId === 'number' &&
+    typeof fromAmount === 'string' &&
+    fromAmount !== '' &&
+    typeof fromTokenAddress === 'string' &&
+    fromTokenAddress !== '' &&
+    typeof toChainId === 'number' &&
+    typeof toTokenAddress === 'string' &&
+    toTokenAddress !== '' &&
+    (!options || isRoutesOptions(options))
+  )
+}
+
+const isRoutesOptions = (
+  routeOptions: RouteOptions
+): routeOptions is RouteOptions =>
+  !routeOptions?.slippage || typeof routeOptions.slippage === 'number'
+
+export const isStep = (step: LiFiStep): step is LiFiStep => {
+  const { id, type, tool, action, estimate } = step
+
+  return (
+    typeof id === 'string' &&
+    ['swap', 'cross', 'lifi'].includes(type) &&
+    typeof tool === 'string' &&
+    isAction(action) &&
+    isEstimate(estimate)
+  )
+}
+
+const isAction = (action: Action): action is Action => {
+  const { fromChainId, fromAmount, fromToken, toChainId, toToken, slippage } =
+    action
+
+  return (
+    typeof fromChainId === 'number' &&
+    typeof fromAmount === 'string' &&
+    fromAmount !== '' &&
+    isToken(fromToken) &&
+    typeof toChainId === 'number' &&
+    isToken(toToken) &&
+    typeof slippage === 'number'
+  )
+}
+
+const isEstimate = (estimate: Estimate): estimate is Estimate => {
+  const { fromAmount, toAmount, toAmountMin, approvalAddress } = estimate
+
+  return (
+    typeof fromAmount === 'string' &&
+    fromAmount !== '' &&
+    typeof toAmount === 'string' &&
+    toAmount !== '' &&
+    typeof toAmountMin === 'string' &&
+    toAmountMin !== '' &&
+    typeof approvalAddress === 'string'
+  )
+}
+
+export const isToken = (token: StaticToken): token is StaticToken => {
+  const { address, decimals, chainId } = token
+
+  return (
+    typeof address === 'string' &&
+    typeof decimals === 'number' &&
+    typeof chainId === 'number'
+  )
+}

package/src/types/index.ts

@@ -0,0 +1 @@
+export * from './internal.js'

package/src/types/internal.ts

@@ -0,0 +1,62 @@
+import type { ChainId, ExtendedChain, RouteOptions } from '@lifi/types'
+import type { SDKProvider } from '../core/types.js'
+
+export interface SDKBaseConfig {
+  apiKey?: string
+  apiUrl: string
+  integrator: string
+  userId?: string
+  providers: SDKProvider[]
+  routeOptions?: RouteOptions
+  rpcUrls: RPCUrls
+  chains: ExtendedChain[]
+  disableVersionCheck?: boolean
+  widgetVersion?: string
+  preloadChains: boolean
+}
+
+export interface SDKConfig extends Partial<Omit<SDKBaseConfig, 'integrator'>> {
+  integrator: string
+}
+
+export type RPCUrls = Partial<Record<ChainId, string[]>>
+
+export interface TenderlyResponse {
+  hash: string
+  block_hash: string
+  block_number: number
+  from: string
+  gas: number
+  gas_price: number
+  gas_fee_cap: number
+  gas_tip_cap: number
+  cumulative_gas_used: number
+  gas_used: number
+  effective_gas_price: number
+  input: string
+  nonce: number
+  to: string
+  index: number
+  value: string
+  access_list: unknown
+  status: boolean
+  addresses: string[]
+  contract_ids: string[]
+  network_id: string
+  timestamp: string
+  function_selector: string
+  l1_block_number: number
+  l1_timestamp: number
+  deposit_tx: boolean
+  system_tx: boolean
+  mint: number
+  sig: {
+    v: string
+    r: string
+    s: string
+  }
+  error_message: string
+  method: string
+  decoded_input: unknown
+  call_trace: unknown
+}

package/src/utils/base64ToUint8Array.ts

@@ -0,0 +1,9 @@
+export function base64ToUint8Array(base64String: string) {
+  const binaryString = atob(base64String)
+  const len = binaryString.length
+  const bytes = new Uint8Array(len)
+  for (let i = 0; i < len; i++) {
+    bytes[i] = binaryString.charCodeAt(i)
+  }
+  return bytes
+}

package/src/utils/errors.ts

@@ -0,0 +1,232 @@
+enum ErrorType {
+  RPCError = 'RPCError',
+  ProviderError = 'ProviderError',
+  ServerError = 'ServerError',
+  TransactionError = 'TransactionError',
+  ValidationError = 'ValidationError',
+  NotFoundError = 'NotFoundError',
+  UnknownError = 'UnknownError',
+  SlippageError = 'SlippageError',
+}
+
+export enum LiFiErrorCode {
+  InternalError = 1000,
+  ValidationError = 1001,
+  TransactionUnderpriced = 1002,
+  TransactionFailed = 1003,
+  Timeout = 1004,
+  ProviderUnavailable = 1005,
+  NotFound = 1006,
+  ChainSwitchError = 1007,
+  TransactionUnprepared = 1008,
+  GasLimitError = 1009,
+  TransactionCanceled = 1010,
+  SlippageError = 1011,
+  SignatureRejected = 1012,
+  BalanceError = 1013,
+  AllowanceRequired = 1014,
+  InsufficientFunds = 1015,
+  ExchangeRateUpdateCanceled = 1016,
+  WalletChangedDuringExecution = 1017,
+}
+
+export enum EthersErrorType {
+  ActionRejected = 'ACTION_REJECTED',
+  CallExecption = 'CALL_EXCEPTION',
+  InsufficientFunds = 'INSUFFICIENT_FUNDS',
+}
+
+export enum EthersErrorMessage {
+  ERC20Allowance = 'ERC20: transfer amount exceeds allowance',
+  LowGas = 'intrinsic gas too low',
+  OutOfGas = 'out of gas',
+  Underpriced = 'underpriced',
+  LowReplacementFee = 'replacement fee too low',
+}
+
+export enum ErrorMessage {
+  UnknownError = 'Unknown error occurred.',
+  SlippageError = 'The slippage is larger than the defined threshold. Please request a new route to get a fresh quote.',
+  GasLimitLow = 'Gas limit is too low.',
+  TransactionUnderpriced = 'Transaction is underpriced.',
+  Default = 'Something went wrong.',
+}
+
+export enum MetaMaskRPCErrorCode {
+  invalidInput = -32000,
+  resourceNotFound = -32001,
+  resourceUnavailable = -32002,
+  transactionRejected = -32003,
+  methodNotSupported = -32004,
+  limitExceeded = -32005,
+  parse = -32700,
+  invalidRequest = -32600,
+  methodNotFound = -32601,
+  invalidParams = -32602,
+  internal = -32603,
+}
+
+export enum MetaMaskProviderErrorCode {
+  userRejectedRequest = 4001,
+  unauthorized = 4100,
+  unsupportedMethod = 4200,
+  disconnected = 4900,
+  chainDisconnected = 4901,
+}
+
+export type ErrorCode =
+  | LiFiErrorCode
+  | MetaMaskRPCErrorCode
+  | MetaMaskProviderErrorCode
+
+export class LiFiError extends Error {
+  code: ErrorCode
+  htmlMessage?: string
+
+  constructor(
+    type: ErrorType,
+    code: number,
+    message: string,
+    htmlMessage?: string,
+    stack?: string
+  ) {
+    super(message)
+
+    // Set the prototype explicitly: https://github.com/Microsoft/TypeScript/wiki/Breaking-Changes#extending-built-ins-like-error-array-and-map-may-no-longer-work
+    Object.setPrototypeOf(this, LiFiError.prototype)
+
+    this.code = code
+
+    // the name property is used by toString(). It is a string and we can't use our custom ErrorTypes, that's why we have to cast
+    this.name = type.toString()
+
+    this.htmlMessage = htmlMessage
+
+    // passing a stack allows us to preserve the stack from errors that we caught and just want to transform in one of our custom errors
+    if (stack) {
+      this.stack = stack
+    }
+  }
+}
+
+export class RPCError extends LiFiError {
+  constructor(
+    code: ErrorCode,
+    message: string,
+    htmlMessage?: string,
+    stack?: string
+  ) {
+    super(ErrorType.RPCError, code, message, htmlMessage, stack)
+  }
+}
+
+export class ProviderError extends LiFiError {
+  constructor(
+    code: ErrorCode,
+    message: string,
+    htmlMessage?: string,
+    stack?: string
+  ) {
+    super(ErrorType.ProviderError, code, message, htmlMessage, stack)
+  }
+}
+
+export class ServerError extends LiFiError {
+  constructor(message: string, htmlMessage?: string, stack?: string) {
+    super(
+      ErrorType.ServerError,
+      LiFiErrorCode.InternalError,
+      message,
+      htmlMessage,
+      stack
+    )
+  }
+}
+
+export class ValidationError extends LiFiError {
+  constructor(message: string, htmlMessage?: string, stack?: string) {
+    super(
+      ErrorType.ValidationError,
+      LiFiErrorCode.ValidationError,
+      message,
+      htmlMessage,
+      stack
+    )
+  }
+}
+
+export class TransactionError extends LiFiError {
+  constructor(
+    code: ErrorCode,
+    message: string,
+    htmlMessage?: string,
+    stack?: string
+  ) {
+    super(ErrorType.TransactionError, code, message, htmlMessage, stack)
+  }
+}
+
+export class SlippageError extends LiFiError {
+  constructor(message: string, htmlMessage?: string, stack?: string) {
+    super(
+      ErrorType.SlippageError,
+      LiFiErrorCode.SlippageError,
+      message,
+      htmlMessage,
+      stack
+    )
+  }
+}
+
+export class BalanceError extends LiFiError {
+  constructor(message: string, htmlMessage?: string, stack?: string) {
+    super(
+      ErrorType.ValidationError,
+      LiFiErrorCode.BalanceError,
+      message,
+      htmlMessage,
+      stack
+    )
+  }
+}
+
+export class NotFoundError extends LiFiError {
+  constructor(message: string, htmlMessage?: string, stack?: string) {
+    super(
+      ErrorType.NotFoundError,
+      LiFiErrorCode.NotFound,
+      message,
+      htmlMessage,
+      stack
+    )
+  }
+}
+
+export class UnknownError extends LiFiError {
+  constructor(
+    code: ErrorCode,
+    message: string,
+    htmlMessage?: string,
+    stack?: string
+  ) {
+    super(ErrorType.UnknownError, code, message, htmlMessage, stack)
+  }
+}
+
+export class HTTPError extends Error {
+  public response: Response
+  public status: number
+
+  constructor(response: Response) {
+    const code = response.status || response.status === 0 ? response.status : ''
+    const title = response.statusText || ''
+    const status = `${code} ${title}`.trim()
+    const reason = status ? `status code ${status}` : 'an unknown error'
+
+    super(`Request failed with ${reason}`)
+
+    this.name = 'HTTPError'
+    this.response = response
+    this.status = response.status
+  }
+}

package/src/utils/getTransactionMessage.ts

@@ -0,0 +1,46 @@
+import type { LiFiStep, Process } from '@lifi/types'
+import { formatUnits } from 'viem'
+import { config } from '../config.js'
+
+export const getTransactionNotSentMessage = async (
+  step?: LiFiStep,
+  process?: Process
+): Promise<string> => {
+  let transactionNotSend =
+    'Transaction was not sent, your funds are still in your wallet'
+
+  // add information about funds if available
+  if (step) {
+    const chain = await config.getChainById(step.action.fromChainId)
+
+    transactionNotSend += ` (${formatUnits(
+      BigInt(step.action.fromAmount),
+      step.action.fromToken.decimals
+    )} ${step.action.fromToken.symbol} on ${chain.name})`
+  }
+
+  transactionNotSend +=
+    ", please retry.<br/>If it still doesn't work, it is safe to delete this transfer and start a new one."
+
+  // add transaction explorer link if available
+  transactionNotSend +=
+    process && process.txLink
+      ? `<br>You can check the failed transaction&nbsp;<a href="${process.txLink}" target="_blank" rel="nofollow noreferrer">here</a>.`
+      : ''
+
+  return transactionNotSend
+}
+
+export const getTransactionFailedMessage = async (
+  step: LiFiStep,
+  txLink?: string
+): Promise<string> => {
+  const chain = await config.getChainById(step.action.toChainId)
+
+  const baseString = `It appears that your transaction may not have been successful.
+  However, to confirm this, please check your ${chain.name} wallet for ${step.action.toToken.symbol}.`
+  return txLink
+    ? `${baseString}
+    You can also check the&nbsp;<a href="${txLink}" target="_blank" rel="nofollow noreferrer">block explorer</a> for more information.`
+    : baseString
+}

package/src/utils/index.ts

@@ -0,0 +1,5 @@
+export * from './errors.js'
+export * from './getTransactionMessage.js'
+export * from './median.js'
+export * from './parseError.js'
+export * from './utils.js'

package/src/utils/median.ts

@@ -0,0 +1,11 @@
+export const median = (arr: bigint[]): bigint | undefined => {
+  if (!arr.length) {
+    return
+  }
+  const s = [...arr].sort((a, b) => (a > b ? 1 : a < b ? -1 : 0))
+  const mid = Math.floor(s.length / 2)
+  if (s.length % 2 === 0) {
+    return (s[mid - 1] + s[mid]) / 2n
+  }
+  return s[mid]
+}

package/src/utils/parseBackendError.ts

@@ -0,0 +1,50 @@
+import type { LiFiError } from './errors.js'
+import {
+  ErrorMessage,
+  NotFoundError,
+  ServerError,
+  SlippageError,
+  ValidationError,
+} from './errors.js'
+
+export const parseBackendError = async (e: any): Promise<LiFiError> => {
+  let data
+  try {
+    data = await e.response?.json()
+  } catch (error) {
+    // ignore
+  }
+  if (e.response?.status === 400) {
+    return new ValidationError(
+      data?.message || e.response?.statusText,
+      undefined,
+      e.stack
+    )
+  }
+
+  if (e.response?.status === 404) {
+    return new NotFoundError(
+      data?.message || e.response?.statusText,
+      undefined,
+      e.stack
+    )
+  }
+
+  if (e.response?.status === 409) {
+    return new SlippageError(
+      data?.message || e.response?.statusText,
+      ErrorMessage.SlippageError,
+      e.stack
+    )
+  }
+
+  if (e.response?.status === 500) {
+    return new ServerError(
+      data?.message || e.response?.statusText,
+      undefined,
+      e.stack
+    )
+  }
+
+  return new ServerError(ErrorMessage.Default, undefined, e.stack)
+}