@lifi/sdk 3.13.5 → 4.0.0-alpha.1

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

@@ -0,0 +1,86 @@
+import { setupServer } from 'msw/node'
+import type { Client } from 'viem'
+import { sendTransaction } from 'viem/actions'
+import {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  vi,
+} from 'vitest'
+import { createClient } from '../client/createClient.js'
+import { requestSettings } from '../utils/request.js'
+import { executeRoute } from './execution.js'
+import { lifiHandlers } from './execution.unit.handlers.js'
+import { buildRouteObject, buildStepObject } from './execution.unit.mock.js'
+
+const client = createClient({
+  integrator: 'lifi-sdk',
+})
+
+let viemClient: Partial<Client>
+
+vi.mock('../balance', () => ({
+  checkBalance: vi.fn(() => Promise.resolve([])),
+}))
+
+vi.mock('../execution/switchChain', () => ({
+  switchChain: vi.fn(() => Promise.resolve(viemClient)),
+}))
+
+vi.mock('../allowance/getAllowance', () => ({
+  getAllowance: vi.fn(() => Promise.resolve(1500000n)),
+}))
+
+const step = buildStepObject({
+  includingExecution: true,
+})
+
+describe.skip('Should pick up gas from wallet client estimation', () => {
+  const server = setupServer(...lifiHandlers)
+
+  beforeAll(() => server.listen({ onUnhandledRequest: 'error' }))
+
+  beforeEach(() => {
+    requestSettings.retries = 0
+    vi.clearAllMocks()
+
+    viemClient = {
+      sendTransaction: () => Promise.resolve('0xabc'),
+      getChainId: () => Promise.resolve(137),
+      getAddresses: () =>
+        Promise.resolve(['0x552008c0f6870c2f77e5cC1d2eb9bdff03e30Ea0']),
+    } as Partial<Client>
+  })
+
+  afterEach(() => server.resetHandlers())
+  afterAll(() => {
+    server.close()
+  })
+
+  it('should pick up gas limit + price estimation from wallet client', async () => {
+    const route = buildRouteObject({
+      step,
+    })
+
+    await executeRoute(client, route)
+
+    expect(sendTransaction).toHaveBeenCalledWith(viemClient, {
+      gasLimit: 125000n,
+      gasPrice: 100000n,
+      // TODO: Check the cause for gasLimit being outside transactionRequest. Currently working as expected in widget
+      transactionRequest: {
+        chainId: 137,
+        data: '0xdata',
+        from: '0x552008c0f6870c2f77e5cC1d2eb9bdff03e30Ea0',
+        gasLimit: '682701',
+        gasPrice: '0x27c01c1727',
+        to: '0x1231DEB6f5749EF6cE6943a275A1D3E7486F4EaE',
+        value: '0x0600830dbc7f5bf7',
+      },
+    })
+  })
+})

package/src/core/executionState.ts

