@lifi/sdk 3.13.5 → 4.0.0-alpha.1

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

@@ -0,0 +1,298 @@
+import type { Route } from '@lifi/types'
+import type { Mock } from 'vitest'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type {
+  ExecutionStatus,
+  LiFiStepExtended,
+  ProcessStatus,
+} from '../types/core.js'
+import {
+  buildRouteObject,
+  buildStepObject,
+  SOME_DATE,
+} from './execution.unit.mock.js'
+import { executionState } from './executionState.js'
+import { StatusManager } from './StatusManager.js'
+
+// Note: using structuredClone when passing objects to the StatusManager shall make sure that we are not facing any unknown call-by-reference-issues anymore
+
+describe('StatusManager', () => {
+  let statusManager: StatusManager
+  let updateRouteHookMock: Mock
+  let route: Route
+  let step: LiFiStepExtended
+
+  const expectCallbacksToHaveBeenCalledWith = (route: Route) => {
+    expect(updateRouteHookMock).toHaveBeenCalledWith(route)
+  }
+
+  const initializeStatusManager = ({
+    includingExecution,
+  }: {
+    includingExecution: boolean
+  }): StatusManager => {
+    step = buildStepObject({ includingExecution })
+    route = buildRouteObject({ step })
+
+    executionState.create({
+      route,
+      executionOptions: {
+        updateRouteHook: updateRouteHookMock,
+      },
+    })
+
+    return new StatusManager(route.id)
+  }
+
+  beforeEach(() => {
+    updateRouteHookMock = vi.fn()
+    vi.spyOn(Date, 'now').mockImplementation(() => SOME_DATE)
+  })
+
+  describe('initExecutionObject', () => {
+    describe('when no execution is defined yet', () => {
+      beforeEach(() => {
+        statusManager = initializeStatusManager({ includingExecution: false })
+        statusManager.initExecutionObject(step)
+      })
+
+      it('should create an empty execution & call the callbacks with the updated route', () => {
+        const updatedStep = Object.assign({}, step, {
+          execution: {
+            status: 'PENDING',
+            process: [],
+            startedAt: SOME_DATE,
+          },
+        })
+
+        const updatedRoute = Object.assign({}, route, {
+          steps: [updatedStep],
+        })
+
+        expectCallbacksToHaveBeenCalledWith(updatedRoute)
+      })
+    })
+
+    describe('when an execution is already defined', () => {
+      beforeEach(() => {
+        statusManager = initializeStatusManager({ includingExecution: true })
+        statusManager.initExecutionObject(structuredClone(step))
+      })
+
+      it('should not call the callbacks', () => {
+        expect(updateRouteHookMock).not.toHaveBeenCalled()
+      })
+    })
+  })
+
+  describe('updateExecution', () => {
+    beforeEach(() => {
+      vi.spyOn(Date, 'now').mockImplementation(() => SOME_DATE + 10)
+    })
+    describe('when no execution is defined yet', () => {
+      beforeEach(() => {
+        statusManager = initializeStatusManager({ includingExecution: false })
+      })
+
+      it('should throw an error', () => {
+        // function has to be wrapped into a function https://jestjs.io/docs/expect#tothrowerror
+        expect(() =>
+          statusManager.updateExecution(structuredClone(step), 'DONE')
+        ).toThrow("Can't update empty execution.")
+      })
+    })
+
+    describe('when an execution is defined', () => {
+      beforeEach(() => {
+        statusManager = initializeStatusManager({ includingExecution: true })
+        statusManager.updateExecution(structuredClone(step), 'DONE', {
+          fromAmount: '123',
+          toAmount: '312',
+        })
+      })
+
+      it('should update the execution & call the callbacks with the updated route', () => {
+        const updatedExecution = Object.assign({}, step.execution, {
+          fromAmount: '123',
+          toAmount: '312',
+          status: 'DONE',
+        })
+
+        const updatedStep = Object.assign({}, step, {
+          execution: updatedExecution,
+        })
+
+        const updatedRoute = Object.assign({}, route, {
+          steps: [updatedStep],
+        })
+
+        expectCallbacksToHaveBeenCalledWith(updatedRoute)
+      })
+    })
+  })
+
+  describe('findOrCreateProcess', () => {
+    describe('when no execution is defined yet', () => {
+      beforeEach(() => {
+        statusManager = initializeStatusManager({ includingExecution: false })
+      })
+
+      it('should throw an error', () => {
+        expect(() =>
+          statusManager.findOrCreateProcess({
+            step: structuredClone(step),
+            type: 'SWAP',
+          })
+        ).toThrow("Execution hasn't been initialized.")
+      })
+    })
+
+    describe('when an execution is defined', () => {
+      beforeEach(() => {
+        statusManager = initializeStatusManager({ includingExecution: true })
+      })
+
+      describe('and the process already exists', () => {
+        it('should return the process and not call the callbacks', () => {
+          const process = statusManager.findOrCreateProcess({
+            step: structuredClone(step),
+            type: 'TOKEN_ALLOWANCE',
+          })
+
+          expect(process).toEqual(step.execution?.process[0])
+
+          expect(updateRouteHookMock).not.toHaveBeenCalled()
+        })
+      })
+
+      describe("and the process doesn't exist", () => {
+        it('should create a process and call the callbacks with the updated route', () => {
+          const process = statusManager.findOrCreateProcess({
+            step: structuredClone(step),
+            type: 'CROSS_CHAIN',
+          })
+
+          expect(process.type).toEqual('CROSS_CHAIN')
+          expect(process.status).toEqual('STARTED')
+          expect(process.message).toEqual('Preparing bridge transaction')
+
+          const updatedExecution = Object.assign({}, step.execution, {
+            process: [...step.execution!.process, process],
+          })
+
+          const updatedStep = Object.assign({}, step, {
+            execution: updatedExecution,
+          })
+
+          const updatedRoute = Object.assign({}, route, {
+            steps: [updatedStep],
+          })
+
+          expectCallbacksToHaveBeenCalledWith(updatedRoute)
+        })
+      })
+    })
+  })
+
+  describe('updateProcess', () => {
+    beforeEach(() => {
+      statusManager = initializeStatusManager({ includingExecution: true })
+    })
+
+    describe('when no process can be found', () => {
+      it('should throw an error', () => {
+        expect(() =>
+          statusManager.updateProcess(
+            structuredClone(step),
+            'CROSS_CHAIN',
+            'CANCELLED'
+          )
+        ).toThrow("Can't find a process for the given type.")
+      })
+    })
+
+    describe('when a process is found', () => {
+      const statuses = [
+        { status: 'ACTION_REQUIRED' },
+        { status: 'PENDING' },
+        { status: 'FAILED', doneAt: true },
+        { status: 'DONE', doneAt: true },
+        { status: 'CANCELLED', doneAt: true },
+      ]
+      for (const { status, doneAt } of statuses) {
+        describe(`and the status is ${status}`, () => {
+          it('should update the process and call the callbacks', () => {
+            const process = statusManager.updateProcess(
+              structuredClone(step),
+              'SWAP',
+              status as ProcessStatus
+            )
+
+            expect(process.type).toEqual('SWAP')
+            expect(process.status).toEqual(status)
+            // expect(process.message).toEqual(
+            //   getProcessMessage('SWAP', status as Status)
+            // )
+            doneAt
+              ? expect(process.doneAt).toBeDefined()
+              : expect(process.doneAt).toBeUndefined()
+
+            const notUpdateableStatus =
+              status === 'DONE' || status === 'CANCELLED'
+            const updatedExecution = Object.assign({}, step.execution, {
+              process: [step.execution!.process[0], process],
+              status: notUpdateableStatus
+                ? step.execution!.status
+                : (status as ExecutionStatus),
+            })
+
+            const updatedStep = { ...step, execution: updatedExecution }
+
+            const updatedRoute = Object.assign({}, route, {
+              steps: [updatedStep],
+            })
+
+            expectCallbacksToHaveBeenCalledWith(updatedRoute)
+          })
+        })
+      }
+    })
+  })
+
+  describe('removeProcess', () => {
+    describe('when no execution is defined yet', () => {
+      beforeEach(() => {
+        statusManager = initializeStatusManager({ includingExecution: false })
+      })
+
+      it('should throw an error', () => {
+        expect(() =>
+          statusManager.removeProcess(structuredClone(step), 'TOKEN_ALLOWANCE')
+        ).toThrow("Execution hasn't been initialized.")
+      })
+    })
+
+    describe('when an execution is defined', () => {
+      beforeEach(() => {
+        statusManager = initializeStatusManager({ includingExecution: true })
+        statusManager.removeProcess(structuredClone(step), 'TOKEN_ALLOWANCE')
+      })
+
+      it('should remove the process and call the callbacks', () => {
+        const updatedExecution = Object.assign({}, step.execution, {
+          process: [step.execution!.process[1]],
+        })
+
+        const updatedStep = Object.assign({}, step, {
+          execution: updatedExecution,
+        })
+
+        const updatedRoute = Object.assign({}, route, {
+          steps: [updatedStep],
+        })
+
+        expectCallbacksToHaveBeenCalledWith(updatedRoute)
+      })
+    })
+  })
+})

