@lifi/sdk 4.0.0-alpha.1 → 4.0.0-alpha.3

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

@@ -1,220 +0,0 @@
-import type {
-  LiFiStep,
-  RelayerQuoteResponse,
-  RequestOptions,
-} from '@lifi/types'
-import { ChainId } 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 type { QuoteRequestFromAmount } from '../types/actions.js'
-import { client, setupTestServer } from './actions.unit.handlers.js'
-import { getRelayerQuote } from './getRelayerQuote.js'
-
-describe('getRelayerQuote', () => {
-  const server = setupTestServer()
-
-  const createMockQuoteRequest = (
-    overrides: Partial<QuoteRequestFromAmount> = {}
-  ): QuoteRequestFromAmount => ({
-    fromChain: ChainId.ETH,
-    fromToken: '0xA0b86a33E6441c8C06DDD4f36e4C4C5B4c3B4c3B',
-    fromAddress: '0x1234567890123456789012345678901234567890',
-    fromAmount: '1000000',
-    toChain: ChainId.POL,
-    toToken: '0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174',
-    ...overrides,
-  })
-
-  const mockLiFiStep: LiFiStep = {
-    id: 'test-step-id',
-    type: 'lifi',
-    includedSteps: [],
-    tool: 'test-tool',
-    toolDetails: {
-      key: 'test-tool',
-      name: 'Test Tool',
-      logoURI: 'https://example.com/logo.png',
-    },
-    action: {
-      fromChainId: ChainId.ETH,
-      toChainId: ChainId.POL,
-      fromToken: {
-        address: '0xA0b86a33E6441c8C06DDD4f36e4C4C5B4c3B4c3B',
-        symbol: 'USDC',
-        decimals: 6,
-        chainId: ChainId.ETH,
-        name: 'USD Coin',
-        priceUSD: '1.00',
-      },
-      toToken: {
-        address: '0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174',
-        symbol: 'USDC',
-        decimals: 6,
-        chainId: ChainId.POL,
-        name: 'USD Coin',
-        priceUSD: '1.00',
-      },
-      fromAmount: '1000000',
-      fromAddress: '0x1234567890123456789012345678901234567890',
-      toAddress: '0x1234567890123456789012345678901234567890',
-    },
-    estimate: {
-      fromAmount: '1000000',
-      toAmount: '1000000',
-      toAmountMin: '970000',
-      approvalAddress: '0x1234567890123456789012345678901234567890',
-      tool: 'test-tool',
-      executionDuration: 30000,
-    },
-    transactionRequest: {
-      to: '0x1234567890123456789012345678901234567890',
-      data: '0x',
-      value: '0',
-      gasLimit: '100000',
-    },
-  }
-
-  const mockSuccessResponse: RelayerQuoteResponse = {
-    status: 'ok',
-    data: mockLiFiStep,
-  }
-
-  const mockErrorResponse: RelayerQuoteResponse = {
-    status: 'error',
-    data: {
-      code: 400,
-      message: 'Invalid request parameters',
-    },
-  }
-
-  describe('success scenarios', () => {
-    it('should get relayer quote successfully', async () => {
-      server.use(
-        http.get(`${client.config.apiUrl}/relayer/quote`, async () => {
-          return HttpResponse.json(mockSuccessResponse)
-        })
-      )
-
-      const request = createMockQuoteRequest()
-
-      const result = await getRelayerQuote(client, request)
-
-      expect(result).toEqual(mockLiFiStep)
-    })
-
-    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/quote`,
-          async ({ request }) => {
-            capturedOptions = request
-            return HttpResponse.json(mockSuccessResponse)
-          }
-        )
-      )
-
-      const request = createMockQuoteRequest()
-
-      await getRelayerQuote(client, request, options)
-
-      expect(capturedOptions.signal).toBeDefined()
-      expect(capturedOptions.signal).toBeInstanceOf(AbortSignal)
-    })
-  })
-
-  describe('validation scenarios', () => {
-    it('should throw SDKError when required parameters are missing', async () => {
-      const testCases = [
-        { param: 'fromChain', value: undefined },
-        { param: 'fromToken', value: undefined },
-        { param: 'fromAddress', value: undefined },
-        { param: 'fromAmount', value: undefined },
-        { param: 'toChain', value: undefined },
-        { param: 'toToken', value: undefined },
-      ]
-
-      for (const testCase of testCases) {
-        const invalidRequest = createMockQuoteRequest({
-          [testCase.param]: testCase.value,
-        })
-
-        await expect(getRelayerQuote(client, invalidRequest)).rejects.toThrow(
-          SDKError
-        )
-
-        try {
-          await getRelayerQuote(client, invalidRequest)
-        } catch (error) {
-          expect(error).toBeInstanceOf(SDKError)
-          expect((error as SDKError).cause).toBeInstanceOf(ValidationError)
-          expect((error as SDKError).cause.message).toBe(
-            `Required parameter "${testCase.param}" is missing.`
-          )
-        }
-      }
-    })
-  })
-
-  describe('error scenarios', () => {
-    it('should throw BaseError when server returns error status', async () => {
-      server.use(
-        http.get(`${client.config.apiUrl}/relayer/quote`, async () => {
-          return HttpResponse.json(mockErrorResponse)
-        })
-      )
-
-      const request = createMockQuoteRequest()
-
-      await expect(getRelayerQuote(client, request)).rejects.toThrow(BaseError)
-
-      try {
-        await getRelayerQuote(client, request)
-      } catch (error) {
-        expect(error).toBeInstanceOf(BaseError)
-        expect((error as BaseError).name).toBe(ErrorName.ServerError)
-        expect((error as BaseError).code).toBe(400)
-        expect((error as BaseError).message).toBe('Invalid request parameters')
-      }
-    })
-
-    it('should throw SDKError when network request fails', async () => {
-      server.use(
-        http.get(`${client.config.apiUrl}/relayer/quote`, async () => {
-          return HttpResponse.error()
-        })
-      )
-
-      const request = createMockQuoteRequest()
-
-      await expect(getRelayerQuote(client, request)).rejects.toThrow(SDKError)
-    })
-
-    it('should throw SDKError when request times out', async () => {
-      server.use(
-        http.get(`${client.config.apiUrl}/relayer/quote`, async () => {
-          // Simulate timeout by not responding
-          await new Promise(() => {}) // Never resolves
-        })
-      )
-
-      const request = createMockQuoteRequest()
-      const timeoutOptions: RequestOptions = {
-        signal: AbortSignal.timeout(100), // 100ms timeout
-      }
-
-      await expect(
-        getRelayerQuote(client, request, timeoutOptions)
-      ).rejects.toThrow()
-    })
-  })
-})

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

@@ -1,112 +0,0 @@
-import { findDefaultToken } from '@lifi/data-types'
-import type { RoutesRequest } from '@lifi/types'
-import { ChainId, CoinKey } from '@lifi/types'
-import { describe, expect, it, vi } from 'vitest'
-import * as request from '../utils/request.js'
-import { client, setupTestServer } from './actions.unit.handlers.js'
-import { getRoutes } from './getRoutes.js'
-
-const mockedFetch = vi.spyOn(request, 'request')
-
-describe('getRoutes', () => {
-  setupTestServer()
-
-  const getRoutesRequest = ({
-    fromChainId = ChainId.BSC,
-    fromAmount = '10000000000000',
-    fromTokenAddress = findDefaultToken(CoinKey.USDC, ChainId.BSC).address,
-    toChainId = ChainId.DAI,
-    toTokenAddress = findDefaultToken(CoinKey.USDC, ChainId.DAI).address,
-    options = { slippage: 0.03 },
-  }: {
-    fromChainId?: ChainId
-    fromAmount?: string
-    fromTokenAddress?: string
-    toChainId?: ChainId
-    toTokenAddress?: string
-    options?: { slippage: number }
-  }): RoutesRequest => ({
-    fromChainId,
-    fromAmount,
-    fromTokenAddress,
-    toChainId,
-    toTokenAddress,
-    options,
-  })
-
-  describe('user input is invalid', () => {
-    it('should throw Error because of invalid fromChainId type', async () => {
-      const request = getRoutesRequest({
-        fromChainId: 'xxx' as unknown as ChainId,
-      })
-
-      await expect(getRoutes(client, request)).rejects.toThrow(
-        'Invalid routes request.'
-      )
-      expect(mockedFetch).toHaveBeenCalledTimes(0)
-    })
-
-    it('should throw Error because of invalid fromAmount type', async () => {
-      const request = getRoutesRequest({
-        fromAmount: 10000000000000 as unknown as string,
-      })
-
-      await expect(getRoutes(client, request)).rejects.toThrow(
-        'Invalid routes request.'
-      )
-      expect(mockedFetch).toHaveBeenCalledTimes(0)
-    })
-
-    it('should throw Error because of invalid fromTokenAddress type', async () => {
-      const request = getRoutesRequest({
-        fromTokenAddress: 1234 as unknown as string,
-      })
-
-      await expect(getRoutes(client, request)).rejects.toThrow(
-        'Invalid routes request.'
-      )
-      expect(mockedFetch).toHaveBeenCalledTimes(0)
-    })
-
-    it('should throw Error because of invalid toChainId type', async () => {
-      const request = getRoutesRequest({
-        toChainId: 'xxx' as unknown as ChainId,
-      })
-
-      await expect(getRoutes(client, request)).rejects.toThrow(
-        'Invalid routes request.'
-      )
-      expect(mockedFetch).toHaveBeenCalledTimes(0)
-    })
-
-    it('should throw Error because of invalid toTokenAddress type', async () => {
-      const request = getRoutesRequest({ toTokenAddress: '' })
-
-      await expect(getRoutes(client, request)).rejects.toThrow(
-        'Invalid routes request.'
-      )
-      expect(mockedFetch).toHaveBeenCalledTimes(0)
-    })
-
-    it('should throw Error because of invalid options type', async () => {
-      const request = getRoutesRequest({
-        options: { slippage: 'not a number' as unknown as number },
-      })
-
-      await expect(getRoutes(client, request)).rejects.toThrow(
-        'Invalid routes request.'
-      )
-      expect(mockedFetch).toHaveBeenCalledTimes(0)
-    })
-  })
-
-  describe('user input is valid', () => {
-    describe('and the backend call is successful', () => {
-      it('call the server once', async () => {
-        const request = getRoutesRequest({})
-        await getRoutes(client, request)
-        expect(mockedFetch).toHaveBeenCalledTimes(1)
-      })
-    })
-  })
-})

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

@@ -1,53 +0,0 @@
-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 { getStatus } from './getStatus.js'
-
-const mockedFetch = vi.spyOn(request, 'request')
-
-describe('getStatus', () => {
-  setupTestServer()
-
-  const fromChain = ChainId.DAI
-  const toChain = ChainId.POL
-  const txHash = 'some tx hash'
-  const bridge = 'some bridge tool'
-
-  describe('user input is invalid', () => {
-    it('throw an error', async () => {
-      await expect(
-        getStatus(client, {
-          bridge,
-          fromChain,
-          toChain,
-          txHash: undefined as unknown as string,
-        })
-      ).rejects.toThrowError(
-        new SDKError(
-          new ValidationError(
-            'Either "taskId" or "txHash" must be provided and non-empty.'
-          )
-        )
-      )
-
-      expect(mockedFetch).toHaveBeenCalledTimes(0)
-    })
-  })
-
-  describe('user input is valid', () => {
-    describe('and the backend call is successful', () => {
-      it('call the server once', async () => {
-        await getStatus(client, {
-          bridge,
-          fromChain,
-          toChain,
-          txHash,
-        })
-        expect(mockedFetch).toHaveBeenCalledTimes(1)
-      })
-    })
-  })
-})

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

@@ -1,140 +0,0 @@
-import { findDefaultToken } from '@lifi/data-types'
-import type { Action, Estimate, LiFiStep, StepTool, Token } from '@lifi/types'
-import { ChainId, CoinKey } from '@lifi/types'
-import { describe, expect, it, vi } from 'vitest'
-import * as request from '../utils/request.js'
-import { client, setupTestServer } from './actions.unit.handlers.js'
-import { getStepTransaction } from './getStepTransaction.js'
-
-const mockedFetch = vi.spyOn(request, 'request')
-
-describe('getStepTransaction', () => {
-  setupTestServer()
-
-  const getAction = ({
-    fromChainId = ChainId.BSC,
-    fromAmount = '10000000000000',
-    fromToken = findDefaultToken(CoinKey.USDC, ChainId.BSC),
-    fromAddress = 'some from address', // we don't validate the format of addresses atm
-    toChainId = ChainId.DAI,
-    toToken = findDefaultToken(CoinKey.USDC, ChainId.DAI),
-    toAddress = 'some to address',
-    slippage = 0.03,
-  }): Action => ({
-    fromChainId,
-    fromAmount,
-    fromToken: fromToken as Token,
-    fromAddress,
-    toChainId,
-    toToken: toToken as Token,
-    toAddress,
-    slippage,
-  })
-
-  const getEstimate = ({
-    fromAmount = '10000000000000',
-    toAmount = '10000000000000',
-    toAmountMin = '999999999999',
-    approvalAddress = 'some approval address', // we don't validate the format of addresses atm;
-    executionDuration = 300,
-    tool = '1inch',
-  }): Estimate => ({
-    fromAmount,
-    toAmount,
-    toAmountMin,
-    approvalAddress,
-    executionDuration,
-    tool,
-  })
-
-  const getStep = ({
-    id = 'some random id',
-    type = 'lifi',
-    tool = 'some swap tool',
-    action = getAction({}),
-    estimate = getEstimate({}),
-  }: {
-    id?: string
-    type?: 'lifi'
-    tool?: StepTool
-    action?: Action
-    estimate?: Estimate
-  }): LiFiStep => ({
-    id,
-    type,
-    tool,
-    toolDetails: {
-      key: tool,
-      name: tool,
-      logoURI: '',
-    },
-    action,
-    estimate,
-    includedSteps: [],
-  })
-
-  describe('with a swap step', () => {
-    // While the validation fails for some users we should not enforce it
-    describe.skip('user input is invalid', () => {
-      it('should throw Error because of invalid id', async () => {
-        const step = getStep({ id: null as unknown as string })
-
-        await expect(getStepTransaction(client, step)).rejects.toThrow(
-          'Invalid step.'
-        )
-        expect(mockedFetch).toHaveBeenCalledTimes(0)
-      })
-
-      it('should throw Error because of invalid type', async () => {
-        const step = getStep({ type: 42 as unknown as 'lifi' })
-
-        await expect(getStepTransaction(client, step)).rejects.toThrow(
-          'Invalid Step'
-        )
-        expect(mockedFetch).toHaveBeenCalledTimes(0)
-      })
-
-      it('should throw Error because of invalid tool', async () => {
-        const step = getStep({ tool: null as unknown as StepTool })
-
-        await expect(getStepTransaction(client, step)).rejects.toThrow(
-          'Invalid step.'
-        )
-        expect(mockedFetch).toHaveBeenCalledTimes(0)
-      })
-
-      // more indepth checks for the action type should be done once we have real schema validation
-      it('should throw Error because of invalid action', async () => {
-        const step = getStep({ action: 'xxx' as unknown as Action })
-
-        await expect(getStepTransaction(client, step)).rejects.toThrow(
-          'Invalid step.'
-        )
-        expect(mockedFetch).toHaveBeenCalledTimes(0)
-      })
-
-      // more indepth checks for the estimate type should be done once we have real schema validation
-      it('should throw Error because of invalid estimate', async () => {
-        const step = getStep({
-          estimate: 'Is this really an estimate?' as unknown as Estimate,
-        })
-
-        await expect(getStepTransaction(client, step)).rejects.toThrow(
-          'Invalid step.'
-        )
-        expect(mockedFetch).toHaveBeenCalledTimes(0)
-      })
-    })
-
-    describe('user input is valid', () => {
-      describe('and the backend call is successful', () => {
-        it('call the server once', async () => {
-          const step = getStep({})
-
-          await getStepTransaction(client, step)
-          expect(mockedFetch).toHaveBeenCalledTimes(1)
-        })
-      })
-    })
-  })
-})

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

@@ -1,45 +0,0 @@
-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 { getToken } from './getToken.js'
-
-const mockedFetch = vi.spyOn(request, 'request')
-
-describe('getToken', () => {
-  setupTestServer()
-
-  describe('user input is invalid', () => {
-    it('throw an error', async () => {
-      await expect(
-        getToken(client, undefined as unknown as ChainId, 'DAI')
-      ).rejects.toThrowError(
-        new SDKError(
-          new ValidationError('Required parameter "chain" is missing.')
-        )
-      )
-      expect(mockedFetch).toHaveBeenCalledTimes(0)
-
-      await expect(
-        getToken(client, ChainId.ETH, undefined as unknown as string)
-      ).rejects.toThrowError(
-        new SDKError(
-          new ValidationError('Required parameter "token" 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 getToken(client, ChainId.DAI, 'DAI')
-
-        expect(mockedFetch).toHaveBeenCalledTimes(1)
-      })
-    })
-  })
-})

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

@@ -1,61 +0,0 @@
-import { findDefaultToken } from '@lifi/data-types'
-import type { Token } from '@lifi/types'
-import { ChainId, CoinKey } from '@lifi/types'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { client } from './actions.unit.handlers.js'
-import { getTokenBalance } from './getTokenBalance.js'
-
-const mockedGetTokenBalance = vi.spyOn(
-  await import('./getTokenBalance.js'),
-  'getTokenBalance'
-)
-
-describe('getTokenBalance', () => {
-  beforeEach(() => {
-    vi.clearAllMocks()
-  })
-
-  const SOME_TOKEN = {
-    ...findDefaultToken(CoinKey.USDC, ChainId.DAI),
-    priceUSD: '',
-  }
-  const SOME_WALLET_ADDRESS = 'some wallet address'
-
-  describe('user input is invalid', () => {
-    it('should throw Error because of missing walletAddress', async () => {
-      await expect(getTokenBalance(client, '', SOME_TOKEN)).rejects.toThrow(
-        'Missing walletAddress.'
-      )
-    })
-
-    it('should throw Error because of invalid token', async () => {
-      await expect(
-        getTokenBalance(client, SOME_WALLET_ADDRESS, {
-          address: 'some wrong stuff',
-          chainId: 'not a chain Id',
-        } as unknown as Token)
-      ).rejects.toThrow('Invalid tokens passed.')
-    })
-  })
-
-  describe('user input is valid', () => {
-    it('should call the balance service', async () => {
-      const balanceResponse = {
-        ...SOME_TOKEN,
-        amount: 123n,
-        blockNumber: 1n,
-      }
-
-      mockedGetTokenBalance.mockReturnValue(Promise.resolve(balanceResponse))
-
-      const result = await getTokenBalance(
-        client,
-        SOME_WALLET_ADDRESS,
-        SOME_TOKEN
-      )
-
-      expect(mockedGetTokenBalance).toHaveBeenCalledTimes(1)
-      expect(result).toEqual(balanceResponse)
-    })
-  })
-})

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

@@ -1,68 +0,0 @@
-import { findDefaultToken } from '@lifi/data-types'
-import type { Token } from '@lifi/types'
-import { ChainId, CoinKey } from '@lifi/types'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { client } from './actions.unit.handlers.js'
-import { getTokenBalances } from './getTokenBalances.js'
-
-const mockedGetTokenBalances = vi.spyOn(
-  await import('./getTokenBalances.js'),
-  'getTokenBalances'
-)
-
-describe('getTokenBalances', () => {
-  beforeEach(() => {
-    vi.clearAllMocks()
-  })
-
-  const SOME_TOKEN = {
-    ...findDefaultToken(CoinKey.USDC, ChainId.DAI),
-    priceUSD: '',
-  }
-  const SOME_WALLET_ADDRESS = 'some wallet address'
-
-  describe('user input is invalid', () => {
-    it('should throw Error because of missing walletAddress', async () => {
-      await expect(getTokenBalances(client, '', [SOME_TOKEN])).rejects.toThrow(
-        'Missing walletAddress.'
-      )
-    })
-
-    it('should throw Error because of an invalid token', async () => {
-      await expect(
-        getTokenBalances(client, SOME_WALLET_ADDRESS, [
-          SOME_TOKEN,
-          { not: 'a token' } as unknown as Token,
-        ])
-      ).rejects.toThrow('Invalid tokens passed.')
-    })
-
-    it('should return empty token list as it is', async () => {
-      mockedGetTokenBalances.mockReturnValue(Promise.resolve([]))
-      const result = await getTokenBalances(client, SOME_WALLET_ADDRESS, [])
-      expect(result).toEqual([])
-      expect(mockedGetTokenBalances).toHaveBeenCalledTimes(1)
-    })
-  })
-
-  describe('user input is valid', () => {
-    it('should call the balance service', async () => {
-      const balanceResponse = [
-        {
-          ...SOME_TOKEN,
-          amount: 123n,
-          blockNumber: 1n,
-        },
-      ]
-
-      mockedGetTokenBalances.mockReturnValue(Promise.resolve(balanceResponse))
-
-      const result = await getTokenBalances(client, SOME_WALLET_ADDRESS, [
-        SOME_TOKEN,
-      ])
-
-      expect(mockedGetTokenBalances).toHaveBeenCalledTimes(1)
-      expect(result).toEqual(balanceResponse)
-    })
-  })
-})