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

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

@@ -1,108 +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 { getTokenBalancesByChain } from './getTokenBalancesByChain.js'
-
-const mockedGetTokenBalancesForChains = vi.spyOn(
-  await import('./getTokenBalancesByChain.js'),
-  'getTokenBalancesByChain'
-)
-
-describe('getTokenBalancesByChain', () => {
-  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(
-        getTokenBalancesByChain(client, '', {
-          [ChainId.DAI]: [SOME_TOKEN],
-        })
-      ).rejects.toThrow('Missing walletAddress.')
-    })
-
-    it('should throw Error because of an invalid token', async () => {
-      await expect(
-        getTokenBalancesByChain(client, SOME_WALLET_ADDRESS, {
-          [ChainId.DAI]: [{ not: 'a token' } as unknown as Token],
-        })
-      ).rejects.toThrow('Invalid tokens passed.')
-    })
-
-    it('should return empty token list as it is', async () => {
-      mockedGetTokenBalancesForChains.mockReturnValue(Promise.resolve([]))
-
-      const result = await getTokenBalancesByChain(
-        client,
-        SOME_WALLET_ADDRESS,
-        {
-          [ChainId.DAI]: [],
-        }
-      )
-
-      expect(result).toEqual([])
-      expect(mockedGetTokenBalancesForChains).toHaveBeenCalledTimes(1)
-    })
-  })
-
-  describe('user input is valid', () => {
-    it('should call the balance service', async () => {
-      const balanceResponse = {
-        [ChainId.DAI]: [
-          {
-            ...SOME_TOKEN,
-            amount: 123n,
-            blockNumber: 1n,
-          },
-        ],
-      }
-
-      mockedGetTokenBalancesForChains.mockReturnValue(
-        Promise.resolve(balanceResponse)
-      )
-
-      const result = await getTokenBalancesByChain(
-        client,
-        SOME_WALLET_ADDRESS,
-        {
-          [ChainId.DAI]: [SOME_TOKEN],
-        }
-      )
-
-      expect(mockedGetTokenBalancesForChains).toHaveBeenCalledTimes(1)
-      expect(result).toEqual(balanceResponse)
-    })
-  })
-
-  describe('provider is not the same as the chain type', () => {
-    it('should return the tokens as is', async () => {
-      const balanceResponse = {
-        [ChainId.DAI]: [SOME_TOKEN],
-      }
-
-      mockedGetTokenBalancesForChains.mockReturnValue(
-        Promise.resolve(balanceResponse)
-      )
-
-      const result = await getTokenBalancesByChain(
-        client,
-        SOME_WALLET_ADDRESS,
-        {
-          [ChainId.DAI]: [SOME_TOKEN],
-        }
-      )
-
-      expect(mockedGetTokenBalancesForChains).toHaveBeenCalledTimes(1)
-      expect(result).toEqual(balanceResponse)
-    })
-  })
-})

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

@@ -1,16 +0,0 @@
-import { ChainId } from '@lifi/types'
-import { describe, expect, it } from 'vitest'
-import { client, setupTestServer } from './actions.unit.handlers.js'
-import { getTokens } from './getTokens.js'
-
-describe('getTokens', () => {
-  setupTestServer()
-
-  it('return the tokens', async () => {
-    const result = await getTokens(client, {
-      chains: [ChainId.ETH, ChainId.POL],
-    })
-    expect(result).toBeDefined()
-    expect(result.tokens[ChainId.ETH]).toBeDefined()
-  })
-})

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

@@ -1,20 +0,0 @@
-import { ChainId } from '@lifi/types'
-import { describe, expect, it } from 'vitest'
-import { client, setupTestServer } from './actions.unit.handlers.js'
-import { getTools } from './getTools.js'
-
-describe('getTools', () => {
-  setupTestServer()
-
-  describe('and the backend succeeds', () => {
-    it('returns the tools', async () => {
-      const tools = await getTools(client, {
-        chains: [ChainId.ETH, ChainId.POL],
-      })
-
-      expect(tools).toBeDefined()
-      expect(tools.bridges).toBeDefined()
-      expect(tools.exchanges).toBeDefined()
-    })
-  })
-})

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

