@lifi/sdk 3.0.0-alpha.2 → 3.0.0-alpha.21

package/dist/utils/errors.ts

@@ -0,0 +1,231 @@
+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,
+}
+
+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/dist/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/dist/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/dist/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/dist/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)
+}

package/dist/utils/parseError.ts

@@ -0,0 +1,204 @@
+import type { LiFiStep, Process } from '@lifi/types'
+import {
+  errorCodes as MetaMaskErrorCodes,
+  getMessageFromCode,
+} from 'eth-rpc-errors'
+import { fetchTxErrorDetails } from '../helpers.js'
+import {
+  ErrorMessage,
+  EthersErrorMessage,
+  EthersErrorType,
+  LiFiError,
+  LiFiErrorCode,
+  MetaMaskProviderErrorCode,
+  ProviderError,
+  RPCError,
+  TransactionError,
+  UnknownError,
+} from './errors.js'
+import { getTransactionNotSentMessage } from './getTransactionMessage.js'
+
+/**
+ * Available MetaMask error codes:
+ *
+ * export const errorCodes: ErrorCodes = {
+     rpc: {
+      invalidInput: -32000,
+      resourceNotFound: -32001,
+      resourceUnavailable: -32002,
+      transactionRejected: -32003,
+      methodNotSupported: -32004,
+      limitExceeded: -32005,
+      parse: -32700,
+      invalidRequest: -32600,
+      methodNotFound: -32601,
+      invalidParams: -32602,
+      internal: -32603,
+    },
+    provider: {
+      userRejectedRequest: 4001,
+      unauthorized: 4100,
+      unsupportedMethod: 4200,
+      disconnected: 4900,
+      chainDisconnected: 4901,
+    },
+  };
+ *
+ * For more information about error codes supported by metamask check
+ * https://github.com/MetaMask/eth-rpc-errors
+ * https://eips.ethereum.org/EIPS/eip-1474#error-codes
+ * https://eips.ethereum.org/EIPS/eip-1193#provider-errors
+ */
+
+export const parseError = async (
+  e: any,
+  step?: LiFiStep,
+  process?: Process
+): Promise<LiFiError> => {
+  if (e instanceof LiFiError) {
+    return e
+  }
+
+  const errorCode = e.code || e.cause?.code
+
+  switch (errorCode) {
+    case EthersErrorType.CallExecption:
+      const defaultErrorMessage = await getTransactionNotSentMessage(
+        step,
+        process
+      )
+      try {
+        if (!step?.action.fromChainId) {
+          throw new Error('fromChainId is not defined.')
+        }
+
+        const response = await fetchTxErrorDetails(
+          e.transactionHash,
+          step?.action.fromChainId
+        )
+
+        const errorMessage = response?.error_message ?? e.reason
+
+        const isAllowanceError =
+          response?.error_message?.includes(
+            EthersErrorMessage.ERC20Allowance
+          ) || e.reason?.includes(EthersErrorMessage.ERC20Allowance)
+
+        if (isAllowanceError) {
+          return new TransactionError(
+            LiFiErrorCode.AllowanceRequired,
+            e.reason,
+            errorMessage,
+            e.stack
+          )
+        }
+
+        // Error messages other than allowance error will be handled in catch block
+        throw new Error(e)
+      } catch (error) {
+        return new ProviderError(
+          LiFiErrorCode.TransactionFailed,
+          e.reason,
+          defaultErrorMessage,
+          e.stack
+        )
+      }
+    case EthersErrorType.InsufficientFunds:
+      return new TransactionError(
+        LiFiErrorCode.InsufficientFunds,
+        e.message,
+        await getTransactionNotSentMessage(step, process),
+        e.stack
+      )
+    case EthersErrorType.ActionRejected:
+    case MetaMaskProviderErrorCode.userRejectedRequest:
+      return new TransactionError(
+        LiFiErrorCode.SignatureRejected,
+        e.message,
+        await getTransactionNotSentMessage(step, process),
+        e.stack
+      )
+    case LiFiErrorCode.TransactionUnprepared:
+      return new TransactionError(
+        LiFiErrorCode.TransactionUnprepared,
+        e.message,
+        await getTransactionNotSentMessage(step, process),
+        e.stack
+      )
+    case LiFiErrorCode.ValidationError:
+      return new TransactionError(
+        LiFiErrorCode.ValidationError,
+        e.message,
+        e.htmlMessage
+      )
+    case LiFiErrorCode.TransactionCanceled:
+      return new TransactionError(
+        LiFiErrorCode.TransactionCanceled,
+        e.message,
+        e.htmlMessage
+      )
+    case LiFiErrorCode.ExchangeRateUpdateCanceled:
+      return new TransactionError(
+        LiFiErrorCode.ExchangeRateUpdateCanceled,
+        e.message,
+        e.htmlMessage
+      )
+    default: {
+      if (errorCode && typeof errorCode === 'number') {
+        if (Object.values(MetaMaskErrorCodes.rpc).includes(errorCode as any)) {
+          // rpc errors
+          // underpriced errors are sent as internal errors, so we need to parse the message manually
+          if (
+            errorCode === MetaMaskErrorCodes.rpc.internal &&
+            (e.message?.includes(EthersErrorMessage.Underpriced) ||
+              e.message?.includes(EthersErrorMessage.LowReplacementFee))
+          ) {
+            return new RPCError(
+              LiFiErrorCode.TransactionUnderpriced,
+              ErrorMessage.TransactionUnderpriced,
+              await getTransactionNotSentMessage(step, process),
+              e.stack
+            )
+          }
+
+          if (
+            e.message?.includes(EthersErrorMessage.LowGas) ||
+            e.message?.includes(EthersErrorMessage.OutOfGas)
+          ) {
+            return new TransactionError(
+              LiFiErrorCode.GasLimitError,
+              ErrorMessage.GasLimitLow,
+              await getTransactionNotSentMessage(step, process),
+              e.stack
+            )
+          }
+
+          return new RPCError(
+            errorCode,
+            getMessageFromCode(errorCode),
+            await getTransactionNotSentMessage(step, process),
+            e.stack
+          )
+        }
+
+        // provider errors
+        if (
+          Object.values(MetaMaskErrorCodes.provider).includes(errorCode as any)
+        ) {
+          return new ProviderError(
+            errorCode,
+            getMessageFromCode(errorCode),
+            await getTransactionNotSentMessage(step, process),
+            e.stack
+          )
+        }
+      }
+      return new UnknownError(
+        LiFiErrorCode.InternalError,
+        e.message || ErrorMessage.UnknownError,
+        undefined,
+        e.stack
+      )
+    }
+  }
+}

