@portal-hq/web 3.13.2 → 3.14.0-alpha.0

package/src/integrations/trading/lifi/lifi.tradeAsset.test.ts

@@ -0,0 +1,436 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import LiFi, { normalizeChainToNetwork } from './index'
+import Mpc from '../../../mpc'
+import portalMock from '../../../__mocks/portal/portal'
+import {
+  mockEip155Address,
+  mockHost,
+  mockLifiAction,
+  mockLifiGetRouteStepResponse,
+  mockLifiGetRoutesResponse,
+  mockLifiGetStatusResponse,
+  mockLifiRoute,
+  mockLifiStep,
+} from '../../../__mocks/constants'
+
+describe('normalizeChainToNetwork', () => {
+  it('maps hex chain ids to eip155', () => {
+    expect(normalizeChainToNetwork('0x1')).toBe('eip155:1')
+    expect(normalizeChainToNetwork('0xa')).toBe('eip155:10')
+    expect(normalizeChainToNetwork('0x89')).toBe('eip155:137')
+  })
+
+  it('preserves existing eip155 and numeric decimal strings', () => {
+    expect(normalizeChainToNetwork('eip155:42161')).toBe('eip155:42161')
+    expect(normalizeChainToNetwork('42161')).toBe('eip155:42161')
+  })
+})
+
+describe('LiFi tradeAsset', () => {
+  let mpc: Mpc
+  let lifi: LiFi
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    portalMock.host = mockHost
+    mpc = new Mpc({ portal: portalMock })
+    lifi = new LiFi({
+      mpc,
+      signAndSendTransaction: async () => '0xsent',
+      waitForConfirmation: async () => false,
+    })
+  })
+
+  it('throws when waitForConfirmation returns false and does not poll bridge status', async () => {
+    jest
+      .spyOn(mpc, 'getLifiRoutes')
+      .mockResolvedValue(mockLifiGetRoutesResponse as never)
+    jest
+      .spyOn(mpc, 'getLifiRouteStep')
+      .mockResolvedValue(mockLifiGetRouteStepResponse as never)
+    const pollSpy = jest
+      .spyOn(lifi, 'pollStatus')
+      .mockRejectedValue(new Error('pollStatus should not run'))
+
+    await expect(
+      lifi.tradeAsset({
+        fromChain: 'eip155:8453',
+        toChain: 'eip155:42161',
+        fromToken: 'ETH',
+        toToken: 'USDC',
+        amount: '1000000000000000',
+        fromAddress: mockEip155Address,
+      }),
+    ).rejects.toThrow(/on-chain confirmation did not complete/)
+
+    expect(pollSpy).not.toHaveBeenCalled()
+  })
+
+  it('strips nonce from EVM transaction request before sign', async () => {
+    const swapStep = {
+      ...mockLifiStep,
+      type: 'swap' as const,
+      action: {
+        ...mockLifiAction,
+        fromChainId: 'eip155:1',
+        toChainId: 'eip155:1',
+      },
+    }
+    const route = {
+      ...mockLifiRoute,
+      fromChainId: 'eip155:1',
+      toChainId: 'eip155:1',
+      steps: [swapStep],
+    }
+    const routesRes = {
+      data: {
+        rawResponse: {
+          routes: [route],
+          unavailableRoutes: { filteredOut: [], failed: [] },
+        },
+      },
+    }
+    const stepRes = {
+      data: {
+        rawResponse: {
+          ...swapStep,
+          transactionRequest: {
+            ...swapStep.transactionRequest,
+            nonce: '0xdeadbeef',
+          },
+        },
+      },
+    }
+
+    jest.spyOn(mpc, 'getLifiRoutes').mockResolvedValue(routesRes as never)
+    jest.spyOn(mpc, 'getLifiRouteStep').mockResolvedValue(stepRes as never)
+
+    const signer = jest.fn().mockResolvedValue('0xsigned')
+    const waiter = jest.fn().mockResolvedValue(true)
+    const lifiOk = new LiFi({
+      mpc,
+      signAndSendTransaction: signer,
+      waitForConfirmation: waiter,
+    })
+
+    await lifiOk.tradeAsset({
+      fromChain: 'eip155:1',
+      toChain: 'eip155:1',
+      fromToken: 'ETH',
+      toToken: 'USDC',
+      amount: '1000000000000000',
+      fromAddress: mockEip155Address,
+    })
+
+    expect(signer).toHaveBeenCalledTimes(1)
+    const sent = signer.mock.calls[0]![0] as Record<string, unknown>
+    expect(sent.nonce).toBeUndefined()
+  })
+
+  it('emits onProgress failed on unexpected errors (outer catch)', async () => {
+    const onProgress = jest.fn()
+    jest.spyOn(mpc, 'getLifiRoutes').mockRejectedValue(new Error('network down'))
+
+    await expect(
+      lifi.tradeAsset(
+        {
+          fromChain: 'eip155:8453',
+          toChain: 'eip155:42161',
+          fromToken: 'ETH',
+          toToken: 'USDC',
+          amount: '1000000000000000',
+          fromAddress: mockEip155Address,
+          onProgress,
+        },
+        {
+          signAndSendTransaction: async () => '0x',
+          waitForConfirmation: async () => true,
+        },
+      ),
+    ).rejects.toThrow('network down')
+
+    expect(onProgress).toHaveBeenCalledWith(
+      'failed',
+      expect.objectContaining({ errorMessage: 'network down' }),
+    )
+  })
+
+  it('throws when routeIndex is out of bounds', async () => {
+    jest
+      .spyOn(mpc, 'getLifiRoutes')
+      .mockResolvedValue(mockLifiGetRoutesResponse as never)
+    const lifiOk = new LiFi({
+      mpc,
+      signAndSendTransaction: async () => '0x',
+      waitForConfirmation: async () => true,
+    })
+
+    await expect(
+      lifiOk.tradeAsset({
+        fromChain: 'eip155:8453',
+        toChain: 'eip155:42161',
+        fromToken: 'ETH',
+        toToken: 'USDC',
+        amount: '1000000000000000',
+        fromAddress: mockEip155Address,
+        routeIndex: 99,
+      }),
+    ).rejects.toThrow(/no route available at index 99/)
+  })
+
+  it('throws when getRouteStep returns error', async () => {
+    jest
+      .spyOn(mpc, 'getLifiRoutes')
+      .mockResolvedValue(mockLifiGetRoutesResponse as never)
+    jest.spyOn(mpc, 'getLifiRouteStep').mockResolvedValue({
+      error: 'step build failed',
+    } as never)
+    const lifiOk = new LiFi({
+      mpc,
+      signAndSendTransaction: async () => '0x',
+      waitForConfirmation: async () => true,
+    })
+
+    await expect(
+      lifiOk.tradeAsset({
+        fromChain: 'eip155:8453',
+        toChain: 'eip155:42161',
+        fromToken: 'ETH',
+        toToken: 'USDC',
+        amount: '1000000000000000',
+        fromAddress: mockEip155Address,
+      }),
+    ).rejects.toThrow('getRouteStep: step build failed')
+  })
+
+  it('cross-chain step calls pollStatus with fast statusPoll options', async () => {
+    jest
+      .spyOn(mpc, 'getLifiRoutes')
+      .mockResolvedValue(mockLifiGetRoutesResponse as never)
+    jest
+      .spyOn(mpc, 'getLifiRouteStep')
+      .mockResolvedValue(mockLifiGetRouteStepResponse as never)
+    jest
+      .spyOn(mpc, 'getLifiStatus')
+      .mockResolvedValue(mockLifiGetStatusResponse as never)
+
+    const pollSpy = jest.spyOn(LiFi.prototype, 'pollStatus')
+    const signer = jest.fn().mockResolvedValue('0xstep1')
+    const lifiOk = new LiFi({
+      mpc,
+      signAndSendTransaction: signer,
+      waitForConfirmation: async () => true,
+    })
+
+    await lifiOk.tradeAsset({
+      fromChain: 'eip155:8453',
+      toChain: 'eip155:42161',
+      fromToken: 'ETH',
+      toToken: 'USDC',
+      amount: '1000000000000000',
+      fromAddress: mockEip155Address,
+      statusPoll: {
+        initialDelayMs: 0,
+        everyMs: 5,
+        timeoutMs: 20000,
+      },
+    })
+
+    expect(signer).toHaveBeenCalled()
+    expect(pollSpy).toHaveBeenCalled()
+    pollSpy.mockRestore()
+  })
+
+  it('same-chain swap does not call pollStatus', async () => {
+    const swapStep = {
+      ...mockLifiStep,
+      type: 'swap' as const,
+      action: {
+        ...mockLifiAction,
+        fromChainId: 'eip155:1',
+        toChainId: 'eip155:1',
+      },
+    }
+    const route = {
+      ...mockLifiRoute,
+      fromChainId: 'eip155:1',
+      toChainId: 'eip155:1',
+      steps: [swapStep],
+    }
+    const routesRes = {
+      data: {
+        rawResponse: {
+          routes: [route],
+          unavailableRoutes: { filteredOut: [], failed: [] },
+        },
+      },
+    }
+    const stepRes = {
+      data: {
+        rawResponse: {
+          ...swapStep,
+          transactionRequest: { ...swapStep.transactionRequest, chainId: 'eip155:1' },
+        },
+      },
+    }
+    jest.spyOn(mpc, 'getLifiRoutes').mockResolvedValue(routesRes as never)
+    jest.spyOn(mpc, 'getLifiRouteStep').mockResolvedValue(stepRes as never)
+
+    const pollSpy = jest.spyOn(LiFi.prototype, 'pollStatus')
+    const lifiOk = new LiFi({
+      mpc,
+      signAndSendTransaction: async () => '0xswap',
+      waitForConfirmation: async () => true,
+    })
+
+    await lifiOk.tradeAsset({
+      fromChain: 'eip155:1',
+      toChain: 'eip155:1',
+      fromToken: 'ETH',
+      toToken: 'USDC',
+      amount: '1000000000000000',
+      fromAddress: mockEip155Address,
+    })
+
+    expect(pollSpy).not.toHaveBeenCalled()
+    pollSpy.mockRestore()
+  })
+
+  it('throws when signer returns empty hash', async () => {
+    jest
+      .spyOn(mpc, 'getLifiRoutes')
+      .mockResolvedValue(mockLifiGetRoutesResponse as never)
+    jest
+      .spyOn(mpc, 'getLifiRouteStep')
+      .mockResolvedValue(mockLifiGetRouteStepResponse as never)
+    const onProgress = jest.fn()
+    const lifiOk = new LiFi({
+      mpc,
+      signAndSendTransaction: async () => '   ',
+      waitForConfirmation: async () => true,
+    })
+
+    await expect(
+      lifiOk.tradeAsset({
+        fromChain: 'eip155:8453',
+        toChain: 'eip155:42161',
+        fromToken: 'ETH',
+        toToken: 'USDC',
+        amount: '1000000000000000',
+        fromAddress: mockEip155Address,
+        onProgress,
+      }),
+    ).rejects.toThrow(/Invalid transaction hash/)
+
+    expect(onProgress).toHaveBeenCalledWith(
+      'failed',
+      expect.objectContaining({ errorMessage: expect.stringContaining('Invalid') }),
+    )
+  })
+
+  it('emits failed only ONCE when signer returns empty hash (no duplicate)', async () => {
+    jest
+      .spyOn(mpc, 'getLifiRoutes')
+      .mockResolvedValue(mockLifiGetRoutesResponse as never)
+    jest
+      .spyOn(mpc, 'getLifiRouteStep')
+      .mockResolvedValue(mockLifiGetRouteStepResponse as never)
+    const onProgress = jest.fn()
+    const lifiOk = new LiFi({
+      mpc,
+      signAndSendTransaction: async () => '',
+      waitForConfirmation: async () => true,
+    })
+
+    await expect(
+      lifiOk.tradeAsset({
+        fromChain: 'eip155:8453',
+        toChain: 'eip155:42161',
+        fromToken: 'ETH',
+        toToken: 'USDC',
+        amount: '1000000000000000',
+        fromAddress: mockEip155Address,
+        onProgress,
+      }),
+    ).rejects.toThrow(/Invalid transaction hash/)
+
+    const failedCalls = onProgress.mock.calls.filter(
+      (call) => call[0] === 'failed',
+    )
+    expect(failedCalls).toHaveLength(1)
+    expect(failedCalls[0]![1]).toMatchObject({
+      errorMessage: expect.stringContaining('Invalid transaction hash'),
+      stepIndex: 0,
+      totalSteps: 1,
+    })
+  })
+
+  it('emits failed only ONCE when waitForConfirmation returns false (no duplicate)', async () => {
+    jest
+      .spyOn(mpc, 'getLifiRoutes')
+      .mockResolvedValue(mockLifiGetRoutesResponse as never)
+    jest
+      .spyOn(mpc, 'getLifiRouteStep')
+      .mockResolvedValue(mockLifiGetRouteStepResponse as never)
+    const onProgress = jest.fn()
+    const lifiOk = new LiFi({
+      mpc,
+      signAndSendTransaction: async () => '0xhash',
+      waitForConfirmation: async () => false,
+    })
+
+    await expect(
+      lifiOk.tradeAsset({
+        fromChain: 'eip155:8453',
+        toChain: 'eip155:42161',
+        fromToken: 'ETH',
+        toToken: 'USDC',
+        amount: '1000000000000000',
+        fromAddress: mockEip155Address,
+        onProgress,
+      }),
+    ).rejects.toThrow(/on-chain confirmation did not complete/)
+
+    const failedCalls = onProgress.mock.calls.filter(
+      (call) => call[0] === 'failed',
+    )
+    expect(failedCalls).toHaveLength(1)
+    expect(failedCalls[0]![1]).toMatchObject({
+      errorMessage: expect.stringContaining('on-chain confirmation'),
+      txHash: '0xhash',
+      stepIndex: 0,
+      totalSteps: 1,
+    })
+  })
+
+  it('throws when waitForConfirmation throws', async () => {
+    jest
+      .spyOn(mpc, 'getLifiRoutes')
+      .mockResolvedValue(mockLifiGetRoutesResponse as never)
+    jest
+      .spyOn(mpc, 'getLifiRouteStep')
+      .mockResolvedValue(mockLifiGetRouteStepResponse as never)
+
+    const lifiOk = new LiFi({
+      mpc,
+      signAndSendTransaction: async () => '0xabc',
+      waitForConfirmation: async () => {
+        throw new Error('waiter boom')
+      },
+    })
+
+    await expect(
+      lifiOk.tradeAsset({
+        fromChain: 'eip155:8453',
+        toChain: 'eip155:42161',
+        fromToken: 'ETH',
+        toToken: 'USDC',
+        amount: '1000000000000000',
+        fromAddress: mockEip155Address,
+      }),
+    ).rejects.toThrow('waiter boom')
+  })
+})

