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

package/src/core/stepComparison.unit.spec.ts

@@ -1,89 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-import { TransactionError } from '../errors/errors.js'
-import type { LiFiStep, StatusManager } from '../index.js'
-import { stepComparison } from './stepComparison.js'
-
-describe('stepComparison', () => {
-  const mockStatusManager = {
-    updateStepInRoute: vi.fn((step) => step),
-  } as unknown as StatusManager
-
-  const oldStep: LiFiStep = {
-    id: 'test',
-    type: 'swap',
-    tool: 'test',
-    action: {
-      fromChainId: 1,
-      fromAmount: '1000',
-      fromToken: { address: '0x1', decimals: 18, chainId: 1 },
-      toChainId: 1,
-      toToken: { address: '0x2', decimals: 18, chainId: 1 },
-      slippage: 0.003,
-    },
-    estimate: {
-      toAmount: '2000',
-      toAmountMin: '1940',
-    },
-  } as any
-
-  const newStep: LiFiStep = {
-    ...oldStep,
-    estimate: {
-      toAmount: '1950',
-      toAmountMin: '1940',
-    },
-  } as any
-
-  it('should return updated step if within slippage threshold', async () => {
-    const result = await stepComparison(
-      mockStatusManager,
-      oldStep,
-      newStep,
-      false
-    )
-
-    expect(result).toBeDefined()
-    expect(mockStatusManager.updateStepInRoute).toHaveBeenCalled()
-  })
-
-  it('should throw error when rate changed and user declined', async () => {
-    const farNewStep = {
-      ...oldStep,
-      estimate: {
-        toAmount: '100',
-        toAmountMin: '50',
-      },
-    } as any
-
-    await expect(
-      stepComparison(mockStatusManager, oldStep, farNewStep, false)
-    ).rejects.toThrow(TransactionError)
-  })
-
-  it('should call acceptExchangeRateUpdateHook when user interaction allowed', async () => {
-    const acceptHook = vi.fn().mockResolvedValue(true)
-
-    const farNewStep = {
-      ...oldStep,
-      estimate: {
-        toAmount: '100',
-        toAmountMin: '50',
-      },
-    } as any
-
-    const executionOptions = {
-      acceptExchangeRateUpdateHook: acceptHook,
-    }
-
-    const result = await stepComparison(
-      mockStatusManager,
-      oldStep,
-      farNewStep,
-      true,
-      executionOptions
-    )
-
-    expect(acceptHook).toHaveBeenCalled()
-    expect(result).toBeDefined()
-  })
-})

package/src/errors/SDKError.unit.spec.ts