package/dist/utils/utils.ts

@@ -0,0 +1,48 @@
+import { AddressZero, AlternativeAddressZero } from '../constants.js'
+
+export const wait = (ms: number): Promise<undefined> => {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms)
+  })
+}
+
+/**
+ * Repeatedly calls a given asynchronous function until it resolves with a value
+ * @param toRepeat The function that should be repeated
+ * @param timeout The timeout in milliseconds between retries, defaults to 5000
+ * @returns The result of the toRepeat function
+ */
+export const repeatUntilDone = async <T>(
+  toRepeat: () => Promise<T | undefined>,
+  timeout = 5000
+): Promise<T> => {
+  let result: T | undefined
+
+  while (!result) {
+    result = await toRepeat()
+    if (!result) {
+      await wait(timeout)
+    }
+  }
+
+  return result
+}
+
+export const isZeroAddress = (address: string): boolean => {
+  if (address === AddressZero || address === AlternativeAddressZero) {
+    return true
+  }
+  return false
+}
+
+export const isNativeTokenAddress = (address: string): boolean => {
+  if (
+    address === AddressZero ||
+    address === AlternativeAddressZero ||
+    // CELO native token
+    address === '0x471ece3750da237f93b8e339c536989b8978a438'
+  ) {
+    return true
+  }
+  return false
+}

package/dist/version.ts

@@ -0,0 +1,2 @@
+export const name = '@lifi/sdk'
+export const version = '3.0.0-alpha.21'