tapimo 0.4.4 → 0.5.1

package/src/apps/data/routes/funding.test.ts

@@ -1,235 +1,256 @@
 import { Schema } from 'tapimo'
 
+import type * as FundingQuotes from '../../../internal/FundingQuotes.js'
+import type * as Log from '../../../internal/Log.js'
 import * as TestApp from '../../../../test/App.js'
 import * as Funding from './funding.js'
 
-describe('GET /funding/routes', () => {
-  test('returns static inventory-backed route candidates', async () => {
-    const response = await TestApp.client().v1.funding.routes.$get(
-      {
-        query: {
-          destinationToken: 'USDC.e',
-          sourceAmount: '1000000',
-          sourceChain: 'base',
-          sourceToken: 'USDC',
-        },
-      },
-      TestApp.auth,
-    )
+describe('GET /funding/quotes', () => {
+  test('returns successful live quotes with output amounts', async () => {
+    const app = TestApp.create({ funding: { adapters: { relay: relayAdapter() } } })
+    const response = await app.request(quoteUrl(), { headers: TestApp.auth.headers })
     expect(response.status).toBe(200)
-    const body = await TestApp.json(response, Funding.schema.listFundingRoutes.Response)
+    expect(response.headers.get('cache-control')).toBe('no-store')
+    const body = await TestApp.json(response, Funding.schema.quoteFunding.Response)
 
-    expect(body.data.map((route) => route.provider.id)).toEqual(['relay', 'bridge', 'bungee'])
+    expect(body.data).toHaveLength(1)
     expect(body.data[0]).toMatchObject({
-      destinationChain: { id: 'eip155:4217', name: 'Tempo' },
-      destinationToken: { symbol: 'USDC.e' },
       id: 'base-usdc-tempo-usdce-relay',
-      quality: { liquiditySource: 'staticInventory', tier: 'unknown' },
+      provider: { id: 'relay' },
+      quality: { liquiditySource: 'providerQuote', tier: 'liquid' },
+      quote: {
+        inputAmount: '1000000',
+        outputAmount: '990000',
+        outputAmountFormatted: '0.99',
+      },
       sourceAmount: { amount: '1000000', formatted: '1' },
-      sourceChain: { id: 'eip155:8453', name: 'Base' },
-      sourceToken: { symbol: 'USDC' },
-      status: 'unknown',
     })
   })
 
-  test('enriches route candidates with configured provider adapters', async () => {
+  test('queries only the requested provider', async () => {
+    let acrossCalls = 0
+    let relayCalls = 0
     const app = TestApp.create({
-      fundingRoutes: {
+      funding: {
         adapters: {
-          relay: {
-            async probeQuote(input, signal) {
-              expect(signal.aborted).toBe(false)
-              expect(input.cache.bypass).toBe(true)
-              expect(input.include).toEqual(['quotes'])
-              expect(input.route.id).toBe('base-usdc-tempo-usdce-relay')
-              expect(input.sourceAmount.amount).toBe('1000000')
-              expect(input.sourceChain.id).toBe('eip155:8453')
-              expect(input.sourceToken.symbol).toBe('USDC')
-              return {
-                expiresAt: '2026-01-01T00:00:30Z',
-                limits: {
-                  instantSourceAmount: '1000000000',
-                  maxSourceAmount: '100000000000',
-                  minSourceAmount: '500000',
-                },
-                minimumOutputAmount: '980000',
-                outputAmount: '990000',
-                outputAmountFormatted: '0.99',
-                quality: {
-                  availableVolumeUsd: '1000.00',
-                  estimatedSeconds: 4,
-                  feeBps: 12,
-                  historicalVolumeUsd24h: '100000.00',
-                  instantVolumeUsd: '1000.00',
-                  liquiditySource: 'providerQuote',
-                  score: 91,
-                  sourceDetail: 'providerEndpoint',
-                  tier: 'liquid',
-                },
-                sampledAt: '2026-01-01T00:00:00Z',
-                status: 'available',
-              }
-            },
-          },
+          across: acrossAdapter(() => {
+            acrossCalls += 1
+          }),
+          relay: relayAdapter(() => {
+            relayCalls += 1
+          }),
         },
       },
     })
+    const response = await app.request(quoteUrl({ ...baseUsdcQuery, provider: 'across' }), {
+      headers: TestApp.auth.headers,
+    })
 
+    expect(response.status).toBe(200)
+    expect(acrossCalls).toBe(1)
+    expect(relayCalls).toBe(0)
+    const body = await TestApp.json(response, Funding.schema.quoteFunding.Response)
+    expect(body.data[0]?.quote.expiresAt).toBe('2026-01-01T00:01:00Z')
+  })
+
+  test('returns non-EVM Rhino quotes with stable chain and token ids', async () => {
+    const app = TestApp.create({ funding: { adapters: { rhino: rhinoAdapter() } } })
     const response = await app.request(
-      '/v1/funding/routes?sourceChain=base&sourceToken=USDC&sourceAmount=1000000&provider=relay&include=quotes',
-      { headers: { ...TestApp.auth.headers, 'Cache-Control': 'no-cache' } },
+      quoteUrl({
+        destinationToken: 'USDC.e',
+        provider: 'rhino',
+        sourceAmount: '1000000',
+        sourceChain: 'solana',
+        sourceToken: 'USDC',
+      }),
+      { headers: TestApp.auth.headers },
     )
-    expect(response.status).toBe(200)
-    const body = await TestApp.json(response, Funding.schema.listFundingRoutes.Response)
 
-    expect(body.data).toHaveLength(1)
+    expect(response.status).toBe(200)
+    const body = await TestApp.json(response, Funding.schema.quoteFunding.Response)
     expect(body.data[0]).toMatchObject({
-      errorCode: null,
-      id: 'base-usdc-tempo-usdce-relay',
-      quality: {
-        availableVolumeUsd: '1000.00',
-        liquiditySource: 'providerQuote',
-        sourceDetail: 'providerEndpoint',
-        tier: 'liquid',
+      id: 'solana-usdc-tempo-usdce-rhino',
+      provider: { id: 'rhino' },
+      sourceChain: {
+        addressFormat: 'base58',
+        id: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+        kind: 'solana',
       },
-      quote: {
-        expiresAt: '2026-01-01T00:00:30Z',
-        inputAmount: '1000000',
-        limits: {
-          instantSourceAmount: '1000000000',
-          maxSourceAmount: '100000000000',
-          minSourceAmount: '500000',
-        },
-        minimumOutputAmount: '980000',
-        outputAmount: '990000',
-        outputAmountFormatted: '0.99',
-        sampledAt: '2026-01-01T00:00:00Z',
+      sourceToken: {
+        tokenKey:
+          'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp/token:EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
       },
-      status: 'available',
     })
   })
 
-  test('converts decimal source amounts after resolving the source token', async () => {
-    const response = await TestApp.client().v1.funding.routes.$get(
-      {
-        query: {
-          provider: 'relay',
-          sourceAmount: '1.25',
-          sourceAmountUnits: 'decimal',
-          sourceChain: 'eip155:8453',
-          sourceToken: '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913',
-        },
-      },
-      TestApp.auth,
-    )
+  test('returns an empty list when no provider is configured', async () => {
+    const response = await TestApp.create().request(quoteUrl(), {
+      headers: TestApp.auth.headers,
+    })
     expect(response.status).toBe(200)
-    const body = await TestApp.json(response, Funding.schema.listFundingRoutes.Response)
+    const body = await TestApp.json(response, Funding.schema.quoteFunding.Response)
+    expect(body.data).toEqual([])
+  })
 
-    expect(body.data).toHaveLength(1)
-    expect(body.data[0]?.sourceAmount).toMatchObject({
-      amount: '1250000',
-      formatted: '1.25',
+  test('returns an empty list when the provider reports no quote', async () => {
+    const app = TestApp.create({
+      funding: {
+        adapters: {
+          relay: {
+            async probeQuote() {
+              return { sampledAt: '2026-01-01T00:00:00Z', status: 'unavailable' }
+            },
+          },
+        },
+      },
     })
+    const response = await app.request(quoteUrl(), { headers: TestApp.auth.headers })
+    expect(response.status).toBe(200)
+    const body = await TestApp.json(response, Funding.schema.quoteFunding.Response)
+    expect(body.data).toEqual([])
   })
 
-  test('does not case-fold non-EVM source token identifiers', async () => {
-    const solanaMint = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'
-    const exactResponse = await TestApp.client().v1.funding.routes.$get(
-      {
-        query: {
-          sourceAmount: '1000000',
-          sourceChain: 'solana',
-          sourceToken: solanaMint,
+  test('returns 502 when every matching provider fails', async () => {
+    const app = TestApp.create({
+      funding: {
+        adapters: {
+          relay: {
+            async probeQuote() {
+              throw new Error('upstream unavailable')
+            },
+          },
         },
       },
-      TestApp.auth,
-    )
-    expect(exactResponse.status).toBe(200)
-    const exactBody = await TestApp.json(exactResponse, Funding.schema.listFundingRoutes.Response)
-    expect(exactBody.data.map((route) => route.provider.id)).toEqual(['bridge'])
+    })
+    const response = await app.request(quoteUrl(), { headers: TestApp.auth.headers })
+    expect(response.status).toBe(502)
+    const body = await TestApp.json(response, Schema.ErrorResponse)
+    expect(body.error.code).toBe('upstream_error')
+  })
 
-    const lowercasedSolanaResponse = await TestApp.client().v1.funding.routes.$get(
-      {
-        query: {
-          sourceAmount: '1000000',
-          sourceChain: 'solana',
-          sourceToken: solanaMint.toLowerCase(),
+  test('logs provider quote deadlines as timeouts', async () => {
+    const entries: Log.Entry[] = []
+    const app = TestApp.create({
+      funding: {
+        adapterTimeoutMs: 1,
+        adapters: {
+          across: {
+            probeQuote() {
+              return new Promise<FundingQuotes.QuoteProbeResult>(() => {})
+            },
+          },
         },
       },
-      TestApp.auth,
-    )
-    expect(lowercasedSolanaResponse.status).toBe(200)
-    const lowercasedSolanaBody = await TestApp.json(
-      lowercasedSolanaResponse,
-      Funding.schema.listFundingRoutes.Response,
-    )
-    expect(lowercasedSolanaBody.data).toEqual([])
+      logger: (entry) => {
+        entries.push(entry)
+      },
+    })
 
-    const lowercasedTronResponse = await TestApp.client().v1.funding.routes.$get(
-      {
-        query: {
-          sourceAmount: '1000000',
-          sourceChain: 'tron',
-          sourceToken: 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t'.toLowerCase(),
+    const response = await app.request(quoteUrl({ ...baseUsdcQuery, provider: 'across' }), {
+      headers: TestApp.auth.headers,
+    })
+
+    expect(response.status).toBe(502)
+    expect(entries[0]?.provider).toEqual({
+      failure: 'timeout',
+      id: 'across',
+      operation: 'swap/approval',
+    })
+  })
+
+  test('logs every failure when multiple providers fail', async () => {
+    const entries: Log.Entry[] = []
+    const app = TestApp.create({
+      funding: {
+        adapters: {
+          across: {
+            async probeQuote() {
+              throw new TypeError('Across network failure')
+            },
+          },
+          relay: {
+            async probeQuote() {
+              throw new Error('Relay failure')
+            },
+          },
         },
       },
-      TestApp.auth,
-    )
-    expect(lowercasedTronResponse.status).toBe(200)
-    const lowercasedTronBody = await TestApp.json(
-      lowercasedTronResponse,
-      Funding.schema.listFundingRoutes.Response,
-    )
-    expect(lowercasedTronBody.data).toEqual([])
+      logger: (entry) => {
+        entries.push(entry)
+      },
+    })
+
+    const response = await app.request(quoteUrl(), { headers: TestApp.auth.headers })
+
+    expect(response.status).toBe(502)
+    expect(entries[0]?.provider).toEqual({
+      failure: 'network',
+      id: 'across',
+      operation: 'swap/approval',
+    })
+    expect(entries[0]?.providerFailures).toEqual([
+      { failure: 'network', id: 'across', operation: 'swap/approval' },
+      { failure: 'unknown', id: 'relay', operation: 'quote/v2' },
+    ])
   })
 
-  test('returns no candidates for an unsupported source token', async () => {
-    const response = await TestApp.client().v1.funding.routes.$get(
-      {
-        query: {
-          sourceAmount: '1.234567890',
-          sourceAmountUnits: 'decimal',
-          sourceChain: 'base',
-          sourceToken: 'DAI',
+  test('rejects successful provider results without output amounts', async () => {
+    const app = TestApp.create({
+      funding: {
+        adapters: {
+          relay: {
+            async probeQuote() {
+              return { sampledAt: '2026-01-01T00:00:00Z', status: 'available' }
+            },
+          },
         },
       },
-      TestApp.auth,
+    })
+    const response = await app.request(quoteUrl(), { headers: TestApp.auth.headers })
+    expect(response.status).toBe(502)
+  })
+
+  test('rejects invalid query parameters', async () => {
+    const response = await TestApp.create().request(
+      quoteUrl({ sourceAmount: '1000000', sourceChain: 'base' }),
+      { headers: TestApp.auth.headers },
     )
-    expect(response.status).toBe(200)
-    const body = await TestApp.json(response, Funding.schema.listFundingRoutes.Response)
-    expect(body.data).toEqual([])
+    expect(response.status).toBe(400)
+    const body = await TestApp.json(response, Schema.ErrorResponse)
+    expect(body.error.code).toBe('query_invalid')
   })
 
-  test('rejects amounts that cannot be represented in source decimals', async () => {
-    const response = await TestApp.client().v1.funding.routes.$get(
-      {
-        query: {
-          sourceAmount: '1.0000001',
-          sourceAmountUnits: 'decimal',
-          sourceChain: 'base',
-          sourceToken: 'USDC',
-        },
-      },
-      TestApp.auth,
+  test('rejects unsupported providers', async () => {
+    const response = await TestApp.create().request(
+      quoteUrl({ ...baseUsdcQuery, provider: 'bridge' }),
+      { headers: TestApp.auth.headers },
     )
     expect(response.status).toBe(400)
     const body = await TestApp.json(response, Schema.ErrorResponse)
     expect(body.error.code).toBe('query_invalid')
   })
 
-  test('rejects unsupported include parameters', async () => {
+  test('rejects unsupported source chains', async () => {
     const response = await TestApp.create().request(
-      '/v1/funding/routes?sourceChain=base&sourceToken=USDC&sourceAmount=1000000&include=debug',
+      quoteUrl({ ...baseUsdcQuery, sourceChain: 'bitcoin' }),
       { headers: TestApp.auth.headers },
     )
     expect(response.status).toBe(400)
     const body = await TestApp.json(response, Schema.ErrorResponse)
     expect(body.error.code).toBe('query_invalid')
   })
+
+  test('does not expose the removed routes endpoint', async () => {
+    const response = await TestApp.create().request(
+      '/v1/funding/routes?sourceChain=base&sourceToken=USDC&sourceAmount=1000000',
+      { headers: TestApp.auth.headers },
+    )
+    expect(response.status).toBe(404)
+  })
 })
 
 describe('GET /funding/chains', () => {
-  test('lists source chain and stablecoin inventory', async () => {
+  test('lists only inputs supported by quote providers', async () => {
     const response = await TestApp.client().v1.funding.chains.$get(undefined, TestApp.auth)
     expect(response.status).toBe(200)
     const body = await TestApp.json(response, Funding.schema.listFundingChains.Response)
@@ -238,42 +259,133 @@ describe('GET /funding/chains', () => {
       'eip155:1',
       'eip155:8453',
       'eip155:56',
-      'solana:mainnet',
-      'tron:mainnet',
+      'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+      'tron:0x2b6653dc',
     ])
-    expect(body.data.find((chain) => chain.id === 'solana:mainnet')?.tokens).toEqual(
-      expect.arrayContaining([expect.objectContaining({ symbol: 'USDC', standard: 'SPL' })]),
+    expect(body.data.flatMap((chain) => chain.tokens.map((token) => token.symbol))).toEqual(
+      expect.arrayContaining(['USDC', 'USDT']),
     )
   })
 })
 
-describe('GET /providers', () => {
-  test('lists providers filtered by capability', async () => {
-    const response = await TestApp.client().v1.providers.$get(
-      { query: { capability: 'fundingRoutes' } },
-      TestApp.auth,
-    )
+describe('GET /funding/providers', () => {
+  test('lists quote providers and their configuration status', async () => {
+    const app = TestApp.create({ funding: { adapters: { relay: relayAdapter() } } })
+    const response = await app.request('/v1/funding/providers', {
+      headers: TestApp.auth.headers,
+    })
     expect(response.status).toBe(200)
     const body = await TestApp.json(response, Funding.schema.listProviders.Response)
 
-    expect(body.data.map((provider) => provider.id)).toEqual(['relay', 'bridge', 'bungee', 'lifi'])
-    expect(body.data.every((provider) => provider.capabilities.includes('fundingRoutes'))).toBe(
-      true,
-    )
-    expect(body.data.map((provider) => provider.status)).toEqual([
-      'inventoryOnly',
-      'inventoryOnly',
-      'inventoryOnly',
-      'planned',
+    expect(body.data).toEqual([
+      {
+        id: 'across',
+        kind: 'intentBridge',
+        name: 'Across',
+        requiresApiKey: true,
+        status: 'unconfigured',
+      },
+      {
+        id: 'relay',
+        kind: 'solverNetwork',
+        name: 'Relay',
+        requiresApiKey: false,
+        status: 'configured',
+      },
+      {
+        id: 'rhino',
+        kind: 'bridge',
+        name: 'Rhino',
+        requiresApiKey: false,
+        status: 'unconfigured',
+      },
     ])
   })
 
-  test('rejects unsupported provider capabilities', async () => {
-    const response = await TestApp.create().request('/v1/providers?capability=settlement', {
+  test('does not expose the removed generic provider endpoint', async () => {
+    const response = await TestApp.create().request('/v1/providers', {
       headers: TestApp.auth.headers,
     })
-    expect(response.status).toBe(400)
-    const body = await TestApp.json(response, Schema.ErrorResponse)
-    expect(body.error.code).toBe('query_invalid')
+    expect(response.status).toBe(404)
   })
 })
+
+const baseUsdcQuery = {
+  sourceAmount: '1000000',
+  sourceChain: 'base',
+  sourceToken: 'USDC',
+} as const
+
+type QuoteQuery = Record<string, string>
+
+function quoteUrl(query: QuoteQuery = baseUsdcQuery) {
+  return `/v1/funding/quotes?${new URLSearchParams(
+    Object.entries(query).map(([key, value]) => [key, String(value)]),
+  )}`
+}
+
+function relayAdapter(onProbe: () => void = () => {}): FundingQuotes.ProviderAdapter {
+  return {
+    async probeQuote(input, signal) {
+      onProbe()
+      expect(signal.aborted).toBe(false)
+      expect(input.candidate.id).toBe('base-usdc-tempo-usdce-relay')
+      return {
+        minimumOutputAmount: '980000',
+        outputAmount: '990000',
+        outputAmountFormatted: '0.99',
+        quality: {
+          estimatedSeconds: 4,
+          liquiditySource: 'providerQuote',
+          sourceDetail: 'relay:quote-v2',
+          tier: 'liquid',
+        },
+        sampledAt: '2026-01-01T00:00:00Z',
+        status: 'available',
+      }
+    },
+  }
+}
+
+function acrossAdapter(onProbe: () => void = () => {}): FundingQuotes.ProviderAdapter {
+  return {
+    async probeQuote(input, signal) {
+      onProbe()
+      expect(signal.aborted).toBe(false)
+      expect(input.candidate.id).toBe('base-usdc-tempo-usdce-across')
+      return {
+        expiresAt: '2026-01-01T00:01:00Z',
+        minimumOutputAmount: '988000',
+        outputAmount: '990000',
+        outputAmountFormatted: '0.99',
+        quality: {
+          estimatedSeconds: 2,
+          liquiditySource: 'providerQuote',
+          sourceDetail: 'across:swap-approval',
+          tier: 'liquid',
+        },
+        sampledAt: '2026-01-01T00:00:00Z',
+        status: 'available',
+      }
+    },
+  }
+}
+
+function rhinoAdapter(): FundingQuotes.ProviderAdapter {
+  return {
+    async probeQuote(input, signal) {
+      expect(signal.aborted).toBe(false)
+      expect(input.candidate.id).toBe('solana-usdc-tempo-usdce-rhino')
+      return {
+        outputAmount: '983000',
+        quality: {
+          liquiditySource: 'providerQuote',
+          sourceDetail: 'rhino:bridge-swap-public',
+          tier: 'liquid',
+        },
+        sampledAt: '2026-01-01T00:00:00Z',
+        status: 'available',
+      }
+    },
+  }
+}