tapimo 0.13.0 → 0.15.0

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

@@ -2,8 +2,8 @@
 
 import type * as z from 'zod/mini'
 import { Address, Value as core_Value } from 'ox'
-import { Db, Schema } from 'tapimo'
 import { FxOracle } from 'tapimo/apps'
+import { Db, Schema } from 'tapimo/server'
 import { decodeFunctionData, zeroHash } from 'viem'
 import { Abis, Actions, Addresses } from 'viem/tempo'
 
@@ -13,20 +13,33 @@ import * as Runtime from '../../../../test/runtime.js'
 import * as Exchanges from './exchanges.js'
 
 type JsonSchema = {
+  $ref?: string
   anyOf?: readonly JsonSchema[]
+  description?: string
+  enum?: readonly string[]
   examples?: readonly unknown[]
+  format?: string
+  items?: JsonSchema
   properties?: Record<string, JsonSchema>
   required?: readonly string[]
 }
+type OpenApiResponse = {
+  $ref?: string
+  content?: Record<string, { schema?: JsonSchema }>
+}
+type OpenApiOperation = {
+  operationId?: string
+  requestBody?: { content?: Record<string, { schema?: JsonSchema }> }
+  responses?: Record<string, OpenApiResponse>
+}
 type OrdersResponse = z.output<typeof Exchanges.schema.getOrders.Response>
 type OpenApiDocument = {
+  components: { schemas: Record<string, JsonSchema> }
   paths: Record<
     string,
     {
-      post?: {
-        requestBody?: { content?: Record<string, { schema?: JsonSchema }> }
-        responses?: Record<string, { content?: Record<string, { schema?: JsonSchema }> }>
-      }
+      get?: OpenApiOperation
+      post?: OpenApiOperation
     }
   >
 }
@@ -42,6 +55,704 @@ const fixed = FxOracle.from({
   }),
 })
 
