@lifi/sdk 3.13.5 → 4.0.0-alpha.1

package/src/utils/getTransactionMessage.ts

@@ -1,11 +1,12 @@
 import type { LiFiStep } from '@lifi/types'
-import { config } from '../config.js'
+import type { SDKClient } from '../types/core.js'
 
 export const getTransactionFailedMessage = async (
+  client: SDKClient,
   step: LiFiStep,
   txLink?: string
 ): Promise<string> => {
-  const chain = await config.getChainById(step.action.toChainId)
+  const chain = await client.getChainById(step.action.toChainId)
 
   const baseString = `It appears that your transaction may not have been successful.
   However, to confirm this, please check your ${chain.name} wallet for ${step.action.toToken.symbol}.`

package/src/utils/getTransactionMessage.unit.spec.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it, vi } from 'vitest'
+import { getTransactionFailedMessage } from './getTransactionMessage.js'
+
+describe('getTransactionFailedMessage', () => {
+  const mockClient = {
+    getChainById: vi.fn().mockResolvedValue({
+      id: 1,
+      name: 'Ethereum',
+    }),
+  } as any
+
+  const mockStep = {
+    action: {
+      toChainId: 1,
+      toToken: { symbol: 'USDC' },
+    },
+  } as any
+
+  it('should return message without tx link', async () => {
+    const message = await getTransactionFailedMessage(mockClient, mockStep)
+
+    expect(message).toContain('Ethereum')
+    expect(message).toContain('USDC')
+    expect(message).not.toContain('block explorer')
+  })
+
+  it('should return message with tx link', async () => {
+    const txLink = 'https://etherscan.io/tx/0x123'
+    const message = await getTransactionFailedMessage(
+      mockClient,
+      mockStep,
+      txLink
+    )
+
+    expect(message).toContain('block explorer')
+    expect(message).toContain(txLink)
+  })
+})

package/src/utils/isRoutesRequest.ts

@@ -0,0 +1,31 @@
+import type { RouteOptions, RoutesRequest } from '@lifi/types'
+
+const isRoutesOptions = (
+  routeOptions: RouteOptions
+): routeOptions is RouteOptions =>
+  !routeOptions?.slippage || typeof routeOptions.slippage === 'number'
+
+export const isRoutesRequest = (
+  routesRequest: RoutesRequest
+): routesRequest is RoutesRequest => {
+  const {
+    fromChainId,
+    fromAmount,
+    fromTokenAddress,
+    toChainId,
+    toTokenAddress,
+    options,
+  } = routesRequest
+
+  return (
+    typeof fromChainId === 'number' &&
+    typeof fromAmount === 'string' &&
+    fromAmount !== '' &&
+    typeof fromTokenAddress === 'string' &&
+    fromTokenAddress !== '' &&
+    typeof toChainId === 'number' &&
+    typeof toTokenAddress === 'string' &&
+    toTokenAddress !== '' &&
+    (!options || isRoutesOptions(options))
+  )
+}

package/src/utils/isRoutesRequest.unit.spec.ts

@@ -0,0 +1,46 @@
+import { describe, expect, it } from 'vitest'
+import { isRoutesRequest } from './isRoutesRequest.js'
+
+describe('isRoutesRequest', () => {
+  const validRequest = {
+    fromChainId: 1,
+    fromAmount: '1000000000000000000',
+    fromTokenAddress: '0x111',
+    toChainId: 1,
+    toTokenAddress: '0x222',
+    options: { slippage: 0.001 },
+  }
+
+  it('should return true for valid request', () => {
+    expect(isRoutesRequest(validRequest)).toBe(true)
+  })
+
+  it('should return true for request without options', () => {
+    expect(isRoutesRequest({ ...validRequest, options: undefined })).toBe(true)
+  })
+
+  it('should return false for invalid chainId', () => {
+    expect(isRoutesRequest({ ...validRequest, fromChainId: '1' } as any)).toBe(
+      false
+    )
+  })
+
+  it('should return false for empty fromAmount', () => {
+    expect(isRoutesRequest({ ...validRequest, fromAmount: '' })).toBe(false)
+  })
+
+  it('should return false for empty token address', () => {
+    expect(isRoutesRequest({ ...validRequest, fromTokenAddress: '' })).toBe(
+      false
+    )
+  })
+
+  it('should return false for invalid slippage', () => {
+    expect(
+      isRoutesRequest({
+        ...validRequest,
+        options: { slippage: 'invalid' },
+      } as any)
+    ).toBe(false)
+  })
+})

