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

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

@@ -1,298 +0,0 @@
-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/execution.unit.handlers.ts

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

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

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

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