@lifi/sdk 3.5.1-beta.0 → 3.6.0-beta.0

package/src/core/EVM/waitForBatchTransactionReceipt.ts

@@ -0,0 +1,61 @@
+import type {
+  Client,
+  Hash,
+  WalletCallReceipt as _WalletCallReceipt,
+} from 'viem'
+import { getCallsStatus } from 'viem/experimental'
+import { getAction } from 'viem/utils'
+import { LiFiErrorCode } from '../../errors/constants.js'
+import { TransactionError } from '../../errors/errors.js'
+import { waitForResult } from '../../utils/waitForResult.js'
+
+export type WalletCallReceipt = _WalletCallReceipt<
+  bigint,
+  'success' | 'reverted'
+>
+
+export const waitForBatchTransactionReceipt = async (
+  client: Client,
+  batchHash: Hash
+): Promise<WalletCallReceipt> => {
+  return waitForResult(
+    async () => {
+      const callsDetails = await getAction(
+        client,
+        getCallsStatus,
+        'getCallsStatus'
+      )({
+        id: batchHash,
+      })
+
+      if (callsDetails.status === 'PENDING') {
+        return undefined
+      }
+
+      if (callsDetails.status === 'CONFIRMED') {
+        if (
+          !callsDetails.receipts?.length ||
+          !callsDetails.receipts.every((receipt) => receipt.transactionHash) ||
+          callsDetails.receipts.some((receipt) => receipt.status === 'reverted')
+        ) {
+          throw new TransactionError(
+            LiFiErrorCode.TransactionFailed,
+            'Transaction was reverted.'
+          )
+        }
+        const transactionReceipt = callsDetails.receipts.at(-1)!
+        return transactionReceipt
+      }
+
+      throw new TransactionError(
+        LiFiErrorCode.TransactionNotFound,
+        'Transaction not found.'
+      )
+    },
+    5000,
+    3,
+    (_, error) => {
+      return !(error instanceof TransactionError)
+    }
+  )
+}

package/src/core/EVM/waitForRelayedTransactionReceipt.ts

@@ -0,0 +1,50 @@
+import type { ExtendedTransactionInfo } from '@lifi/types'
+import type { Hash, WalletCallReceipt as _WalletCallReceipt } from 'viem'
+import { LiFiErrorCode } from '../../errors/constants.js'
+import { TransactionError } from '../../errors/errors.js'
+import { getRelayedTransactionStatus } from '../../services/api.js'
+import { waitForResult } from '../../utils/waitForResult.js'
+
+export type WalletCallReceipt = _WalletCallReceipt<
+  bigint,
+  'success' | 'reverted'
+>
+
+export const waitForRelayedTransactionReceipt = async (
+  taskId: Hash
+): Promise<WalletCallReceipt> => {
+  return waitForResult(async () => {
+    const result = await getRelayedTransactionStatus({
+      taskId,
+    }).catch((e) => {
+      if (process.env.NODE_ENV === 'development') {
+        console.debug('Fetching status from relayer failed.', e)
+      }
+      return undefined
+    })
+
+    switch (result?.data.status) {
+      case 'PENDING':
+        return undefined
+      case 'DONE': {
+        const sending: ExtendedTransactionInfo | undefined = result?.data
+          .transactionStatus?.sending as ExtendedTransactionInfo
+        return {
+          status: 'success',
+          gasUsed: sending?.gasUsed,
+          transactionHash: result?.data.metadata.txHash,
+        } as unknown as WalletCallReceipt
+      }
+      case 'FAILED':
+        throw new TransactionError(
+          LiFiErrorCode.TransactionFailed,
+          'Transaction was reverted.'
+        )
+      default:
+        throw new TransactionError(
+          LiFiErrorCode.TransactionNotFound,
+          'Transaction not found.'
+        )
+    }
+  }, 5000)
+}

package/src/core/checkBalance.ts

