tapimo 0.5.3 → 0.7.0

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

@@ -1,12 +1,45 @@
 import type * as z from 'zod/mini'
-import { Schema } from 'tapimo'
+import { Address, Value as core_Value } from 'ox'
+import { Db, Schema } from 'tapimo'
+import { FxOracle } from 'tapimo/apps'
+import { decodeFunctionData, zeroHash } from 'viem'
+import { Abis, Actions, Addresses } from 'viem/tempo'
 
 import * as TestApp from '../../../../test/App.js'
+import * as Relay from '../../../../test/Relay.js'
+import * as Runtime from '../../../../test/runtime.js'
 import * as Exchanges from './exchanges.js'
 
+type JsonSchema = {
+  examples?: readonly unknown[]
+  oneOf?: readonly JsonSchema[]
+  properties?: Record<string, JsonSchema>
+  required?: readonly string[]
+}
 type OrdersResponse = z.output<typeof Exchanges.schema.getOrders.Response>
+type OpenApiDocument = {
+  paths: Record<
+    string,
+    {
+      post?: {
+        requestBody?: { content?: Record<string, { schema?: JsonSchema }> }
+        responses?: Record<string, { content?: Record<string, { schema?: JsonSchema }> }>
+      }
+    }
+  >
+}
 type PairsResponse = z.output<typeof Exchanges.schema.getPairs.Response>
 
