@lifi/sdk 3.13.4 → 4.0.0-alpha.1

package/src/actions/getQuote.ts

@@ -0,0 +1,102 @@
+import type { LiFiStep, RequestOptions } from '@lifi/types'
+import { ValidationError } from '../errors/errors.js'
+import { SDKError } from '../errors/SDKError.js'
+import type {
+  QuoteRequest,
+  QuoteRequestFromAmount,
+  QuoteRequestToAmount,
+} from '../types/actions.js'
+import type { SDKClient } from '../types/core.js'
+import { request } from '../utils/request.js'
+
+/**
+ * Get a quote for a token transfer
+ * @param client - The SDK client
+ * @param params - The configuration of the requested quote
+ * @param options - Request options
+ * @throws {LiFiError} - Throws a LiFiError if request fails
+ * @returns Quote for a token transfer
+ */
+export async function getQuote(
+  client: SDKClient,
+  params: QuoteRequestFromAmount,
+  options?: RequestOptions
+): Promise<LiFiStep>
+export async function getQuote(
+  client: SDKClient,
+  params: QuoteRequestToAmount,
+  options?: RequestOptions
+): Promise<LiFiStep>
+export async function getQuote(
+  client: SDKClient,
+  params: QuoteRequest,
+  options?: RequestOptions
+): Promise<LiFiStep> {
+  const requiredParameters: Array<keyof QuoteRequest> = [
+    'fromChain',
+    'fromToken',
+    'fromAddress',
+    'toChain',
+    'toToken',
+  ]
+
+  for (const requiredParameter of requiredParameters) {
+    if (!params[requiredParameter]) {
+      throw new SDKError(
+        new ValidationError(
+          `Required parameter "${requiredParameter}" is missing.`
+        )
+      )
+    }
+  }
+
+  const isFromAmountRequest =
+    'fromAmount' in params && params.fromAmount !== undefined
+  const isToAmountRequest =
+    'toAmount' in params && params.toAmount !== undefined
+
+  if (!isFromAmountRequest && !isToAmountRequest) {
+    throw new SDKError(
+      new ValidationError(
+        'Required parameter "fromAmount" or "toAmount" is missing.'
+      )
+    )
+  }
+
+  if (isFromAmountRequest && isToAmountRequest) {
+    throw new SDKError(
+      new ValidationError(
+        'Cannot provide both "fromAmount" and "toAmount" parameters.'
+      )
+    )
+  }
+
+  // apply defaults
+  params.integrator ??= client.config.integrator
+  params.order ??= client.config.routeOptions?.order
+  params.slippage ??= client.config.routeOptions?.slippage
+  params.referrer ??= client.config.routeOptions?.referrer
+  params.fee ??= client.config.routeOptions?.fee
+  params.allowBridges ??= client.config.routeOptions?.bridges?.allow
+  params.denyBridges ??= client.config.routeOptions?.bridges?.deny
+  params.preferBridges ??= client.config.routeOptions?.bridges?.prefer
+  params.allowExchanges ??= client.config.routeOptions?.exchanges?.allow
+  params.denyExchanges ??= client.config.routeOptions?.exchanges?.deny
+  params.preferExchanges ??= client.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<LiFiStep>(
+    client.config,
+    `${client.config.apiUrl}/${isFromAmountRequest ? 'quote' : 'quote/toAmount'}?${new URLSearchParams(
+      params as unknown as Record<string, string>
+    )}`,
+    {
+      signal: options?.signal,
+    }
+  )
+}

package/src/actions/getQuote.unit.spec.ts