+function resolveSchema(spec: OpenApiDocument, schema: JsonSchema | undefined): JsonSchema {
+  if (!schema) throw new Error('Missing OpenAPI schema')
+  if (!schema.$ref) return schema
+  const name = schema.$ref.split('/').at(-1)
+  if (!name) throw new Error(`Invalid OpenAPI component ref ${schema.$ref}`)
+  return component(spec, name)
+}
+
+function component(spec: OpenApiDocument, name: string): JsonSchema {
+  const schema = spec.components.schemas[name]
+  if (!schema) throw new Error(`Missing OpenAPI component ${name}`)
+  return schema
+}
+
+describe('OpenAPI', () => {
+  test('publishes generator-ready exchange contracts', async () => {
+    const app = TestApp.create({ auth: false })
+    const spec = (await (await app.request('/openapi.json')).json()) as OpenApiDocument
+    const operations = {
+      createQuote: spec.paths['/v1/exchange/quotes']?.post,
+      finalizeQuote: spec.paths['/v1/exchange/quotes/execute']?.post,
+      getDepth: spec.paths['/v1/exchange/pairs/{base}/depth']?.get,
+      getOhlc: spec.paths['/v1/exchange/pairs/{base}/ohlc']?.get,
+      getOrder: spec.paths['/v1/exchange/orders/{orderId}']?.get,
+      getOrderFills: spec.paths['/v1/exchange/orders/{orderId}/fills']?.get,
+      getOrders: spec.paths['/v1/exchange/orders']?.get,
+      getPair: spec.paths['/v1/exchange/pairs/{base}']?.get,
+      getPairs: spec.paths['/v1/exchange/pairs']?.get,
+      getSwaps: spec.paths['/v1/exchange/swaps']?.get,
+    }
+    if (Object.values(operations).some((operation) => !operation))
+      throw new Error('Missing exchange OpenAPI operation')
+
+    const summarizeError = (response: OpenApiResponse | undefined) => {
+      if (!response) return undefined
+      if (response.$ref) return { $ref: response.$ref }
+      const schema = response.content?.['application/json']?.schema
+      return resolveSchema(spec, schema).properties?.['error']?.properties?.['code']?.enum
+    }
+    const summarize = (operation: OpenApiOperation | undefined) => {
+      if (!operation) throw new Error('Missing exchange OpenAPI operation')
+      return {
+        errors: Object.fromEntries(
+          [400, 401, 402, 403, 404, 429, 500, 502, 504]
+            .filter((status) => operation.responses?.[status])
+            .map((status) => [status, summarizeError(operation.responses?.[status])]),
+        ),
+        operationId: operation.operationId,
+        request: operation.requestBody?.content?.['application/json']?.schema,
+        response: operation.responses?.['200']?.content?.['application/json']?.schema,
+      }
+    }
+    const components = {
+      depth: component(spec, 'ExchangePairDepth'),
+      ohlc: component(spec, 'ExchangePairOhlc'),
+      ohlcBucket: component(spec, 'ExchangeOhlcBucket'),
+      order: component(spec, 'ExchangeRestingOrder'),
+      orderFill: component(spec, 'ExchangeOrderFill'),
+      orderFillList: component(spec, 'ExchangeOrderFillList'),
+      orderList: component(spec, 'ExchangeOrderList'),
+      pair: component(spec, 'ExchangePair'),
+      pairList: component(spec, 'ExchangePairList'),
+      quote: component(spec, 'ExchangeQuote'),
+      quoteApproval: component(spec, 'ExchangeQuoteExactSourceApprovalRequired'),
+      quoteReady: component(spec, 'ExchangeQuoteExactSourceReady'),
+      quoteSignature: component(spec, 'ExchangeQuoteExactSourceSignatureRequired'),
+      swap: component(spec, 'ExchangeSwap'),
+      swapList: component(spec, 'ExchangeSwapList'),
+    }
+    const quote = components.quote
+    const quoteVariants = quote.anyOf ?? []
+    const exchangeComponentNames = Object.keys(spec.components.schemas)
+      .filter((name) => name.includes('Exchange'))
+      .sort()
+
+    expect({
+      components: exchangeComponentNames,
+      formats: {
+        ohlc: components.ohlcBucket.properties?.['timestamp']?.format,
+        order: components.order.properties?.['placedAt']?.format,
+        orderFill: components.orderFill.properties?.['filledAt']?.format,
+        pair: components.pair.properties?.['timestamp']?.format,
+        swap: components.swap.properties?.['filledAt']?.format,
+      },
+      models: {
+        depthLevels: components.depth.properties?.['asks']?.items,
+        ohlcBuckets: components.ohlc.properties?.['data']?.items,
+        orderFills: components.orderFillList.properties?.['data']?.items,
+        orderFillsMeta: components.orderFillList.properties?.['meta'],
+        orders: components.orderList.properties?.['data']?.items,
+        ordersMeta: components.orderList.properties?.['meta'],
+        pairDetail: operations.getPair?.responses?.['200']?.content?.['application/json']?.schema,
+        pairs: components.pairList.properties?.['data']?.items,
+        pairsMeta: components.pairList.properties?.['meta'],
+        quoteApproval: components.quoteApproval.properties?.['approval'],
+        quoteAmount: components.quoteSignature.properties?.['sourceAmount'],
+        quoteMeta: components.quoteSignature.properties?.['meta'],
+        quoteToken: components.quoteSignature.properties?.['sourceToken'],
+        quoteTransaction: components.quoteReady.properties?.['transaction'],
+        quoteTypedData: components.quoteSignature.properties?.['typedData'],
+        quoteVariants: {
+          count: quoteVariants.length,
+          referenced: quoteVariants.every((variant) => variant.$ref),
+          schemas: quoteVariants,
+        },
+        swapFills: components.swap.properties?.['fills']?.items,
+        swaps: components.swapList.properties?.['data']?.items,
+        swapsMeta: components.swapList.properties?.['meta'],
+      },
+      operations: Object.fromEntries(
+        Object.entries(operations).map(([name, operation]) => [name, summarize(operation)]),
+      ),
+      undescribedComponents: exchangeComponentNames.filter(
+        (name) => !component(spec, name).description,
+      ),
+    }).toMatchInlineSnapshot(`
+      {
+        "components": [
+          "CreateExchangeQuoteRequest",
+          "ExchangeDepthLevel",
+          "ExchangeOhlcBucket",
+          "ExchangeOrder",
+          "ExchangeOrderFill",
+          "ExchangeOrderFillList",
+          "ExchangeOrderFillListMeta",
+          "ExchangeOrderList",
+          "ExchangeOrderListMeta",
+          "ExchangeOrderPair",
+          "ExchangePair",
+          "ExchangePairDepth",
+          "ExchangePairList",
+          "ExchangePairListMeta",
+          "ExchangePairOhlc",
+          "ExchangePairToken",
+          "ExchangeQuote",
+          "ExchangeQuoteApproval",
+          "ExchangeQuoteCall",
+          "ExchangeQuoteDestinationToken",
+          "ExchangeQuoteExactDestinationApprovalRequired",
+          "ExchangeQuoteExactDestinationReady",
+          "ExchangeQuoteExactDestinationSignatureRequired",
+          "ExchangeQuoteExactSourceApprovalRequired",
+          "ExchangeQuoteExactSourceReady",
+          "ExchangeQuoteExactSourceSignatureRequired",
+          "ExchangeQuoteMeta",
+          "ExchangeQuoteSourceToken",
+          "ExchangeQuoteTransaction",
+          "ExchangeQuoteTypedData",
+          "ExchangeRestingOrder",
+          "ExchangeSwap",
+          "ExchangeSwapFill",
+          "ExchangeSwapList",
+          "ExchangeSwapListMeta",
+          "ExchangeSwapToken",
+          "ExchangeValuedAmount",
+          "FinalizeExchangeQuoteRequest",
+          "FinalizedExchangeQuote",
+        ],
+        "formats": {
+          "ohlc": "date-time",
+          "order": "date-time",
+          "orderFill": "date-time",
+          "pair": "date-time",
+          "swap": "date-time",
+        },
+        "models": {
+          "depthLevels": {
+            "$ref": "#/components/schemas/ExchangeDepthLevel",
+          },
+          "ohlcBuckets": {
+            "$ref": "#/components/schemas/ExchangeOhlcBucket",
+          },
+          "orderFills": {
+            "$ref": "#/components/schemas/ExchangeOrderFill",
+          },
+          "orderFillsMeta": {
+            "$ref": "#/components/schemas/ExchangeOrderFillListMeta",
+          },
+          "orders": {
+            "$ref": "#/components/schemas/ExchangeRestingOrder",
+          },
+          "ordersMeta": {
+            "$ref": "#/components/schemas/ExchangeOrderListMeta",
+          },
+          "pairDetail": {
+            "$ref": "#/components/schemas/ExchangePair",
+          },
+          "pairs": {
+            "$ref": "#/components/schemas/ExchangePair",
+          },
+          "pairsMeta": {
+            "$ref": "#/components/schemas/ExchangePairListMeta",
+          },
+          "quoteAmount": {
+            "$ref": "#/components/schemas/ExchangeValuedAmount",
+          },
+          "quoteApproval": {
+            "$ref": "#/components/schemas/ExchangeQuoteApproval",
+          },
+          "quoteMeta": {
+            "$ref": "#/components/schemas/ExchangeQuoteMeta",
+          },
+          "quoteToken": {
+            "$ref": "#/components/schemas/ExchangeQuoteSourceToken",
+          },
+          "quoteTransaction": {
+            "$ref": "#/components/schemas/ExchangeQuoteTransaction",
+          },
+          "quoteTypedData": {
+            "$ref": "#/components/schemas/ExchangeQuoteTypedData",
+          },
+          "quoteVariants": {
+            "count": 6,
+            "referenced": true,
+            "schemas": [
+              {
+                "$ref": "#/components/schemas/ExchangeQuoteExactSourceApprovalRequired",
+              },
+              {
+                "$ref": "#/components/schemas/ExchangeQuoteExactSourceReady",
+              },
+              {
+                "$ref": "#/components/schemas/ExchangeQuoteExactSourceSignatureRequired",
+              },
+              {
+                "$ref": "#/components/schemas/ExchangeQuoteExactDestinationApprovalRequired",
+              },
+              {
+                "$ref": "#/components/schemas/ExchangeQuoteExactDestinationReady",
+              },
+              {
+                "$ref": "#/components/schemas/ExchangeQuoteExactDestinationSignatureRequired",
+              },
+            ],
+          },
+          "swapFills": {
+            "$ref": "#/components/schemas/ExchangeSwapFill",
+          },
+          "swaps": {
+            "$ref": "#/components/schemas/ExchangeSwap",
+          },
+          "swapsMeta": {
+            "$ref": "#/components/schemas/ExchangeSwapListMeta",
+          },
+        },
+        "operations": {
+          "createQuote": {
+            "errors": {
+              "400": [
+                "api_key_malformed",
+                "body_invalid",
+                "chain_id_invalid",
+                "chain_id_unsupported",
+                "query_invalid",
+                "quote_amount_out_of_range",
+              ],
+              "401": [
+                "api_key_invalid",
+                "api_key_missing",
+                "unauthorized",
+              ],
+              "402": {
+                "$ref": "#/components/responses/PaymentRequired",
+              },
+              "403": [
+                "api_key_forbidden",
+                "api_key_ip_forbidden",
+                "forbidden",
+              ],
+              "404": [
+                "quote_not_available",
+              ],
+              "429": {
+                "$ref": "#/components/responses/RateLimited",
+              },
+              "500": {
+                "$ref": "#/components/responses/InternalError",
+              },
+              "502": [
+                "upstream_error",
+              ],
+              "504": {
+                "$ref": "#/components/responses/RequestTimeout",
+              },
+            },
+            "operationId": "createExchangeQuote",
+            "request": {
+              "$ref": "#/components/schemas/CreateExchangeQuoteRequest",
+            },
+            "response": {
+              "$ref": "#/components/schemas/ExchangeQuote",
+            },
+          },
+          "finalizeQuote": {
+            "errors": {
+              "400": [
+                "api_key_malformed",
+                "body_invalid",
+                "chain_id_invalid",
+                "chain_id_unsupported",
+                "query_invalid",
+                "swap_continuation_invalid",
+                "swap_provider_invalid",
+              ],
+              "401": [
+                "api_key_invalid",
+                "api_key_missing",
+                "unauthorized",
+              ],
+              "402": {
+                "$ref": "#/components/responses/PaymentRequired",
+              },
+              "403": [
+                "api_key_forbidden",
+                "api_key_ip_forbidden",
+                "forbidden",
+              ],
+              "429": {
+                "$ref": "#/components/responses/RateLimited",
+              },
+              "500": {
+                "$ref": "#/components/responses/InternalError",
+              },
+              "502": [
+                "upstream_error",
+              ],
+              "504": {
+                "$ref": "#/components/responses/RequestTimeout",
+              },
+            },
+            "operationId": "finalizeExchangeQuote",
+            "request": {
+              "$ref": "#/components/schemas/FinalizeExchangeQuoteRequest",
+            },
+            "response": {
+              "$ref": "#/components/schemas/FinalizedExchangeQuote",
+            },
+          },
+          "getDepth": {
+            "errors": {
+              "400": [
+                "api_key_malformed",
+                "chain_id_invalid",
+                "chain_id_unsupported",
+                "pair_invalid",
+                "query_invalid",
+              ],
+              "401": [
+                "api_key_invalid",
+                "api_key_missing",
+                "unauthorized",
+              ],
+              "402": {
+                "$ref": "#/components/responses/PaymentRequired",
+              },
+              "403": [
+                "api_key_forbidden",
+                "api_key_ip_forbidden",
+                "forbidden",
+              ],
+              "404": [
+                "pair_not_found",
+              ],
+              "429": {
+                "$ref": "#/components/responses/RateLimited",
+              },
+              "500": {
+                "$ref": "#/components/responses/InternalError",
+              },
+              "502": [
+                "upstream_error",
+              ],
+              "504": {
+                "$ref": "#/components/responses/RequestTimeout",
+              },
+            },
+            "operationId": "getPairDepth",
+            "request": undefined,
+            "response": {
+              "$ref": "#/components/schemas/ExchangePairDepth",
+            },
+          },
+          "getOhlc": {
+            "errors": {
+              "400": [
+                "api_key_malformed",
+                "chain_id_invalid",
+                "chain_id_unsupported",
+                "pair_invalid",
+                "query_invalid",
+              ],
+              "401": [
+                "api_key_invalid",
+                "api_key_missing",
+                "unauthorized",
+              ],
+              "402": {
+                "$ref": "#/components/responses/PaymentRequired",
+              },
+              "403": [
+                "api_key_forbidden",
+                "api_key_ip_forbidden",
+                "forbidden",
+              ],
+              "404": [
+                "pair_not_found",
+              ],
+              "429": {
+                "$ref": "#/components/responses/RateLimited",
+              },
+              "500": {
+                "$ref": "#/components/responses/InternalError",
+              },
+              "502": [
+                "upstream_error",
+              ],
+              "504": {
+                "$ref": "#/components/responses/RequestTimeout",
+              },
+            },
+            "operationId": "getPairOhlc",
+            "request": undefined,
+            "response": {
+              "$ref": "#/components/schemas/ExchangePairOhlc",
+            },
+          },
+          "getOrder": {
+            "errors": {
+              "400": [
+                "api_key_malformed",
+                "chain_id_invalid",
+                "chain_id_unsupported",
+                "order_invalid",
+                "query_invalid",
+              ],
+              "401": [
+                "api_key_invalid",
+                "api_key_missing",
+                "unauthorized",
+              ],
+              "402": {
+                "$ref": "#/components/responses/PaymentRequired",
+              },
+              "403": [
+                "api_key_forbidden",
+                "api_key_ip_forbidden",
+                "forbidden",
+              ],
+              "404": [
+                "order_not_found",
+              ],
+              "429": {
+                "$ref": "#/components/responses/RateLimited",
+              },
+              "500": {
+                "$ref": "#/components/responses/InternalError",
+              },
+              "502": [
+                "upstream_error",
+              ],
+              "504": {
+                "$ref": "#/components/responses/RequestTimeout",
+              },
+            },
+            "operationId": "getOrder",
+            "request": undefined,
+            "response": {
+              "$ref": "#/components/schemas/ExchangeOrder",
+            },
+          },
+          "getOrderFills": {
+            "errors": {
+              "400": [
+                "api_key_malformed",
+                "chain_id_invalid",
+                "chain_id_unsupported",
+                "order_invalid",
+                "query_invalid",
+              ],
+              "401": [
+                "api_key_invalid",
+                "api_key_missing",
+                "unauthorized",
+              ],
+              "402": {
+                "$ref": "#/components/responses/PaymentRequired",
+              },
+              "403": [
+                "api_key_forbidden",
+                "api_key_ip_forbidden",
+                "forbidden",
+              ],
+              "429": {
+                "$ref": "#/components/responses/RateLimited",
+              },
+              "500": {
+                "$ref": "#/components/responses/InternalError",
+              },
+              "502": [
+                "upstream_error",
+              ],
+              "504": {
+                "$ref": "#/components/responses/RequestTimeout",
+              },
+            },
+            "operationId": "getOrderFills",
+            "request": undefined,
+            "response": {
+              "$ref": "#/components/schemas/ExchangeOrderFillList",
+            },
+          },
+          "getOrders": {
+            "errors": {
+              "400": [
+                "api_key_malformed",
+                "chain_id_invalid",
+                "chain_id_unsupported",
+                "query_invalid",
+              ],
+              "401": [
+                "api_key_invalid",
+                "api_key_missing",
+                "unauthorized",
+              ],
+              "402": {
+                "$ref": "#/components/responses/PaymentRequired",
+              },
+              "403": [
+                "api_key_forbidden",
+                "api_key_ip_forbidden",
+                "forbidden",
+              ],
+              "404": [
+                "pair_not_found",
+              ],
+              "429": {
+                "$ref": "#/components/responses/RateLimited",
+              },
+              "500": {
+                "$ref": "#/components/responses/InternalError",
+              },
+              "502": [
+                "upstream_error",
+              ],
+              "504": {
+                "$ref": "#/components/responses/RequestTimeout",
+              },
+            },
+            "operationId": "getOrders",
+            "request": undefined,
+            "response": {
+              "$ref": "#/components/schemas/ExchangeOrderList",
+            },
+          },
+          "getPair": {
+            "errors": {
+              "400": [
+                "api_key_malformed",
+                "chain_id_invalid",
+                "chain_id_unsupported",
+                "pair_invalid",
+                "query_invalid",
+              ],
+              "401": [
+                "api_key_invalid",
+                "api_key_missing",
+                "unauthorized",
+              ],
+              "402": {
+                "$ref": "#/components/responses/PaymentRequired",
+              },
+              "403": [
+                "api_key_forbidden",
+                "api_key_ip_forbidden",
+                "forbidden",
+              ],
+              "404": [
+                "pair_not_found",
+              ],
+              "429": {
+                "$ref": "#/components/responses/RateLimited",
+              },
+              "500": {
+                "$ref": "#/components/responses/InternalError",
+              },
+              "502": [
+                "upstream_error",
+              ],
+              "504": {
+                "$ref": "#/components/responses/RequestTimeout",
+              },
+            },
+            "operationId": "getPair",
+            "request": undefined,
+            "response": {
+              "$ref": "#/components/schemas/ExchangePair",
+            },
+          },
+          "getPairs": {
+            "errors": {
+              "400": [
+                "api_key_malformed",
+                "chain_id_invalid",
+                "chain_id_unsupported",
+                "query_invalid",
+              ],
+              "401": [
+                "api_key_invalid",
+                "api_key_missing",
+                "unauthorized",
+              ],
+              "402": {
+                "$ref": "#/components/responses/PaymentRequired",
+              },
+              "403": [
+                "api_key_forbidden",
+                "api_key_ip_forbidden",
+                "forbidden",
+              ],
+              "429": {
+                "$ref": "#/components/responses/RateLimited",
+              },
+              "500": {
+                "$ref": "#/components/responses/InternalError",
+              },
+              "502": [
+                "upstream_error",
+              ],
+              "504": {
+                "$ref": "#/components/responses/RequestTimeout",
+              },
+            },
+            "operationId": "getPairs",
+            "request": undefined,
+            "response": {
+              "$ref": "#/components/schemas/ExchangePairList",
+            },
+          },
+          "getSwaps": {
+            "errors": {
+              "400": [
+                "api_key_malformed",
+                "chain_id_invalid",
+                "chain_id_unsupported",
+                "query_invalid",
+              ],
+              "401": [
+                "api_key_invalid",
+                "api_key_missing",
+                "unauthorized",
+              ],
+              "402": {
+                "$ref": "#/components/responses/PaymentRequired",
+              },
+              "403": [
+                "api_key_forbidden",
+                "api_key_ip_forbidden",
+                "forbidden",
+              ],
+              "429": {
+                "$ref": "#/components/responses/RateLimited",
+              },
+              "500": {
+                "$ref": "#/components/responses/InternalError",
+              },
+              "502": [
+                "upstream_error",
+              ],
+              "504": {
+                "$ref": "#/components/responses/RequestTimeout",
+              },
+            },
+            "operationId": "getSwaps",
+            "request": undefined,
+            "response": {
+              "$ref": "#/components/schemas/ExchangeSwapList",
+            },
+          },
+        },
+        "undescribedComponents": [],
+      }
+    `)
+  })
+
+  test('returns exact chain and pair validation errors', async () => {
+    const app = TestApp.create({ auth: false })
+    const invalidChain = await app.request('/v1/exchange/pairs?chainId=abc')
+    const unsupportedChain = await app.request('/v1/exchange/pairs?chainId=999999')
+    const invalidPair = await app.request('/v1/exchange/pairs/not-an-address')
+
+    expect([
+      (await TestApp.json(invalidChain, Schema.ErrorResponse)).error.code,
+      (await TestApp.json(unsupportedChain, Schema.ErrorResponse)).error.code,
+      (await TestApp.json(invalidPair, Schema.ErrorResponse)).error.code,
+    ]).toStrictEqual(['chain_id_invalid', 'chain_id_unsupported', 'pair_invalid'])
+  })
+})
+
 describe('schema.createQuote.TypedData', () => {
   test('accepts provider-specific EIP-712 types', () => {
     expect(
@@ -879,21 +1590,18 @@ describe('POST and QUERY /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: {
-          account: Relay.accounts[1]!.address,
-          amount: '1',
-          destinationToken: Addresses.pathUsd,
-          mode: 'exactSource',
-          slippageBps: 50,
-          sourceToken: '0x20c0000000000000000000008f5425160ebe5525',
-        },
-        query: { 'valuation.currency': 'JPY' },
+    const client = TestApp.client({ auth: false, db, fx: { oracle: fixed } })
+    const response = await client.v1.exchange.quotes.$post({
+      json: {
+        account: Relay.accounts[1]!.address,
+        amount: '1',
+        destinationToken: Addresses.pathUsd,
+        mode: 'exactSource',
+        slippageBps: 50,
+        sourceToken: '0x20c0000000000000000000008f5425160ebe5525',
       },
-      TestApp.auth,
-    )
+      query: { 'valuation.currency': 'JPY' },
+    })
     expect(response.status).toBe(400)
   })
 
@@ -949,7 +1657,10 @@ describe('POST and QUERY /exchange/quotes', () => {
     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 requestSchema = resolveSchema(
+      spec,
+      operation.requestBody?.content?.['application/json']?.schema,
+    )
     const requestExample = Object.fromEntries(
       ['account', 'amount', 'destinationToken', 'mode', 'slippageBps', 'sourceToken'].map(
         (property) => [property, requestSchema?.properties?.[property]?.examples?.[0]],
@@ -965,16 +1676,20 @@ describe('POST and QUERY /exchange/quotes', () => {
     expect(requestExample['account']).toMatch(/^0x[\da-f]{40}$/)
     expect(Exchanges.schema.createQuote.Request.safeParse(requestExample).success).toBe(true)
 
-    const responseSchema = operation.responses?.['200']?.content?.['application/json']?.schema
+    const responseSchema = resolveSchema(
+      spec,
+      operation.responses?.['200']?.content?.['application/json']?.schema,
+    )
     const variants = responseSchema?.anyOf
     if (!variants) throw new Error('Missing create quote response variants')
     for (const [variants_amount, names] of [
       [variants.slice(0, 3), ['destinationAmount', 'destinationAmountMin', 'sourceAmount']],
       [variants.slice(3), ['destinationAmount', 'sourceAmount', 'sourceAmountMax']],
     ] as const)
-      for (const variant of variants_amount)
+      for (const variant_ref of variants_amount) {
+        const variant = resolveSchema(spec, variant_ref)
         for (const name of names) {
-          const amount = variant?.properties?.[name]
+          const amount = resolveSchema(spec, variant.properties?.[name])
           expect(amount?.required).toEqual(['baseUnits', 'currency', 'decimals', 'formatted'])
           expect(
             Object.fromEntries(
@@ -985,10 +1700,12 @@ describe('POST and QUERY /exchange/quotes', () => {
             ),
           ).toEqual({ baseUnits: '1000000', currency: 'USD', decimals: 6, formatted: '1' })
         }
+      }
 
-    for (const variant of variants)
+    for (const variant_ref of variants) {
+      const variant = resolveSchema(spec, variant_ref)
       for (const name of ['destinationToken', 'sourceToken']) {
-        const token = variant.properties?.[name]
+        const token = resolveSchema(spec, variant.properties?.[name])
         expect(token?.required).toEqual(['address', 'currency', 'decimals', 'name', 'symbol'])
         expect(token?.properties).not.toHaveProperty('amount')
         expect(token?.properties).not.toHaveProperty('maximumAmount')
@@ -996,9 +1713,13 @@ describe('POST and QUERY /exchange/quotes', () => {
         expect(token?.required).not.toContain('logoUri')
         expect(token?.required).not.toContain('verified')
       }
+    }
 
-    const callsExample = variants.find((variant) => variant.properties?.['transaction'])
-      ?.properties?.['transaction']?.properties?.['calls']?.examples?.[0]
+    const ready = variants
+      .map((variant) => resolveSchema(spec, variant))
+      .find((variant) => variant.properties?.['transaction'])
+    const transaction = resolveSchema(spec, ready?.properties?.['transaction'])
+    const callsExample = 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({
@@ -1015,9 +1736,10 @@ describe('POST and QUERY /exchange/quotes', () => {
       functionName: 'swapExactAmountIn',
     })
 
-    const typedData = variants.find((variant) => variant.properties?.['typedData'])?.properties?.[
-      'typedData'
-    ]
+    const signatureRequired = variants
+      .map((variant) => resolveSchema(spec, variant))
+      .find((variant) => variant.properties?.['typedData'])
+    const typedData = resolveSchema(spec, signatureRequired?.properties?.['typedData'])
     expect(typedData?.properties?.['primaryType']?.examples).toEqual(['PermitSingle'])
     expect(typedData?.properties?.['domain']?.examples?.[0]).toMatchObject({
       chainId: 4217,