@lifi/sdk 3.0.2-beta.0 → 3.1.0-beta.0

package/src/helpers.ts

@@ -1,8 +1,7 @@
-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'
+import { ValidationError } from './errors/errors.js'
+import { SDKError } from './errors/SDKError.js'
+import type { Route, LiFiStep } from '@lifi/types'
 
 export const checkPackageUpdates = async (
   packageName?: string,
@@ -10,12 +9,11 @@ export const checkPackageUpdates = async (
 ) => {
   try {
     const pkgName = packageName ?? name
-    const response = await request<{ version: string }>(
-      `https://registry.npmjs.org/${pkgName}/latest`,
-      { skipTrackingHeaders: true }
-    )
-    const latestVersion = response.version
+    const response = await fetch(`https://registry.npmjs.org/${pkgName}/latest`)
+    const reponseBody = await response.json()
+    const latestVersion = reponseBody.version
     const currentVersion = packageVersion ?? version
+
     if (latestVersion > currentVersion) {
       console.warn(
         // eslint-disable-next-line max-len
@@ -30,16 +28,22 @@ export const checkPackageUpdates = async (
 /**
  * Converts a quote to Route
  * @param step - Step returned from the quote endpoint.
+ * @param txHash
+ * @param chainId
  * @returns - The route to be executed.
- * @throws {ValidationError} Throws a ValidationError if the step has missing values.
+ * @throws {BaseError} 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.")
+    throw new SDKError(
+      new ValidationError("Missing 'fromAmountUSD' in step estimate.")
+    )
   }
 
   if (!step.estimate.toAmountUSD) {
-    throw new ValidationError("Missing 'toAmountUSD' in step estimate.")
+    throw new SDKError(
+      new ValidationError("Missing 'toAmountUSD' in step estimate.")
+    )
   }
 
   const route: Route = {
@@ -61,9 +65,12 @@ export const convertQuoteToRoute = (step: LiFiStep): 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}`
-  )
+  try {
+    const response = await fetch(
+      `https://api.tenderly.co/api/v1/public-contract/${chainId}/tx/${txHash}`
+    )
+    const reponseBody = await response.json()
 
-  return response
+    return reponseBody
+  } catch (_) {}
 }

package/src/index.ts

@@ -26,5 +26,5 @@ export * from './services/api.js'
 export * from './services/balance.js'
 export * from './services/getNameServiceAddress.js'
 export * from './types/index.js'
-export * from './utils/errors.js'
-export { LiFiError, type ErrorCode } from './utils/errors.js'
+export * from './errors/index.js'
+export { type ErrorCode } from './errors/index.js'

package/src/request.ts

@@ -1,16 +1,21 @@
 import { config } from './config.js'
-import { HTTPError } from './utils/errors.js'
+import { HTTPError } from './errors/httpError.js'
 import { wait } from './utils/utils.js'
+import { ValidationError } from './errors/errors.js'
+import { SDKError } from './errors/SDKError.js'
+import type { ExtendedRequestInit } from './types/request.js'
 import { version } from './version.js'
 
 export const requestSettings = {
   retries: 1,
 }
 
-interface ExtendedRequestInit extends RequestInit {
-  retries?: number
-  skipTrackingHeaders?: boolean
-}
+const stripExtendRequestInitProperties = ({
+  retries,
+  ...rest
+}: ExtendedRequestInit): RequestInit => ({
+  ...rest,
+})
 
 export const request = async <T = Response>(
   url: RequestInfo | URL,
@@ -19,61 +24,70 @@ export const request = async <T = Response>(
   }
 ): 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'
+    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 (!options.skipTrackingHeaders) {
-      if (apiKey) {
-        options.headers = {
-          ...options.headers,
-          'x-lifi-api-key': apiKey,
-        }
-      }
 
-      if (userId) {
-        options.headers = {
-          ...options.headers,
-          'x-lifi-userid': userId,
-        }
+  try {
+    if (apiKey) {
+      options.headers = {
+        ...options.headers,
+        'x-lifi-api-key': apiKey,
       }
+    }
 
-      if (widgetVersion) {
-        options.headers = {
-          ...options.headers,
-          'x-lifi-widget': widgetVersion,
-        }
+    if (userId) {
+      options.headers = {
+        ...options.headers,
+        'x-lifi-userid': userId,
       }
+    }
 
-      if (version) {
-        options.headers = {
-          ...options.headers,
-          'x-lifi-sdk': version,
-        }
+    if (widgetVersion) {
+      options.headers = {
+        ...options.headers,
+        'x-lifi-widget': widgetVersion,
       }
+    }
 
-      // integrator is mandatory during SDK initialization
+    if (version) {
       options.headers = {
         ...options.headers,
-        'x-lifi-integrator': integrator,
+        'x-lifi-sdk': version,
       }
     }
 
-    const response: Response = await fetch(url, options)
+    // 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)
+      throw new HTTPError(response, url, options)
     }
 
-    const data: T = await response.json()
-    return data
+    return await response.json()
   } catch (error) {
-    if (options.retries > 0 && (error as HTTPError)?.status === 500) {
+    if (options.retries > 0 && (error as HTTPError).status === 500) {
       await wait(500)
       return request<T>(url, { ...options, retries: options.retries - 1 })
     }
-    throw error
+
+    await (error as HTTPError).buildAdditionalDetails?.()
+
+    throw new SDKError(error as HTTPError)
   }
 }

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
+}