@@ -1,160 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { version } from '../version.js'
-import { BaseError } from './baseError.js'
-import { ErrorName, LiFiErrorCode } from './constants.js'
-import { HTTPError } from './httpError.js'
-import { SDKError } from './SDKError.js'
-
-const url = 'http://some.where'
-const options = { method: 'POST' }
-const responseBody = { message: 'Oops' }
-
-describe('SDKError', () => {
-  describe('when the cause is a http error', () => {
-    it('should present the causing errors stack trace for http errors', async () => {
-      expect.assertions(1)
-
-      const testFunction = async () => {
-        try {
-          const mockResponse = {
-            status: 400,
-            statusText: 'Bad Request',
-            json: () => Promise.resolve(responseBody),
-          } as Response
-
-          const httpError = new HTTPError(mockResponse, url, options)
-
-          await httpError.buildAdditionalDetails()
-
-          throw httpError
-        } catch (e: any) {
-          throw new SDKError(e)
-        }
-      }
-
-      try {
-        await testFunction()
-      } catch (e: any) {
-        expect((e as SDKError).stack).toBe((e as SDKError).cause.stack)
-      }
-    })
-
-    it('should feature the causing http error message as part of its own message', async () => {
-      const mockResponse = {
-        status: 400,
-        statusText: 'Bad Request',
-        json: () => Promise.resolve(responseBody),
-      } as Response
-
-      const httpError = new HTTPError(mockResponse, url, options)
-
-      await httpError.buildAdditionalDetails()
-
-      const testFunction = () => {
-        throw new SDKError(httpError)
-      }
-
-      expect(() => testFunction()).toThrowError(
-        `[HTTPError] [ValidationError] Request failed with status code 400 Bad Request. Oops\nLI.FI SDK version: ${version}`
-      )
-    })
-  })
-
-  describe('when the cause is a base error', () => {
-    it('should present the causing errors stack trace for base errors', () => {
-      expect.assertions(1)
-
-      const testFunction = () => {
-        try {
-          const baseError = new BaseError(
-            ErrorName.ValidationError,
-            LiFiErrorCode.ValidationError,
-            'problem validating'
-          )
-
-          throw baseError
-        } catch (e: any) {
-          throw new SDKError(e)
-        }
-      }
-
-      try {
-        testFunction()
-      } catch (e: any) {
-        expect((e as SDKError).stack).toBe((e as SDKError).cause.stack)
-      }
-    })
-
-    it('should present the causing errors stack trace for base errors own causing error', () => {
-      expect.assertions(1)
-
-      const causingError = () => {
-        try {
-          throw new Error('this was the root cause')
-        } catch (e: any) {
-          throw new BaseError(
-            ErrorName.ValidationError,
-            LiFiErrorCode.ValidationError,
-            'problem validating',
-            e
-          )
-        }
-      }
-
-      const testFunction = () => {
-        try {
-          causingError()
-        } catch (e: any) {
-          throw new SDKError(e)
-        }
-      }
-
-      try {
-        testFunction()
-      } catch (e: any) {
-        expect((e as SDKError).stack).toBe(
-          ((e as SDKError).cause as SDKError).cause.stack
-        )
-      }
-    })
-
-    it('should feature the causing base error message as part of its own message', () => {
-      const testFunction = () => {
-        throw new SDKError(
-          new BaseError(
-            ErrorName.UnknownError,
-            LiFiErrorCode.InternalError,
-            'There was an error'
-          )
-        )
-      }
-
-      expect(() => testFunction()).toThrowError(
-        `[UnknownError] There was an error\nLI.FI SDK version: ${version}`
-      )
-    })
-
-    it('should use a fail back error message if one is not defined on the base error', () => {
-      const testFunction = () => {
-        throw new SDKError(
-          new BaseError(ErrorName.BalanceError, LiFiErrorCode.BalanceError, '')
-        )
-      }
-
-      expect(() => testFunction()).toThrowError(
-        `Unknown error occurred\nLI.FI SDK version: ${version}`
-      )
-    })
-
-    it('should present the passed base error as the cause', () => {
-      const baseError = new BaseError(
-        ErrorName.UnknownError,
-        LiFiErrorCode.InternalError,
-        'There was an error'
-      )
-      const sdkError = new SDKError(baseError)
-
-      expect(sdkError.cause).toBe(baseError)
-    })
-  })
-})

package/src/errors/baseError.unit.spec.ts

@@ -1,22 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { BaseError } from './baseError.js'
-import { ErrorName, LiFiErrorCode } from './constants.js'
-
-describe('baseError', () => {
-  it('should set the stack to the same as the deep rooted cause', () => {
-    const rootError = new Error()
-    rootError.stack = 'root stack trace'
-
-    const intermediateError = new Error()
-    intermediateError.cause = rootError
-
-    const errorChain = new BaseError(
-      ErrorName.UnknownError,
-      LiFiErrorCode.InternalError,
-      'There was an error',
-      intermediateError
-    )
-
-    expect(errorChain.stack).toBe(rootError.stack)
-  })
-})

package/src/errors/httpError.unit.spec.ts

