tapimo 0.4.3 → 0.5.0

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

@@ -1,381 +1,224 @@
 import { Schema } from 'tapimo'
 
+import type * as FundingQuotes from '../../../internal/FundingQuotes.js'
 import * as TestApp from '../../../../test/App.js'
-import type * as Log from '../../../internal/Log.js'
-import * as FundingRouteProviders from '../FundingRouteProviders.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([
-      'across',
-      '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-across',
-      quality: { liquiditySource: 'staticInventory', tier: 'unknown' },
+      id: 'base-usdc-tempo-usdce-relay',
+      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 calls = 0
     const app = TestApp.create({
-      fundingRoutes: {
+      funding: {
         adapters: {
-          across: {
-            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-across')
-              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',
-              }
-            },
-          },
+          relay: relayAdapter(() => {
+            calls += 1
+          }),
         },
       },
     })
+    const response = await app.request(quoteUrl({ ...baseUsdcQuery, provider: 'relay' }), {
+      headers: TestApp.auth.headers,
+    })
 
-    const response = await app.request(
-      '/v1/funding/routes?sourceChain=base&sourceToken=USDC&sourceAmount=1000000&provider=across&include=quotes',
-      { headers: { ...TestApp.auth.headers, 'Cache-Control': 'no-cache' } },
-    )
     expect(response.status).toBe(200)
-    const body = await TestApp.json(response, Funding.schema.listFundingRoutes.Response)
+    expect(calls).toBe(1)
+  })
 
-    expect(body.data).toHaveLength(1)
-    expect(body.data[0]).toMatchObject({
-      errorCode: null,
-      id: 'base-usdc-tempo-usdce-across',
-      quality: {
-        availableVolumeUsd: '1000.00',
-        liquiditySource: 'providerQuote',
-        sourceDetail: 'providerEndpoint',
-        tier: 'liquid',
-      },
-      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',
-      },
-      status: 'available',
+  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.quoteFunding.Response)
+    expect(body.data).toEqual([])
   })
 
-  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',
+  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' }
+            },
+          },
         },
       },
-      TestApp.auth,
-    )
-    expect(response.status).toBe(200)
-    const body = await TestApp.json(response, Funding.schema.listFundingRoutes.Response)
-
-    expect(body.data).toHaveLength(1)
-    expect(body.data[0]?.sourceAmount).toMatchObject({
-      amount: '1250000',
-      formatted: '1.25',
     })
+    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,
-        },
-      },
-      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 lowercasedSolanaResponse = await TestApp.client().v1.funding.routes.$get(
-      {
-        query: {
-          sourceAmount: '1000000',
-          sourceChain: 'solana',
-          sourceToken: solanaMint.toLowerCase(),
-        },
-      },
-      TestApp.auth,
-    )
-    expect(lowercasedSolanaResponse.status).toBe(200)
-    const lowercasedSolanaBody = await TestApp.json(
-      lowercasedSolanaResponse,
-      Funding.schema.listFundingRoutes.Response,
-    )
-    expect(lowercasedSolanaBody.data).toEqual([])
-
-    const lowercasedTronResponse = await TestApp.client().v1.funding.routes.$get(
-      {
-        query: {
-          sourceAmount: '1000000',
-          sourceChain: 'tron',
-          sourceToken: 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t'.toLowerCase(),
+  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(lowercasedTronResponse.status).toBe(200)
-    const lowercasedTronBody = await TestApp.json(
-      lowercasedTronResponse,
-      Funding.schema.listFundingRoutes.Response,
-    )
-    expect(lowercasedTronBody.data).toEqual([])
+    })
+    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')
   })
 
-  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,
-    )
-    expect(response.status).toBe(200)
-    const body = await TestApp.json(response, Funding.schema.listFundingRoutes.Response)
-    expect(body.data).toEqual([])
+    })
+    const response = await app.request(quoteUrl(), { headers: TestApp.auth.headers })
+    expect(response.status).toBe(502)
   })
 