package/src/utils/isStep.ts

@@ -0,0 +1,41 @@
+import type { Action, Estimate, LiFiStep } from '@lifi/types'
+import { isToken } from './isToken.js'
+
+const isAction = (action: Action): action is Action => {
+  const { fromChainId, fromAmount, fromToken, toChainId, toToken } = action
+
+  return (
+    typeof fromChainId === 'number' &&
+    typeof fromAmount === 'string' &&
+    fromAmount !== '' &&
+    isToken(fromToken) &&
+    typeof toChainId === 'number' &&
+    isToken(toToken)
+  )
+}
+
+const isEstimate = (estimate: Estimate): estimate is Estimate => {
+  const { fromAmount, toAmount, toAmountMin, approvalAddress } = estimate
+
+  return (
+    typeof fromAmount === 'string' &&
+    fromAmount !== '' &&
+    typeof toAmount === 'string' &&
+    toAmount !== '' &&
+    typeof toAmountMin === 'string' &&
+    toAmountMin !== '' &&
+    (typeof approvalAddress === 'string' || approvalAddress === null)
+  )
+}
+
+export const isStep = (step: LiFiStep): step is LiFiStep => {
+  const { id, type, tool, action, estimate } = step
+
+  return (
+    typeof id === 'string' &&
+    ['swap', 'cross', 'lifi'].includes(type) &&
+    typeof tool === 'string' &&
+    isAction(action) &&
+    isEstimate(estimate)
+  )
+}

package/src/utils/isStep.unit.spec.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it } from 'vitest'
+import { isStep } from './isStep.js'
+
+describe('isStep', () => {
+  const validStep = {
+    id: 'test-step',
+    type: 'swap',
+    tool: 'test-tool',
+    action: {
+      fromChainId: 1,
+      fromAmount: '1000000000000000000',
+      fromToken: {
+        address: '0x111',
+        decimals: 18,
+        chainId: 1,
+      },
+      toChainId: 1,
+      toToken: {
+        address: '0x222',
+        decimals: 18,
+        chainId: 1,
+      },
+    },
+    estimate: {
+      fromAmount: '1000000000000000000',
+      toAmount: '2000000000000000000',
+      toAmountMin: '1900000000000000000',
+      approvalAddress: '0x333',
+    },
+  }
+
+  it('should return true for valid step', () => {
+    expect(isStep(validStep as any)).toBe(true)
+  })
+
+  it('should return false for invalid id', () => {
+    expect(isStep({ ...validStep, id: 123 } as any)).toBe(false)
+  })
+
+  it('should return false for invalid type', () => {
+    expect(isStep({ ...validStep, type: 'invalid' } as any)).toBe(false)
+  })
+
+  it('should return false for empty fromAmount', () => {
+    const step = {
+      ...validStep,
+      action: { ...validStep.action, fromAmount: '' },
+    }
+    expect(isStep(step as any)).toBe(false)
+  })
+
+  it('should return false for invalid tool', () => {
+    expect(isStep({ ...validStep, tool: 123 } as any)).toBe(false)
+  })
+})

package/src/utils/isToken.ts

@@ -0,0 +1,11 @@
+import type { StaticToken } from '@lifi/types'
+
+export const isToken = (token: StaticToken): token is StaticToken => {
+  const { address, decimals, chainId } = token
+
+  return (
+    typeof address === 'string' &&
+    typeof decimals === 'number' &&
+    typeof chainId === 'number'
+  )
+}

package/src/utils/isToken.unit.spec.ts

@@ -0,0 +1,49 @@
+import type { StaticToken } from '@lifi/types'
+import { describe, expect, it } from 'vitest'
+import { isToken } from './isToken.js'
+
+describe('isToken', () => {
+  it('should return true for valid token', () => {
+    const token = {
+      address: '0x1234567890123456789012345678901234567890',
+      decimals: 18,
+      chainId: 1,
+      symbol: 'ETH',
+    } as StaticToken
+
+    expect(isToken(token)).toBe(true)
+  })
+
+  it('should return false for invalid address', () => {
+    const token = {
+      address: 123,
+      decimals: 18,
+      chainId: 1,
+      symbol: 'ETH',
+    }
+
+    expect(isToken(token as any)).toBe(false)
+  })
+
+  it('should return false for invalid decimals', () => {
+    const token = {
+      address: '0x123',
+      decimals: '18',
+      chainId: 1,
+      symbol: 'ETH',
+    }
+
+    expect(isToken(token as any)).toBe(false)
+  })
+
+  it('should return false for invalid chainId', () => {
+    const token = {
+      address: '0x123',
+      decimals: 18,
+      chainId: '1',
+      symbol: 'ETH',
+    }
+
+    expect(isToken(token as any)).toBe(false)
+  })
+})