@@ -1,36 +0,0 @@
-import type { TransactionAnalyticsRequest } from '@lifi/types'
-import { HttpResponse, http } from 'msw'
-import { describe, expect, it, vi } from 'vitest'
-import * as request from '../utils/request.js'
-import { client, setupTestServer } from './actions.unit.handlers.js'
-import { getTransactionHistory } from './getTransactionHistory.js'
-
-const mockedFetch = vi.spyOn(request, 'request')
-
-describe('getTransactionHistory', () => {
-  const server = setupTestServer()
-
-  it('returns empty array in response', async () => {
-    server.use(
-      http.get(`${client.config.apiUrl}/analytics/transfers`, async () =>
-        HttpResponse.json({})
-      )
-    )
-
-    const walletAnalyticsRequest: TransactionAnalyticsRequest = {
-      fromTimestamp: 1696326609361,
-      toTimestamp: 1696326609362,
-      wallet: '0x5520abcd',
-    }
-
-    const generatedURL =
-      'https://li.quest/v1/analytics/transfers?integrator=lifi-sdk&wallet=0x5520abcd&fromTimestamp=1696326609361&toTimestamp=1696326609362'
-
-    await expect(
-      getTransactionHistory(client, walletAnalyticsRequest)
-    ).resolves.toEqual({})
-
-    expect((mockedFetch.mock.calls[0][1] as URL).href).toEqual(generatedURL)
-    expect(mockedFetch).toHaveBeenCalledOnce()
-  })
-})

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

@@ -1,90 +0,0 @@
-import { findDefaultToken } from '@lifi/data-types'
-import type { WalletTokenExtended } 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 { getWalletBalances } from './getWalletBalances.js'
-
-const mockedGetWalletBalances = vi.spyOn(
-  await import('./getWalletBalances.js'),
-  'getWalletBalances'
-)
-
-describe('getWalletBalances', () => {
-  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(getWalletBalances(client, '')).rejects.toThrow(
-        'Missing walletAddress.'
-      )
-    })
-  })
-
-  describe('user input is valid', () => {
-    it('should call the balance service without options', async () => {
-      const balanceResponse: Record<number, WalletTokenExtended[]> = {
-        [ChainId.DAI]: [
-          {
-            ...SOME_TOKEN,
-            amount: '123',
-            marketCapUSD: 1000000,
-            volumeUSD24H: 50000,
-            fdvUSD: 2000000,
-          },
-        ],
-      }
-
-      mockedGetWalletBalances.mockReturnValue(Promise.resolve(balanceResponse))
-
-      const result = await getWalletBalances(client, SOME_WALLET_ADDRESS)
-
-      expect(mockedGetWalletBalances).toHaveBeenCalledTimes(1)
-      expect(mockedGetWalletBalances).toHaveBeenCalledWith(
-        client,
-        SOME_WALLET_ADDRESS
-      )
-      expect(result).toEqual(balanceResponse)
-    })
-
-    it('should call the balance service with options', async () => {
-      const balanceResponse: Record<number, WalletTokenExtended[]> = {
-        [ChainId.DAI]: [
-          {
-            ...SOME_TOKEN,
-            amount: '123',
-            marketCapUSD: 1000000,
-            volumeUSD24H: 50000,
-            fdvUSD: 2000000,
-          },
-        ],
-      }
-
-      const options = { signal: new AbortController().signal }
-
-      mockedGetWalletBalances.mockReturnValue(Promise.resolve(balanceResponse))
-
-      const result = await getWalletBalances(
-        client,
-        SOME_WALLET_ADDRESS,
-        options
-      )
-
-      expect(mockedGetWalletBalances).toHaveBeenCalledTimes(1)
-      expect(mockedGetWalletBalances).toHaveBeenCalledWith(
-        client,
-        SOME_WALLET_ADDRESS,
-        options
-      )
-      expect(result).toEqual(balanceResponse)
-    })
-  })
-})

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