@@ -0,0 +1,154 @@
+import { ChainId } from '@lifi/types'
+import { describe, expect, it, vi } from 'vitest'
+import { ValidationError } from '../errors/errors.js'
+import { SDKError } from '../errors/SDKError.js'
+import * as request from '../utils/request.js'
+import { client, setupTestServer } from './actions.unit.handlers.js'
+import { getQuote } from './getQuote.js'
+
+const mockedFetch = vi.spyOn(request, 'request')
+
+describe('getQuote', () => {
+  setupTestServer()
+
+  const fromChain = ChainId.DAI
+  const fromToken = 'DAI'
+  const fromAddress = 'Some wallet address'
+  const fromAmount = '1000'
+  const toChain = ChainId.POL
+  const toToken = 'MATIC'
+  const toAmount = '1000'
+
+  describe('user input is invalid', () => {
+    it('throw an error', async () => {
+      await expect(
+        getQuote(client, {
+          fromChain: undefined as unknown as ChainId,
+          fromToken,
+          fromAddress,
+          fromAmount,
+          toChain,
+          toToken,
+        })
+      ).rejects.toThrowError(
+        new SDKError(
+          new ValidationError('Required parameter "fromChain" is missing.')
+        )
+      )
+
+      await expect(
+        getQuote(client, {
+          fromChain,
+          fromToken: undefined as unknown as string,
+          fromAddress,
+          fromAmount,
+          toChain,
+          toToken,
+        })
+      ).rejects.toThrowError(
+        new SDKError(
+          new ValidationError('Required parameter "fromToken" is missing.')
+        )
+      )
+
+      await expect(
+        getQuote(client, {
+          fromChain,
+          fromToken,
+          fromAddress: undefined as unknown as string,
+          fromAmount,
+          toChain,
+          toToken,
+        })
+      ).rejects.toThrowError(
+        new SDKError(
+          new ValidationError('Required parameter "fromAddress" is missing.')
+        )
+      )
+
+      await expect(
+        getQuote(client, {
+          fromChain,
+          fromToken,
+          fromAddress,
+          fromAmount: undefined as unknown as string,
+          toChain,
+          toToken,
+        })
+      ).rejects.toThrowError(
+        new SDKError(
+          new ValidationError(
+            'Required parameter "fromAmount" or "toAmount" is missing.'
+          )
+        )
+      )
+
+      await expect(
+        getQuote(client, {
+          fromChain,
+          fromToken,
+          fromAddress,
+          fromAmount,
+          toChain,
+          toToken,
+          toAmount,
+        } as any)
+      ).rejects.toThrowError(
+        new SDKError(
+          new ValidationError(
+            'Cannot provide both "fromAmount" and "toAmount" parameters.'
+          )
+        )
+      )
+
+      await expect(
+        getQuote(client, {
+          fromChain,
+          fromToken,
+          fromAddress,
+          fromAmount,
+          toChain: undefined as unknown as ChainId,
+          toToken,
+        })
+      ).rejects.toThrowError(
+        new SDKError(
+          new ValidationError('Required parameter "toChain" is missing.')
+        )
+      )
+
+      await expect(
+        getQuote(client, {
+          fromChain,
+          fromToken,
+          fromAddress,
+          fromAmount,
+          toChain,
+          toToken: undefined as unknown as string,
+        })
+      ).rejects.toThrowError(
+        new SDKError(
+          new ValidationError('Required parameter "toToken" is missing.')
+        )
+      )
+
+      expect(mockedFetch).toHaveBeenCalledTimes(0)
+    })
+  })
+
+  describe('user input is valid', () => {
+    describe('and the backend call is successful', () => {
+      it('call the server once', async () => {
+        await getQuote(client, {
+          fromChain,
+          fromToken,
+          fromAddress,
+          fromAmount,
+          toChain,
+          toToken,
+        })
+
+        expect(mockedFetch).toHaveBeenCalledTimes(1)
+      })
+    })
+  })
+})

package/src/actions/getRelayedTransactionStatus.ts

