@lifi/sdk 3.13.5 → 4.0.0-alpha.1

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

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

package/src/client/createClient.ts

@@ -0,0 +1,94 @@
+import type { ChainId, ChainType } from '@lifi/types'
+import type {
+  SDKBaseConfig,
+  SDKClient,
+  SDKConfig,
+  SDKProvider,
+} from '../types/core.js'
+import { checkPackageUpdates } from '../utils/checkPackageUpdates.js'
+import { name, version } from '../version.js'
+import { getClientStorage } from './getClientStorage.js'
+
+export function createClient(options: SDKConfig): SDKClient {
+  if (!options.integrator) {
+    throw new Error(
+      'Integrator not found. Please see documentation https://docs.li.fi/integrate-li.fi-js-sdk/set-up-the-sdk'
+    )
+  }
+
+  if (!options.disableVersionCheck && process.env.NODE_ENV === 'development') {
+    checkPackageUpdates(name, version)
+  }
+
+  const _config: SDKBaseConfig = {
+    ...options,
+    apiUrl: options?.apiUrl ?? 'https://li.quest/v1',
+    rpcUrls: options?.rpcUrls ?? {},
+    debug: options?.debug ?? false,
+    integrator: options?.integrator ?? 'lifi-sdk',
+  }
+
+  let _providers: SDKProvider[] = []
+  const _storage = getClientStorage(_config)
+
+  const client: SDKClient = {
+    get config() {
+      return _config
+    },
+    get providers() {
+      return _providers
+    },
+    getProvider(type: ChainType) {
+      return this.providers.find((provider) => provider.type === type)
+    },
+    setProviders(newProviders: SDKProvider[]) {
+      const providerMap = new Map(
+        this.providers.map((provider) => [provider.type, provider])
+      )
+      for (const provider of newProviders) {
+        providerMap.set(provider.type, provider)
+      }
+      _providers = Array.from(providerMap.values())
+    },
+    async getChains() {
+      return await _storage.getChains()
+    },
+    async getChainById(chainId: ChainId) {
+      const chains = await this.getChains()
+      const chain = chains?.find((chain) => chain.id === chainId)
+      if (!chain) {
+        throw new Error(`ChainId ${chainId} not found`)
+      }
+      return chain
+    },
+    async getRpcUrls() {
+      return await _storage.getRpcUrls()
+    },
+    async getRpcUrlsByChainId(chainId: ChainId) {
+      const rpcUrls = await this.getRpcUrls()
+      const chainRpcUrls = rpcUrls[chainId]
+      if (!chainRpcUrls?.length) {
+        throw new Error(`RPC URL not found for chainId: ${chainId}`)
+      }
+      return chainRpcUrls
+    },
+  }
+
+  function extend<TClient extends SDKClient>(
+    base: TClient
+  ): <TExtensions extends Record<string, any>>(
+    extendFn: (client: TClient) => TExtensions
+  ) => TClient & TExtensions {
+    return (extendFn) => {
+      const extensions = extendFn(base)
+      const extended = { ...base, ...extensions } as TClient & typeof extensions
+
+      // Preserve the extend function for further extensions
+      return Object.assign(extended, {
+        extend: extend(extended),
+      })
+    }
+  }
+
+  return Object.assign(client, { extend: extend(client) })
+}

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

@@ -0,0 +1,274 @@
+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.ts

@@ -0,0 +1,40 @@
+import { ChainId, ChainType, type ExtendedChain } from '@lifi/types'
+import { getChainsFromConfig } from '../actions/getChains.js'
+import { getRpcUrlsFromChains } from '../core/utils.js'
+import type { RPCUrls, SDKBaseConfig } from '../types/core.js'
+
+export const getClientStorage = (config: SDKBaseConfig) => {
+  let _chains = [] as ExtendedChain[]
+  let _rpcUrls = { ...config.rpcUrls } as RPCUrls
+  let _chainsUpdatedAt: number | undefined
+
+  return {
+    get needReset() {
+      return (
+        !_chainsUpdatedAt ||
+        Date.now() - _chainsUpdatedAt >= 1000 * 60 * 60 * 24
+      )
+    },
+    async getChains() {
+      if (this.needReset || !_chains.length) {
+        _chains = await getChainsFromConfig(config, {
+          chainTypes: [
+            ChainType.EVM,
+            ChainType.SVM,
+            ChainType.UTXO,
+            ChainType.MVM,
+          ],
+        })
+        _chainsUpdatedAt = Date.now()
+      }
+      return _chains
+    },
+    async getRpcUrls() {
+      if (this.needReset || !Object.keys(_rpcUrls).length) {
+        const chains = await this.getChains()
+        _rpcUrls = getRpcUrlsFromChains(_rpcUrls, chains, [ChainId.SOL])
+      }
+      return _rpcUrls
+    },
+  }
+}