@lifi/sdk 3.13.5 → 4.0.0-alpha.1

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

@@ -0,0 +1,323 @@
+import type {
+  ContractCallsQuoteRequest,
+  LiFiStep,
+  RequestOptions,
+} from '@lifi/types'
+import { ChainId } from '@lifi/types'
+import { HttpResponse, http } from 'msw'
+import { describe, expect, it } from 'vitest'
+import { ValidationError } from '../errors/errors.js'
+import { SDKError } from '../errors/SDKError.js'
+import { client, setupTestServer } from './actions.unit.handlers.js'
+import { getContractCallsQuote } from './getContractCallsQuote.js'
+
+describe('getContractCallsQuote', () => {
+  const server = setupTestServer()
+
+  const createMockContractCallsRequest = (
+    overrides: Partial<ContractCallsQuoteRequest> = {}
+  ): ContractCallsQuoteRequest => ({
+    fromChain: ChainId.ETH,
+    fromToken: '0xA0b86a33E6441c8C06DDD4f36e4C4C5B4c3B4c3B',
+    fromAddress: '0x1234567890123456789012345678901234567890',
+    toChain: ChainId.POL,
+    toToken: '0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174',
+    contractCalls: [
+      {
+        fromAmount: '1000000',
+        fromTokenAddress: '0xA0b86a33E6441c8C06DDD4f36e4C4C5B4c3B4c3B',
+        toContractAddress: '0x1234567890123456789012345678901234567890',
+        toContractCallData: '0x1234567890abcdef',
+        toContractGasLimit: '100000',
+      },
+    ],
+    fromAmount: '1000000',
+    ...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',
+    },
+  }
+
+  describe('success scenarios', () => {
+    it('should get contract calls quote successfully with fromAmount', async () => {
+      server.use(
+        http.post(`${client.config.apiUrl}/quote/contractCalls`, async () => {
+          return HttpResponse.json(mockLiFiStep)
+        })
+      )
+
+      const request = createMockContractCallsRequest({
+        fromAmount: '1000000',
+      })
+
+      const result = await getContractCallsQuote(client, request)
+
+      expect(result).toEqual(mockLiFiStep)
+    })
+
+    it('should get contract calls quote successfully with toAmount', async () => {
+      server.use(
+        http.post(`${client.config.apiUrl}/quote/contractCalls`, async () => {
+          return HttpResponse.json(mockLiFiStep)
+        })
+      )
+
+      const request = createMockContractCallsRequest({
+        toAmount: '1000000',
+        fromAmount: undefined,
+      })
+
+      const result = await getContractCallsQuote(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.post(
+          `${client.config.apiUrl}/quote/contractCalls`,
+          async ({ request }) => {
+            capturedOptions = request
+            return HttpResponse.json(mockLiFiStep)
+          }
+        )
+      )
+
+      const request = createMockContractCallsRequest()
+
+      await getContractCallsQuote(client, request, options)
+
+      expect(capturedOptions.signal).toBeDefined()
+      expect(capturedOptions.signal).toBeInstanceOf(AbortSignal)
+    })
+  })
+
+  describe('validation scenarios', () => {
+    it('should throw SDKError when fromChain is missing', async () => {
+      const invalidRequest = createMockContractCallsRequest({
+        fromChain: undefined as any,
+      })
+
+      await expect(
+        getContractCallsQuote(client, invalidRequest)
+      ).rejects.toThrow(SDKError)
+
+      try {
+        await getContractCallsQuote(client, invalidRequest)
+      } catch (error) {
+        expect(error).toBeInstanceOf(SDKError)
+        expect((error as SDKError).cause).toBeInstanceOf(ValidationError)
+        expect((error as SDKError).cause.message).toBe(
+          'Required parameter "fromChain" is missing.'
+        )
+      }
+    })
+
+    it('should throw SDKError when fromToken is missing', async () => {
+      const invalidRequest = createMockContractCallsRequest({
+        fromToken: undefined as any,
+      })
+
+      await expect(
+        getContractCallsQuote(client, invalidRequest)
+      ).rejects.toThrow(SDKError)
+
+      try {
+        await getContractCallsQuote(client, invalidRequest)
+      } catch (error) {
+        expect(error).toBeInstanceOf(SDKError)
+        expect((error as SDKError).cause).toBeInstanceOf(ValidationError)
+        expect((error as SDKError).cause.message).toBe(
+          'Required parameter "fromToken" is missing.'
+        )
+      }
+    })
+
+    it('should throw SDKError when fromAddress is missing', async () => {
+      const invalidRequest = createMockContractCallsRequest({
+        fromAddress: undefined as any,
+      })
+
+      await expect(
+        getContractCallsQuote(client, invalidRequest)
+      ).rejects.toThrow(SDKError)
+
+      try {
+        await getContractCallsQuote(client, invalidRequest)
+      } catch (error) {
+        expect(error).toBeInstanceOf(SDKError)
+        expect((error as SDKError).cause).toBeInstanceOf(ValidationError)
+        expect((error as SDKError).cause.message).toBe(
+          'Required parameter "fromAddress" is missing.'
+        )
+      }
+    })
+
+    it('should throw SDKError when toChain is missing', async () => {
+      const invalidRequest = createMockContractCallsRequest({
+        toChain: undefined as any,
+      })
+
+      await expect(
+        getContractCallsQuote(client, invalidRequest)
+      ).rejects.toThrow(SDKError)
+
+      try {
+        await getContractCallsQuote(client, invalidRequest)
+      } catch (error) {
+        expect(error).toBeInstanceOf(SDKError)
+        expect((error as SDKError).cause).toBeInstanceOf(ValidationError)
+        expect((error as SDKError).cause.message).toBe(
+          'Required parameter "toChain" is missing.'
+        )
+      }
+    })
+
+    it('should throw SDKError when toToken is missing', async () => {
+      const invalidRequest = createMockContractCallsRequest({
+        toToken: undefined as any,
+      })
+
+      await expect(
+        getContractCallsQuote(client, invalidRequest)
+      ).rejects.toThrow(SDKError)
+
+      try {
+        await getContractCallsQuote(client, invalidRequest)
+      } catch (error) {
+        expect(error).toBeInstanceOf(SDKError)
+        expect((error as SDKError).cause).toBeInstanceOf(ValidationError)
+        expect((error as SDKError).cause.message).toBe(
+          'Required parameter "toToken" is missing.'
+        )
+      }
+    })
+
+    it('should throw SDKError when contractCalls is missing', async () => {
+      const invalidRequest = createMockContractCallsRequest({
+        contractCalls: undefined as any,
+      })
+
+      await expect(
+        getContractCallsQuote(client, invalidRequest)
+      ).rejects.toThrow(SDKError)
+
+      try {
+        await getContractCallsQuote(client, invalidRequest)
+      } catch (error) {
+        expect(error).toBeInstanceOf(SDKError)
+        expect((error as SDKError).cause).toBeInstanceOf(ValidationError)
+        expect((error as SDKError).cause.message).toBe(
+          'Required parameter "contractCalls" is missing.'
+        )
+      }
+    })
+
+    it('should throw SDKError when both fromAmount and toAmount are missing', async () => {
+      const invalidRequest = createMockContractCallsRequest()
+      // Remove both fromAmount and toAmount to test validation
+      delete (invalidRequest as any).fromAmount
+      delete (invalidRequest as any).toAmount
+
+      await expect(
+        getContractCallsQuote(client, invalidRequest)
+      ).rejects.toThrow(SDKError)
+
+      try {
+        await getContractCallsQuote(client, invalidRequest)
+      } catch (error) {
+        expect(error).toBeInstanceOf(SDKError)
+        expect((error as SDKError).cause).toBeInstanceOf(ValidationError)
+        expect((error as SDKError).cause.message).toBe(
+          'Required parameter "fromAmount" or "toAmount" is missing.'
+        )
+      }
+    })
+  })
+
+  describe('error scenarios', () => {
+    it('should throw SDKError when network request fails', async () => {
+      server.use(
+        http.post(`${client.config.apiUrl}/quote/contractCalls`, async () => {
+          return HttpResponse.error()
+        })
+      )
+
+      const request = createMockContractCallsRequest()
+
+      await expect(getContractCallsQuote(client, request)).rejects.toThrow(
+        SDKError
+      )
+    })
+
+    it('should throw SDKError when request times out', async () => {
+      server.use(
+        http.post(`${client.config.apiUrl}/quote/contractCalls`, async () => {
+          // Simulate timeout by not responding
+          await new Promise(() => {}) // Never resolves
+        })
+      )
+
+      const request = createMockContractCallsRequest()
+      const timeoutOptions: RequestOptions = {
+        signal: AbortSignal.timeout(100), // 100ms timeout
+      }
+
+      await expect(
+        getContractCallsQuote(client, request, timeoutOptions)
+      ).rejects.toThrow()
+    })
+  })
+})

