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

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

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

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

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

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

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

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

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

@@ -1,26 +0,0 @@
-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/tsconfig.json

@@ -1,18 +0,0 @@
-{
-  "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"
-  ]
-}