tapimo 0.7.1 → 0.8.0

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

@@ -1,503 +0,0 @@
-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/quotes', () => {
-  test('publishes alphabetically ordered quote example fields', async () => {
-    const app = TestApp.create({ auth: false })
-    const spec = await (await app.request('/openapi.json')).json()
-    const operation = spec.paths['/v1/funding/quotes'].get
-    const response = operation.responses['200'].content['application/json']
-    const fields = Object.keys(response.example.data[0])
-
-    expect(fields).toEqual([...fields].sort())
-  })
-
-  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)
-    expect(response.headers.get('cache-control')).toBe('no-store')
-    const body = await TestApp.json(response, Funding.schema.quoteFunding.Response)
-
-    expect(body.data).toHaveLength(1)
-    expect(body.data[0]).toMatchObject({
-      destinationAmount: {
-        baseUnits: '990000',
-        currency: 'USD',
-        decimals: 6,
-        formatted: '0.99',
-      },
-      destinationAmountMin: {
-        baseUnits: '980000',
-        currency: 'USD',
-        decimals: 6,
-        formatted: '0.98',
-      },
-      id: 'base-usdc-tempo-usdce-relay',
-      provider: { id: 'relay' },
-      quality: { liquiditySource: 'providerQuote', 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')
-  })
-
-  test('queries only the requested provider', async () => {
-    let acrossCalls = 0
-    let relayCalls = 0
-    const app = TestApp.create({
-      funding: {
-        adapters: {
-          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(
-      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.quoteFunding.Response)
-    expect(body.data[0]).toMatchObject({
-      id: 'solana-usdc-tempo-usdce-rhino',
-      provider: { id: 'rhino' },
-      sourceChain: {
-        addressFormat: 'base58',
-        id: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
-        kind: 'solana',
-      },
-      sourceToken: {
-        tokenKey:
-          'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp/token:EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
-      },
-    })
-  })
-
-  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('returns an empty list when the provider reports no quote', async () => {
-    const entries: Log.Entry[] = []
-    const app = TestApp.create({
-      funding: {
-        adapters: {
-          relay: {
-            async probeQuote() {
-              return { sampledAt: '2026-01-01T00:00:00Z', status: 'unavailable' }
-            },
-          },
-        },
-      },
-      logger: (entry) => {
-        entries.push(entry)
-      },
-    })
-    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([])
-    expect(entries[0]?.fundingProviderAttempts).toEqual([
-      {
-        durationMs: expect.any(Number),
-        id: 'relay',
-        operation: 'quote/v2',
-        outcome: 'unavailable',
-      },
-    ])
-  })
-
-  test('returns 502 when every matching provider fails', async () => {
-    const app = TestApp.create({
-      funding: {
-        adapters: {
-          relay: {
-            async probeQuote() {
-              throw new Error('upstream unavailable')
-            },
-          },
-        },
-      },
-    })
-    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('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>(() => {})
-            },
-          },
-        },
-      },
-      logger: (entry) => {
-        entries.push(entry)
-      },
-    })
-
-    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',
-    })
-    expect(entries[0]?.fundingProviderAttempts).toEqual([
-      {
-        durationMs: expect.any(Number),
-        failure: 'timeout',
-        id: 'across',
-        operation: 'swap/approval',
-        outcome: 'failed',
-      },
-    ])
-  })
-
-  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')
-            },
-          },
-        },
-      },
-      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' },
-    ])
-    expect(entries[0]?.fundingProviderAttempts).toEqual([
-      {
-        durationMs: expect.any(Number),
-        failure: 'network',
-        id: 'across',
-        operation: 'swap/approval',
-        outcome: 'failed',
-      },
-      {
-        durationMs: expect.any(Number),
-        failure: 'unknown',
-        id: 'relay',
-        operation: 'quote/v2',
-        outcome: 'failed',
-      },
-    ])
-  })
-
-  test('logs failed providers when another provider returns a quote', async () => {
-    const entries: Log.Entry[] = []
-    const app = TestApp.create({
-      funding: {
-        adapters: {
-          across: {
-            async probeQuote() {
-              throw new TypeError(`wallet ${'0xaa'.repeat(20)} could not reach secret-provider`)
-            },
-          },
-          relay: relayAdapter(),
-        },
-      },
-      logger: (entry) => {
-        entries.push(entry)
-      },
-    })
-
-    const response = await app.request(quoteUrl(), { headers: TestApp.auth.headers })
-
-    expect(response.status).toBe(200)
-    expect(entries[0]?.fundingProviderAttempts).toEqual([
-      {
-        durationMs: expect.any(Number),
-        failure: 'network',
-        id: 'across',
-        operation: 'swap/approval',
-        outcome: 'failed',
-      },
-      {
-        durationMs: expect.any(Number),
-        id: 'relay',
-        operation: 'quote/v2',
-        outcome: 'available',
-      },
-    ])
-    expect(JSON.stringify(entries[0])).not.toContain('secret-provider')
-    expect(JSON.stringify(entries[0])).not.toContain('0xaa')
-  })
-
-  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' }
-            },
-          },
-        },
-      },
-    })
-    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(400)
-    const body = await TestApp.json(response, Schema.ErrorResponse)
-    expect(body.error.code).toBe('query_invalid')
-  })
-
-  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 source chains', async () => {
-    const response = await TestApp.create().request(
-      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 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:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
-      'tron:0x2b6653dc',
-    ])
-    expect(body.data.flatMap((chain) => chain.tokens.map((token) => token.symbol))).toEqual(
-      expect.arrayContaining(['USDC', 'USDT']),
-    )
-    expect(
-      body.data.flatMap((chain) => chain.tokens).every((token) => token.currency === 'USD'),
-    ).toBe(true)
-  })
-})
-
-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).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',
-      },
-      {
-        id: 'squid',
-        kind: 'solverNetwork',
-        name: 'Squid',
-        requiresApiKey: true,
-        status: 'unconfigured',
-      },
-      {
-        id: 'symbiosis',
-        kind: 'crossChainDex',
-        name: 'Symbiosis',
-        requiresApiKey: false,
-        status: 'unconfigured',
-      },
-    ])
-  })
-
-  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(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',
-        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',
-        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',
-      }
-    },
-  }
-}