package/src/actions/getGasRecommendation.ts

@@ -0,0 +1,47 @@
+import type {
+  GasRecommendationRequest,
+  GasRecommendationResponse,
+  RequestOptions,
+} from '@lifi/types'
+import { ValidationError } from '../errors/errors.js'
+import { SDKError } from '../errors/SDKError.js'
+import type { SDKClient } from '../types/core.js'
+import { request } from '../utils/request.js'
+
+/**
+ * Get gas recommendation for a certain chain
+ * @param client - The SDK client
+ * @param params - Configuration of the requested gas recommendation.
+ * @param options - Request options
+ * @throws {LiFiError} Throws a LiFiError if request fails.
+ * @returns Gas recommendation response.
+ */
+export const getGasRecommendation = async (
+  client: SDKClient,
+  params: GasRecommendationRequest,
+  options?: RequestOptions
+): Promise<GasRecommendationResponse> => {
+  if (!params.chainId) {
+    throw new SDKError(
+      new ValidationError('Required parameter "chainId" is missing.')
+    )
+  }
+
+  const url = new URL(
+    `${client.config.apiUrl}/gas/suggestion/${params.chainId}`
+  )
+  if (params.fromChain) {
+    url.searchParams.append('fromChain', params.fromChain as unknown as string)
+  }
+  if (params.fromToken) {
+    url.searchParams.append('fromToken', params.fromToken)
+  }
+
+  return await request<GasRecommendationResponse>(
+    client.config,
+    url.toString(),
+    {
+      signal: options?.signal,
+    }
+  )
+}

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