@@ -0,0 +1,67 @@
+import type {
+  RelayStatusRequest,
+  RelayStatusResponse,
+  RelayStatusResponseData,
+  RequestOptions,
+} from '@lifi/types'
+import { BaseError } from '../errors/baseError.js'
+import { ErrorName } from '../errors/constants.js'
+import { ValidationError } from '../errors/errors.js'
+import { SDKError } from '../errors/SDKError.js'
+import type { SDKClient } from '../types/core.js'
+import { decodeTaskId } from '../utils/decode.js'
+import { request } from '../utils/request.js'
+import { getStatus } from './getStatus.js'
+
+/**
+ * Get the status of a relayed transaction
+ * @param client - The SDK client
+ * @param params - Parameters for the relay status request
+ * @param options - Request options
+ * @throws {LiFiError} - Throws a LiFiError if request fails
+ * @returns Status of the relayed transaction
+ */
+export const getRelayedTransactionStatus = async (
+  client: SDKClient,
+  params: RelayStatusRequest,
+  options?: RequestOptions
+): Promise<RelayStatusResponseData> => {
+  if (!params.taskId) {
+    throw new SDKError(
+      new ValidationError('Required parameter "taskId" is missing.')
+    )
+  }
+
+  const { taskId, ...otherParams } = params
+  const queryParams = new URLSearchParams(
+    otherParams as unknown as Record<string, string>
+  )
+
+  const decodedTaskId = decodeTaskId(taskId)
+  // Temporary solution during the transition between status endpoints
+  if (decodedTaskId.length === 3) {
+    return (await getStatus(
+      client,
+      params,
+      options
+    )) as unknown as RelayStatusResponseData
+  }
+
+  const result = await request<RelayStatusResponse>(
+    client.config,
+    `${client.config.apiUrl}/relayer/status/${taskId}?${queryParams}`,
+    {
+      signal: options?.signal,
+    }
+  )
+
+  if (result.status === 'error') {
+    throw new BaseError(
+      ErrorName.ServerError,
+      result.data.code,
+      result.data.message
+    )
+  }
+
+  return result.data
+}

package/src/actions/getRelayedTransactionStatus.unit.spec.ts

