@lifi/sdk 3.0.2-beta.0 → 3.1.0

package/src/services/api.ts

@@ -27,8 +27,8 @@ import type {
 import { config } from '../config.js'
 import { request } from '../request.js'
 import { isRoutesRequest, isStep } from '../typeguards.js'
-import { ValidationError } from '../utils/errors.js'
-import { parseBackendError } from '../utils/parseBackendError.js'
+import { ValidationError } from '../errors/errors.js'
+import { SDKError } from '../errors/SDKError.js'
 /**
  * Fetch information about a Token
  * @param chain - Id or key of the chain that contains the token
@@ -43,25 +43,24 @@ export const getToken = async (
   options?: RequestOptions
 ): Promise<Token> => {
   if (!chain) {
-    throw new ValidationError('Required parameter "chain" is missing.')
+    throw new SDKError(
+      new ValidationError('Required parameter "chain" is missing.')
+    )
   }
   if (!token) {
-    throw new ValidationError('Required parameter "token" is missing.')
-  }
-  try {
-    const response = await request<Token>(
-      `${config.get().apiUrl}/token?${new URLSearchParams({
-        chain,
-        token,
-      } as Record<string, string>)}`,
-      {
-        signal: options?.signal,
-      }
+    throw new SDKError(
+      new ValidationError('Required parameter "token" is missing.')
     )
-    return response
-  } catch (e) {
-    throw await parseBackendError(e)
   }
+  return await request<Token>(
+    `${config.get().apiUrl}/token?${new URLSearchParams({
+      chain,
+      token,
+    } as Record<string, string>)}`,
+    {
+      signal: options?.signal,
+    }
+  )
 }
 
 /**
@@ -85,8 +84,10 @@ export const getQuote = async (
   ]
   requiredParameters.forEach((requiredParameter) => {
     if (!params[requiredParameter]) {
-      throw new ValidationError(
-        `Required parameter "${requiredParameter}" is missing.`
+      throw new SDKError(
+        new ValidationError(
+          `Required parameter "${requiredParameter}" is missing.`
+        )
       )
     }
   })
@@ -110,19 +111,14 @@ export const getQuote = async (
       delete params[key as keyof QuoteRequest]
   )
 
-  try {
-    const response = await request<LiFiStep>(
-      `${_config.apiUrl}/quote?${new URLSearchParams(
-        params as unknown as Record<string, string>
-      )}`,
-      {
-        signal: options?.signal,
-      }
-    )
-    return response
-  } catch (e) {
-    throw await parseBackendError(e)
-  }
+  return await request<LiFiStep>(
+    `${_config.apiUrl}/quote?${new URLSearchParams(
+      params as unknown as Record<string, string>
+    )}`,
+    {
+      signal: options?.signal,
+    }
+  )
 }
 
 /**
@@ -148,8 +144,10 @@ export const getContractCallsQuote = async (
   ]
   requiredParameters.forEach((requiredParameter) => {
     if (!params[requiredParameter]) {
-      throw new ValidationError(
-        `Required parameter "${requiredParameter}" is missing.`
+      throw new SDKError(
+        new ValidationError(
+          `Required parameter "${requiredParameter}" is missing.`
+        )
       )
     }
   })
@@ -167,22 +165,14 @@ export const getContractCallsQuote = async (
   params.denyExchanges ??= _config.routeOptions?.exchanges?.deny
   params.preferExchanges ??= _config.routeOptions?.exchanges?.prefer
   // send request
-  try {
-    const response = await request<LiFiStep>(
-      `${_config.apiUrl}/quote/contractCalls`,
-      {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify(params),
-        signal: options?.signal,
-      }
-    )
-    return response
-  } catch (e) {
-    throw await parseBackendError(e)
-  }
+  return await request<LiFiStep>(`${_config.apiUrl}/quote/contractCalls`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(params),
+    signal: options?.signal,
+  })
 }
 
 /**
@@ -197,22 +187,19 @@ export const getStatus = async (
   options?: RequestOptions
 ): Promise<StatusResponse> => {
   if (!params.txHash) {
-    throw new ValidationError('Required parameter "txHash" is missing.')
+    throw new SDKError(
+      new ValidationError('Required parameter "txHash" is missing.')
+    )
   }
   const queryParams = new URLSearchParams(
     params as unknown as Record<string, string>
   )
-  try {
-    const response = await request<StatusResponse>(
-      `${config.get().apiUrl}/status?${queryParams}`,
-      {
-        signal: options?.signal,
-      }
-    )
-    return response
-  } catch (e) {
-    throw await parseBackendError(e)
-  }
+  return await request<StatusResponse>(
+    `${config.get().apiUrl}/status?${queryParams}`,
+    {
+      signal: options?.signal,
+    }
+  )
 }
 
 /**
@@ -233,19 +220,16 @@ export const getChains = async (
         delete params[key as keyof ChainsRequest]
     )
   }
-  try {
-    const response = await request<ChainsResponse>(
-      `${config.get().apiUrl}/chains?${new URLSearchParams(
-        params as Record<string, string>
-      )}`,
-      {
-        signal: options?.signal,
-      }
-    )
-    return response.chains
-  } catch (e) {
-    throw await parseBackendError(e)
-  }
+
+  const response = await request<ChainsResponse>(
+    `${config.get().apiUrl}/chains?${new URLSearchParams(
+      params as Record<string, string>
+    )}`,
+    {
+      signal: options?.signal,
+    }
+  )
+  return response.chains
 }
 
 /**
@@ -260,7 +244,7 @@ export const getRoutes = async (
   options?: RequestOptions
 ): Promise<RoutesResponse> => {
   if (!isRoutesRequest(params)) {
-    throw new ValidationError('Invalid routes request.')
+    throw new SDKError(new ValidationError('Invalid routes request.'))
   }
   const _config = config.get()
   // apply defaults
@@ -269,23 +253,15 @@ export const getRoutes = async (
     ..._config.routeOptions,
     ...params.options,
   }
-  // send request
-  try {
-    const response = await request<RoutesResponse>(
-      `${_config.apiUrl}/advanced/routes`,
-      {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify(params),
-        signal: options?.signal,
-      }
-    )
-    return response
-  } catch (e) {
-    throw await parseBackendError(e)
-  }
+
+  return await request<RoutesResponse>(`${_config.apiUrl}/advanced/routes`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(params),
+    signal: options?.signal,
+  })
 }
 
 /**
@@ -304,22 +280,18 @@ export const getStepTransaction = async (
     // eslint-disable-next-line no-console
     console.warn('SDK Validation: Invalid Step', step)
   }
-  try {
-    const response = await request<LiFiStep>(
-      `${config.get().apiUrl}/advanced/stepTransaction`,
-      {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify(step),
-        signal: options?.signal,
-      }
-    )
-    return response
-  } catch (e) {
-    throw await parseBackendError(e)
-  }
+
+  return await request<LiFiStep>(
+    `${config.get().apiUrl}/advanced/stepTransaction`,
+    {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(step),
+      signal: options?.signal,
+    }
+  )
 }
 
 /**
@@ -339,19 +311,14 @@ export const getTools = async (
         delete params[key as keyof ToolsRequest]
     )
   }
-  try {
-    const response = await request<ToolsResponse>(
-      `${config.get().apiUrl}/tools?${new URLSearchParams(
-        params as Record<string, string>
-      )}`,
-      {
-        signal: options?.signal,
-      }
-    )
-    return response
-  } catch (e) {
-    throw await parseBackendError(e)
-  }
+  return await request<ToolsResponse>(
+    `${config.get().apiUrl}/tools?${new URLSearchParams(
+      params as Record<string, string>
+    )}`,
+    {
+      signal: options?.signal,
+    }
+  )
 }
 
 /**
@@ -372,19 +339,14 @@ export const getTokens = async (
     )
   }
 
-  try {
-    const response = await request<TokensResponse>(
-      `${config.get().apiUrl}/tokens?${new URLSearchParams(
-        params as Record<string, string>
-      )}`,
-      {
-        signal: options?.signal,
-      }
-    )
-    return response
-  } catch (e) {
-    throw await parseBackendError(e)
-  }
+  return await request<TokensResponse>(
+    `${config.get().apiUrl}/tokens?${new URLSearchParams(
+      params as Record<string, string>
+    )}`,
+    {
+      signal: options?.signal,
+    }
+  )
 }
 
 /**
@@ -399,7 +361,9 @@ export const getGasRecommendation = async (
   options?: RequestOptions
 ): Promise<GasRecommendationResponse> => {
   if (!params.chainId) {
-    throw new ValidationError('Required parameter "chainId" is missing.')
+    throw new SDKError(
+      new ValidationError('Required parameter "chainId" is missing.')
+    )
   }
 
   const url = new URL(`${config.get().apiUrl}/gas/suggestion/${params.chainId}`)
@@ -410,14 +374,9 @@ export const getGasRecommendation = async (
     url.searchParams.append('fromToken', params.fromToken)
   }
 
-  try {
-    const response = await request<GasRecommendationResponse>(url.toString(), {
-      signal: options?.signal,
-    })
-    return response
-  } catch (e) {
-    throw await parseBackendError(e)
-  }
+  return await request<GasRecommendationResponse>(url.toString(), {
+    signal: options?.signal,
+  })
 }
 
 /**
@@ -465,12 +424,8 @@ export const getConnections = async (
       })
     }
   })
-  try {
-    const response = await request<ConnectionsResponse>(url, options)
-    return response
-  } catch (e) {
-    throw await parseBackendError(e)
-  }
+
+  return await request<ConnectionsResponse>(url, options)
 }
 
 export const getTransactionHistory = async (
@@ -478,7 +433,9 @@ export const getTransactionHistory = async (
   options?: RequestOptions
 ): Promise<TransactionAnalyticsResponse> => {
   if (!wallet) {
-    throw new ValidationError('Required parameter "wallet" is missing.')
+    throw new SDKError(
+      new ValidationError('Required parameter "wallet" is missing.')
+    )
   }
 
   const _config = config.get()
@@ -500,10 +457,5 @@ export const getTransactionHistory = async (
     url.searchParams.append('toTimestamp', toTimestamp.toString())
   }
 
-  try {
-    const response = await request<TransactionAnalyticsResponse>(url, options)
-    return response
-  } catch (e) {
-    throw await parseBackendError(e)
-  }
+  return await request<TransactionAnalyticsResponse>(url, options)
 }

package/src/services/balance.ts

@@ -1,14 +1,14 @@
 import type { Token, TokenAmount } from '@lifi/types'
 import { config } from '../config.js'
 import { isToken } from '../typeguards.js'
-import { ValidationError } from '../utils/errors.js'
+import { ValidationError } from '../errors/errors.js'
 
 /**
  * Returns the balances of a specific token a wallet holds across all aggregated chains.
  * @param walletAddress - A wallet address.
  * @param token - A Token object.
  * @returns An object containing the token and the amounts on different chains.
- * @throws {ValidationError} Throws a ValidationError if parameters are invalid.
+ * @throws {BaseError} Throws a ValidationError if parameters are invalid.
  */
 export const getTokenBalance = async (
   walletAddress: string,
@@ -23,7 +23,7 @@ export const getTokenBalance = async (
  * @param walletAddress - A wallet address.
  * @param tokens - A list of Token objects.
  * @returns A list of objects containing the tokens and the amounts on different chains.
- * @throws {ValidationError} Throws a ValidationError if parameters are invalid.
+ * @throws {BaseError} Throws a ValidationError if parameters are invalid.
  */
 export const getTokenBalances = async (
   walletAddress: string,
@@ -53,7 +53,7 @@ export const getTokenBalances = async (
  * @param walletAddress - A walletaddress.
  * @param tokensByChain - A list of Token objects organized by chain ids.
  * @returns A list of objects containing the tokens and the amounts on different chains organized by the chosen chains.
- * @throws {ValidationError} Throws a ValidationError if parameters are invalid.
+ * @throws {BaseError} Throws a ValidationError if parameters are invalid.
  */
 export const getTokenBalancesByChain = async (
   walletAddress: string,

package/src/types/request.ts

@@ -0,0 +1,3 @@
+export interface ExtendedRequestInit extends RequestInit {
+  retries?: number
+}

package/src/utils/errors.ts

@@ -1,233 +0,0 @@
-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,
-  TransactionExpired = 1018,
-}
-
-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/index.ts

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

package/src/version.ts

@@ -1,2 +1,2 @@
 export const name = '@lifi/sdk'
-export const version = '3.0.2-beta.0'
+export const version = '3.1.0'