+// Deterministic EUR-based rate set so conversion math is exact in assertions.
+const fixed = FxOracle.from({
+  name: 'fixed',
+  rates: async () => ({
+    asOf: '2026-01-01T00:00:00.000Z',
+    base: 'EUR',
+    rates: { AUD: '1.6', USD: '1.0' },
+  }),
+})
+
 type Client = ReturnType<typeof TestApp.client>
 type OrdersQuery = {
   chainId?: string
@@ -569,6 +602,68 @@ describe('GET /exchange/pairs/:base/depth', () => {
 describe('GET /exchange/swaps', () => {
   type GlobalSwapsResponse = z.output<typeof Exchanges.schema.getSwaps.Response>
 
+  test('validates denominations without swap rows', async () => {
+    const client = TestApp.client({ fx: { oracle: fixed } })
+    const response = await client.v1.exchange.swaps.$get(
+      { query: { denomination: 'JPY', transactionHash: zeroHash } },
+      TestApp.auth,
+    )
+    expect(response.status).toBe(400)
+  })
+
+  test('parses granular token includes', () => {
+    expect(
+      Exchanges.schema.getSwaps.Query.parse({
+        include: 'token.logoUri,token.verified',
+      }).include,
+    ).toMatchInlineSnapshot(`
+      [
+        "token.logoUri",
+        "token.verified",
+      ]
+    `)
+    expect(Exchanges.schema.getSwaps.Query.safeParse({ include: 'tokens' }).success).toBe(false)
+  })
+
+  test.skipIf(Runtime.get().mode !== 'localnet')(
+    'values swap legs in a requested denomination',
+    async () => {
+      const db = TestApp.database()
+      await TestApp.verifiedSeed(db, Runtime.get().chainId)
+      const client = TestApp.client({ db, fx: { oracle: fixed } })
+
+      const response = await client.v1.exchange.swaps.$get(
+        { query: { denomination: 'AUD', limit: '10' } },
+        TestApp.auth,
+      )
+      expect(response.status).toBe(200)
+      const body = await TestApp.json(response, Exchanges.schema.getSwaps.Response)
+      expect(body.data.length).toBeGreaterThan(0)
+
+      // Curated legs value at the fixed 1.6 USD -> AUD rate; uncurated
+      // created-token legs stay null.
+      const legs = body.data.flatMap((swap) => [
+        swap.sourceAmount,
+        swap.destinationAmount,
+        ...swap.fills.flatMap((fill) => [fill.sourceAmount, fill.destinationAmount]),
+      ])
+      const valued = legs.filter((leg) => leg.valuation)
+      expect(valued.length).toBeGreaterThan(0)
+      for (const leg of valued)
+        expect(leg.valuation).toEqual({
+          amount: core_Value.format((BigInt(leg.baseUnits) * 16n) / 10n, 6),
+          currency: 'AUD',
+        })
+      expect(body.meta?.pricing).toMatchInlineSnapshot(`
+        {
+          "asOf": "2026-01-01T00:00:00.000Z",
+          "basis": "nominal",
+          "source": "fixed",
+        }
+      `)
+    },
+  )
+
   test('returns a global, newest-first page of swaps across all pairs', async () => {
     const client = TestApp.client()
     const response = await client.v1.exchange.swaps.$get({ query: { limit: '10' } }, TestApp.auth)
@@ -582,9 +677,29 @@ describe('GET /exchange/swaps', () => {
       expect(swap.transactionHash).toMatch(/^0x[0-9a-f]{64}$/)
       expect(['exactSource', 'exactDestination', null]).toContain(swap.mode)
       expect(swap.sourceToken.address).toMatch(/^0x[0-9a-f]{40}$/)
-      expect(swap.sourceToken.amount).toMatch(/^\d+$/)
+      expect(swap.sourceToken).not.toHaveProperty('amount')
+      expect(typeof swap.sourceToken.currency).toBe('string')
+      expect(typeof swap.sourceToken.decimals).toBe('number')
+      expect(typeof swap.sourceToken.name).toBe('string')
+      expect(typeof swap.sourceToken.symbol).toBe('string')
+      expect(swap.sourceToken.logoUri).toBeUndefined()
+      expect(swap.sourceToken.verified).toBeUndefined()
+      expect(swap.sourceAmount.baseUnits).toMatch(/^\d+$/)
+      expect(swap.sourceAmount.currency).toBe(swap.sourceToken.currency)
+      expect(swap.sourceAmount.decimals).toBe(swap.sourceToken.decimals)
+      expect(swap.sourceAmount.formatted).toMatch(/^\d+(\.\d+)?$/)
       expect(swap.destinationToken.address).toMatch(/^0x[0-9a-f]{40}$/)
-      expect(swap.destinationToken.amount).toMatch(/^\d+$/)
+      expect(swap.destinationToken).not.toHaveProperty('amount')
+      expect(typeof swap.destinationToken.currency).toBe('string')
+      expect(typeof swap.destinationToken.decimals).toBe('number')
+      expect(typeof swap.destinationToken.name).toBe('string')
+      expect(typeof swap.destinationToken.symbol).toBe('string')
+      expect(swap.destinationToken.logoUri).toBeUndefined()
+      expect(swap.destinationToken.verified).toBeUndefined()
+      expect(swap.destinationAmount.baseUnits).toMatch(/^\d+$/)
+      expect(swap.destinationAmount.currency).toBe(swap.destinationToken.currency)
+      expect(swap.destinationAmount.decimals).toBe(swap.destinationToken.decimals)
+      expect(swap.destinationAmount.formatted).toMatch(/^\d+(\.\d+)?$/)
       expect(swap.rate).toMatch(/^\d+(\.\d+)?$/)
       expect(swap.filledAt).toMatch(/^\d{4}-\d{2}-\d{2}T/)
       // `route` spans source → destination; its ends mirror the side tokens.
@@ -600,6 +715,14 @@ describe('GET /exchange/swaps', () => {
         expect(fill.price).toMatch(/^\d+(\.\d+)?$/)
         expect(swap.route).toContain(fill.sourceToken.address)
         expect(swap.route).toContain(fill.destinationToken.address)
+        expect(fill.sourceToken).not.toHaveProperty('amount')
+        expect(fill.sourceAmount.baseUnits).toMatch(/^\d+$/)
+        expect(fill.sourceAmount.currency).toBe(fill.sourceToken.currency)
+        expect(fill.sourceAmount.decimals).toBe(fill.sourceToken.decimals)
+        expect(fill.destinationToken).not.toHaveProperty('amount')
+        expect(fill.destinationAmount.baseUnits).toMatch(/^\d+$/)
+        expect(fill.destinationAmount.currency).toBe(fill.destinationToken.currency)
+        expect(fill.destinationAmount.decimals).toBe(fill.destinationToken.decimals)
       }
       for (let i = 1; i < swap.fills.length; i++)
         expect(swap.fills[i]!.logIndex).toBeGreaterThan(swap.fills[i - 1]!.logIndex)
@@ -627,6 +750,9 @@ describe('GET /exchange/swaps', () => {
       TestApp.auth,
     )
     const secondBody = await TestApp.json(second, Exchanges.schema.getSwaps.Response)
+    expect(second.headers.get('cache-control')).toMatchInlineSnapshot(
+      `"private, max-age=60, stale-while-revalidate=300"`,
+    )
 
     // A swap row is unique on `(block, first fill logIndex)`.
     const key = (swap: GlobalSwapsResponse['data'][number]) =>
@@ -669,24 +795,433 @@ describe('GET /exchange/swaps', () => {
     for (const swap of body.data) expect(swap.fills.some((fill) => fill.maker === maker)).toBe(true)
   }, 60000)
 
-  test('embeds token metadata on swap sides when requested via `include=tokens`', async () => {
+  test('includes curated token fields on swap sides and fills', async () => {
     const client = TestApp.client()
     const response = await client.v1.exchange.swaps.$get(
-      { query: { include: 'tokens', limit: '10' } },
+      { query: { include: 'token.logoUri,token.verified', limit: '10' } },
       TestApp.auth,
     )
     expect(response.status).toBe(200)
     const body = await TestApp.json(response, Exchanges.schema.getSwaps.Response)
     if (body.data.length === 0) return
 
-    const enriched = body.data.find((swap) => typeof swap.sourceToken.symbol === 'string')
-    if (enriched) {
-      expect(typeof enriched.sourceToken.symbol).toBe('string')
-      expect(typeof enriched.sourceToken.decimals).toBe('number')
+    const enriched = body.data[0]!
+    expect(typeof enriched.sourceToken.verified).toBe('boolean')
+    expect(typeof enriched.destinationToken.verified).toBe('boolean')
+    for (const fill of enriched.fills) {
+      expect(typeof fill.sourceToken.verified).toBe('boolean')
+      expect(typeof fill.destinationToken.verified).toBe('boolean')
     }
   }, 60000)
 })
 
+describe('POST /exchange/quotes', () => {
+  test('validates denominations without verification data', async () => {
+    const db = () =>
+      Db.postgres({ connectionString: 'postgresql://postgres:postgres@127.0.0.1:1/none' })
+    const client = TestApp.client({ db, fx: { oracle: fixed } })
+    const response = await client.v1.exchange.quotes.$post(
+      {
+        json: {
+          amount: '1',
+          destinationToken: Addresses.pathUsd,
+          mode: 'exactSource',
+          slippageBps: 50,
+          sourceToken: '0x20c0000000000000000000008f5425160ebe5525',
+        },
+        query: { denomination: 'JPY' },
+      },
+      TestApp.auth,
+    )
+    expect(response.status).toBe(400)
+  })
+
+  test('parses granular token includes', () => {
+    expect(
+      Exchanges.schema.createQuote.Query.parse({
+        include: 'token.logoUri,token.verified',
+      }).include,
+    ).toMatchInlineSnapshot(`
+      [
+        "token.logoUri",
+        "token.verified",
+      ]
+    `)
+    expect(Exchanges.schema.createQuote.Query.safeParse({ include: 'tokens' }).success).toBe(false)
+  })
+
+  test.each([
+    {
+      destinationToken: '0x20c0000000000000000000008f5425160ebe5525' as const,
+      label: 'identical tokens',
+      slippageBps: 50,
+      sourceToken: '0x20c0000000000000000000008f5425160ebe5525' as const,
+    },
+    {
+      destinationToken: '0x20c000000000000000000000b9537d11c60e8b50' as const,
+      label: 'invalid slippage',
+      slippageBps: 10_000,
+      sourceToken: '0x20c0000000000000000000008f5425160ebe5525' as const,
+    },
+  ])('rejects $label', async ({ destinationToken, slippageBps, sourceToken }) => {
+    const response = await TestApp.client().v1.exchange.quotes.$post(
+      {
+        json: {
+          amount: '1000000',
+          destinationToken,
+          mode: 'exactSource',
+          slippageBps,
+          sourceToken,
+        },
+        query: {},
+      },
+      TestApp.auth,
+    )
+    expect(response.status).toBe(400)
+    expect(await response.json()).toMatchObject({ error: { code: 'body_invalid' } })
+  })
+
+  test('publishes valid request and executable call examples', async () => {
+    const app = TestApp.create({ auth: false })
+    const spec = (await (await app.request('/openapi.json')).json()) as OpenApiDocument
+    const operation = spec.paths['/v1/exchange/quotes']?.post
+    if (!operation) throw new Error('Missing create quote OpenAPI operation')
+
+    const requestSchema = operation.requestBody?.content?.['application/json']?.schema
+    const requestExample = Object.fromEntries(
+      ['amount', 'destinationToken', 'mode', 'slippageBps', 'sourceToken'].map((property) => [
+        property,
+        requestSchema?.properties?.[property]?.examples?.[0],
+      ]),
+    )
+    expect(requestExample).toEqual({
+      amount: '1000000',
+      destinationToken: '0x20c000000000000000000000b9537d11c60e8b50',
+      mode: 'exactSource',
+      slippageBps: 50,
+      sourceToken: '0x20c0000000000000000000008f5425160ebe5525',
+    })
+    expect(Exchanges.schema.createQuote.Request.safeParse(requestExample).success).toBe(true)
+
+    const responseSchema = operation.responses?.['200']?.content?.['application/json']?.schema
+    for (const [variant, names] of [
+      [responseSchema?.oneOf?.[0], ['destinationAmount', 'destinationAmountMin', 'sourceAmount']],
+      [responseSchema?.oneOf?.[1], ['destinationAmount', 'sourceAmount', 'sourceAmountMax']],
+    ] as const)
+      for (const name of names) {
+        const amount = variant?.properties?.[name]
+        expect(amount?.required).toEqual(['baseUnits', 'currency', 'decimals', 'formatted'])
+        expect(
+          Object.fromEntries(
+            ['baseUnits', 'currency', 'decimals', 'formatted'].map((property) => [
+              property,
+              amount?.properties?.[property]?.examples?.[0],
+            ]),
+          ),
+        ).toEqual({ baseUnits: '1000000', currency: 'USD', decimals: 6, formatted: '1' })
+      }
+
+    for (const variant of responseSchema?.oneOf ?? [])
+      for (const name of ['destinationToken', 'sourceToken']) {
+        const token = variant.properties?.[name]
+        expect(token?.required).toEqual(['address', 'currency', 'decimals', 'name', 'symbol'])
+        expect(token?.properties).not.toHaveProperty('amount')
+        expect(token?.properties).not.toHaveProperty('maximumAmount')
+        expect(token?.properties).not.toHaveProperty('minimumAmount')
+        expect(token?.required).not.toContain('logoUri')
+        expect(token?.required).not.toContain('verified')
+      }
+
+    const callsExample =
+      responseSchema?.oneOf?.[0]?.properties?.['transaction']?.properties?.['calls']?.examples?.[0]
+    if (!Array.isArray(callsExample)) throw new Error('Missing create quote call examples')
+    const calls = callsExample.map((call) => Exchanges.schema.createQuote.Call.parse(call))
+    expect(decodeFunctionData({ abi: Abis.tip20, data: calls[0]!.data })).toEqual({
+      args: [Address.checksum(Addresses.stablecoinDex), 1_000_000n],
+      functionName: 'approve',
+    })
+    expect(decodeFunctionData({ abi: Abis.stablecoinDex, data: calls[1]!.data })).toEqual({
+      args: [
+        Address.checksum('0x20c0000000000000000000008f5425160ebe5525'),
+        Address.checksum('0x20c000000000000000000000b9537d11c60e8b50'),
+        1_000_000n,
+        995_000n,
+      ],
+      functionName: 'swapExactAmountIn',
+    })
+  })
+
+  describe.skipIf(Runtime.get().mode !== 'localnet')('localnet quotes', () => {
+    const account = Relay.accounts[1]!
+    let baseToken: z.output<typeof Schema.TokenAddress>
+
+    beforeAll(async () => {
+      const rpc = Relay.getClient({ account })
+      const created = await Actions.token.createSync(rpc, {
+        currency: 'USD',
+        name: 'Quote Base',
+        symbol: 'QBASE',
+      })
+      baseToken = Schema.TokenAddress.parse(created.token)
+      await Actions.token.grantRolesSync(rpc, {
+        roles: ['issuer', 'pause', 'unpause'],
+        to: account.address,
+        token: baseToken,
+      })
+      await Actions.token.mintSync(rpc, {
+        amount: 2_000_000_000n,
+        to: account.address,
+        token: baseToken,
+      })
+      await Actions.token.approveSync(rpc, {
+        amount: 1_000_000_000n,
+        spender: Addresses.stablecoinDex,
+        token: baseToken,
+      })
+      await Actions.token.approveSync(rpc, {
+        amount: 1_000_000_000n,
+        spender: Addresses.stablecoinDex,
+        token: Addresses.pathUsd,
+      })
+      await Actions.dex.createPairSync(rpc, { base: baseToken })
+      await Actions.dex.placeSync(rpc, {
+        amount: 1_000_000_000n,
+        tick: 0,
+        token: baseToken,
+        type: 'buy',
+      })
+      await Actions.dex.placeSync(rpc, {
+        amount: 1_000_000_000n,
+        tick: -10,
+        token: baseToken,
+        type: 'sell',
+      })
+    }, 120_000)
+
+    test('quotes exact-source liquidity and returns approval then sell calls', async () => {
+      // Pin an empty curated list so both legs deterministically value `null`.
+      const db = TestApp.database()
+      await TestApp.verifiedSeed(db, Runtime.get().chainId, { tokens: [] })
+      const client = TestApp.client({ db })
+      const request = {
+        amount: '1',
+        destinationToken: Addresses.pathUsd,
+        mode: 'exactSource',
+        slippageBps: 50,
+        sourceToken: baseToken,
+      } as const
+      const response = await client.v1.exchange.quotes.$post(
+        { json: request, query: { include: 'token.logoUri,token.verified' } },
+        TestApp.auth,
+      )
+      expect(response.status).toBe(200)
+      if (response.status !== 200) throw new Error(await response.text())
+
+      const body = await TestApp.json(response, Exchanges.schema.createQuote.Response)
+      if (body.mode !== 'exactSource') throw new Error('Expected an exact-source exchange quote')
+      expect(body.destinationAmount).toEqual({
+        baseUnits: '1',
+        currency: 'USD',
+        decimals: 6,
+        formatted: '0.000001',
+        valuation: null,
+      })
+      expect(body.destinationToken).toMatchObject({
+        address: Addresses.pathUsd,
+      })
+      expect(body.destinationToken).not.toHaveProperty('amount')
+      expect(body.destinationToken).not.toHaveProperty('minimumAmount')
+      expect(typeof body.destinationToken.symbol).toBe('string')
+      expect(typeof body.destinationToken.verified).toBe('boolean')
+      expect(body.destinationAmountMin).toEqual(body.destinationAmount)
+      expect(body.sourceAmount).toEqual({
+        baseUnits: '1',
+        currency: 'USD',
+        decimals: 6,
+        formatted: '0.000001',
+        valuation: null,
+      })
+      expect(body.sourceToken).toMatchObject({
+        address: baseToken,
+        name: 'Quote Base',
+        symbol: 'QBASE',
+      })
+      expect(body.sourceToken).not.toHaveProperty('amount')
+      expect(typeof body.sourceToken.verified).toBe('boolean')
+      expect(body.transaction.calls).toHaveLength(2)
+      expect(body.transaction.calls[0]!.to).toBe(baseToken)
+      expect(body.transaction.calls[1]!.to).toBe(Addresses.stablecoinDex.toLowerCase())
+      expect(
+        decodeFunctionData({ abi: Abis.tip20, data: body.transaction.calls[0]!.data }),
+      ).toEqual({
+        args: [Address.checksum(Addresses.stablecoinDex), 1n],
+        functionName: 'approve',
+      })
+      expect(
+        decodeFunctionData({ abi: Abis.stablecoinDex, data: body.transaction.calls[1]!.data }),
+      ).toEqual({
+        args: [Address.checksum(baseToken), Address.checksum(Addresses.pathUsd), 1n, 1n],
+        functionName: 'swapExactAmountIn',
+      })
+    }, 60_000)
+
+    test('quotes exact-destination liquidity and returns approval then buy calls', async () => {
+      // Pin an empty curated list so both legs deterministically value `null`.
+      const db = TestApp.database()
+      await TestApp.verifiedSeed(db, Runtime.get().chainId, { tokens: [] })
+      const client = TestApp.client({ db })
+      const request = {
+        amount: '1',
+        destinationToken: baseToken,
+        mode: 'exactDestination',
+        slippageBps: 50,
+        sourceToken: Addresses.pathUsd,
+      } as const
+      const response = await client.v1.exchange.quotes.$post(
+        { json: request, query: {} },
+        TestApp.auth,
+      )
+      expect(response.status).toBe(200)
+      if (response.status !== 200) throw new Error(await response.text())
+
+      const body = await TestApp.json(response, Exchanges.schema.createQuote.Response)
+      if (body.mode !== 'exactDestination')
+        throw new Error('Expected an exact-destination exchange quote')
+      expect(body.destinationAmount).toEqual({
+        baseUnits: '1',
+        currency: 'USD',
+        decimals: 6,
+        formatted: '0.000001',
+        valuation: null,
+      })
+      expect(body.destinationToken).toMatchObject({
+        address: baseToken,
+        name: 'Quote Base',
+        symbol: 'QBASE',
+      })
+      expect(body.destinationToken).not.toHaveProperty('amount')
+      expect(body.destinationToken).not.toHaveProperty('logoUri')
+      expect(body.destinationToken).not.toHaveProperty('verified')
+      expect(body.sourceAmountMax).toEqual(body.destinationAmount)
+      expect(body.sourceAmount).toEqual(body.destinationAmount)
+      expect(body.sourceToken).toMatchObject({
+        address: Addresses.pathUsd,
+      })
+      expect(body.sourceToken).not.toHaveProperty('amount')
+      expect(body.sourceToken).not.toHaveProperty('maximumAmount')
+      expect(typeof body.sourceToken.symbol).toBe('string')
+      expect(body.sourceToken).not.toHaveProperty('logoUri')
+      expect(body.sourceToken).not.toHaveProperty('verified')
+      expect(body.transaction.calls).toHaveLength(2)
+      expect(body.transaction.calls[0]!.to).toBe(Addresses.pathUsd)
+      expect(body.transaction.calls[1]!.to).toBe(Addresses.stablecoinDex.toLowerCase())
+      expect(
+        decodeFunctionData({ abi: Abis.tip20, data: body.transaction.calls[0]!.data }),
+      ).toEqual({
+        args: [Address.checksum(Addresses.stablecoinDex), 1n],
+        functionName: 'approve',
+      })
+      expect(
+        decodeFunctionData({ abi: Abis.stablecoinDex, data: body.transaction.calls[1]!.data }),
+      ).toEqual({
+        args: [Address.checksum(Addresses.pathUsd), Address.checksum(baseToken), 1n, 1n],
+        functionName: 'swapExactAmountOut',
+      })
+    }, 60_000)
+
+    test('values quoted amounts in a requested denomination', async () => {
+      // Curate only pathUSD: its leg values at the fixed 1.6 USD -> AUD rate
+      // while the uncurated base token leg stays null.
+      const db = TestApp.database()
+      await TestApp.verifiedSeed(db, Runtime.get().chainId, {
+        tokens: [
+          {
+            address: Addresses.pathUsd,
+            currency: 'USD',
+            decimals: 6,
+            name: 'PathUSD',
+            symbol: 'pathUSD',
+          },
+        ],
+      })
+      const client = TestApp.client({ db, fx: { oracle: fixed } })
+
+      const response = await client.v1.exchange.quotes.$post(
+        {
+          json: {
+            amount: '1000000',
+            destinationToken: Addresses.pathUsd,
+            mode: 'exactSource',
+            slippageBps: 50,
+            sourceToken: baseToken,
+          },
+          query: { denomination: 'aud' },
+        },
+        TestApp.auth,
+      )
+      expect(response.status).toBe(200)
+      const body = await TestApp.json(response, Exchanges.schema.createQuote.Response)
+
+      expect(body.sourceAmount.valuation).toBeNull()
+      expect(body.destinationAmount.valuation).toEqual({
+        amount: core_Value.format((BigInt(body.destinationAmount.baseUnits) * 16n) / 10n, 6),
+        currency: 'AUD',
+      })
+      expect(body.meta?.pricing).toMatchInlineSnapshot(`
+        {
+          "asOf": "2026-01-01T00:00:00.000Z",
+          "basis": "nominal",
+          "source": "fixed",
+        }
+      `)
+    }, 60_000)
+
+    test('returns a client error when the quote amount overflows', async () => {
+      const response = await TestApp.client().v1.exchange.quotes.$post(
+        {
+          json: {
+            amount: (2n ** 128n - 1n).toString(),
+            destinationToken: baseToken,
+            mode: 'exactSource',
+            slippageBps: 50,
+            sourceToken: Addresses.pathUsd,
+          },
+          query: {},
+        },
+        TestApp.auth,
+      )
+      expect(response.status).toBe(400)
+      expect(await response.json()).toMatchObject({
+        error: { code: 'quote_amount_out_of_range' },
+      })
+    }, 60_000)
+
+    test('returns quote unavailable when a route token is paused', async () => {
+      const rpc = Relay.getClient({ account })
+      await Actions.token.pauseSync(rpc, { token: baseToken })
+      try {
+        const response = await TestApp.client().v1.exchange.quotes.$post(
+          {
+            json: {
+              amount: '1',
+              destinationToken: Addresses.pathUsd,
+              mode: 'exactSource',
+              slippageBps: 50,
+              sourceToken: baseToken,
+            },
+            query: {},
+          },
+          TestApp.auth,
+        )
+        expect(response.status).toBe(404)
+        expect(await response.json()).toMatchObject({ error: { code: 'quote_not_available' } })
+      } finally {
+        await Actions.token.unpauseSync(rpc, { token: baseToken })
+      }
+    }, 60_000)
+  })
+})
+
 describe('GET /exchange/orders', () => {
   type GlobalOrdersResponse = z.output<typeof Exchanges.schema.getOrders.Response>