@@ -0,0 +1,40 @@
+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 { getGasRecommendation } from './getGasRecommendation.js'
+
+const mockedFetch = vi.spyOn(request, 'request')
+
+describe('getGasRecommendation', () => {
+  setupTestServer()
+
+  describe('user input is invalid', () => {
+    it('throw an error', async () => {
+      await expect(
+        getGasRecommendation(client, {
+          chainId: undefined as unknown as number,
+        })
+      ).rejects.toThrowError(
+        new SDKError(
+          new ValidationError('Required parameter "chainId" 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 getGasRecommendation(client, {
+          chainId: ChainId.OPT,
+        })
+
+        expect(mockedFetch).toHaveBeenCalledTimes(1)
+      })
+    })
+  })
+})

package/src/actions/getNameServiceAddress.ts

@@ -0,0 +1,42 @@
+import type { ChainType } from '@lifi/types'
+import type { SDKClient } from '../types/core.js'
+
+/**
+ * Get the address of a name service
+ * @param client - The SDK client
+ * @param name - The name to resolve
+ * @param chainType - The chain type to resolve the name on
+ * @returns The address of the name service
+ */
+export const getNameServiceAddress = async (
+  client: SDKClient,
+  name: string,
+  chainType?: ChainType
+): Promise<string | undefined> => {
+  try {
+    let providers = []
+    if (chainType) {
+      providers = client.providers.filter(
+        (provider) => provider.type === chainType
+      )
+    } else {
+      providers = client.providers
+    }
+    const resolvers = providers.map((provider) => provider.resolveAddress)
+    if (!resolvers.length) {
+      return
+    }
+    const result = await Promise.any(
+      resolvers.map(async (resolve) => {
+        const address = await resolve(name, client)
+        if (!address) {
+          throw undefined
+        }
+        return address
+      })
+    )
+    return result
+  } catch (_) {
+    return
+  }
+}

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

@@ -0,0 +1,169 @@
+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

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