@@ -1,229 +0,0 @@
-import type { RelayRequest, RelayResponse, 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 { SDKError } from '../errors/SDKError.js'
-import { client, setupTestServer } from './actions.unit.handlers.js'
-import { relayTransaction } from './relayTransaction.js'
-
-describe('relayTransaction', () => {
-  const server = setupTestServer()
-
-  const createMockRelayRequest = (typedData: any[]): RelayRequest => ({
-    type: 'lifi',
-    id: 'test-step-id',
-    includedSteps: [],
-    tool: 'test-tool',
-    toolDetails: {
-      key: 'test-tool',
-      name: 'Test Tool',
-      logoURI: 'https://example.com/logo.png',
-    },
-    action: {
-      fromChainId: 1,
-      toChainId: 1,
-      fromToken: {
-        address: '0x1234567890123456789012345678901234567890',
-        symbol: 'TEST',
-        decimals: 18,
-        chainId: 1,
-        name: 'Test Token',
-        priceUSD: '1.00',
-      },
-      toToken: {
-        address: '0x0987654321098765432109876543210987654321',
-        symbol: 'TEST2',
-        decimals: 18,
-        chainId: 1,
-        name: 'Test Token 2',
-        priceUSD: '1.00',
-      },
-      fromAmount: '1000000000000000000',
-    },
-    estimate: {
-      fromAmount: '1000000000000000000',
-      toAmount: '1000000000000000000',
-      toAmountMin: '1000000000000000000',
-      approvalAddress: '0x1234567890123456789012345678901234567890',
-      tool: 'test-tool',
-      executionDuration: 30000,
-    },
-    transactionRequest: {
-      to: '0x1234567890123456789012345678901234567890',
-      data: '0x',
-      value: '0',
-      gasLimit: '100000',
-    },
-    typedData,
-  })
-
-  const mockRelayRequest: RelayRequest = createMockRelayRequest([
-    {
-      domain: {
-        name: 'Test Token',
-        version: '1',
-        chainId: 1,
-        verifyingContract: '0x1234567890123456789012345678901234567890',
-      },
-      types: {
-        Permit: [
-          { name: 'owner', type: 'address' },
-          { name: 'spender', type: 'address' },
-          { name: 'value', type: 'uint256' },
-          { name: 'nonce', type: 'uint256' },
-          { name: 'deadline', type: 'uint256' },
-        ],
-      },
-      primaryType: 'Permit',
-      message: {
-        owner: '0x1234567890123456789012345678901234567890',
-        spender: '0x0987654321098765432109876543210987654321',
-        value: '1000000000000000000',
-        nonce: 0,
-        deadline: 1234567890,
-      },
-      signature:
-        '0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef12',
-    },
-  ])
-
-  const mockRelayRequestWithPermitWitness: RelayRequest =
-    createMockRelayRequest([
-      {
-        domain: {
-          name: 'Test Token',
-          version: '1',
-          chainId: 1,
-          verifyingContract: '0x1234567890123456789012345678901234567890',
-        },
-        types: {
-          PermitWitnessTransferFrom: [
-            { name: 'owner', type: 'address' },
-            { name: 'spender', type: 'address' },
-            { name: 'value', type: 'uint256' },
-            { name: 'nonce', type: 'uint256' },
-            { name: 'deadline', type: 'uint256' },
-          ],
-        },
-        primaryType: 'PermitWitnessTransferFrom',
-        message: {
-          owner: '0x1234567890123456789012345678901234567890',
-          spender: '0x0987654321098765432109876543210987654321',
-          value: '1000000000000000000',
-          nonce: 0,
-          deadline: 1234567890,
-        },
-        signature:
-          '0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef12',
-      },
-    ])
-
-  const mockSuccessResponse: RelayResponse = {
-    status: 'ok',
-    data: {
-      taskId: 'test-task-id-123',
-    },
-  }
-
-  const mockErrorResponse: RelayResponse = {
-    status: 'error',
-    data: {
-      code: 400,
-      message: 'Invalid request parameters',
-    },
-  }
-
-  describe('success scenarios', () => {
-    it('should relay transaction successfully for advanced relayer', async () => {
-      server.use(
-        http.post(`${client.config.apiUrl}/advanced/relay`, async () => {
-          return HttpResponse.json(mockSuccessResponse)
-        })
-      )
-
-      const result = await relayTransaction(client, mockRelayRequest)
-
-      expect(result).toEqual(mockSuccessResponse.data)
-    })
-
-    it('should relay transaction successfully for gasless relayer', async () => {
-      server.use(
-        http.post(`${client.config.apiUrl}/relayer/relay`, async () => {
-          return HttpResponse.json(mockSuccessResponse)
-        })
-      )
-
-      const result = await relayTransaction(
-        client,
-        mockRelayRequestWithPermitWitness
-      )
-
-      expect(result).toEqual(mockSuccessResponse.data)
-    })
-  })
-
-  describe('error scenarios', () => {
-    it('should throw BaseError when server returns error status', async () => {
-      server.use(
-        http.post(`${client.config.apiUrl}/advanced/relay`, async () => {
-          return HttpResponse.json(mockErrorResponse)
-        })
-      )
-
-      await expect(relayTransaction(client, mockRelayRequest)).rejects.toThrow(
-        BaseError
-      )
-
-      try {
-        await relayTransaction(client, mockRelayRequest)
-      } 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.post(`${client.config.apiUrl}/advanced/relay`, async () => {
-          return HttpResponse.error()
-        })
-      )
-
-      await expect(relayTransaction(client, mockRelayRequest)).rejects.toThrow(
-        SDKError
-      )
-    })
-
-    it('should throw SDKError when request times out', async () => {
-      server.use(
-        http.post(`${client.config.apiUrl}/advanced/relay`, async () => {
-          // Simulate timeout by not responding
-          await new Promise(() => {}) // Never resolves
-        })
-      )
-
-      const timeoutOptions: RequestOptions = {
-        signal: AbortSignal.timeout(100), // 100ms timeout
-      }
-
-      await expect(
-        relayTransaction(client, mockRelayRequest, timeoutOptions)
-      ).rejects.toThrow()
-    })
-  })
-
-  describe('validation scenarios', () => {
-    it('should throw SDKError when typedData is missing', async () => {
-      const invalidRequest = createMockRelayRequest([])
-      // Remove typedData to test validation
-      delete (invalidRequest as any).typedData
-
-      await expect(relayTransaction(client, invalidRequest)).rejects.toThrow(
-        SDKError
-      )
-    })
-  })
-})