@@ -28,13 +28,16 @@ export const checkBalance = async (
       } else {
         const neeeded = formatUnits(neededBalance, token.decimals)
         const current = formatUnits(currentBalance, token.decimals)
-        let _errorMessage = `Your ${token.symbol} balance is too low, you try to transfer ${neeeded} ${token.symbol}, but your wallet only holds ${current} ${token.symbol}. No funds have been sent.`
+        let errorMessage = `Your ${token.symbol} balance is too low, you try to transfer ${neeeded} ${token.symbol}, but your wallet only holds ${current} ${token.symbol}. No funds have been sent.`
 
         if (currentBalance !== 0n) {
-          _errorMessage += `If the problem consists, please delete this transfer and start a new one with a maximum of ${current} ${token.symbol}.`
+          errorMessage += `If the problem consists, please delete this transfer and start a new one with a maximum of ${current} ${token.symbol}.`
         }
 
-        throw new BalanceError('The balance is too low.')
+        throw new BalanceError(
+          'The balance is too low.',
+          new Error(errorMessage)
+        )
       }
     }
   }

package/src/core/waitForTransactionStatus.ts

@@ -49,7 +49,9 @@ export async function waitForTransactionStatus(
         }
       })
       .catch((e) => {
-        console.debug('Fetching status from backend failed.', e)
+        if (process.env.NODE_ENV === 'development') {
+          console.debug('Fetching status from backend failed.', e)
+        }
         return undefined
       })
   }
