tapimo 0.14.0 → 0.15.0

package/src/apps/{funding → routes}/routes/quotes.test.ts

@@ -1,28 +1,75 @@
-import { Schema } from 'tapimo'
+import { Schema } from 'tapimo/server'
 
-import * as FundingProvider from '../../../internal/funding/Provider.js'
+import * as RoutesCatalog from '../../../internal/routes/Catalog.js'
+import * as RoutesProvider from '../../../internal/routes/Provider.js'
 
-import * as Across from '../../../internal/funding/providers/across.js'
+import * as Across from '../../../internal/routes/providers/across.js'
 
-import * as Relay from '../../../internal/funding/providers/relay.js'
+import * as Relay from '../../../internal/routes/providers/relay.js'
 
-import * as Rhino from '../../../internal/funding/providers/rhino.js'
+import * as Rhino from '../../../internal/routes/providers/rhino.js'
 
-import * as Squid from '../../../internal/funding/providers/squid.js'
+import * as Squid from '../../../internal/routes/providers/squid.js'
 
-import * as Stargate from '../../../internal/funding/providers/stargate.js'
+import * as Stargate from '../../../internal/routes/providers/stargate.js'
 
-import * as Symbiosis from '../../../internal/funding/providers/symbiosis.js'
+import * as Symbiosis from '../../../internal/routes/providers/symbiosis.js'
 
 import type * as Log from '../../../internal/Log.js'
 
 import * as TestApp from '../../../../test/App.js'
 
-import * as TestFunding from '../../../../test/Funding.js'
+import * as TestRoutes from '../../../../test/Routes.js'
 
-import * as Funding from './quotes.js'
+import * as Routes from './quotes.js'
 
 const db = TestApp.database()