@@ -1,125 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { ErrorName, LiFiErrorCode } from './constants.js'
-import { HTTPError } from './httpError.js'
-
-const url = 'http://some.where'
-const options = { method: 'POST' }
-const responseBody = { message: 'Oops' }
-
-describe('HTTPError', () => {
-  it.each([
-    [
-      'when status code is 400',
-      options,
-      400,
-      'Bad Request',
-      {
-        initialMessage: 'Request failed with status code 400 Bad Request',
-        type: ErrorName.ValidationError,
-        code: LiFiErrorCode.ValidationError,
-        jsonFunc: () => Promise.resolve(responseBody),
-        responseBody,
-        builtMessage:
-          '[ValidationError] Request failed with status code 400 Bad Request. Oops',
-      },
-    ],
-    [
-      'when status code is 404',
-      options,
-      404,
-      'Not Found',
-      {
-        initialMessage: 'Request failed with status code 404 Not Found',
-        type: ErrorName.NotFoundError,
-        code: LiFiErrorCode.NotFound,
-        jsonFunc: () => Promise.resolve(responseBody),
-        responseBody,
-        builtMessage:
-          '[NotFoundError] Request failed with status code 404 Not Found. Oops',
-      },
-    ],
-    [
-      'when status code is 409',
-      options,
-      409,
-      'Conflict',
-      {
-        initialMessage:
-          'Request failed with status code 409 Conflict\nThe slippage is larger than the defined threshold. Please request a new route to get a fresh quote.',
-        type: ErrorName.SlippageError,
-        code: LiFiErrorCode.SlippageError,
-        jsonFunc: () => Promise.resolve(responseBody),
-        responseBody,
-        builtMessage:
-          '[SlippageError] Request failed with status code 409 Conflict\nThe slippage is larger than the defined threshold. Please request a new route to get a fresh quote. Oops',
-      },
-    ],
-    [
-      'when status code is 500',
-      options,
-      500,
-      'Internal Server Error',
-      {
-        initialMessage:
-          'Request failed with status code 500 Internal Server Error',
-        type: ErrorName.ServerError,
-        code: LiFiErrorCode.InternalError,
-        jsonFunc: () => Promise.resolve(responseBody),
-        responseBody,
-        builtMessage:
-          '[ServerError] Request failed with status code 500 Internal Server Error. Oops',
-      },
-    ],
-    [
-      'when status code is undefined',
-      options,
-      undefined,
-      '',
-      {
-        initialMessage: 'Request failed with an unknown error',
-        type: ErrorName.ServerError,
-        code: LiFiErrorCode.InternalError,
-        jsonFunc: () => Promise.resolve(responseBody),
-        responseBody,
-        builtMessage:
-          '[ServerError] Request failed with an unknown error. Oops',
-      },
-    ],
-    [
-      'when there is a problem processing the body',
-      options,
-      400,
-      'Bad Request',
-      {
-        initialMessage: 'Request failed with status code 400 Bad Request',
-        type: ErrorName.ValidationError,
-        code: LiFiErrorCode.ValidationError,
-        jsonFunc: () => Promise.reject(new Error('fail')),
-        responseBody: undefined,
-        builtMessage:
-          '[ValidationError] Request failed with status code 400 Bad Request',
-      },
-    ],
-  ])('should present correctly %s', async (_, requestOptions, statusCode, statusText, expected) => {
-    const mockResponse = {
-      status: statusCode,
-      statusText,
-      json: expected.jsonFunc,
-    } as Response
-
-    const error = new HTTPError(mockResponse, url, requestOptions)
-
-    expect(error.status).toEqual(statusCode)
-    expect(error.message).toEqual(expected.initialMessage)
-    expect(error.url).toEqual(url)
-    expect(error.fetchOptions).toEqual(requestOptions)
-
-    expect(error.type).toEqual(expected.type)
-    expect(error.code).toEqual(expected.code)
-
-    await error.buildAdditionalDetails()
-
-    expect(error.responseBody).toEqual(expected.responseBody)
-    expect(error.message).toEqual(expected.builtMessage)
-  })
-})

package/src/errors/utils/baseErrorRootCause.unit.spec.ts

