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

package/src/client/createClient.unit.spec.ts

@@ -1,274 +0,0 @@
-import { ChainId, ChainType } from '@lifi/types'
-import { describe, expect, it, vi } from 'vitest'
-import type { SDKConfig } from '../types/core.js'
-import { createClient } from './createClient.js'
-
-// Mock providers locally
-const createMockProvider = (type: ChainType) => ({
-  type,
-  resolveAddress: vi.fn(),
-  isAddress: vi.fn(),
-  getBalance: vi.fn(),
-  getStepExecutor: vi.fn(),
-  setOptions: vi.fn(),
-})
-
-const EVM = (_options?: any) => createMockProvider('EVM' as ChainType)
-const Solana = (_options?: any) => createMockProvider('SVM' as ChainType)
-const UTXO = (_options?: any) => createMockProvider('UTXO' as ChainType)
-
-// Mock the version check
-vi.mock('../utils/checkPackageUpdates.js', () => ({
-  checkPackageUpdates: vi.fn(),
-}))
-
-// Mock the client storage
-vi.mock('./getClientStorage.js', () => ({
-  getClientStorage: vi.fn(() => ({
-    getChains: vi.fn().mockResolvedValue([
-      { id: 1, name: 'Ethereum', type: ChainType.EVM },
-      { id: 137, name: 'Polygon', type: ChainType.EVM },
-    ]),
-    getRpcUrls: vi.fn().mockResolvedValue({
-      [ChainId.ETH]: ['https://eth-mainnet.alchemyapi.io/v2/test'],
-      [ChainId.POL]: ['https://polygon-rpc.com'],
-    }),
-  })),
-}))
-
-describe('createClient', () => {
-  describe('basic functionality', () => {
-    it('should create a client with minimal config', () => {
-      const client = createClient({
-        integrator: 'test-app',
-      })
-
-      expect(client).toBeDefined()
-      expect(client.config.integrator).toBe('test-app')
-      expect(client.config.apiUrl).toBe('https://li.quest/v1')
-      expect(client.config.debug).toBe(false)
-      expect(client.providers).toEqual([])
-    })
-
-    it('should create a client with full config', () => {
-      const config: SDKConfig = {
-        integrator: 'test-app',
-        apiKey: 'test-api-key',
-        apiUrl: 'https://custom-api.com',
-        userId: 'user-123',
-        debug: true,
-        disableVersionCheck: true,
-        widgetVersion: '1.0.0',
-        rpcUrls: {
-          [ChainId.ETH]: ['https://eth-mainnet.alchemyapi.io/v2/test'],
-        },
-      }
-
-      const client = createClient(config)
-
-      expect(client.config).toEqual({
-        integrator: 'test-app',
-        apiKey: 'test-api-key',
-        apiUrl: 'https://custom-api.com',
-        userId: 'user-123',
-        debug: true,
-        disableVersionCheck: true,
-        widgetVersion: '1.0.0',
-        rpcUrls: {
-          [ChainId.ETH]: ['https://eth-mainnet.alchemyapi.io/v2/test'],
-        },
-      })
-    })
-
-    it('should throw error when integrator is missing', () => {
-      expect(() => {
-        createClient({} as SDKConfig)
-      }).toThrow(
-        'Integrator not found. Please see documentation https://docs.li.fi/integrate-li.fi-js-sdk/set-up-the-sdk'
-      )
-    })
-
-    it('should throw error when integrator is empty string', () => {
-      expect(() => {
-        createClient({ integrator: '' })
-      }).toThrow(
-        'Integrator not found. Please see documentation https://docs.li.fi/integrate-li.fi-js-sdk/set-up-the-sdk'
-      )
-    })
-  })
-
-  describe('provider management', () => {
-    it('should handle empty providers list', () => {
-      const client = createClient({ integrator: 'test-app' })
-      expect(client.providers).toEqual([])
-      expect(client.getProvider(ChainType.EVM)).toBeUndefined()
-    })
-
-    it('should set and get providers', () => {
-      const client = createClient({ integrator: 'test-app' })
-      const evmProvider = EVM()
-      const solanaProvider = Solana()
-
-      client.setProviders([evmProvider, solanaProvider])
-
-      expect(client.providers).toHaveLength(2)
-      expect(client.getProvider(ChainType.EVM)).toBe(evmProvider)
-      expect(client.getProvider(ChainType.SVM)).toBe(solanaProvider)
-      expect(client.getProvider(ChainType.UTXO)).toBeUndefined()
-    })
-
-    it('should merge providers when setting new ones', () => {
-      const client = createClient({ integrator: 'test-app' })
-      const evmProvider = EVM()
-      const utxoProvider = UTXO()
-
-      client.setProviders([evmProvider])
-      expect(client.providers).toHaveLength(1)
-
-      client.setProviders([utxoProvider])
-      expect(client.providers).toHaveLength(2)
-      expect(client.getProvider(ChainType.EVM)).toBe(evmProvider)
-      expect(client.getProvider(ChainType.UTXO)).toBe(utxoProvider)
-    })
-
-    it('should merge providers when setting overlapping types', () => {
-      const client = createClient({ integrator: 'test-app' })
-      const evmProvider1 = EVM()
-      const evmProvider2 = EVM()
-      const solanaProvider = Solana()
-
-      client.setProviders([evmProvider1])
-      client.setProviders([evmProvider2, solanaProvider])
-
-      expect(client.providers).toHaveLength(2)
-      expect(client.getProvider(ChainType.EVM)).toBe(evmProvider2)
-      expect(client.getProvider(ChainType.SVM)).toBe(solanaProvider)
-    })
-  })
-
-  describe('chain management', () => {
-    it('should get chains from storage', async () => {
-      const client = createClient({ integrator: 'test-app' })
-      const chains = await client.getChains()
-
-      expect(chains).toEqual([
-        { id: 1, name: 'Ethereum', type: ChainType.EVM },
-        { id: 137, name: 'Polygon', type: ChainType.EVM },
-      ])
-    })
-
-    it('should get chain by id', async () => {
-      const client = createClient({ integrator: 'test-app' })
-      const chain = await client.getChainById(1)
-
-      expect(chain).toEqual({ id: 1, name: 'Ethereum', type: ChainType.EVM })
-    })
-
-    it('should throw error when chain not found', async () => {
-      const client = createClient({ integrator: 'test-app' })
-
-      await expect(client.getChainById(999)).rejects.toThrow(
-        'ChainId 999 not found'
-      )
-    })
-  })
-
-  describe('RPC URL management', () => {
-    it('should get RPC URLs from storage', async () => {
-      const client = createClient({ integrator: 'test-app' })
-      const rpcUrls = await client.getRpcUrls()
-
-      expect(rpcUrls).toEqual({
-        [ChainId.ETH]: ['https://eth-mainnet.alchemyapi.io/v2/test'],
-        [ChainId.POL]: ['https://polygon-rpc.com'],
-      })
-    })
-
-    it('should get RPC URLs by chain id', async () => {
-      const client = createClient({ integrator: 'test-app' })
-      const ethUrls = await client.getRpcUrlsByChainId(ChainId.ETH)
-      const polUrls = await client.getRpcUrlsByChainId(ChainId.POL)
-
-      expect(ethUrls).toEqual(['https://eth-mainnet.alchemyapi.io/v2/test'])
-      expect(polUrls).toEqual(['https://polygon-rpc.com'])
-    })
-
-    it('should throw error when RPC URLs not found for chain', async () => {
-      const client = createClient({ integrator: 'test-app' })
-
-      await expect(client.getRpcUrlsByChainId(999)).rejects.toThrow(
-        'RPC URL not found for chainId: 999'
-      )
-    })
-  })
-
-  describe('extend functionality', () => {
-    it('should extend client with additional functionality', () => {
-      const client = createClient({ integrator: 'test-app' })
-
-      const extendedClient = (client as any).extend((_baseClient: any) => ({
-        customMethod: () => 'custom-value',
-        anotherMethod: (value: string) => `processed-${value}`,
-      }))
-
-      expect(extendedClient.customMethod()).toBe('custom-value')
-      expect(extendedClient.anotherMethod('test')).toBe('processed-test')
-
-      // Should preserve original functionality
-      expect(extendedClient.config.integrator).toBe('test-app')
-      expect(extendedClient.providers).toEqual([])
-    })
-
-    it('should allow chaining multiple extensions', () => {
-      const client = createClient({ integrator: 'test-app' })
-
-      const extendedClient = (client as any)
-        .extend((_baseClient: any) => ({
-          firstExtension: () => 'first',
-        }))
-        .extend((_baseClient: any) => ({
-          secondExtension: () => 'second',
-        }))
-
-      expect(extendedClient.firstExtension()).toBe('first')
-      expect(extendedClient.secondExtension()).toBe('second')
-      expect(extendedClient.config.integrator).toBe('test-app')
-    })
-
-    it('should preserve extend function after extension', () => {
-      const client = createClient({ integrator: 'test-app' })
-
-      const extendedClient = (client as any).extend((_baseClient: any) => ({
-        customMethod: () => 'custom-value',
-      }))
-
-      expect(typeof extendedClient.extend).toBe('function')
-
-      const doubleExtendedClient = extendedClient.extend(
-        (_baseClient: any) => ({
-          anotherMethod: () => 'another-value',
-        })
-      )
-
-      expect(doubleExtendedClient.customMethod()).toBe('custom-value')
-      expect(doubleExtendedClient.anotherMethod()).toBe('another-value')
-    })
-  })
-
-  describe('error handling', () => {
-    it('should handle storage errors gracefully', async () => {
-      // Mock storage to throw error
-      const { getClientStorage } = await import('./getClientStorage.js')
-      vi.mocked(getClientStorage).mockReturnValueOnce({
-        needReset: false,
-        getChains: vi.fn().mockRejectedValue(new Error('Storage error')),
-        getRpcUrls: vi.fn().mockRejectedValue(new Error('Storage error')),
-      })
-
-      const newClient = createClient({ integrator: 'test-app' })
-
-      await expect(newClient.getChains()).rejects.toThrow('Storage error')
-      await expect(newClient.getRpcUrls()).rejects.toThrow('Storage error')
-    })
-  })
-})