+const outboundDb = TestApp.database()
+const sameOrgKey = {
+  id: 'key_same_org',
+  orgId: TestApp.key.orgId,
+  scopes: ['data:read'],
+  token: 'secret_same_org',
+} satisfies TestApp.kvStore.Key
+const otherOrgKey = {
+  id: 'key_other_org',
+  orgId: 'org_other',
+  scopes: ['data:read'],
+  token: 'secret_other_org',
+} satisfies TestApp.kvStore.Key
+const symbiosisQuoteResponse = {
+  kind: 'bridge',
+  routes: [
+    {
+      tokens: [
+        {
+          address: '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913',
+          chainId: 8453,
+          decimals: 6,
+        },
+        {
+          address: '0x20c000000000000000000000b9537d11c60e8b50',
+          chainId: 4217,
+          decimals: 6,
+        },
+      ],
+    },
+  ],
+  tokenAmountOut: {
+    address: '0x20c000000000000000000000b9537d11c60e8b50',
+    amount: '989000',
+    chainId: 4217,
+    decimals: 6,
+  },
+  tokenAmountOutMin: {
+    address: '0x20c000000000000000000000b9537d11c60e8b50',
+    amount: '979000',
+    chainId: 4217,
+    decimals: 6,
+  },
+  tx: { chainId: 8453 },
+  type: 'evm',
+} as const
 
 const providers = [
   Across.across({
@@ -30,7 +77,7 @@ const providers = [
     integratorId: '0xdead',
     userAddress: '0x1111111111111111111111111111111111111111',
   }),
-  Relay.relay({ userAddresses: TestFunding.relayQuoteUsers }),
+  Relay.relay({ userAddresses: TestRoutes.relayQuoteUsers }),
   Rhino.rhino(),
   Squid.squid({
     integratorId: 'squid-integrator-id',
@@ -40,17 +87,41 @@ const providers = [
   Symbiosis.symbiosis({ userAddress: '0x1111111111111111111111111111111111111111' }),
 ] as const
 
-beforeAll(() => TestFunding.publish(db))
+beforeAll(async () => {
+  const inbound = TestRoutes.data.routes.find(
+    (route) =>
+      route.providerId === 'relay' &&
+      route.sourceChainId === 'eip155:8453' &&
+      route.sourceTokenId === 'usdc' &&
+      route.destinationTokenId === 'usdce',
+  )!
+  await Promise.all([
+    TestRoutes.publish(db),
+    RoutesCatalog.publish(outboundDb, {
+      ...TestRoutes.data,
+      routes: [
+        ...TestRoutes.data.routes,
+        {
+          ...inbound,
+          destinationChainId: inbound.sourceChainId,
+          destinationTokenId: inbound.sourceTokenId,
+          sourceChainId: inbound.destinationChainId,
+          sourceTokenId: inbound.destinationTokenId,
+        },
+      ],
+    }),
+  ])
+})
 
 function create(options: TestApp.create.Options = {}) {
   return TestApp.create({ ...options, db })
 }
 
-describe('GET /funding/quotes', () => {
+describe('GET /routes/quotes', () => {
   test('publishes alphabetically ordered quote example fields', async () => {
     const app = create({ auth: false })
     const spec = await (await app.request('/openapi.json')).json()
-    const operation = spec.paths['/v1/funding/quotes'].get
+    const operation = spec.paths['/v1/routes/quotes'].get
     const response = operation.responses['200'].content['application/json']
     const fields = Object.keys(response.example.data[0])
 
@@ -58,11 +129,15 @@ describe('GET /funding/quotes', () => {
   })
 
   test('returns successful live quotes with output amounts', async () => {
-    const app = create({ providers: [relayProvider()] })
+    const entries: Log.Entry[] = []
+    const app = create({
+      logger: (entry) => void entries.push(entry),
+      providers: [relayProvider()],
+    })
     const response = await app.request(quoteUrl(), { headers: TestApp.auth.headers })
     expect(response.status).toBe(200)
     expect(response.headers.get('cache-control')).toBe('no-store')
-    const body = await TestApp.json(response, Funding.schema.quoteFunding.Response)
+    const body = await TestApp.json(response, Routes.schema.quoteRoutes.Response)
 
     expect(body.data).toHaveLength(1)
     expect(body.data[0]).toMatchObject({
@@ -80,12 +155,156 @@ describe('GET /funding/quotes', () => {
       },
       id: 'base-usdc-tempo-usdce-relay',
       provider: { id: 'relay' },
-      quality: { liquiditySource: 'providerQuote', tier: 'liquid' },
+      quality: { tier: 'liquid' },
       quote: { sampledAt: '2026-01-01T00:00:00Z' },
       sourceAmount: { baseUnits: '1000000', currency: 'USD', decimals: 6, formatted: '1' },
     })
     expect(body.data[0]?.sourceToken).not.toHaveProperty('amount')
     expect(body.data[0]?.destinationToken).not.toHaveProperty('amount')
+    expect(entries[0]?.routesQuoteResult).toEqual({
+      candidateCount: 1,
+      outcome: 'available',
+      quotes: [
+        {
+          ageMs: expect.any(Number),
+          customerValueLossBps: 100,
+          destinationChain: 'eip155:4217',
+          destinationToken: 'eip155:4217/erc20:0x20c000000000000000000000b9537d11c60e8b50',
+          futureSkewMs: 0,
+          provider: 'relay',
+          sourceChain: 'eip155:8453',
+          sourceToken: 'eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913',
+        },
+      ],
+    })
+  })
+
+  test('shares the Symbiosis tenant quota across keys in one organization', async () => {
+    let fetches = 0
+    const provider = Symbiosis.symbiosis({
+      fetch: async () => {
+        fetches++
+        return Response.json(symbiosisQuoteResponse)
+      },
+      now: () => new Date('2026-01-01T00:00:00Z'),
+      userAddress: '0x1111111111111111111111111111111111111111',
+    })
+    const app = create({
+      auth: { keys: [TestApp.key, sameOrgKey, otherOrgKey] },
+      providers: [provider],
+    })
+    const request = (key: TestApp.kvStore.Key) =>
+      app.request(quoteUrl({ ...baseUsdcQuery, provider: 'symbiosis' }), {
+        headers: { authorization: `Bearer ${key.token}` },
+      })
+
+    expect((await request(TestApp.key)).status).toBe(200)
+    expect((await request(sameOrgKey)).status).toBe(200)
+    expect((await request(TestApp.key)).status).toBe(200)
+    expect((await request(sameOrgKey)).status).toBe(502)
+    expect((await request(otherOrgKey)).status).toBe(200)
+    expect(fetches).toBe(4)
+  })
+
+  test('normalizes anonymous IPv6 tenant quota identities', async () => {
+    let fetches = 0
+    const provider = Symbiosis.symbiosis({
+      fetch: async () => {
+        fetches++
+        return Response.json(symbiosisQuoteResponse)
+      },
+      now: () => new Date('2026-01-01T00:00:00Z'),
+      userAddress: '0x1111111111111111111111111111111111111111',
+    })
+    const app = create({ providers: [provider] })
+    const request = (ip: string) =>
+      app.request(quoteUrl({ ...baseUsdcQuery, provider: 'symbiosis' }), {
+        headers: { 'cf-connecting-ip': ip },
+      })
+
+    expect((await request('2001:0db8:abcd:0012::1')).status).toBe(200)
+    expect((await request('2001:db8:abcd:12::2')).status).toBe(200)
+    expect((await request('2001:db8:abcd:12::3')).status).toBe(200)
+    expect((await request('2001:db8:abcd:12::4')).status).toBe(502)
+    expect((await request('2001:db8:abcd:13::1')).status).toBe(200)
+    expect(fetches).toBe(4)
+  })
+
+  test('quotes a catalogued Tempo to Base route', async () => {
+    const app = TestApp.create({
+      db: outboundDb,
+      providers: [
+        withGetQuote('relay', async (input) => {
+          expect(input.candidate).toMatchObject({
+            destinationChain: { id: 'eip155:8453' },
+            destinationToken: { symbol: 'USDC' },
+            sourceChain: { id: 'eip155:4217' },
+            sourceToken: { symbol: 'USDC.e' },
+          })
+          return {
+            destinationAmount: '990000',
+            destinationAmountMin: '980000',
+            sampledAt: '2026-01-01T00:00:00Z',
+            status: 'available',
+          }
+        }),
+      ],
+    })
+    const response = await app.request(
+      quoteUrl({
+        destinationChain: 'base',
+        destinationToken: 'USDC',
+        sourceAmount: '1000000',
+        sourceChain: 'tempo',
+        sourceToken: 'USDC.e',
+      }),
+      { headers: TestApp.auth.headers },
+    )
+
+    expect(response.status).toBe(200)
+    const body = await TestApp.json(response, Routes.schema.quoteRoutes.Response)
+    expect(body.data[0]).toMatchObject({
+      destinationChain: { id: 'eip155:8453' },
+      destinationToken: { symbol: 'USDC' },
+      id: 'tempo-usdce-base-usdc-relay',
+      sourceChain: { id: 'eip155:4217' },
+      sourceToken: { symbol: 'USDC.e' },
+    })
+  })
+
+  test('records catalog load failures in quote availability', async () => {
+    const entries: Log.Entry[] = []
+    const unavailable = TestApp.database()
+    await unavailable.kysely
+      .insertInto('routes_chains')
+      .values({
+        aliases: JSON.stringify(['eth']),
+        id: 'eip155:1',
+        name: 'Ethereum',
+        parentChainId: null,
+        rpcUrls: JSON.stringify([]),
+        slug: 'ethereum',
+      })
+      .execute()
+    try {
+      const app = TestApp.create({
+        auth: false,
+        db: unavailable,
+        logger: (entry) => void entries.push(entry),
+        providers: [relayProvider()],
+      })
+
+      const response = await app.request(quoteUrl())
+
+      expect(response.status).toBe(500)
+      expect(entries[0]?.routesQuoteResult).toEqual({
+        candidateCount: 0,
+        outcome: 'failed',
+        quotes: [],
+      })
+    } finally {
+      await unavailable.close()
+    }
   })
 
   test('resolves token identifiers through the composed route', async () => {
@@ -115,7 +334,7 @@ describe('GET /funding/quotes', () => {
         }),
         { headers: TestApp.auth.headers },
       )
-      const body = await TestApp.json(response, Funding.schema.quoteFunding.Response)
+      const body = await TestApp.json(response, Routes.schema.quoteRoutes.Response)
       results.push({
         destinationToken: body.data[0]?.destinationToken.symbol,
         name: identifier.name,
@@ -174,7 +393,7 @@ describe('GET /funding/quotes', () => {
     expect(response.status).toBe(200)
     expect(acrossCalls).toBe(1)
     expect(relayCalls).toBe(0)
-    const body = await TestApp.json(response, Funding.schema.quoteFunding.Response)
+    const body = await TestApp.json(response, Routes.schema.quoteRoutes.Response)
     expect(body.data[0]?.quote.expiresAt).toBe('2026-01-01T00:01:00Z')
   })
 
@@ -185,17 +404,13 @@ describe('GET /funding/quotes', () => {
     })
 
     expect(response.status).toBe(200)
-    const body = await TestApp.json(response, Funding.schema.quoteFunding.Response)
+    const body = await TestApp.json(response, Routes.schema.quoteRoutes.Response)
     expect(body.data[0]).toMatchObject({
       destinationAmount: { baseUnits: '999600' },
       destinationAmountMin: { baseUnits: '999100' },
       id: 'base-usdc-tempo-usdce-stargate',
       provider: { id: 'stargate', name: 'Stargate' },
-      quality: {
-        liquiditySource: 'onchain',
-        sourceDetail: 'stargate:oft-v2:taxi',
-        tier: 'liquid',
-      },
+      quality: { tier: 'liquid' },
     })
   })
 
@@ -213,7 +428,7 @@ describe('GET /funding/quotes', () => {
     )
 
     expect(response.status).toBe(200)
-    const body = await TestApp.json(response, Funding.schema.quoteFunding.Response)
+    const body = await TestApp.json(response, Routes.schema.quoteRoutes.Response)
     expect(body.data[0]).toMatchObject({
       id: 'solana-usdc-tempo-usdce-rhino',
       provider: { id: 'rhino' },
@@ -230,12 +445,21 @@ describe('GET /funding/quotes', () => {
   })
 
   test('returns an empty list when no provider is available', async () => {
-    const response = await create().request(quoteUrl(), {
-      headers: TestApp.auth.headers,
-    })
+    const entries: Log.Entry[] = []
+    const response = await create({ logger: (entry) => void entries.push(entry) }).request(
+      quoteUrl(),
+      {
+        headers: TestApp.auth.headers,
+      },
+    )
     expect(response.status).toBe(200)
-    const body = await TestApp.json(response, Funding.schema.quoteFunding.Response)
+    const body = await TestApp.json(response, Routes.schema.quoteRoutes.Response)
     expect(body.data).toEqual([])
+    expect(entries[0]?.routesQuoteResult).toEqual({
+      candidateCount: 0,
+      outcome: 'unsupported',
+      quotes: [],
+    })
   })
 
   test('returns an empty list when the provider reports no quote', async () => {
@@ -253,9 +477,9 @@ describe('GET /funding/quotes', () => {
     })
     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)
+    const body = await TestApp.json(response, Routes.schema.quoteRoutes.Response)
     expect(body.data).toEqual([])
-    expect(entries[0]?.fundingProviderAttempts).toEqual([
+    expect(entries[0]?.routesProviderAttempts).toEqual([
       {
         durationMs: expect.any(Number),
         id: 'relay',
@@ -263,10 +487,17 @@ describe('GET /funding/quotes', () => {
         outcome: 'unavailable',
       },
     ])
+    expect(entries[0]?.routesQuoteResult).toEqual({
+      candidateCount: 1,
+      outcome: 'unavailable',
+      quotes: [],
+    })
   })
 
   test('returns 502 when every matching provider fails', async () => {
+    const entries: Log.Entry[] = []
     const app = create({
+      logger: (entry) => void entries.push(entry),
       providers: [
         withGetQuote('relay', async () => {
           throw new Error('upstream unavailable')
@@ -277,17 +508,29 @@ describe('GET /funding/quotes', () => {
     expect(response.status).toBe(502)
     const body = await TestApp.json(response, Schema.ErrorResponse)
     expect(body.error.code).toBe('upstream_error')
+    expect(entries[0]?.routesQuoteResult).toEqual({
+      candidateCount: 1,
+      outcome: 'failed',
+      quotes: [],
+    })
   })
 
   test('logs provider quote deadlines as timeouts', async () => {
     vi.useFakeTimers()
     const entries: Log.Entry[] = []
+    let markProviderStarted!: () => void
+    const providerStarted = new Promise<void>((resolve) => {
+      markProviderStarted = resolve
+    })
     const app = create({
       logger: (entry) => {
         entries.push(entry)
       },
       providers: [
-        withGetQuote('across', () => new Promise<FundingProvider.getQuote.ReturnType>(() => {})),
+        withGetQuote('across', () => {
+          markProviderStarted()
+          return new Promise<RoutesProvider.getQuote.ReturnType>(() => {})
+        }),
       ],
     })
 
@@ -295,6 +538,7 @@ describe('GET /funding/quotes', () => {
       const response_promise = app.request(quoteUrl({ ...baseUsdcQuery, provider: 'across' }), {
         headers: TestApp.auth.headers,
       })
+      await providerStarted
       await vi.advanceTimersByTimeAsync(5_000)
       const response = await response_promise
 
@@ -304,7 +548,7 @@ describe('GET /funding/quotes', () => {
         id: 'across',
         operation: 'getQuote',
       })
-      expect(entries[0]?.fundingProviderAttempts).toEqual([
+      expect(entries[0]?.routesProviderAttempts).toEqual([
         {
           durationMs: expect.any(Number),
           failure: 'timeout',
@@ -346,7 +590,7 @@ describe('GET /funding/quotes', () => {
       { failure: 'network', id: 'across', operation: 'getQuote' },
       { failure: 'unknown', id: 'relay', operation: 'getQuote' },
     ])
-    expect(entries[0]?.fundingProviderAttempts).toEqual([
+    expect(entries[0]?.routesProviderAttempts).toEqual([
       {
         durationMs: expect.any(Number),
         failure: 'network',
@@ -381,7 +625,7 @@ describe('GET /funding/quotes', () => {
     const response = await app.request(quoteUrl(), { headers: TestApp.auth.headers })
 
     expect(response.status).toBe(200)
-    expect(entries[0]?.fundingProviderAttempts).toEqual([
+    expect(entries[0]?.routesProviderAttempts).toEqual([
       {
         durationMs: expect.any(Number),
         failure: 'network',
@@ -444,9 +688,22 @@ describe('GET /funding/quotes', () => {
     expect(body.error.code).toBe('query_invalid')
   })
 
+  test('rejects unsupported destination chains', async () => {
+    const response = await create().request(
+      quoteUrl({ ...baseUsdcQuery, destinationChain: 'bitcoin' }),
+      { headers: TestApp.auth.headers },
+    )
+    expect(response.status).toBe(400)
+    const body = await TestApp.json(response, Schema.ErrorResponse)
+    expect(body.error).toMatchObject({
+      code: 'query_invalid',
+      message: 'Unsupported `destinationChain`.',
+    })
+  })
+
   test('does not expose the removed routes endpoint', async () => {
     const response = await create().request(
-      '/v1/funding/routes?sourceChain=base&sourceToken=USDC&sourceAmount=1000000',
+      '/v1/routes/routes?sourceChain=base&sourceToken=USDC&sourceAmount=1000000',
       { headers: TestApp.auth.headers },
     )
     expect(response.status).toBe(404)
@@ -462,7 +719,7 @@ const baseUsdcQuery = {
 type QuoteQuery = Record<string, string>
 
 function quoteUrl(query: QuoteQuery = baseUsdcQuery) {
-  return `/v1/funding/quotes?${new URLSearchParams(
+  return `/v1/routes/quotes?${new URLSearchParams(
     Object.entries(query).map(([key, value]) => [key, String(value)]),
   )}`
 }
@@ -544,10 +801,10 @@ function stargateProvider() {
 }
 
 function withGetQuote(
-  id: FundingProvider.ProviderId,
-  getQuote: FundingProvider.Provider['getQuote'],
+  id: RoutesProvider.ProviderId,
+  getQuote: RoutesProvider.Provider['getQuote'],
 ) {
   const provider = providers.find((entry) => entry.id === id)
   if (!provider) throw new Error(`Missing ${id} provider`)
-  return FundingProvider.from({ ...provider, getQuote })
+  return RoutesProvider.from({ ...provider, getQuote })
 }