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

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

@@ -1,169 +0,0 @@
-import type { ChainType } from '@lifi/types'
-import { describe, expect, it, vi } from 'vitest'
-import { client } from './actions.unit.handlers.js'
-import { getNameServiceAddress } from './getNameServiceAddress.js'
-
-// Mock providers locally
-const createMockProvider = (type: ChainType, resolveAddressMock: any) => ({
-  type,
-  resolveAddress: resolveAddressMock,
-  isAddress: vi.fn(),
-  getBalance: vi.fn(),
-  getStepExecutor: vi.fn(),
-  setOptions: vi.fn(),
-})
-
-const EVM = (_options: any) => createMockProvider('EVM' as ChainType, vi.fn())
-const Solana = (_options: any) =>
-  createMockProvider('SVM' as ChainType, vi.fn())
-const UTXO = (_options: any) => createMockProvider('UTXO' as ChainType, vi.fn())
-
-describe('getNameServiceAddress', () => {
-  describe('success scenarios', () => {
-    it('should resolve address successfully with single provider', async () => {
-      const mockResolveAddress = vi
-        .fn()
-        .mockResolvedValue('0x1234567890123456789012345678901234567890')
-
-      const provider = EVM({ getWalletClient: vi.fn() })
-      vi.spyOn(provider, 'resolveAddress').mockImplementation(
-        mockResolveAddress
-      )
-
-      client.setProviders([provider])
-
-      const result = await getNameServiceAddress(client, 'test.eth')
-
-      expect(result).toBe('0x1234567890123456789012345678901234567890')
-      expect(mockResolveAddress).toHaveBeenCalledWith('test.eth', client)
-    })
-
-    it('should resolve address successfully with multiple providers', async () => {
-      const mockResolveAddress1 = vi
-        .fn()
-        .mockResolvedValue('0x1111111111111111111111111111111111111111')
-      const mockResolveAddress2 = vi
-        .fn()
-        .mockResolvedValue('0x2222222222222222222222222222222222222222')
-
-      const provider1 = EVM({ getWalletClient: vi.fn() })
-      const provider2 = Solana({ getWalletAdapter: vi.fn() })
-
-      vi.spyOn(provider1, 'resolveAddress').mockImplementation(
-        mockResolveAddress1
-      )
-      vi.spyOn(provider2, 'resolveAddress').mockImplementation(
-        mockResolveAddress2
-      )
-
-      client.setProviders([provider1, provider2])
-
-      const result = await getNameServiceAddress(client, 'test.sol')
-
-      // Should return the first successful result
-      expect(result).toBe('0x1111111111111111111111111111111111111111')
-      expect(mockResolveAddress1).toHaveBeenCalledWith('test.sol', client)
-    })
-
-    it('should resolve address with specific chain type', async () => {
-      const mockResolveAddress = vi
-        .fn()
-        .mockResolvedValue('0x1234567890123456789012345678901234567890')
-
-      const evmProvider = EVM({ getWalletClient: vi.fn() })
-      const svmProvider = Solana({ getWalletAdapter: vi.fn() })
-
-      vi.spyOn(evmProvider, 'resolveAddress').mockImplementation(
-        mockResolveAddress
-      )
-
-      client.setProviders([evmProvider, svmProvider])
-
-      const result = await getNameServiceAddress(
-        client,
-        'test.eth',
-        'EVM' as ChainType
-      )
-
-      expect(result).toBe('0x1234567890123456789012345678901234567890')
-      expect(mockResolveAddress).toHaveBeenCalledWith('test.eth', client)
-    })
-  })
-
-  describe('chain type filtering', () => {
-    it('should filter providers by chain type', async () => {
-      const mockResolveAddress = vi
-        .fn()
-        .mockResolvedValue('0x1234567890123456789012345678901234567890')
-
-      const evmProvider = EVM({ getWalletClient: vi.fn() })
-      const svmProvider = Solana({ getWalletAdapter: vi.fn() })
-      const utxoProvider = UTXO({ getWalletClient: vi.fn() })
-
-      vi.spyOn(evmProvider, 'resolveAddress').mockImplementation(
-        mockResolveAddress
-      )
-
-      client.setProviders([evmProvider, svmProvider, utxoProvider])
-
-      const result = await getNameServiceAddress(
-        client,
-        'test.eth',
-        'EVM' as ChainType
-      )
-
-      expect(result).toBe('0x1234567890123456789012345678901234567890')
-      expect(mockResolveAddress).toHaveBeenCalledWith('test.eth', client)
-    })
-
-    it('should return undefined when no providers match chain type', async () => {
-      const mockResolveAddress = vi
-        .fn()
-        .mockResolvedValue('0x1234567890123456789012345678901234567890')
-      const evmProvider = EVM({ getWalletClient: vi.fn() })
-      client.setProviders([evmProvider])
-
-      const result = await getNameServiceAddress(
-        client,
-        'test.name',
-        'SVM' as ChainType
-      )
-
-      expect(result).toBeUndefined()
-      expect(mockResolveAddress).not.toHaveBeenCalled()
-    })
-  })
-
-  describe('error scenarios', () => {
-    it('should handle mixed success and failure scenarios', async () => {
-      const mockResolveAddress1 = vi
-        .fn()
-        .mockRejectedValue(new Error('Provider 1 failed'))
-      const mockResolveAddress2 = vi
-        .fn()
-        .mockResolvedValue('0x2222222222222222222222222222222222222222')
-      const mockResolveAddress3 = vi.fn().mockResolvedValue(undefined)
-
-      const provider1 = EVM({ getWalletClient: vi.fn() })
-      const provider2 = Solana({ getWalletAdapter: vi.fn() })
-      const provider3 = UTXO({ getWalletClient: vi.fn() })
-
-      vi.spyOn(provider1, 'resolveAddress').mockImplementation(
-        mockResolveAddress1
-      )
-      vi.spyOn(provider2, 'resolveAddress').mockImplementation(
-        mockResolveAddress2
-      )
-      vi.spyOn(provider3, 'resolveAddress').mockImplementation(
-        mockResolveAddress3
-      )
-
-      client.setProviders([provider1, provider2, provider3])
-
-      const result = await getNameServiceAddress(client, 'test.name')
-
-      // Should return the first successful result (provider2)
-      expect(result).toBe('0x2222222222222222222222222222222222222222')
-    })
-  })
-})

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

@@ -1,18 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { client } from './actions.unit.handlers.js'
-import { getQuote } from './getQuote.js'
-
-describe('ApiService Integration Tests', () => {
-  it('should successfully request a quote', async () => {
-    const quote = await getQuote(client, {
-      fromChain: '1',
-      fromToken: '0x0000000000000000000000000000000000000000',
-      fromAddress: '0x552008c0f6870c2f77e5cC1d2eb9bdff03e30Ea0',
-      fromAmount: '1000000000000000000',
-      toChain: '137',
-      toToken: '0x0000000000000000000000000000000000000000',
-      // allowBridges: ['hop', 'multichain'],
-    })
-    expect(quote).toBeDefined()
-  }, 100000)
-})

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

@@ -1,154 +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 { 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.unit.spec.ts

@@ -1,243 +0,0 @@
-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()
-    })
-  })
-})