-  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 invalid query parameters', async () => {
+    const response = await TestApp.create().request(
+      quoteUrl({ sourceAmount: '1000000', sourceChain: 'base' }),
+      { 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 providers', async () => {
     const response = await TestApp.create().request(
-      '/v1/funding/routes?sourceChain=base&sourceToken=USDC&sourceAmount=1000000&include=debug',
+      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')
   })
-})
-
-describe('POST /funding/routes/quote', () => {
-  test('rejects invalid depositor addresses', async () => {
-    const response = await TestApp.create().request('/v1/funding/routes/quote', {
-      body: JSON.stringify({
-        depositor: 'invalid',
-        provider: 'across',
-        sourceAmount: '1000000',
-        sourceChain: 'base',
-        sourceToken: 'USDC',
-      }),
-      headers: { ...TestApp.auth.headers, 'content-type': 'application/json' },
-      method: 'POST',
-    })
 
+  test('rejects source chains without a live quote adapter', async () => {
+    const response = await TestApp.create().request(
+      quoteUrl({ ...baseUsdcQuery, sourceChain: 'solana' }),
+      { headers: TestApp.auth.headers },
+    )
     expect(response.status).toBe(400)
-    expect(response.headers.get('cache-control')).toBe('no-store')
-    expect(await response.json()).toMatchObject({ error: { code: 'body_invalid' } })
-  })
-
-  test('returns a stable error when Across quoting is not configured', async () => {
-    const response = await TestApp.create().request('/v1/funding/routes/quote', {
-      body: JSON.stringify(quoteRequest()),
-      headers: { ...TestApp.auth.headers, 'content-type': 'application/json' },
-      method: 'POST',
-    })
-
-    expect(response.status).toBe(501)
-    expect(response.headers.get('cache-control')).toBe('no-store')
-    expect(await response.json()).toMatchObject({ error: { code: 'provider_unconfigured' } })
-  })
-
-  test('records bounded Across failure details in the request log', async () => {
-    const entries: Log.Entry[] = []
-    const response = await TestApp.create({
-      fundingRoutes: {
-        async acrossQuote() {
-          throw FundingRouteProviders.mapAcrossQuoteError({
-            body: { code: 'AUTH_FAILED', detail: 'not logged' },
-            status: 401,
-          })
-        },
-      },
-      logger: (entry) => void entries.push(entry),
-    }).request('/v1/funding/routes/quote', {
-      body: JSON.stringify(quoteRequest()),
-      headers: { ...TestApp.auth.headers, 'content-type': 'application/json' },
-      method: 'POST',
-    })
-
-    expect(response.status).toBe(502)
-    expect(entries[0]).toMatchObject({
-      errorCode: 'provider_error',
-      provider: {
-        code: 'AUTH_FAILED',
-        failure: 'http',
-        id: 'across',
-        operation: 'swap/approval',
-        status: 401,
-      },
-    })
-    expect(JSON.stringify(entries[0])).not.toContain('not logged')
+    const body = await TestApp.json(response, Schema.ErrorResponse)
+    expect(body.error.code).toBe('query_invalid')
   })
 
-  test('publishes the normalized quote contract in OpenAPI', async () => {
-    const response = await TestApp.create().request('/openapi.json')
-    const document = (await response.json()) as {
-      paths: Record<string, { post?: { operationId?: string; responses?: object } }>
-    }
-    const operation = document.paths['/v1/funding/routes/quote']?.post
-
-    expect(operation).toMatchObject({
-      operationId: 'quoteFundingRoute',
-      responses: { 200: expect.any(Object), 400: expect.any(Object), 502: expect.any(Object) },
-    })
-    expect(JSON.stringify(operation)).not.toMatch(/approvalTxns|checks|swapTx/)
+  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)
 
-    expect(body.data.map((chain) => chain.id)).toEqual([
-      'eip155:1',
-      'eip155:8453',
-      'eip155:56',
-      'solana:mainnet',
-      'tron:mainnet',
-    ])
-    expect(body.data.find((chain) => chain.id === 'solana:mainnet')?.tokens).toEqual(
-      expect.arrayContaining([expect.objectContaining({ symbol: 'USDC', standard: 'SPL' })]),
+    expect(body.data.map((chain) => chain.id)).toEqual(['eip155:1', 'eip155:8453', 'eip155:56'])
+    expect(body.data.flatMap((chain) => chain.tokens.map((token) => token.symbol))).toEqual(
+      expect.arrayContaining(['USDC', 'USDT']),
     )
   })
 })
 
-function quoteRequest() {
-  return {
-    depositor: '0x1111111111111111111111111111111111111111',
-    provider: 'across',
-    sourceAmount: '1000000',
-    sourceChain: 'base',
-    sourceToken: 'USDC',
-  }
-}
-
-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([
-      'across',
-      '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',
-      'inventoryOnly',
-      'planned',
+    expect(body.data).toEqual([
+      {
+        id: 'relay',
+        kind: 'solverNetwork',
+        name: 'Relay',
+        requiresApiKey: false,
+        status: 'configured',
+      },
     ])
   })
 
-  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',
+      }
+    },
+  }
+}