@@ -0,0 +1,243 @@
+import type {
+  RelayStatusRequest,
+  RelayStatusResponse,
+  RelayStatusResponseData,
+  RequestOptions,
+} from '@lifi/types'
+import { HttpResponse, http } from 'msw'
+import { describe, expect, it } from 'vitest'
+import { BaseError } from '../errors/baseError.js'
+import { ErrorName } from '../errors/constants.js'
+import { ValidationError } from '../errors/errors.js'
+import { SDKError } from '../errors/SDKError.js'
+import { client, setupTestServer } from './actions.unit.handlers.js'
+import { getRelayedTransactionStatus } from './getRelayedTransactionStatus.js'
+
+describe('getRelayedTransactionStatus', () => {
+  const server = setupTestServer()
+
+  const createMockRelayStatusRequest = (
+    overrides: Partial<RelayStatusRequest> = {}
+  ): RelayStatusRequest => ({
+    taskId:
+      '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
+    ...overrides,
+  })
+
+  const mockStatusResponseData: RelayStatusResponseData = {
+    status: 'PENDING',
+    metadata: {
+      chainId: 1,
+    },
+  }
+
+  const mockSuccessResponse: RelayStatusResponse = {
+    status: 'ok',
+    data: mockStatusResponseData,
+  }
+
+  const mockErrorResponse: RelayStatusResponse = {
+    status: 'error',
+    data: {
+      code: 404,
+      message: 'Task not found',
+    },
+  }
+
+  describe('success scenarios', () => {
+    it('should get relayed transaction status successfully', async () => {
+      server.use(
+        http.get(
+          `${client.config.apiUrl}/relayer/status/0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef`,
+          async () => {
+            return HttpResponse.json(mockSuccessResponse)
+          }
+        )
+      )
+
+      const request = createMockRelayStatusRequest()
+
+      const result = await getRelayedTransactionStatus(client, request)
+
+      expect(result).toEqual(mockStatusResponseData)
+    })
+
+    it('should pass request options correctly', async () => {
+      const mockAbortController = new AbortController()
+      const options: RequestOptions = {
+        signal: mockAbortController.signal,
+      }
+
+      let capturedOptions: any
+      server.use(
+        http.get(
+          `${client.config.apiUrl}/relayer/status/0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef`,
+          async ({ request }) => {
+            capturedOptions = request
+            return HttpResponse.json(mockSuccessResponse)
+          }
+        )
+      )
+
+      const request = createMockRelayStatusRequest()
+
+      await getRelayedTransactionStatus(client, request, options)
+
+      expect(capturedOptions.signal).toBeDefined()
+      expect(capturedOptions.signal).toBeInstanceOf(AbortSignal)
+    })
+
+    it('should handle different task statuses', async () => {
+      const pendingResponse = {
+        ...mockSuccessResponse,
+        data: { ...mockStatusResponseData, status: 'PENDING' },
+      }
+      const completedResponse = {
+        ...mockSuccessResponse,
+        data: { ...mockStatusResponseData, status: 'COMPLETED' },
+      }
+      const failedResponse = {
+        ...mockSuccessResponse,
+        data: { ...mockStatusResponseData, status: 'FAILED' },
+      }
+
+      // Test PENDING status
+      server.use(
+        http.get(
+          `${client.config.apiUrl}/relayer/status/0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef`,
+          async () => {
+            return HttpResponse.json(pendingResponse)
+          }
+        )
+      )
+
+      let result = await getRelayedTransactionStatus(
+        client,
+        createMockRelayStatusRequest()
+      )
+      expect(result.status).toBe('PENDING')
+
+      // Test COMPLETED status
+      server.resetHandlers()
+      server.use(
+        http.get(
+          `${client.config.apiUrl}/relayer/status/0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef`,
+          async () => {
+            return HttpResponse.json(completedResponse)
+          }
+        )
+      )
+
+      result = await getRelayedTransactionStatus(
+        client,
+        createMockRelayStatusRequest()
+      )
+      expect(result.status).toBe('COMPLETED')
+
+      // Test FAILED status
+      server.resetHandlers()
+      server.use(
+        http.get(
+          `${client.config.apiUrl}/relayer/status/0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef`,
+          async () => {
+            return HttpResponse.json(failedResponse)
+          }
+        )
+      )
+
+      result = await getRelayedTransactionStatus(
+        client,
+        createMockRelayStatusRequest()
+      )
+      expect(result.status).toBe('FAILED')
+    })
+  })
+
+  describe('validation scenarios', () => {
+    it('should throw SDKError when taskId is missing', async () => {
+      const invalidRequest = createMockRelayStatusRequest({
+        taskId: undefined as any,
+      })
+
+      await expect(
+        getRelayedTransactionStatus(client, invalidRequest)
+      ).rejects.toThrow(SDKError)
+
+      try {
+        await getRelayedTransactionStatus(client, invalidRequest)
+      } catch (error) {
+        expect(error).toBeInstanceOf(SDKError)
+        expect((error as SDKError).cause).toBeInstanceOf(ValidationError)
+        expect((error as SDKError).cause.message).toBe(
+          'Required parameter "taskId" is missing.'
+        )
+      }
+    })
+  })
+
+  describe('error scenarios', () => {
+    it('should throw BaseError when server returns error status', async () => {
+      server.use(
+        http.get(
+          `${client.config.apiUrl}/relayer/status/0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef`,
+          async () => {
+            return HttpResponse.json(mockErrorResponse)
+          }
+        )
+      )
+
+      const request = createMockRelayStatusRequest()
+
+      await expect(
+        getRelayedTransactionStatus(client, request)
+      ).rejects.toThrow(BaseError)
+
+      try {
+        await getRelayedTransactionStatus(client, request)
+      } catch (error) {
+        expect(error).toBeInstanceOf(BaseError)
+        expect((error as BaseError).name).toBe(ErrorName.ServerError)
+        expect((error as BaseError).code).toBe(404)
+        expect((error as BaseError).message).toBe('Task not found')
+      }
+    })
+
+    it('should throw SDKError when network request fails', async () => {
+      server.use(
+        http.get(
+          `${client.config.apiUrl}/relayer/status/0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef`,
+          async () => {
+            return HttpResponse.error()
+          }
+        )
+      )
+
+      const request = createMockRelayStatusRequest()
+
+      await expect(
+        getRelayedTransactionStatus(client, request)
+      ).rejects.toThrow(SDKError)
+    })
+
+    it('should throw SDKError when request times out', async () => {
+      server.use(
+        http.get(
+          `${client.config.apiUrl}/relayer/status/0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef`,
+          async () => {
+            // Simulate timeout by not responding
+            await new Promise(() => {}) // Never resolves
+          }
+        )
+      )
+
+      const request = createMockRelayStatusRequest()
+      const timeoutOptions: RequestOptions = {
+        signal: AbortSignal.timeout(100), // 100ms timeout
+      }
+
+      await expect(
+        getRelayedTransactionStatus(client, request, timeoutOptions)
+      ).rejects.toThrow()
+    })
+  })
+})