package/src/integrations/trading/lifi/lifiStatusPoll.test.ts

@@ -0,0 +1,74 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import {
+  pollLifiStatusUntilTerminal,
+  isLikelyLifiIndexerNotReadyMessage,
+} from './lifiStatusPoll'
+import type { LifiStatusResponse } from '../../../shared/types'
+
+describe('lifiStatusPoll', () => {
+  describe('isLikelyLifiIndexerNotReadyMessage', () => {
+    it('returns true for known indexer lag phrases', () => {
+      expect(
+        isLikelyLifiIndexerNotReadyMessage('No transfer information found'),
+      ).toBe(true)
+      expect(isLikelyLifiIndexerNotReadyMessage('transfer not found')).toBe(
+        true,
+      )
+    })
+
+    it('returns false for unrelated errors', () => {
+      expect(isLikelyLifiIndexerNotReadyMessage('Network error 400')).toBe(
+        false,
+      )
+    })
+  })
+
+  describe('pollLifiStatusUntilTerminal', () => {
+    it('treats response error field as hard error without resetting counter incorrectly', async () => {
+      const getStatus = jest
+        .fn()
+        .mockResolvedValueOnce({
+          error: 'temporary',
+          data: undefined,
+        } as LifiStatusResponse)
+        .mockResolvedValueOnce({
+          data: { rawResponse: { status: 'DONE' as const } },
+        } as LifiStatusResponse)
+
+      const result = await pollLifiStatusUntilTerminal({
+        getStatus,
+        request: { txHash: '0x1' },
+        everyMs: 5,
+        initialDelayMs: 0,
+        timeoutMs: 5000,
+        maxConsecutiveErrors: 10,
+      })
+
+      expect(result.status).toBe('DONE')
+      expect(getStatus).toHaveBeenCalledTimes(2)
+    })
+
+    it('retries on indexer lag message without counting as hard error', async () => {
+      const getStatus = jest
+        .fn()
+        .mockRejectedValueOnce(new Error('transfer not found'))
+        .mockResolvedValue({
+          data: { rawResponse: { status: 'DONE' as const } },
+        } as LifiStatusResponse)
+
+      const result = await pollLifiStatusUntilTerminal({
+        getStatus,
+        request: { txHash: '0x1' },
+        everyMs: 5,
+        initialDelayMs: 0,
+        timeoutMs: 5000,
+        maxConsecutiveErrors: 2,
+      })
+
+      expect(result.status).toBe('DONE')
+    })
+  })
+})

