tapimo 0.3.0 → 0.4.0

package/src/apps/data/FundingRouteProviders.test.ts

@@ -0,0 +1,281 @@
+import * as FundingRoutes from '../../internal/FundingRoutes.js'
+import * as FundingRouteProviders from './FundingRouteProviders.js'
+
+const now = () => new Date('2026-01-01T00:00:00.000Z')
+
+describe('FundingRouteProviders', () => {
+  test('maps Across suggested-fees responses into quote probes', async () => {
+    const requests: RecordedRequest[] = []
+    const fetch = recordingFetch(requests, async () =>
+      jsonResponse({
+        estimatedFillTimeSec: 2,
+        limits: {
+          maxDeposit: '2000000',
+          maxDepositInstant: '1500000',
+          minDeposit: '500000',
+        },
+        outputAmount: '990000',
+        relayFeePct: '1200000000000000',
+        timestamp: '1767225600',
+      }),
+    )
+    const adapter = FundingRouteProviders.across({
+      apiKey: 'across-api-key',
+      baseUrl: 'https://across.test/api/',
+      fetch,
+      integratorId: 'tempo',
+      now,
+    })
+
+    const result = await adapter.probeQuote(
+      await probeInput('across'),
+      new AbortController().signal,
+    )
+
+    expect(requests).toHaveLength(1)
+    expect(requests[0]?.url.pathname).toBe('/api/suggested-fees')
+    expect(requests[0]?.url.searchParams.get('originChainId')).toBe('8453')
+    expect(requests[0]?.url.searchParams.get('destinationChainId')).toBe('4217')
+    expect(requests[0]?.url.searchParams.get('amount')).toBe('1000000')
+    expect(requests[0]?.url.searchParams.get('integratorId')).toBe('tempo')
+    expect(requests[0]?.url.searchParams.get('allowUnmatchedDecimals')).toBe('true')
+    expect(new Headers(requests[0]?.init?.headers).get('authorization')).toBe(
+      'Bearer across-api-key',
+    )
+    expect(result).toMatchObject({
+      expiresAt: '2026-01-01T00:10:00.000Z',
+      limits: {
+        instantSourceAmount: '1500000',
+        maxSourceAmount: '2000000',
+        minSourceAmount: '500000',
+      },
+      outputAmount: '990000',
+      outputAmountFormatted: '0.99',
+      quality: {
+        availableVolumeUsd: '2',
+        estimatedSeconds: 2,
+        feeBps: 12,
+        instantVolumeUsd: '1.5',
+        liquiditySource: 'providerLimit',
+        sourceDetail: 'across:suggested-fees',
+        tier: 'liquid',
+      },
+      sampledAt: '2026-01-01T00:00:00.000Z',
+      status: 'available',
+    })
+  })
+
+  test('maps recognized Across quote errors to unavailable probes', async () => {
+    const fetch = recordingFetch([], async () =>
+      jsonResponse({ code: 'AMOUNT_TOO_HIGH', message: 'Amount exceeds max deposit' }, 400),
+    )
+    const adapter = FundingRouteProviders.across({
+      apiKey: 'across-api-key',
+      fetch,
+      integratorId: 'tempo',
+      now,
+    })
+
+    const result = await adapter.probeQuote(
+      await probeInput('across'),
+      new AbortController().signal,
+    )
+
+    expect(result).toMatchObject({
+      quality: {
+        liquiditySource: 'providerLimit',
+        score: 0,
+        sourceDetail: 'across:suggested-fees:AMOUNT_TOO_HIGH',
+        tier: 'unavailable',
+      },
+      sampledAt: '2026-01-01T00:00:00.000Z',
+      status: 'unavailable',
+    })
+  })
+
+  test('maps Relay liquidity and quote responses into quote probes', async () => {
+    const requests: RecordedRequest[] = []
+    const route = await staticRoute('relay')
+    const fetch = recordingFetch(requests, async (request) => {
+      if (request.url.pathname === '/quote/v2')
+        return jsonResponse({
+          details: {
+            currencyOut: {
+              amount: '990000',
+              minimumAmount: '980000',
+            },
+            timeEstimate: 15,
+            totalImpact: { percent: '-1.20' },
+          },
+        })
+      return jsonResponse({
+        liquidity: [
+          {
+            address: route.destinationToken.address.toUpperCase(),
+            amountUsd: '5.00',
+            balance: '5000000',
+            chainId: 4217,
+          },
+        ],
+      })
+    })
+    const adapter = FundingRouteProviders.relay({
+      apiKey: 'relay-api-key',
+      fetch,
+      now,
+      userAddress: '0x1111111111111111111111111111111111111111',
+    })
+
+    const result = await adapter.probeQuote(
+      probeInputFromRoute(route),
+      new AbortController().signal,
+    )
+
+    expect(requests.map((request) => request.url.pathname)).toEqual([
+      '/quote/v2',
+      '/chains/liquidity',
+    ])
+    expect(requests[1]?.url.searchParams.get('chainId')).toBe('4217')
+    expect(new Headers(requests[0]?.init?.headers).get('x-api-key')).toBe('relay-api-key')
+    expect(jsonRequestBody(requests[0])).toMatchObject({
+      amount: '1000000',
+      destinationChainId: 4217,
+      destinationCurrency: route.destinationToken.address,
+      originChainId: 8453,
+      originCurrency: route.sourceToken.address,
+      tradeType: 'EXACT_INPUT',
+      user: '0x1111111111111111111111111111111111111111',
+    })
+    expect(result).toMatchObject({
+      limits: null,
+      minimumOutputAmount: '980000',
+      outputAmount: '990000',
+      outputAmountFormatted: '0.99',
+      quality: {
+        availableVolumeUsd: '5.00',
+        estimatedSeconds: 15,
+        feeBps: null,
+        instantVolumeUsd: '5.00',
+        liquiditySource: 'providerQuote',
+        sourceDetail: 'relay:quote-v2',
+        tier: 'liquid',
+      },
+      sampledAt: '2026-01-01T00:00:00.000Z',
+      status: 'available',
+    })
+  })
+
+  test('keeps Relay quotes when the liquidity probe fails', async () => {
+    const route = await staticRoute('relay')
+    const fetch = recordingFetch([], async (request) => {
+      if (request.url.pathname === '/quote/v2')
+        return jsonResponse({
+          details: {
+            currencyOut: {
+              amount: '990000',
+              minimumAmount: '980000',
+            },
+            timeEstimate: 15,
+          },
+        })
+      return jsonResponse({ message: 'temporarily unavailable' }, 503)
+    })
+    const adapter = FundingRouteProviders.relay({
+      fetch,
+      now,
+      userAddress: '0x1111111111111111111111111111111111111111',
+    })
+
+    const result = await adapter.probeQuote(
+      probeInputFromRoute(route),
+      new AbortController().signal,
+    )
+
+    expect(result).toMatchObject({
+      outputAmount: '990000',
+      quality: {
+        availableVolumeUsd: null,
+        instantVolumeUsd: null,
+        liquiditySource: 'providerQuote',
+        tier: 'unknown',
+      },
+      status: 'unknown',
+    })
+  })
+})
+
+type RecordedRequest = {
+  init: RequestInit | undefined
+  url: URL
+}
+
+async function staticRoute(
+  provider: FundingRoutes.ProviderId,
+): Promise<FundingRoutes.QuoteProbeInput['route']> {
+  const [route] = await FundingRoutes.listRoutes({
+    limit: 10,
+    provider,
+    sourceAmount: '1000000',
+    sourceAmountUnits: 'baseUnits',
+    sourceToken: 'USDC',
+    sourceChain: 'base',
+  })
+  if (!route) throw new Error(`Missing ${provider} route`)
+  return route as FundingRoutes.QuoteProbeInput['route']
+}
+
+async function probeInput(provider: FundingRoutes.ProviderId) {
+  return probeInputFromRoute(await staticRoute(provider))
+}
+
+function probeInputFromRoute(
+  route: FundingRoutes.QuoteProbeInput['route'],
+): FundingRoutes.QuoteProbeInput {
+  return {
+    cache: { bypass: false },
+    destinationChain: route.destinationChain,
+    destinationToken: route.destinationToken,
+    include: ['quotes'],
+    request: {
+      include: ['quotes'],
+      limit: 10,
+      provider: route.provider.id,
+      sourceAmount: route.sourceAmount.amount,
+      sourceAmountUnits: 'baseUnits',
+      sourceChain: route.sourceChain.id,
+      sourceToken: route.sourceToken.symbol,
+    },
+    route,
+    sourceAmount: route.sourceAmount,
+    sourceChain: route.sourceChain,
+    sourceToken: route.sourceToken,
+  }
+}
+
+function recordingFetch(
+  requests: RecordedRequest[],
+  respond: (request: RecordedRequest) => Response | Promise<Response>,
+): typeof globalThis.fetch {
+  return async (input, init) => {
+    const request = { init, url: toUrl(input) }
+    requests.push(request)
+    return respond(request)
+  }
+}
+
+function toUrl(input: Parameters<typeof globalThis.fetch>[0]) {
+  if (input instanceof Request) return new URL(input.url)
+  return new URL(String(input))
+}
+
+function jsonResponse(body: unknown, status = 200) {
+  return new Response(JSON.stringify(body), {
+    headers: { 'content-type': 'application/json' },
+    status,
+  })
+}
+
+function jsonRequestBody(request: RecordedRequest | undefined) {
+  if (typeof request?.init?.body !== 'string') throw new Error('Expected JSON request body')
+  return JSON.parse(request.init.body) as unknown
+}