package/src/core/checkBalance.ts

@@ -1,15 +1,21 @@
 import type { LiFiStep } from '@lifi/types'
 import { formatUnits } from 'viem'
+import { getTokenBalance } from '../actions/getTokenBalance.js'
 import { BalanceError } from '../errors/errors.js'
-import { getTokenBalance } from '../services/balance.js'
+import type { SDKClient } from '../types/core.js'
 import { sleep } from '../utils/sleep.js'
 
 export const checkBalance = async (
+  client: SDKClient,
   walletAddress: string,
   step: LiFiStep,
   depth = 0
 ): Promise<void> => {
-  const token = await getTokenBalance(walletAddress, step.action.fromToken)
+  const token = await getTokenBalance(
+    client,
+    walletAddress,
+    step.action.fromToken
+  )
   if (token) {
     const currentBalance = token.amount ?? 0n
     const neededBalance = BigInt(step.action.fromAmount)
@@ -17,7 +23,7 @@ export const checkBalance = async (
     if (currentBalance < neededBalance) {
       if (depth <= 3) {
         await sleep(200)
-        await checkBalance(walletAddress, step, depth + 1)
+        await checkBalance(client, walletAddress, step, depth + 1)
       } else if (
         (neededBalance *
           BigInt((1 - (step.action.slippage ?? 0)) * 1_000_000_000)) /

package/src/core/execution.ts

@@ -1,19 +1,25 @@
 import type { Route } from '@lifi/types'
-import { config } from '../config.js'
 import { LiFiErrorCode } from '../errors/constants.js'
 import { ProviderError } from '../errors/errors.js'
+import type {
+  ExecutionOptions,
+  RouteExtended,
+  SDKClient,
+  SDKProvider,
+} from '../types/core.js'
 import { executionState } from './executionState.js'
 import { prepareRestart } from './prepareRestart.js'
-import type { ExecutionOptions, RouteExtended } from './types.js'
 
 /**
  * Execute a route.
+ * @param client - The SDK client.
  * @param route - The route that should be executed. Cannot be an active route.
  * @param executionOptions - An object containing settings and callbacks.
  * @returns The executed route.
  * @throws {LiFiError} Throws a LiFiError if the execution fails.
  */
 export const executeRoute = async (
+  client: SDKClient,
   route: Route,
   executionOptions?: ExecutionOptions
 ): Promise<RouteExtended> => {
@@ -27,7 +33,7 @@ export const executeRoute = async (
   }
 
   executionState.create({ route: clonedRoute, executionOptions })
-  executionPromise = executeSteps(clonedRoute)
+  executionPromise = executeSteps(client, clonedRoute)
   executionState.update({
     route: clonedRoute,
     promise: executionPromise,
@@ -38,12 +44,14 @@ export const executeRoute = async (
 
 /**
  * Resume the execution of a route that has been stopped or had an error while executing.
+ * @param client - The SDK client.
  * @param route - The route that is to be executed. Cannot be an active route.
  * @param executionOptions - An object containing settings and callbacks.
  * @returns The executed route.
  * @throws {LiFiError} Throws a LiFiError if the execution fails.
  */
 export const resumeRoute = async (
+  client: SDKClient,
   route: Route,
   executionOptions?: ExecutionOptions
 ): Promise<RouteExtended> => {
@@ -68,10 +76,13 @@ export const resumeRoute = async (
 
   prepareRestart(route)
 
-  return executeRoute(route, executionOptions)
+  return executeRoute(client, route, executionOptions)
 }
 
-const executeSteps = async (route: RouteExtended): Promise<RouteExtended> => {
+const executeSteps = async (
+  client: SDKClient,
+  route: RouteExtended
+): Promise<RouteExtended> => {
   // Loop over steps and execute them
   for (let index = 0; index < route.steps.length; index++) {
     const execution = executionState.get(route.id)
@@ -103,9 +114,9 @@ const executeSteps = async (route: RouteExtended): Promise<RouteExtended> => {
         throw new Error('Action fromAddress is not specified.')
       }
 
-      const provider = config
-        .get()
-        .providers.find((provider) => provider.isAddress(fromAddress))
+      const provider = client.providers.find((provider: SDKProvider) =>
+        provider.isAddress(fromAddress)
+      )
 
       if (!provider) {
         throw new ProviderError(
@@ -125,7 +136,7 @@ const executeSteps = async (route: RouteExtended): Promise<RouteExtended> => {
         updateRouteExecution(route, execution.executionOptions)
       }
 
-      const executedStep = await stepExecutor.executeStep(step)
+      const executedStep = await stepExecutor.executeStep(client, step)
 
       // We may reach this point if user interaction isn't allowed. We want to stop execution until we resume it
       if (executedStep.execution?.status !== 'DONE') {

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

@@ -0,0 +1,32 @@
+import { HttpResponse, http } from 'msw'
+import { createClient } from '../client/createClient.js'
+import {
+  buildStepObject,
+  mockChainsResponse,
+  mockStatus,
+  mockStepTransactionWithTxRequest,
+} from './execution.unit.mock.js'
+
+const client = createClient({
+  integrator: 'lifi-sdk',
+})
+
+export const lifiHandlers = [
+  http.post(`${client.config.apiUrl}/advanced/stepTransaction`, async () =>
+    HttpResponse.json(
+      mockStepTransactionWithTxRequest(
+        buildStepObject({
+          includingExecution: true,
+        })
+      )
+    )
+  ),
+  http.get(`${client.config.apiUrl}/chains`, async () =>
+    HttpResponse.json({
+      chains: mockChainsResponse,
+    })
+  ),
+  http.get(`${client.config.apiUrl}/status`, async () =>
+    HttpResponse.json(mockStatus)
+  ),
+]

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

@@ -0,0 +1,252 @@
+import { findDefaultToken } from '@lifi/data-types'
+import type { LiFiStep, Route, Token } from '@lifi/types'
+import { ChainId, CoinKey } from '@lifi/types'
+import type { LiFiStepExtended } from '../types/core.js'
+
+const SOME_TOKEN: Token = {
+  ...findDefaultToken(CoinKey.USDC, ChainId.DAI),
+  priceUSD: '',
+}
+const SOME_OTHER_TOKEN: Token = {
+  ...findDefaultToken(CoinKey.USDT, ChainId.DAI),
+  priceUSD: '',
+}
+
+export const SOME_DATE = new Date('2021-04-10').getTime()
+
+export const mockChainsResponse = [
+  {
+    key: 'pol',
+    chainType: 'EVM',
+    name: 'Polygon',
+    coin: 'MATIC',
+    id: 137,
+    mainnet: true,
+    logoURI:
+      'https://raw.githubusercontent.com/lifinance/types/main/src/assets/icons/chains/polygon.svg',
+    tokenlistUrl:
+      'https://unpkg.com/quickswap-default-token-list@1.0.71/build/quickswap-default.tokenlist.json',
+    faucetUrls: ['https://stakely.io/faucet/polygon-matic'],
+    multicallAddress: '0xcA11bde05977b3631167028862bE2a173976CA11',
+    metamask: {
+      chainId: '0x89',
+      blockExplorerUrls: [
+        'https://polygonscan.com/',
+        'https://explorer-mainnet.maticvigil.com/',
+      ],
+      chainName: 'Matic(Polygon) Mainnet',
+      nativeCurrency: {
+        name: 'MATIC',
+        symbol: 'MATIC',
+        decimals: 18,
+      },
+      rpcUrls: [
+        'https://polygon-rpc.com/',
+        'https://rpc-mainnet.maticvigil.com/',
+      ],
+    },
+    nativeToken: {
+      address: '0x0000000000000000000000000000000000000000',
+      chainId: 137,
+      symbol: 'MATIC',
+      decimals: 18,
+      name: 'MATIC',
+      priceUSD: '0.899628',
+      logoURI:
+        'https://static.debank.com/image/matic_token/logo_url/matic/6f5a6b6f0732a7a235131bd7804d357c.png',
+      coinKey: 'MATIC',
+    },
+  },
+]
+
+const mockTransactionRequest = {
+  transactionRequest: {
+    data: '0xdata',
+    to: '0x1231DEB6f5749EF6cE6943a275A1D3E7486F4EaE',
+    value: '0x0600830dbc7f5bf7',
+    from: '0x552008c0f6870c2f77e5cC1d2eb9bdff03e30Ea0',
+    chainId: 137,
+    gasPrice: '0x27c01c1727',
+    gasLimit: '682701',
+  },
+}
+
+export const mockStatus = {
+  status: 'DONE',
+  receiving: true,
+  sending: {
+    amount: '123',
+    gasAmount: '123',
+    gasAmountUSD: '123',
+    gasPrice: '123',
+    gasToken: '123',
+    gasUsed: '123',
+  },
+}
+
+export const mockStepTransactionWithTxRequest = (
+  step: LiFiStep = buildStepObject({
+    includingExecution: false,
+  })
+) => ({
+  ...step,
+  transactionRequest: mockTransactionRequest,
+})
+
+export const buildStepObject = ({
+  includingExecution = true,
+}: {
+  includingExecution?: boolean
+}): LiFiStepExtended => ({
+  id: '8d3a0474-4ee3-4a7a-90c7-2a2264b7f3a9',
+  type: 'lifi',
+  tool: '1inch',
+  toolDetails: {
+    key: '1inch',
+    name: '1inch',
+    logoURI:
+      'https://raw.githubusercontent.com/lifinance/types/main/src/assets/icons/exchanges/oneinch.png',
+  },
+  action: {
+    fromChainId: 137,
+    toChainId: 137,
+    fromToken: SOME_TOKEN,
+    toToken: SOME_OTHER_TOKEN,
+    fromAmount: '1500000',
+    slippage: 0.03,
+    fromAddress: '0x552008c0f6870c2f77e5cC1d2eb9bdff03e30Ea0',
+    toAddress: '0x552008c0f6870c2f77e5cC1d2eb9bdff03e30Ea0',
+  },
+  estimate: {
+    fromAmount: '1000000',
+    fromAmountUSD: '100',
+    toAmount: '260982615655554',
+    toAmountUSD: '26098',
+    toAmountMin: '253153137185887',
+    approvalAddress: '0x11111112542d85b3ef69ae05771c2dccff4faa26',
+    executionDuration: 300,
+    tool: '1inch',
+  },
+  includedSteps: [
+    {
+      id: 'f8474598-a553-4643-bbd1-bf8c77e679b3',
+      type: 'swap',
+      action: {
+        fromChainId: 137,
+        fromAmount: '5000000000000000000',
+        fromToken: {
+          address: '0x0000000000000000000000000000000000000000',
+          chainId: 137,
+          symbol: 'MATIC',
+          decimals: 18,
+          name: 'MATIC',
+          priceUSD: '1.124763',
+          logoURI:
+            'https://static.debank.com/image/matic_token/logo_url/matic/6f5a6b6f0732a7a235131bd7804d357c.png',
+          coinKey: CoinKey.MATIC,
+        },
+        toChainId: 137,
+        toToken: {
+          address: '0xc2132d05d31c914a87c6611c10748aeb04b58e8f',
+          chainId: 137,
+          symbol: 'USDT',
+          decimals: 6,
+          name: '(PoS) Tether USD',
+          priceUSD: '1.00081',
+          logoURI:
+            'https://static.debank.com/image/coin/logo_url/usdt/23af7472292cb41dc39b3f1146ead0fe.png',
+          coinKey: CoinKey.USDT,
+        },
+        slippage: 0.005,
+      },
+      estimate: {
+        tool: '1inch',
+        fromAmount: '5000000000000000000',
+        toAmount: '5617317',
+        toAmountMin: '5589230',
+        approvalAddress: '0x1111111254eeb25477b68fb85ed929f73a960582',
+        executionDuration: 30,
+        feeCosts: [],
+        gasCosts: [
+          {
+            type: 'SEND',
+            price: '149725515512',
+            estimate: '258059',
+            limit: '344079',
+            amount: '51517405651853448',
+            amountUSD: '0.06',
+            token: {
+              address: '0x0000000000000000000000000000000000000000',
+              chainId: 137,
+              symbol: 'MATIC',
+              decimals: 18,
+              name: 'MATIC',
+              priceUSD: '1.124763',
+              logoURI:
+                'https://static.debank.com/image/matic_token/logo_url/matic/6f5a6b6f0732a7a235131bd7804d357c.png',
+              coinKey: CoinKey.MATIC,
+            },
+          },
+        ],
+      },
+      tool: '1inch',
+      toolDetails: {
+        key: '1inch',
+        name: '1inch',
+        logoURI:
+          'https://raw.githubusercontent.com/lifinance/types/main/src/assets/icons/exchanges/oneinch.png',
+      },
+    },
+  ],
+  execution: includingExecution
+    ? {
+        status: 'PENDING',
+        startedAt: SOME_DATE,
+        doneAt: SOME_DATE + 10,
+        process: [
+          {
+            type: 'TOKEN_ALLOWANCE',
+            startedAt: SOME_DATE,
+            message: 'Somethings done',
+            status: 'DONE',
+            doneAt: SOME_DATE + 10,
+            txHash: '0x11111112542d85b3ef69ae05771c2dccff4faa26',
+            txLink: 'https://example.com',
+          },
+          {
+            type: 'SWAP',
+            startedAt: SOME_DATE + 20,
+            message: 'Somethings pending',
+            status: 'PENDING',
+          },
+        ],
+        fromAmount: '1000000',
+        toAmount: '261490494702370',
+      }
+    : undefined,
+})
+
+export const buildRouteObject = ({
+  step = buildStepObject({}),
+}: {
+  step?: LiFiStep
+}): Route => ({
+  id: '0x433df53dbf6dbd7b946fc4f3b501c3ff32957d77d96c9d5ba1805b01eb6461cc',
+  fromChainId: 137,
+  fromAmountUSD: '1.00',
+  fromAmount: '1000000',
+  fromToken: SOME_TOKEN,
+  fromAddress: '0x552008c0f6870c2f77e5cC1d2eb9bdff03e30Ea0',
+  toChainId: 137,
+  toAmountUSD: '1.00',
+  toAmount: '260982615655554',
+  toAmountMin: '253153137185887',
+  toToken: SOME_OTHER_TOKEN,
+  toAddress: '0x552008c0f6870c2f77e5cC1d2eb9bdff03e30Ea0',
+  gasCostUSD: '0.01',
+  steps: [step],
+  insurance: {
+    feeAmountUsd: '0',
+    state: 'NOT_INSURABLE',
+  },
+})