package/src/utils/request.ts

@@ -0,0 +1,97 @@
+import { ValidationError } from '../errors/errors.js'
+import { HTTPError } from '../errors/httpError.js'
+import { SDKError } from '../errors/SDKError.js'
+import type { SDKBaseConfig } from '../types/core.js'
+import type { ExtendedRequestInit } from '../types/request.js'
+import { version } from '../version.js'
+import { sleep } from './sleep.js'
+
+export const requestSettings = {
+  retries: 1,
+}
+
+const stripExtendRequestInitProperties = ({
+  retries,
+  ...rest
+}: ExtendedRequestInit): RequestInit => ({
+  ...rest,
+})
+
+export const request = async <T = Response>(
+  config: SDKBaseConfig,
+  url: RequestInfo | URL,
+  options: ExtendedRequestInit = {
+    retries: requestSettings.retries,
+  }
+): Promise<T> => {
+  const { userId, integrator, widgetVersion, apiKey } = config
+
+  if (!integrator) {
+    throw new SDKError(
+      new ValidationError(
+        'You need to provide the Integrator property. Please see documentation https://docs.li.fi/integrate-li.fi-js-sdk/set-up-the-sdk'
+      )
+    )
+  }
+
+  options.retries = options.retries ?? requestSettings.retries
+
+  try {
+    if (apiKey) {
+      options.headers = {
+        ...options.headers,
+        'x-lifi-api-key': apiKey,
+      }
+    }
+
+    if (userId) {
+      options.headers = {
+        ...options.headers,
+        'x-lifi-userid': userId,
+      }
+    }
+
+    if (widgetVersion) {
+      options.headers = {
+        ...options.headers,
+        'x-lifi-widget': widgetVersion,
+      }
+    }
+
+    if (version) {
+      options.headers = {
+        ...options.headers,
+        'x-lifi-sdk': version,
+      }
+    }
+
+    // integrator is mandatory during SDK initialization
+    options.headers = {
+      ...options.headers,
+      'x-lifi-integrator': integrator,
+    }
+
+    const response: Response = await fetch(
+      url,
+      stripExtendRequestInitProperties(options)
+    )
+
+    if (!response.ok) {
+      throw new HTTPError(response, url, options)
+    }
+
+    return await response.json()
+  } catch (error) {
+    if (options.retries > 0 && (error as HTTPError).status === 500) {
+      await sleep(500)
+      return request<T>(config, url, {
+        ...options,
+        retries: options.retries - 1,
+      })
+    }
+
+    await (error as HTTPError).buildAdditionalDetails?.()
+
+    throw new SDKError(error as HTTPError)
+  }
+}

package/src/utils/request.unit.spec.ts