@@ -1,89 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { BaseError } from '../baseError.js'
-import { ErrorName, LiFiErrorCode } from '../constants.js'
-import { HTTPError } from '../httpError.js'
-import { SDKError } from '../SDKError.js'
-import {
-  getRootCauseBaseError,
-  getRootCauseBaseErrorMessage,
-} from './baseErrorRootCause.js'
-
-const getErrorChain = () => {
-  const NonLiFiErrorChain = new Error('non lifi error')
-  NonLiFiErrorChain.cause = new Error('root cause')
-  return new SDKError(
-    new BaseError(
-      ErrorName.ValidationError,
-      LiFiErrorCode.ValidationError,
-      'something happened',
-      NonLiFiErrorChain
-    )
-  )
-}
-
-describe('getRootCauseBaseError', () => {
-  it('should return the top level error when there is no root cause', () => {
-    const error = new Error('top level')
-
-    expect(getRootCauseBaseError(error).message).toEqual('top level')
-  })
-
-  it('should return the lowest BaseError in the cause chain', () => {
-    const errorChain = getErrorChain()
-
-    expect(getRootCauseBaseError(errorChain).message).toEqual(
-      'something happened'
-    )
-  })
-})
-
-describe('getRootCauseBaseErrorMessage', () => {
-  describe('when root cause is HTTP Error', () => {
-    it('should return the HTTP response message if present', async () => {
-      const mockResponse = {
-        status: 400,
-        statusText: 'Bad Request',
-        json: () =>
-          Promise.resolve({ message: 'something went wrong on the server' }),
-      } as Response
-
-      const httpError = new HTTPError(mockResponse, 'http://some.where', {})
-
-      await httpError.buildAdditionalDetails()
-
-      const errorChain = new SDKError(httpError)
-
-      expect(getRootCauseBaseErrorMessage(errorChain)).toEqual(
-        'something went wrong on the server'
-      )
-    })
-
-    it('should return the HTTP error message if response message not present', async () => {
-      const mockResponse = {
-        status: 400,
-        statusText: 'Bad Request',
-        json: () => Promise.resolve({}),
-      } as Response
-
-      const httpError = new HTTPError(mockResponse, 'http://some.where', {})
-
-      await httpError.buildAdditionalDetails()
-
-      const errorChain = new SDKError(httpError)
-
-      expect(getRootCauseBaseErrorMessage(errorChain)).toEqual(
-        '[ValidationError] Request failed with status code 400 Bad Request'
-      )
-    })
-  })
-
-  describe('when root cause is base Error', () => {
-    it('should return the BaseError message', () => {
-      const errorChain = getErrorChain()
-
-      expect(getRootCauseBaseErrorMessage(errorChain)).toEqual(
-        'something happened'
-      )
-    })
-  })
-})

package/src/errors/utils/rootCause.unit.spec.ts

@@ -1,36 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { BaseError } from '../baseError.js'
-import { ErrorName, LiFiErrorCode } from '../constants.js'
-import { SDKError } from '../SDKError.js'
-import { getRootCause } from './rootCause.js'
-
-const getErrorChain = () => {
-  const NonLiFiErrorChain = new Error('non lifi error')
-  NonLiFiErrorChain.cause = new Error('root cause')
-  return new SDKError(
-    new BaseError(
-      ErrorName.ValidationError,
-      LiFiErrorCode.ValidationError,
-      'something happened',
-      NonLiFiErrorChain
-    )
-  )
-}
-
-describe('getRootCause', () => {
-  it('should return the top level error when there is no root cause', () => {
-    const error = new Error('top level')
-
-    expect(getRootCause(error)!.message).toEqual('top level')
-  })
-
-  it('should return the root cause', () => {
-    const errorChain = getErrorChain()
-
-    expect(getRootCause(errorChain)!.message).toEqual('root cause')
-  })
-
-  it('should return undefined when passed undefined', () => {
-    expect(getRootCause(undefined)).toBeUndefined()
-  })
-})

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

@@ -1,71 +0,0 @@
-import {
-  afterEach,
-  beforeEach,
-  describe,
-  expect,
-  it,
-  type Mock,
-  vi,
-} from 'vitest'
-import { checkPackageUpdates } from './checkPackageUpdates.js'
-
-const latestVersion = '2.5.6'
-
-describe('checkPackageUpdates', () => {
-  beforeEach(() => {
-    vi.spyOn(global, 'fetch').mockResolvedValue({
-      json: () => Promise.resolve({ version: latestVersion }),
-    } as Response)
-
-    vi.spyOn(console, 'warn').mockImplementation(() => {})
-  })
-
-  afterEach(() => {
-    vi.resetAllMocks()
-  })
-
-  it('should be able to check the version number against npm', async () => {
-    const packageName = '@lifi/sdk'
-    const currentVersion = '0.0.0'
-
-    await checkPackageUpdates(packageName, currentVersion)
-
-    expect(global.fetch as Mock).toBeCalledWith(
-      `https://registry.npmjs.org/${packageName}/latest`
-    )
-
-    expect(console.warn).toBeCalledWith(
-      `${packageName}: new package version is available. Please update as soon as possible to enjoy the newest features. Current version: ${currentVersion}. Latest version: ${latestVersion}.`
-    )
-  })
-
-  it('should not report if version matchs the latest on npm', async () => {
-    const packageName = '@lifi/sdk'
-    const currentVersion = '2.5.6'
-
-    await checkPackageUpdates(packageName, currentVersion)
-
-    expect(global.fetch as Mock).toBeCalledWith(
-      `https://registry.npmjs.org/${packageName}/latest`
-    )
-
-    expect(console.warn).not.toBeCalled()
-  })
-
-  it('should fail sliently if it encounters a problem', async () => {
-    vi.spyOn(global, 'fetch').mockRejectedValue({
-      json: () => Promise.resolve({ version: latestVersion }),
-    } as Response)
-
-    const packageName = '@lifi/sdk'
-    const currentVersion = '0.0.0'
-
-    await checkPackageUpdates(packageName, currentVersion)
-
-    expect(global.fetch as Mock).toBeCalledWith(
-      `https://registry.npmjs.org/${packageName}/latest`
-    )
-
-    expect(console.warn).not.toBeCalled()
-  })
-})

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