package/src/actions/getRelayerQuote.ts

@@ -0,0 +1,83 @@
+import type {
+  LiFiStep,
+  RelayerQuoteResponse,
+  RequestOptions,
+} from '@lifi/types'
+import { BaseError } from '../errors/baseError.js'
+import { ErrorName } from '../errors/constants.js'
+import { ValidationError } from '../errors/errors.js'
+import { SDKError } from '../errors/SDKError.js'
+import type { QuoteRequest, QuoteRequestFromAmount } from '../types/actions.js'
+import type { SDKClient } from '../types/core.js'
+import { request } from '../utils/request.js'
+
+/**
+ * Get a relayer quote for a token transfer
+ * @param client - The SDK client
+ * @param params - The configuration of the requested quote
+ * @param options - Request options
+ * @throws {LiFiError} - Throws a LiFiError if request fails
+ * @returns Relayer quote for a token transfer
+ */
+export const getRelayerQuote = async (
+  client: SDKClient,
+  params: QuoteRequestFromAmount,
+  options?: RequestOptions
+): Promise<LiFiStep> => {
+  const requiredParameters: Array<keyof QuoteRequestFromAmount> = [
+    'fromChain',
+    'fromToken',
+    'fromAddress',
+    'fromAmount',
+    'toChain',
+    'toToken',
+  ]
+  for (const requiredParameter of requiredParameters) {
+    if (!params[requiredParameter]) {
+      throw new SDKError(
+        new ValidationError(
+          `Required parameter "${requiredParameter}" is missing.`
+        )
+      )
+    }
+  }
+
+  // apply defaults
+  params.integrator ??= client.config.integrator
+  params.order ??= client.config.routeOptions?.order
+  params.slippage ??= client.config.routeOptions?.slippage
+  params.referrer ??= client.config.routeOptions?.referrer
+  params.fee ??= client.config.routeOptions?.fee
+  params.allowBridges ??= client.config.routeOptions?.bridges?.allow
+  params.denyBridges ??= client.config.routeOptions?.bridges?.deny
+  params.preferBridges ??= client.config.routeOptions?.bridges?.prefer
+  params.allowExchanges ??= client.config.routeOptions?.exchanges?.allow
+  params.denyExchanges ??= client.config.routeOptions?.exchanges?.deny
+  params.preferExchanges ??= client.config.routeOptions?.exchanges?.prefer
+
+  for (const key of Object.keys(params)) {
+    if (!params[key as keyof QuoteRequest]) {
+      delete params[key as keyof QuoteRequest]
+    }
+  }
+
+  const result = await request<RelayerQuoteResponse>(
+    client.config,
+    `${client.config.apiUrl}/relayer/quote?${new URLSearchParams(
+      params as unknown as Record<string, string>
+    )}`,
+    {
+      signal: options?.signal,
+    }
+  )
+
+  if (result.status === 'error') {
+    throw new BaseError(
+      ErrorName.ServerError,
+      result.data.code,
+      result.data.message
+    )
+  }
+
+  return result.data
+}