tapimo 0.2.0 → 0.4.0

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

@@ -0,0 +1,314 @@
+import { Schema } from 'tapimo'
+
+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,
+    )
+    expect(response.status).toBe(200)
+    const body = await TestApp.json(response, Funding.schema.listFundingRoutes.Response)
+
+    expect(body.data.map((route) => route.provider.id)).toEqual([
+      'across',
+      'relay',
+      'bridge',
+      'bungee',
+    ])
+    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' },
+      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 () => {
+    const app = TestApp.create({
+      fundingRoutes: {
+        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',
+              }
+            },
+          },
+        },
+      },
+    })
+
+    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(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('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,
+    )
+    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',
+    })
+  })
+
+  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(),
+        },
+      },
+      TestApp.auth,
+    )
+    expect(lowercasedTronResponse.status).toBe(200)
+    const lowercasedTronBody = await TestApp.json(
+      lowercasedTronResponse,
+      Funding.schema.listFundingRoutes.Response,
+    )
+    expect(lowercasedTronBody.data).toEqual([])
+  })
+
+  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',
+        },
+      },
+      TestApp.auth,
+    )
+    expect(response.status).toBe(200)
+    const body = await TestApp.json(response, Funding.schema.listFundingRoutes.Response)
+    expect(body.data).toEqual([])
+  })
+
+  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,
+    )
+    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 () => {
+    const response = await TestApp.create().request(
+      '/v1/funding/routes?sourceChain=base&sourceToken=USDC&sourceAmount=1000000&include=debug',
+      { 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('GET /funding/chains', () => {
+  test('lists source chain and stablecoin inventory', 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' })]),
+    )
+  })
+})
+
+describe('GET /providers', () => {
+  test('lists providers filtered by capability', async () => {
+    const response = await TestApp.client().v1.providers.$get(
+      { query: { capability: 'fundingRoutes' } },
+      TestApp.auth,
+    )
+    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',
+    ])
+  })
+
+  test('marks configured live provider adapters', async () => {
+    const app = TestApp.create({
+      fundingRoutes: {
+        adapters: {
+          across: {
+            async probeQuote() {
+              throw new Error('not used')
+            },
+          },
+        },
+      },
+    })
+
+    const response = await app.request('/v1/providers?capability=fundingRoutes', {
+      headers: TestApp.auth.headers,
+    })
+    expect(response.status).toBe(200)
+    const body = await TestApp.json(response, Funding.schema.listProviders.Response)
+
+    expect(body.data.find((provider) => provider.id === 'across')?.status).toBe('configured')
+    expect(body.data.find((provider) => provider.id === 'relay')?.status).toBe('inventoryOnly')
+  })
+
+  test('rejects unsupported provider capabilities', async () => {
+    const response = await TestApp.create().request('/v1/providers?capability=settlement', {
+      headers: TestApp.auth.headers,
+    })
+    expect(response.status).toBe(400)
+    const body = await TestApp.json(response, Schema.ErrorResponse)
+    expect(body.error.code).toBe('query_invalid')
+  })
+})