@@ -1,56 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { SDKError } from '../errors/SDKError.js'
-import { convertQuoteToRoute } from './convertQuoteToRoute.js'
-
-describe('convertQuoteToRoute', () => {
-  const validQuote = {
-    id: 'test-quote',
-    type: 'swap',
-    tool: 'test-tool',
-    action: {
-      fromToken: { address: '0x111', decimals: 18, chainId: 1 },
-      fromAmount: '1000000000000000000',
-      fromAddress: '0xaaa',
-      toToken: { address: '0x222', decimals: 18, chainId: 1 },
-      toAddress: '0xbbb',
-    },
-    estimate: {
-      fromAmount: '1000000000000000000',
-      toAmount: '2000000000000000000',
-      toAmountMin: '1900000000000000000',
-      fromAmountUSD: '100',
-      toAmountUSD: '200',
-      approvalAddress: '0x333',
-    },
-  }
-
-  it('should convert valid quote to route', () => {
-    const route = convertQuoteToRoute(validQuote as any)
-
-    expect(route.id).toBe('test-quote')
-    expect(route.fromChainId).toBe(1)
-    expect(route.toChainId).toBe(1)
-    expect(route.fromAmount).toBe('1000000000000000000')
-    expect(route.toAmount).toBe('2000000000000000000')
-    expect(route.fromAmountUSD).toBe('100')
-    expect(route.toAmountUSD).toBe('200')
-  })
-
-  it('should throw error when fromAmountUSD is missing', () => {
-    const invalidQuote = {
-      ...validQuote,
-      estimate: { ...validQuote.estimate, fromAmountUSD: undefined },
-    }
-
-    expect(() => convertQuoteToRoute(invalidQuote as any)).toThrow(SDKError)
-  })
-
-  it('should throw error when toAmountUSD is missing', () => {
-    const invalidQuote = {
-      ...validQuote,
-      estimate: { ...validQuote.estimate, toAmountUSD: undefined },
-    }
-
-    expect(() => convertQuoteToRoute(invalidQuote as any)).toThrow(SDKError)
-  })
-})

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

@@ -1,42 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { fetchTxErrorDetails } from './fetchTxErrorDetails.js'
-
-// Mock fetch
-global.fetch = vi.fn()
-
-describe('fetchTxErrorDetails', () => {
-  beforeEach(() => {
-    vi.clearAllMocks()
-  })
-
-  it('should return response body on success', async () => {
-    const mockResponse = { error_message: 'Out of gas' }
-    ;(global.fetch as any).mockResolvedValueOnce({
-      json: vi.fn().mockResolvedValueOnce(mockResponse),
-    })
-
-    const result = await fetchTxErrorDetails('0x123', 1)
-
-    expect(result).toEqual(mockResponse)
-  })
-
-  it('should return undefined on error', async () => {
-    ;(global.fetch as any).mockRejectedValueOnce(new Error('Network error'))
-
-    const result = await fetchTxErrorDetails('0x123', 1)
-
-    expect(result).toBeUndefined()
-  })
-
-  it('should call correct tenderly URL', async () => {
-    ;(global.fetch as any).mockResolvedValueOnce({
-      json: vi.fn().mockResolvedValueOnce({}),
-    })
-
-    await fetchTxErrorDetails('0x123abc', 1)
-
-    expect(global.fetch).toHaveBeenCalledWith(
-      'https://api.tenderly.co/api/v1/public-contract/1/tx/0x123abc'
-    )
-  })
-})