@@ -1,4 +1,8 @@
-import type { ExecutionOptions, RouteExtended, StepExecutor } from './types.js'
+import type {
+  ExecutionOptions,
+  RouteExtended,
+  StepExecutor,
+} from '../types/core.js'
 
 interface ExecutionData {
   route: RouteExtended

package/src/core/prepareRestart.ts

@@ -1,4 +1,4 @@
-import type { RouteExtended } from './types.js'
+import type { RouteExtended } from '../types/core.js'
 
 export const prepareRestart = (route: RouteExtended) => {
   for (let index = 0; index < route.steps.length; index++) {

package/src/core/processMessages.ts

@@ -1,5 +1,5 @@
 import type { StatusMessage, Substatus } from '@lifi/types'
-import type { ProcessStatus, ProcessType } from './types.js'
+import type { ProcessStatus, ProcessType } from '../types/core.js'
 
 const processMessages: Record<
   ProcessType,

package/src/core/stepComparison.ts

@@ -1,8 +1,8 @@
 import type { LiFiStep } from '@lifi/types'
 import { LiFiErrorCode } from '../errors/constants.js'
 import { TransactionError } from '../errors/errors.js'
+import type { ExecutionOptions } from '../types/core.js'
 import type { StatusManager } from './StatusManager.js'
-import type { ExecutionOptions } from './types.js'
 import { checkStepSlippageThreshold } from './utils.js'
 
 /**

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

@@ -0,0 +1,89 @@
+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/core/utils.ts

@@ -1,4 +1,5 @@
-import type { LiFiStep, Token } from '@lifi/types'
+import type { ChainId, ExtendedChain, LiFiStep, Token } from '@lifi/types'
+import type { RPCUrls } from '../types/core.js'
 
 // Standard threshold for destination amount difference (0.5%)
 const standardThreshold = 0.005
@@ -29,6 +30,34 @@ export function checkStepSlippageThreshold(
   return actualSlippage <= setSlippage
 }
 
+export function getRpcUrlsFromChains(
+  existingRpcUrls: RPCUrls,
+  chains: ExtendedChain[],
+  skipChains?: ChainId[]
+) {
+  const rpcUrlsFromChains = chains.reduce((rpcUrls, chain) => {
+    if (chain.metamask?.rpcUrls?.length) {
+      rpcUrls[chain.id as ChainId] = chain.metamask.rpcUrls
+    }
+    return rpcUrls
+  }, {} as RPCUrls)
+  const result = { ...existingRpcUrls }
+  for (const rpcUrlsKey in rpcUrlsFromChains) {
+    const chainId = Number(rpcUrlsKey) as ChainId
+    const urls = rpcUrlsFromChains[chainId]
+    if (!urls?.length) {
+      continue
+    }
+    if (!result[chainId]?.length) {
+      result[chainId] = Array.from(urls)
+    } else if (!skipChains?.includes(chainId)) {
+      const filteredUrls = urls.filter((url) => !result[chainId]?.includes(url))
+      result[chainId].push(...filteredUrls)
+    }
+  }
+  return result
+}
+
 /**
  * Checks whether a given token is eligible for message signing.
  * Tokens with '₮' symbol in their name are disallowed,

package/src/core/waitForDestinationChainTransaction.ts

@@ -4,12 +4,13 @@ import type {
   FullStatusData,
 } from '@lifi/types'
 import { LiFiErrorCode } from '../errors/constants.js'
+import type { LiFiStepExtended, Process, SDKClient } from '../types/core.js'
 import { getTransactionFailedMessage } from '../utils/getTransactionMessage.js'
 import type { StatusManager } from './StatusManager.js'
-import type { LiFiStepExtended, Process } from './types.js'
 import { waitForTransactionStatus } from './waitForTransactionStatus.js'
 
 export async function waitForDestinationChainTransaction(
+  client: SDKClient,
   step: LiFiStepExtended,
   process: Process,
   fromChain: ExtendedChain,
@@ -40,6 +41,7 @@ export async function waitForDestinationChainTransaction(
     }
 
     const statusResponse = (await waitForTransactionStatus(
+      client,
       statusManager,
       transactionHash,
       step,
@@ -84,6 +86,7 @@ export async function waitForDestinationChainTransaction(
     return step
   } catch (e: unknown) {
     const htmlMessage = await getTransactionFailedMessage(
+      client,
       step,
       `${toChain.metamask.blockExplorerUrls[0]}tx/${transactionHash}`
     )

package/src/core/waitForTransactionStatus.ts

@@ -1,14 +1,15 @@
 import type { FullStatusData, LiFiStep, StatusResponse } from '@lifi/types'
+import { getStatus } from '../actions/getStatus.js'
 import { ServerError } from '../errors/errors.js'
-import { getStatus } from '../services/api.js'
+import type { ProcessType, SDKClient } from '../types/core.js'
 import { waitForResult } from '../utils/waitForResult.js'
 import { getSubstatusMessage } from './processMessages.js'
 import type { StatusManager } from './StatusManager.js'
-import type { ProcessType } from './types.js'
 
 const TRANSACTION_HASH_OBSERVERS: Record<string, Promise<StatusResponse>> = {}
 
 export async function waitForTransactionStatus(
+  client: SDKClient,
   statusManager: StatusManager,
   txHash: string,
   step: LiFiStep,
@@ -16,7 +17,7 @@ export async function waitForTransactionStatus(
   interval = 5_000
 ): Promise<StatusResponse> {
   const _getStatus = (): Promise<StatusResponse | undefined> => {
-    return getStatus({
+    return getStatus(client, {
       fromChain: step.action.fromChainId,
       fromAddress: step.action.fromAddress,
       toChain: step.action.toChainId,

package/src/errors/SDKError.ts

@@ -1,5 +1,5 @@
 import type { LiFiStep } from '@lifi/types'
-import type { Process } from '../core/types.js'
+import type { Process } from '../types/core.js'
 import { version } from '../version.js'
 import type { BaseError } from './baseError.js'
 import type { ErrorCode } from './constants.js'

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

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

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

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