@@ -0,0 +1,159 @@
+import { HttpResponse, http } from 'msw'
+import { describe, expect, it } from 'vitest'
+import { client, setupTestServer } from '../actions/actions.unit.handlers.js'
+import { ValidationError } from '../errors/errors.js'
+import type { HTTPError } from '../errors/httpError.js'
+import { SDKError } from '../errors/SDKError.js'
+import type { ExtendedRequestInit } from '../types/request.js'
+import { version } from '../version.js'
+import { request } from './request.js'
+
+describe('request new', () => {
+  const server = setupTestServer()
+
+  it('should be able to successfully make a fetch request', async () => {
+    const url = `${client.config.apiUrl}/advanced/routes`
+
+    const response = await request<{ message: string }>(client.config, url, {
+      method: 'POST',
+      retries: 0,
+    })
+
+    expect(response).toEqual({})
+  })
+
+  it('should remove the extended request init properties that fetch does not care about', async () => {
+    const url = `${client.config.apiUrl}/advanced/routes`
+    const successResponse = { message: 'it works' }
+
+    server.use(
+      http.post(url, async ({ request }) => {
+        expect(request.headers.get('x-lifi-integrator')).toEqual('lifi-sdk')
+        expect(request.headers.get('x-lifi-sdk')).toEqual(version)
+        expect(request.headers.get('x-lifi-api-key')).toBeNull()
+        expect(request.headers.get('x-lifi-userid')).toBeNull()
+        expect(request.headers.get('x-lifi-widget')).toBeNull()
+
+        return HttpResponse.json(successResponse, { status: 200 })
+      })
+    )
+
+    const options: ExtendedRequestInit = {
+      method: 'POST',
+      retries: 0,
+    }
+
+    const response = await request<{ message: string }>(
+      client.config,
+      url,
+      options
+    )
+
+    expect(response).toEqual(successResponse)
+  })
+
+  it('should update the headers information available from config', async () => {
+    const url = `${client.config.apiUrl}/advanced/routes`
+    const successResponse = { message: 'it works' }
+
+    server.use(
+      http.post(url, async ({ request }) => {
+        expect(request.headers.get('x-lifi-api-key')).toEqual('mock-apikey')
+        expect(request.headers.get('x-lifi-integrator')).toEqual('lifi-sdk')
+        expect(request.headers.get('x-lifi-sdk')).toEqual(version)
+        expect(request.headers.get('x-lifi-userid')).toEqual('user-id')
+        expect(request.headers.get('x-lifi-widget')).toEqual(
+          'mock-widget-version'
+        )
+
+        return HttpResponse.json(successResponse, { status: 200 })
+      })
+    )
+
+    const options: ExtendedRequestInit = {
+      method: 'POST',
+      retries: 0,
+      headers: {
+        'x-lifi-api-key': 'mock-apikey',
+        'x-lifi-userid': 'user-id',
+        'x-lifi-widget': 'mock-widget-version',
+      },
+    }
+
+    const response = await request<{ message: string }>(
+      client.config,
+      url,
+      options
+    )
+
+    expect(response).toEqual(successResponse)
+  })
+
+  describe('when dealing with errors', () => {
+    it('should throw an error if the Integrator property is missing from the config', async () => {
+      const originalIntegrator = client.config.integrator
+      client.config.integrator = ''
+
+      const url = `${client.config.apiUrl}/advanced/routes`
+
+      await expect(
+        request<{ message: string }>(client.config, url, {
+          method: 'POST',
+          retries: 0,
+        })
+      ).rejects.toThrowError(
+        new SDKError(
+          new ValidationError(
+            'You need to provide the Integrator property. Please see documentation https://docs.li.fi/integrate-li.fi-js-sdk/set-up-the-sdk'
+          )
+        )
+      )
+
+      client.config.integrator = originalIntegrator
+    })
+    it('should throw a error with when the request fails', async () => {
+      expect.assertions(2)
+
+      const url = `${client.config.apiUrl}/advanced/routes`
+      const errorResponse = { message: 'something went wrong on the server' }
+
+      server.use(
+        http.post(url, async () => {
+          return HttpResponse.json(errorResponse, { status: 400 })
+        })
+      )
+
+      try {
+        await request<{ message: string }>(client.config, url, {
+          method: 'POST',
+          retries: 0,
+        })
+      } catch (e) {
+        expect((e as SDKError).name).toEqual('SDKError')
+        expect(((e as SDKError).cause as HTTPError).status).toEqual(400)
+      }
+    })
+    it('should throw a error and attempt retries when the request fails with a 500', async () => {
+      expect.assertions(2)
+
+      const url = `${client.config.apiUrl}/advanced/routes`
+      const errorResponse = { message: 'something went wrong on the server' }
+
+      server.use(
+        http.post(url, async () => {
+          return HttpResponse.json(errorResponse, { status: 500 })
+        })
+      )
+
+      try {
+        await request<{ message: string }>(client.config, url, {
+          method: 'POST',
+          retries: 0,
+        })
+      } catch (e) {
+        expect((e as SDKError).name).toEqual('SDKError')
+        expect(((e as SDKError).cause as HTTPError).status).toEqual(500)
+      }
+    })
+  })
+})

package/src/utils/sleep.unit.spec.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from 'vitest'
+import { sleep } from './sleep.js'
+
+describe('sleep', () => {
+  it('should wait for specified time', async () => {
+    const start = Date.now()
+    await sleep(50)
+    const end = Date.now()
+
+    expect(end - start).toBeGreaterThanOrEqual(45)
+  })
+
+  it('should return null', async () => {
+    const result = await sleep(10)
+    expect(result).toBeNull()
+  })
+})