package/src/client/getClientStorage.unit.spec.ts

@@ -1,382 +0,0 @@
-import {
-  ChainId,
-  ChainKey,
-  ChainType,
-  CoinKey,
-  type ExtendedChain,
-} from '@lifi/types'
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import type { RPCUrls, SDKBaseConfig } from '../types/core.js'
-import { getClientStorage } from './getClientStorage.js'
-
-// Mock the dependencies
-vi.mock('../actions/getChains.js', () => ({
-  getChainsFromConfig: vi.fn(),
-}))
-
-vi.mock('../core/utils.js', () => ({
-  getRpcUrlsFromChains: vi.fn(),
-}))
-
-describe('getClientStorage', () => {
-  let mockConfig: SDKBaseConfig
-  let mockChains: ExtendedChain[]
-  let mockRpcUrls: RPCUrls
-
-  beforeEach(() => {
-    mockConfig = {
-      integrator: 'test-app',
-      apiUrl: 'https://li.quest/v1',
-      debug: false,
-      rpcUrls: {
-        [ChainId.ETH]: ['https://eth-mainnet.alchemyapi.io/v2/test'],
-      },
-    }
-
-    mockChains = [
-      {
-        id: ChainId.ETH,
-        name: 'Ethereum',
-        chainType: ChainType.EVM,
-        key: ChainKey.ETH,
-        coin: CoinKey.ETH,
-        mainnet: true,
-        nativeToken: {
-          address: '0x0000000000000000000000000000000000000000',
-          symbol: 'ETH',
-          decimals: 18,
-          name: 'Ethereum',
-          chainId: ChainId.ETH,
-          priceUSD: '0',
-        },
-        metamask: {
-          chainId: '0x1',
-          chainName: 'Ethereum',
-          nativeCurrency: {
-            name: 'Ethereum',
-            symbol: 'ETH',
-            decimals: 18,
-          },
-          rpcUrls: ['https://eth-mainnet.alchemyapi.io/v2/test'],
-          blockExplorerUrls: ['https://etherscan.io'],
-        },
-      },
-      {
-        id: ChainId.POL,
-        name: 'Polygon',
-        chainType: ChainType.EVM,
-        key: ChainKey.POL,
-        coin: CoinKey.MATIC,
-        mainnet: true,
-        nativeToken: {
-          address: '0x0000000000000000000000000000000000000000',
-          symbol: 'MATIC',
-          decimals: 18,
-          name: 'Polygon',
-          chainId: ChainId.POL,
-          priceUSD: '0',
-        },
-        metamask: {
-          chainId: '0x89',
-          chainName: 'Polygon',
-          nativeCurrency: {
-            name: 'Polygon',
-            symbol: 'MATIC',
-            decimals: 18,
-          },
-          rpcUrls: ['https://polygon-rpc.com'],
-          blockExplorerUrls: ['https://polygonscan.com'],
-        },
-      },
-    ]
-
-    mockRpcUrls = {
-      [ChainId.ETH]: ['https://eth-mainnet.alchemyapi.io/v2/test'],
-      [ChainId.POL]: ['https://polygon-rpc.com'],
-    }
-
-    // Reset mocks
-    vi.clearAllMocks()
-  })
-
-  afterEach(() => {
-    vi.restoreAllMocks()
-  })
-
-  describe('needReset property', () => {
-    it('should return true when chainsUpdatedAt is undefined', () => {
-      const storage = getClientStorage(mockConfig)
-      expect(storage.needReset).toBe(true) // Because _chainsUpdatedAt is undefined
-    })
-
-    it('should return true when chains are older than 24 hours', async () => {
-      const { getChainsFromConfig } = await import('../actions/getChains.js')
-      const { getRpcUrlsFromChains } = await import('../core/utils.js')
-
-      vi.mocked(getChainsFromConfig).mockResolvedValue(mockChains)
-      vi.mocked(getRpcUrlsFromChains).mockReturnValue(mockRpcUrls)
-
-      const storage = getClientStorage(mockConfig)
-
-      // First call to getChains sets the timestamp
-      await storage.getChains()
-
-      // Mock Date.now to return a time 25 hours later
-      const originalDateNow = Date.now
-      vi.spyOn(Date, 'now').mockReturnValue(Date.now() + 25 * 60 * 60 * 1000)
-
-      expect(storage.needReset).toBe(true)
-
-      // Restore Date.now
-      Date.now = originalDateNow
-    })
-
-    it('should return false when chains are fresh', async () => {
-      const { getChainsFromConfig } = await import('../actions/getChains.js')
-      const { getRpcUrlsFromChains } = await import('../core/utils.js')
-
-      vi.mocked(getChainsFromConfig).mockResolvedValue(mockChains)
-      vi.mocked(getRpcUrlsFromChains).mockReturnValue(mockRpcUrls)
-
-      const storage = getClientStorage(mockConfig)
-
-      // First call to getChains sets the timestamp
-      await storage.getChains()
-
-      // Should not need reset immediately after
-      expect(storage.needReset).toBe(false)
-    })
-  })
-
-  describe('getChains method', () => {
-    it('should fetch chains when needReset is true', async () => {
-      const { getChainsFromConfig } = await import('../actions/getChains.js')
-      const { getRpcUrlsFromChains } = await import('../core/utils.js')
-
-      vi.mocked(getChainsFromConfig).mockResolvedValue(mockChains)
-      vi.mocked(getRpcUrlsFromChains).mockReturnValue(mockRpcUrls)
-
-      const storage = getClientStorage(mockConfig)
-      const chains = await storage.getChains()
-
-      expect(getChainsFromConfig).toHaveBeenCalledWith(mockConfig, {
-        chainTypes: [
-          ChainType.EVM,
-          ChainType.SVM,
-          ChainType.UTXO,
-          ChainType.MVM,
-        ],
-      })
-      expect(chains).toEqual(mockChains)
-    })
-
-    it('should return cached chains when not needReset and chains exist', async () => {
-      const { getChainsFromConfig } = await import('../actions/getChains.js')
-      const { getRpcUrlsFromChains } = await import('../core/utils.js')
-
-      vi.mocked(getChainsFromConfig).mockResolvedValue(mockChains)
-      vi.mocked(getRpcUrlsFromChains).mockReturnValue(mockRpcUrls)
-
-      const storage = getClientStorage(mockConfig)
-
-      // First call fetches chains
-      const chains1 = await storage.getChains()
-      expect(getChainsFromConfig).toHaveBeenCalledTimes(1)
-
-      // Second call should return cached chains
-      const chains2 = await storage.getChains()
-      expect(getChainsFromConfig).toHaveBeenCalledTimes(1)
-      expect(chains1).toBe(chains2) // Same reference
-    })
-
-    it('should handle errors from getChainsFromConfig', async () => {
-      const { getChainsFromConfig } = await import('../actions/getChains.js')
-
-      const error = new Error('Failed to fetch chains')
-      vi.mocked(getChainsFromConfig).mockRejectedValue(error)
-
-      const configWithoutRpcUrls = {
-        ...mockConfig,
-        rpcUrls: {},
-      }
-      const storage = getClientStorage(configWithoutRpcUrls)
-
-      await expect(storage.getChains()).rejects.toThrow(
-        'Failed to fetch chains'
-      )
-    })
-  })
-
-  describe('getRpcUrls method', () => {
-    it('should fetch RPC URLs when needReset is true', async () => {
-      const { getChainsFromConfig } = await import('../actions/getChains.js')
-      const { getRpcUrlsFromChains } = await import('../core/utils.js')
-
-      vi.mocked(getChainsFromConfig).mockResolvedValue(mockChains)
-      vi.mocked(getRpcUrlsFromChains).mockReturnValue(mockRpcUrls)
-
-      const configWithoutRpcUrls = {
-        ...mockConfig,
-        rpcUrls: {},
-      }
-      const storage = getClientStorage(configWithoutRpcUrls)
-      const rpcUrls = await storage.getRpcUrls()
-
-      expect(getRpcUrlsFromChains).toHaveBeenCalledWith({}, mockChains, [
-        ChainId.SOL,
-      ])
-      expect(rpcUrls).toEqual(mockRpcUrls)
-    })
-
-    it('should return cached RPC URLs when not needReset and RPC URLs exist', async () => {
-      const { getChainsFromConfig } = await import('../actions/getChains.js')
-      const { getRpcUrlsFromChains } = await import('../core/utils.js')
-
-      vi.mocked(getChainsFromConfig).mockResolvedValue(mockChains)
-      vi.mocked(getRpcUrlsFromChains).mockReturnValue(mockRpcUrls)
-
-      const storage = getClientStorage(mockConfig)
-
-      // First call getChains to set the timestamp and make needReset false
-      await storage.getChains()
-
-      // Now getRpcUrls should use existing RPC URLs without calling getRpcUrlsFromChains
-      const rpcUrls1 = await storage.getRpcUrls()
-      expect(getRpcUrlsFromChains).toHaveBeenCalledTimes(0) // Should use existing RPC URLs
-
-      // Second call should return cached RPC URLs
-      const rpcUrls2 = await storage.getRpcUrls()
-      expect(getRpcUrlsFromChains).toHaveBeenCalledTimes(0)
-      expect(rpcUrls1).toBe(rpcUrls2) // Same reference
-    })
-
-    it('should handle errors from getRpcUrlsFromChains', async () => {
-      const { getChainsFromConfig } = await import('../actions/getChains.js')
-      const { getRpcUrlsFromChains } = await import('../core/utils.js')
-
-      vi.mocked(getChainsFromConfig).mockResolvedValue(mockChains)
-      const error = new Error('Failed to process RPC URLs')
-      vi.mocked(getRpcUrlsFromChains).mockImplementation(() => {
-        throw error
-      })
-
-      const configWithoutRpcUrls = {
-        ...mockConfig,
-        rpcUrls: {},
-      }
-      const storage = getClientStorage(configWithoutRpcUrls)
-
-      await expect(storage.getRpcUrls()).rejects.toThrow(
-        'Failed to process RPC URLs'
-      )
-    })
-  })
-
-  describe('caching behavior', () => {
-    it('should reset cache when needReset becomes true', async () => {
-      const { getChainsFromConfig } = await import('../actions/getChains.js')
-      const { getRpcUrlsFromChains } = await import('../core/utils.js')
-
-      vi.mocked(getChainsFromConfig).mockResolvedValue(mockChains)
-      vi.mocked(getRpcUrlsFromChains).mockReturnValue(mockRpcUrls)
-
-      const configWithoutRpcUrls = {
-        ...mockConfig,
-        rpcUrls: {},
-      }
-      const storage = getClientStorage(configWithoutRpcUrls)
-
-      // First call
-      await storage.getChains()
-      await storage.getRpcUrls()
-
-      // Mock Date.now to return a time 25 hours later
-      const originalDateNow = Date.now
-      vi.spyOn(Date, 'now').mockReturnValue(Date.now() + 25 * 60 * 60 * 1000)
-
-      // Should refetch when needReset is true
-      await storage.getChains()
-      await storage.getRpcUrls()
-
-      expect(getChainsFromConfig).toHaveBeenCalledTimes(2)
-      expect(getRpcUrlsFromChains).toHaveBeenCalledTimes(1) // Only called once because we have existing RPC URLs
-
-      // Restore Date.now
-      Date.now = originalDateNow
-    })
-  })
-
-  describe('edge cases', () => {
-    it('should handle chains without metamask RPC URLs', async () => {
-      const { getChainsFromConfig } = await import('../actions/getChains.js')
-      const { getRpcUrlsFromChains } = await import('../core/utils.js')
-
-      const chainsWithoutRpcUrls = [
-        {
-          id: ChainId.ETH,
-          name: 'Ethereum',
-          key: ChainKey.ETH,
-          chainType: ChainType.EVM,
-          coin: CoinKey.ETH,
-          mainnet: true,
-          nativeToken: {
-            address: '0x0000000000000000000000000000000000000000',
-            symbol: 'ETH',
-            decimals: 18,
-            name: 'Ethereum',
-            chainId: ChainId.ETH,
-            priceUSD: '0',
-          },
-          metamask: {
-            chainId: '0x1',
-            chainName: 'Ethereum',
-            nativeCurrency: {
-              name: 'Ethereum',
-              symbol: 'ETH',
-              decimals: 18,
-            },
-            rpcUrls: [],
-            blockExplorerUrls: ['https://etherscan.io'],
-          },
-        },
-      ]
-
-      vi.mocked(getChainsFromConfig).mockResolvedValue(chainsWithoutRpcUrls)
-      vi.mocked(getRpcUrlsFromChains).mockReturnValue({})
-
-      const configWithoutRpcUrls = {
-        ...mockConfig,
-        rpcUrls: {},
-      }
-      const storage = getClientStorage(configWithoutRpcUrls)
-
-      const rpcUrls = await storage.getRpcUrls()
-
-      expect(getRpcUrlsFromChains).toHaveBeenCalledWith(
-        {},
-        chainsWithoutRpcUrls,
-        [ChainId.SOL]
-      )
-      expect(rpcUrls).toEqual({})
-    })
-
-    it('should preserve existing RPC URLs from config', async () => {
-      const { getChainsFromConfig } = await import('../actions/getChains.js')
-      const { getRpcUrlsFromChains } = await import('../core/utils.js')
-
-      vi.mocked(getChainsFromConfig).mockResolvedValue(mockChains)
-      vi.mocked(getRpcUrlsFromChains).mockReturnValue(mockRpcUrls)
-
-      const storage = getClientStorage(mockConfig)
-
-      // First call getChains to set the timestamp and make needReset false
-      await storage.getChains()
-
-      const rpcUrls = await storage.getRpcUrls()
-
-      // Should not call getRpcUrlsFromChains because we already have RPC URLs
-      expect(getRpcUrlsFromChains).not.toHaveBeenCalled()
-      expect(rpcUrls).toEqual(mockConfig.rpcUrls)
-    })
-  })
-})