@@ -64,7 +66,9 @@ export async function waitForTransactionStatus(
   const resolvedStatus = await status
 
   if (!('receiving' in resolvedStatus)) {
-    throw new ServerError("Status doesn't contain receiving information.")
+    throw new ServerError(
+      "Status doesn't contain destination chain information."
+    )
   }
 
   return resolvedStatus

package/src/createConfig.ts

@@ -1,8 +1,8 @@
 import { ChainType } from '@lifi/types'
 import { config } from './config.js'
-import { checkPackageUpdates } from './helpers.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) {

package/src/errors/constants.ts

@@ -35,6 +35,7 @@ export enum LiFiErrorCode {
   TransactionExpired = 1018,
   TransactionSimulationFailed = 1019,
   TransactionConflict = 1020,
+  TransactionNotFound = 1021,
 }
 
 export enum ErrorMessage {

package/src/index.ts

@@ -15,9 +15,6 @@ export { isEVM } from './core/EVM/types.js'
 export type {
   EVMProvider,
   EVMProviderOptions,
-  MultisigConfig,
-  MultisigTransaction,
-  MultisigTxDetails,
 } from './core/EVM/types.js'
 export { StatusManager } from './core/StatusManager.js'
 export {
@@ -65,17 +62,16 @@ export { UTXO } from './core/UTXO/UTXO.js'
 export { isUTXO } from './core/UTXO/types.js'
 export type { UTXOProvider, UTXOProviderOptions } from './core/UTXO/types.js'
 export { createConfig } from './createConfig.js'
-export {
-  checkPackageUpdates,
-  convertQuoteToRoute,
-  fetchTxErrorDetails,
-} from './helpers.js'
+export { checkPackageUpdates } from './utils/checkPackageUpdates.js'
+export { convertQuoteToRoute } from './utils/convertQuoteToRoute.js'
+export { fetchTxErrorDetails } from './utils/fetchTxErrorDetails.js'
 export {
   getChains,
   getConnections,
   getContractCallsQuote,
   getGasRecommendation,
   getQuote,
+  getRelayerQuote,
   getRoutes,
   getStatus,
   getStepTransaction,

package/src/services/api.ts

@@ -26,44 +26,56 @@ import {
   isContractCallsRequestWithFromAmount,
   isContractCallsRequestWithToAmount,
 } from '@lifi/types'
+import type { Address, Hash, Hex } from 'viem'
 import { config } from '../config.js'
+import type { PermitData } from '../core/EVM/permit2/domain.js'
+import type {
+  PermitTransferFrom,
+  Witness,
+} from '../core/EVM/permit2/signatureTransfer.js'
 import { SDKError } from '../errors/SDKError.js'
 import { ValidationError } from '../errors/errors.js'
 import { request } from '../request.js'
 import { isRoutesRequest, isStep } from '../typeguards.js'
 import { withDedupe } from '../utils/withDedupe.js'
-/**
- * Fetch information about a Token
- * @param chain - Id or key of the chain that contains the token
- * @param token - Address or symbol of the token on the requested chain
- * @param options - Request options
- * @throws {LiFiError} - Throws a LiFiError if request fails
- * @returns Token information
- */
-export const getToken = async (
-  chain: ChainKey | ChainId,
-  token: string,
-  options?: RequestOptions
-): Promise<Token> => {
-  if (!chain) {
-    throw new SDKError(
-      new ValidationError('Required parameter "chain" is missing.')
-    )
-  }
-  if (!token) {
-    throw new SDKError(
-      new ValidationError('Required parameter "token" is missing.')
-    )
+
+interface TaskStatus {
+  data: {
+    status: 'DONE' | 'PENDING' | 'FAILED'
+    message?: string
+    metadata: { chainId: number; txHash?: Hash }
+    transactionStatus?: StatusResponse
   }
-  return await request<Token>(
-    `${config.get().apiUrl}/token?${new URLSearchParams({
-      chain,
-      token,
-    } as Record<string, string>)}`,
-    {
-      signal: options?.signal,
+}
+
+interface RelayStatusRequest {
+  taskId: Hash
+}
+
+interface RelayRequest {
+  tokenOwner: Address
+  chainId: number
+  permit: PermitTransferFrom
+  witness: Witness
+  signedPermitData: Hex
+  callData: string
+}
+
+interface RelayResponse {
+  data: { taskId: Hash }
+}
+
+interface RelayerQuoteResponse {
+  data: {
+    quote: {
+      step: LiFiStep
+      permit: PermitTransferFrom
+      witness: Witness
+      permitData: PermitData
+      tokenOwner: Address
+      chainId: number
     }
-  )
+  }
 }
 
 /**
@@ -124,6 +136,38 @@ export const getQuote = async (
   )
 }
 
+/**
+ * Get a set of routes for a request that describes a transfer of tokens.
+ * @param params - A description of the transfer.
+ * @param options - Request options
+ * @returns The resulting routes that can be used to realize the described transfer of tokens.
+ * @throws {LiFiError} Throws a LiFiError if request fails.
+ */
+export const getRoutes = async (
+  params: RoutesRequest,
+  options?: RequestOptions
+): Promise<RoutesResponse> => {
+  if (!isRoutesRequest(params)) {
+    throw new SDKError(new ValidationError('Invalid routes request.'))
+  }
+  const _config = config.get()
+  // apply defaults
+  params.options = {
+    integrator: _config.integrator,
+    ..._config.routeOptions,
+    ...params.options,
+  }
+
+  return await request<RoutesResponse>(`${_config.apiUrl}/advanced/routes`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(params),
+    signal: options?.signal,
+  })
+}
+
 /**
  * Get a quote for a destination contract call
  * @param params - The configuration of the requested destination call
@@ -187,6 +231,35 @@ export const getContractCallsQuote = async (
   })
 }
 
+/**
+ * Get the transaction data for a single step of a route
+ * @param step - The step object.
+ * @param options - Request options
+ * @returns The step populated with the transaction data.
+ * @throws {LiFiError} Throws a LiFiError if request fails.
+ */
+export const getStepTransaction = async (
+  step: LiFiStep,
+  options?: RequestOptions
+): Promise<LiFiStep> => {
+  if (!isStep(step)) {
+    // While the validation fails for some users we should not enforce it
+    console.warn('SDK Validation: Invalid Step', step)
+  }
+
+  return await request<LiFiStep>(
+    `${config.get().apiUrl}/advanced/stepTransaction`,
+    {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(step),
+      signal: options?.signal,
+    }
+  )
+}
+
 /**
  * Check the status of a transfer. For cross chain transfers, the "bridge" parameter is required.
  * @param params - Configuration of the requested status
@@ -215,125 +288,165 @@ export const getStatus = async (
 }
 
 /**
- * Get all available chains
- * @param params - The configuration of the requested chains
+ * Get a relayer quote for a token transfer
+ * @param params - The configuration of the requested quote
  * @param options - Request options
- * @returns A list of all available chains
- * @throws {LiFiError} Throws a LiFiError if request fails.
+ * @throws {LiFiError} - Throws a LiFiError if request fails
+ * @returns Relayer quote for a token transfer
  */
-export const getChains = async (
-  params?: ChainsRequest,
+export const getRelayerQuote = async (
+  params: QuoteRequest,
   options?: RequestOptions
-): Promise<ExtendedChain[]> => {
-  if (params) {
-    for (const key of Object.keys(params)) {
-      if (!params[key as keyof ChainsRequest]) {
-        delete params[key as keyof ChainsRequest]
-      }
+): Promise<RelayerQuoteResponse> => {
+  const requiredParameters: Array<keyof QuoteRequest> = [
+    'fromChain',
+    'fromToken',
+    'fromAddress',
+    'fromAmount',
+    'toChain',
+    'toToken',
+  ]
+  for (const requiredParameter of requiredParameters) {
+    if (!params[requiredParameter]) {
+      throw new SDKError(
+        new ValidationError(
+          `Required parameter "${requiredParameter}" is missing.`
+        )
+      )
     }
   }
-  const urlSearchParams = new URLSearchParams(
-    params as Record<string, string>
-  ).toString()
-  const response = await withDedupe(
-    () =>
-      request<ChainsResponse>(
-        `${config.get().apiUrl}/chains?${urlSearchParams}`,
-        {
-          signal: options?.signal,
-        }
-      ),
-    { id: `${getChains.name}.${urlSearchParams}` }
+  const _config = config.get()
+  // apply defaults
+  params.integrator ??= _config.integrator
+  params.order ??= _config.routeOptions?.order
+  params.slippage ??= _config.routeOptions?.slippage
+  params.referrer ??= _config.routeOptions?.referrer
+  params.fee ??= _config.routeOptions?.fee
+  params.allowBridges ??= _config.routeOptions?.bridges?.allow
+  params.denyBridges ??= _config.routeOptions?.bridges?.deny
+  params.preferBridges ??= _config.routeOptions?.bridges?.prefer
+  params.allowExchanges ??= _config.routeOptions?.exchanges?.allow
+  params.denyExchanges ??= _config.routeOptions?.exchanges?.deny
+  params.preferExchanges ??= _config.routeOptions?.exchanges?.prefer
+
+  for (const key of Object.keys(params)) {
+    if (!params[key as keyof QuoteRequest]) {
+      delete params[key as keyof QuoteRequest]
+    }
+  }
+
+  return await request<RelayerQuoteResponse>(
+    `${config.get().apiUrl}/relayer/quote?${new URLSearchParams(
+      params as unknown as Record<string, string>
+    )}`,
+    {
+      signal: options?.signal,
+    }
   )
-  return response.chains
 }
 
 /**
- * Get a set of routes for a request that describes a transfer of tokens.
- * @param params - A description of the transfer.
+ * Relay a transaction through the relayer service
+ * @param params - The configuration for the relay request
  * @param options - Request options
- * @returns The resulting routes that can be used to realize the described transfer of tokens.
- * @throws {LiFiError} Throws a LiFiError if request fails.
+ * @throws {LiFiError} - Throws a LiFiError if request fails
+ * @returns Task ID for the relayed transaction
  */
-export const getRoutes = async (
-  params: RoutesRequest,
+export const relayTransaction = async (
+  params: RelayRequest,
   options?: RequestOptions
-): Promise<RoutesResponse> => {
-  if (!isRoutesRequest(params)) {
-    throw new SDKError(new ValidationError('Invalid routes request.'))
-  }
-  const _config = config.get()
-  // apply defaults
-  params.options = {
-    integrator: _config.integrator,
-    ..._config.routeOptions,
-    ...params.options,
+): Promise<RelayResponse> => {
+  const requiredParameters: Array<keyof RelayRequest> = [
+    'tokenOwner',
+    'chainId',
+    'permit',
+    'witness',
+    'signedPermitData',
+    'callData',
+  ]
+
+  for (const requiredParameter of requiredParameters) {
+    if (!params[requiredParameter]) {
+      throw new SDKError(
+        new ValidationError(
+          `Required parameter "${requiredParameter}" is missing.`
+        )
+      )
+    }
   }
 
-  return await request<RoutesResponse>(`${_config.apiUrl}/advanced/routes`, {
+  return await request<RelayResponse>(`${config.get().apiUrl}/relayer/relay`, {
     method: 'POST',
     headers: {
       'Content-Type': 'application/json',
     },
-    body: JSON.stringify(params),
+    body: JSON.stringify(params, (_, value) => {
+      if (typeof value === 'bigint') {
+        return value.toString()
+      }
+      return value
+    }),
     signal: options?.signal,
   })
 }
 
 /**
- * Get the transaction data for a single step of a route
- * @param step - The step object.
+ * Get the status of a relayed transaction
+ * @param params - Parameters for the relay status request
  * @param options - Request options
- * @returns The step populated with the transaction data.
- * @throws {LiFiError} Throws a LiFiError if request fails.
+ * @throws {LiFiError} - Throws a LiFiError if request fails
+ * @returns Status of the relayed transaction
  */
-export const getStepTransaction = async (
-  step: LiFiStep,
+export const getRelayedTransactionStatus = async (
+  params: RelayStatusRequest,
   options?: RequestOptions
-): Promise<LiFiStep> => {
-  if (!isStep(step)) {
-    // While the validation fails for some users we should not enforce it
-    console.warn('SDK Validation: Invalid Step', step)
+): Promise<TaskStatus> => {
+  if (!params.taskId) {
+    throw new SDKError(
+      new ValidationError('Required parameter "taskId" is missing.')
+    )
   }
 
-  return await request<LiFiStep>(
-    `${config.get().apiUrl}/advanced/stepTransaction`,
+  return await request<TaskStatus>(
+    `${config.get().apiUrl}/relayer/status/${params.taskId}`,
     {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify(step),
       signal: options?.signal,
     }
   )
 }
 
 /**
- * Get the available tools to bridge and swap tokens.
- * @param params - The configuration of the requested tools
+ * Get all available chains
+ * @param params - The configuration of the requested chains
  * @param options - Request options
- * @returns The tools that are available on the requested chains
+ * @returns A list of all available chains
+ * @throws {LiFiError} Throws a LiFiError if request fails.
  */
-export const getTools = async (
-  params?: ToolsRequest,
+export const getChains = async (
+  params?: ChainsRequest,
   options?: RequestOptions
-): Promise<ToolsResponse> => {
+): Promise<ExtendedChain[]> => {
   if (params) {
     for (const key of Object.keys(params)) {
-      if (!params[key as keyof ToolsRequest]) {
-        delete params[key as keyof ToolsRequest]
+      if (!params[key as keyof ChainsRequest]) {
+        delete params[key as keyof ChainsRequest]
       }
     }
   }
-  return await request<ToolsResponse>(
-    `${config.get().apiUrl}/tools?${new URLSearchParams(
-      params as Record<string, string>
-    )}`,
-    {
-      signal: options?.signal,
-    }
+  const urlSearchParams = new URLSearchParams(
+    params as Record<string, string>
+  ).toString()
+  const response = await withDedupe(
+    () =>
+      request<ChainsResponse>(
+        `${config.get().apiUrl}/chains?${urlSearchParams}`,
+        {
+          signal: options?.signal,
+        }
+      ),
+    { id: `${getChains.name}.${urlSearchParams}` }
   )
+  return response.chains
 }
 
 /**
@@ -369,6 +482,67 @@ export const getTokens = async (
   return response
 }
 
+/**
+ * Fetch information about a Token
+ * @param chain - Id or key of the chain that contains the token
+ * @param token - Address or symbol of the token on the requested chain
+ * @param options - Request options
+ * @throws {LiFiError} - Throws a LiFiError if request fails
+ * @returns Token information
+ */
+export const getToken = async (
+  chain: ChainKey | ChainId,
+  token: string,
+  options?: RequestOptions
+): Promise<Token> => {
+  if (!chain) {
+    throw new SDKError(
+      new ValidationError('Required parameter "chain" is missing.')
+    )
+  }
+  if (!token) {
+    throw new SDKError(
+      new ValidationError('Required parameter "token" is missing.')
+    )
+  }
+  return await request<Token>(
+    `${config.get().apiUrl}/token?${new URLSearchParams({
+      chain,
+      token,
+    } as Record<string, string>)}`,
+    {
+      signal: options?.signal,
+    }
+  )
+}
+
+/**
+ * Get the available tools to bridge and swap tokens.
+ * @param params - The configuration of the requested tools
+ * @param options - Request options
+ * @returns The tools that are available on the requested chains
+ */
+export const getTools = async (
+  params?: ToolsRequest,
+  options?: RequestOptions
+): Promise<ToolsResponse> => {
+  if (params) {
+    for (const key of Object.keys(params)) {
+      if (!params[key as keyof ToolsRequest]) {
+        delete params[key as keyof ToolsRequest]
+      }
+    }
+  }
+  return await request<ToolsResponse>(
+    `${config.get().apiUrl}/tools?${new URLSearchParams(
+      params as Record<string, string>
+    )}`,
+    {
+      signal: options?.signal,
+    }
+  )
+}
+
 /**
  * Get gas recommendation for a certain chain
  * @param params - Configuration of the requested gas recommendation.