package/src/utils/waitForResult.unit.spec.ts

@@ -0,0 +1,75 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { waitForResult } from './waitForResult.js'
+
+describe('utils', () => {
+  describe('waitForResult', () => {
+    let mockedFunction: any
+
+    beforeEach(() => {
+      mockedFunction = vi.fn()
+      vi.useFakeTimers()
+    })
+
+    afterEach(() => {
+      vi.useRealTimers()
+    })
+
+    it('should throw immediately if shouldRetry returns false', async () => {
+      mockedFunction.mockImplementation(() => Promise.reject('some error'))
+      const shouldRetry = vi.fn().mockReturnValue(false)
+
+      const promise = waitForResult(mockedFunction, 1000, 3, shouldRetry)
+
+      await expect(promise).rejects.toThrowError('some error')
+      expect(mockedFunction).toHaveBeenCalledTimes(1)
+      expect(shouldRetry).toHaveBeenCalledWith(0, 'some error')
+    })
+
+    it('should try until repeat function succeeds', async () => {
+      mockedFunction
+        .mockResolvedValueOnce(undefined)
+        .mockResolvedValueOnce(undefined)
+        .mockResolvedValueOnce('success!')
+
+      const promise = waitForResult(mockedFunction, 1000)
+
+      // Fast-forward through retries
+      for (let i = 0; i < 2; i++) {
+        await vi.advanceTimersByTimeAsync(1000)
+      }
+
+      const result = await promise
+      expect(result).toEqual('success!')
+      expect(mockedFunction).toHaveBeenCalledTimes(3)
+    })
+
+    it('should respect the interval between retries', async () => {
+      mockedFunction
+        .mockResolvedValueOnce(undefined)
+        .mockResolvedValueOnce('success!')
+
+      const promise = waitForResult(mockedFunction, 2000)
+
+      await vi.advanceTimersByTimeAsync(2000)
+      const result = await promise
+
+      expect(result).toEqual('success!')
+      expect(mockedFunction).toHaveBeenCalledTimes(2)
+    })
+
+    it('should throw an error if repeat function fails and maxRetries is reached', async () => {
+      mockedFunction.mockImplementation(() => Promise.reject('some error'))
+      const maxRetries = 2
+
+      const promise = waitForResult(mockedFunction, 1000, maxRetries)
+      const expectPromise = expect(promise).rejects.toThrowError('some error')
+      // Fast-forward through retries
+      for (let i = 0; i < maxRetries - 1; i++) {
+        await vi.advanceTimersByTimeAsync(1000)
+      }
+
+      await expectPromise
+      expect(mockedFunction).toHaveBeenCalledTimes(maxRetries)
+    })
+  })
+})

package/src/utils/withDedupe.unit.spec.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it, vi } from 'vitest'
+import { withDedupe } from './withDedupe.js'
+
+describe('withDedupe', () => {
+  it('should execute function without caching when disabled', async () => {
+    const fn = vi.fn().mockResolvedValue('result')
+    const result = await withDedupe(fn, { enabled: false, id: 'test' })
+
+    expect(result).toBe('result')
+    expect(fn).toHaveBeenCalledOnce()
+  })
+
+  it('should cache and dedupe identical requests', async () => {
+    const fn = vi.fn().mockResolvedValue('result')
+    const id = 'test-id'
+
+    const promise1 = withDedupe(fn, { enabled: true, id })
+    const promise2 = withDedupe(fn, { enabled: true, id })
+
+    const [result1, result2] = await Promise.all([promise1, promise2])
+
+    expect(result1).toBe('result')
+    expect(result2).toBe('result')
+    expect(fn).toHaveBeenCalledOnce()
+  })
+})

package/src/version.ts

@@ -1,2 +1,2 @@
 export const name = '@lifi/sdk'
-export const version = '3.13.5'
+export const version = '4.0.0-alpha.1'

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.tsbuildinfo",
+    "composite": true,
+    "sourceMap": true,
+    "rootDir": "./src",
+    "moduleResolution": "Node",
+    "outDir": "./dist"
+  },
+  "include": ["./src/**/*", "./src/**/*.json"],
+  "exclude": [
+    "tests",
+    "./src/**/*.spec.ts",
+    "./src/**/*.mock.ts",
+    "./src/**/*.handlers.ts"
+  ]
+}