package/src/integrations/trading/lifi/lifiStatusPoll.ts

@@ -0,0 +1,158 @@
+/**
+ * LiFi status polling: domain tick (DONE / FAILED / indexer lag) over shared {@link pollLoop}.
+ */
+import { sdkLogger } from '../../../logger'
+
+import type {
+  LifiStatusRawResponse,
+  LifiStatusRequest,
+  LifiStatusResponse,
+} from '../../../shared/types'
+
+import {
+  pollLoop,
+  PollLoopTimeoutError,
+  type PollTickResult,
+} from '../../../internal/pollLoop'
+
+const LOG_PREFIX = '[LiFi.pollStatus]'
+
+const INDEXER_LAG_MESSAGE_SNIPPETS = [
+  'not an evm transaction',
+  'no transfer information found',
+  'transfer not found',
+] as const
+
+export function isLikelyLifiIndexerNotReadyMessage(message: string): boolean {
+  const m = message.toLowerCase()
+  return INDEXER_LAG_MESSAGE_SNIPPETS.some((s) => m.includes(s))
+}
+
+export type LifiGetStatusFn = (
+  request: LifiStatusRequest,
+) => Promise<LifiStatusResponse>
+
+export interface PollLifiUntilTerminalParams {
+  getStatus: LifiGetStatusFn
+  request: Pick<LifiStatusRequest, 'txHash' | 'fromChain' | 'toChain' | 'bridge'>
+  onUpdate?: (raw: LifiStatusRawResponse) => boolean | void
+  everyMs: number
+  initialDelayMs: number
+  timeoutMs: number
+  maxConsecutiveErrors: number
+  backoff?: { factor: number; maxIntervalMs: number }
+}
+
+export async function pollLifiStatusUntilTerminal(
+  params: PollLifiUntilTerminalParams,
+): Promise<LifiStatusRawResponse> {
+  let consecutiveHardErrors = 0
+
+  try {
+    return await pollLoop<LifiStatusRawResponse>({
+      tick: async (): Promise<PollTickResult<LifiStatusRawResponse>> => {
+        return lifiStatusPollTick(params, {
+          get: () => consecutiveHardErrors,
+          set: (n: number) => {
+            consecutiveHardErrors = n
+          },
+        })
+      },
+      intervalMs: params.everyMs,
+      initialDelayMs: params.initialDelayMs,
+      backoff: params.backoff,
+      timeoutMs: params.timeoutMs,
+    })
+  } catch (error) {
+    if (error instanceof PollLoopTimeoutError) {
+      throw new Error(
+        `${LOG_PREFIX} timed out after ${params.timeoutMs}ms waiting for LiFi terminal status`,
+      )
+    }
+    throw error
+  }
+}
+
+async function lifiStatusPollTick(
+  params: PollLifiUntilTerminalParams,
+  counter: { get: () => number; set: (n: number) => void },
+): Promise<PollTickResult<LifiStatusRawResponse>> {
+  try {
+    const res: LifiStatusResponse = await params.getStatus(
+      params.request as LifiStatusRequest,
+    )
+
+    if (res.error) {
+      sdkLogger.warn(`${LOG_PREFIX} response error field`, res.error)
+      return bumpHardError(counter, params.maxConsecutiveErrors)
+    }
+
+    counter.set(0)
+
+    const raw = res.data?.rawResponse
+    if (!raw) {
+      return { kind: 'continue' }
+    }
+
+    const { status } = raw
+
+    if (status === 'INVALID') {
+      return {
+        kind: 'throw',
+        error: new Error(
+          `${LOG_PREFIX} LiFi status INVALID for ${params.request.txHash}`,
+        ),
+      }
+    }
+
+    if (status === 'DONE') {
+      return { kind: 'stop', value: raw }
+    }
+
+    if (status === 'FAILED') {
+      const detail =
+        raw.substatusMessage ?? raw.substatus ?? 'LiFi transfer FAILED'
+      return {
+        kind: 'throw',
+        error: new Error(`${LOG_PREFIX} ${detail}`),
+      }
+    }
+
+    if (params.onUpdate) {
+      const carryOn = params.onUpdate(raw)
+      if (carryOn === false) {
+        return { kind: 'stop', value: raw }
+      }
+    }
+
+    return { kind: 'continue' }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+
+    if (isLikelyLifiIndexerNotReadyMessage(message)) {
+      sdkLogger.debug(`${LOG_PREFIX} indexer not ready, will retry`, message)
+      counter.set(0)
+      return { kind: 'continue' }
+    }
+
+    sdkLogger.warn(`${LOG_PREFIX} getStatus error`, error)
+    return bumpHardError(counter, params.maxConsecutiveErrors)
+  }
+}
+
+function bumpHardError(
+  counter: { get: () => number; set: (n: number) => void },
+  max: number,
+): PollTickResult<LifiStatusRawResponse> {
+  const next = counter.get() + 1
+  counter.set(next)
+  if (next >= max) {
+    return {
+      kind: 'throw',
+      error: new Error(
+        `${LOG_PREFIX} too many consecutive getStatus failures (${max})`,
+      ),
+    }
+  }
+  return { kind: 'continue' }
+}