tapimo 0.13.0 → 0.14.0

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

@@ -189,67 +189,75 @@ export namespace schema {
    * are absent on the base (no-`include`) response and best-effort when
    * requested (a token whose metadata is unavailable keeps just `address`).
    */
-  export const PairToken = Schema.describe(
-    z.object({
-      address: Schema.tokenAddress(Tokens.tokenExample.address).check(
-        z.describe(
-          'TIP-20 token contract address — the `0x`-prefixed 20-byte identifier for this token.',
-        ),
-        z.meta({ examples: [Tokens.tokenExample.address] }),
-      ),
-      currency: z
-        .optional(z.string())
-        .check(
-          z.describe('Human-readable currency code for the token, when known.'),
-          z.meta({ examples: [Tokens.tokenExample.currency] }),
-        ),
-      decimals: z
-        .optional(z.number().check(z.int(), z.nonnegative()))
-        .check(
+  export const PairToken = OpenApi.component(
+    Schema.describe(
+      z.object({
+        address: Schema.tokenAddress(Tokens.tokenExample.address).check(
           z.describe(
-            'Number of decimal places the token uses; stablecoins on Tempo typically use 6.',
+            'TIP-20 token contract address — the `0x`-prefixed 20-byte identifier for this token.',
           ),
-          z.meta({ examples: [Tokens.tokenExample.decimals] }),
-        ),
-      logoUri: z.optional(z.string()).check(
-        z.describe('URL for the token logo image, when one is available.'),
-        z.meta({
-          examples: [Tokens.tokenExample.logoUri],
-        }),
-      ),
-      name: z
-        .optional(z.string())
-        .check(
-          z.describe('Human-readable token name, such as `USD Coin`.'),
-          z.meta({ examples: [Tokens.tokenExample.name] }),
-        ),
-      symbol: z
-        .optional(z.string())
-        .check(
-          z.describe('Short token ticker symbol, such as `USDC`.'),
-          z.meta({ examples: [Tokens.tokenExample.symbol] }),
+          z.meta({ examples: [Tokens.tokenExample.address] }),
         ),
-      verified: z
-        .optional(z.boolean())
-        .check(
-          z.describe('Whether Tempo has verified this token metadata.'),
-          z.meta({ examples: [true] }),
+        currency: z
+          .optional(z.string())
+          .check(
+            z.describe('Human-readable currency code for the token, when known.'),
+            z.meta({ examples: [Tokens.tokenExample.currency] }),
+          ),
+        decimals: z
+          .optional(z.number().check(z.int(), z.nonnegative()))
+          .check(
+            z.describe(
+              'Number of decimal places the token uses; stablecoins on Tempo typically use 6.',
+            ),
+            z.meta({ examples: [Tokens.tokenExample.decimals] }),
+          ),
+        logoUri: z.optional(z.string()).check(
+          z.describe('URL for the token logo image, when one is available.'),
+          z.meta({
+            examples: [Tokens.tokenExample.logoUri],
+          }),
         ),
-    }),
-    'One side of a trading pair (with metadata when requested via `include=tokens`).',
+        name: z
+          .optional(z.string())
+          .check(
+            z.describe('Human-readable token name, such as `USD Coin`.'),
+            z.meta({ examples: [Tokens.tokenExample.name] }),
+          ),
+        symbol: z
+          .optional(z.string())
+          .check(
+            z.describe('Short token ticker symbol, such as `USDC`.'),
+            z.meta({ examples: [Tokens.tokenExample.symbol] }),
+          ),
+        verified: z
+          .optional(z.boolean())
+          .check(
+            z.describe('Whether Tempo has verified this token metadata.'),
+            z.meta({ examples: [true] }),
+          ),
+      }),
+      'One side of a trading pair (with metadata when requested via `include=tokens`).',
+    ),
+    'ExchangePairToken',
   )
 
-  /** A token amount carrying its nominal value in the requested denomination. */
-  const ValuedAmount = z.extend(Schema.TokenAmount, {
-    valuation: z
-      .optional(z.nullable(Valuation.schema.Value))
-      .check(
-        z.describe(
-          'The amount’s nominal value in the requested `valuation.currency`. `null` when the token is ' +
-            'unverified, its display currency has no rate, or rates were unavailable.',
-        ),
-      ),
-  })
+  const ValuedAmount = OpenApi.component(
+    Schema.describe(
+      z.extend(Schema.TokenAmount, {
+        valuation: z
+          .optional(z.nullable(Valuation.schema.Value))
+          .check(
+            z.describe(
+              'The amount’s nominal value in the requested `valuation.currency`. `null` when the token is ' +
+                'unverified, its display currency has no rate, or rates were unavailable.',
+            ),
+          ),
+      }),
+      'A token amount carrying its nominal value in the requested denomination.',
+    ),
+    'ExchangeValuedAmount',
+  )
 
   /** Schemas for creating an executable exchange quote. */
   export namespace createQuote {
@@ -292,63 +300,69 @@ export namespace schema {
       .check(z.describe('Query parameters for creating an exchange quote.'))
 
     /** Quote request with one pinned side and caller-selected slippage. */
-    export const Request = z
-      .strictObject({
-        account: z
-          .optional(Schema.Address)
-          .check(
-            z.describe('Wallet that will sign and execute the swap.'),
-            z.meta({ examples: ['0x1111111111111111111111111111111111111111'] }),
+    export const Request = OpenApi.component(
+      z
+        .strictObject({
+          account: z
+            .optional(Schema.Address)
+            .check(
+              z.describe('Wallet that will sign and execute the swap.'),
+              z.meta({ examples: ['0x1111111111111111111111111111111111111111'] }),
+            ),
+          amount: Amount.check(
+            z.describe(
+              'Pinned amount in base units: source amount for `exactSource`, destination amount for `exactDestination`.',
+            ),
           ),
-        amount: Amount.check(
-          z.describe(
-            'Pinned amount in base units: source amount for `exactSource`, destination amount for `exactDestination`.',
+          destinationToken: DestinationTokenAddress.check(
+            z.describe('TIP-20 token the swap receives.'),
           ),
+          mode: z
+            .enum(['exactSource', 'exactDestination'])
+            .check(
+              z.describe('Which side of the swap keeps the requested amount exact.'),
+              z.meta({ examples: ['exactSource'] }),
+            ),
+          slippageBps: z
+            .number()
+            .check(
+              z.int(),
+              z.gte(0),
+              z.lt(10_000),
+              z.describe('Allowed execution slippage in basis points, where 100 is 1%.'),
+              z.meta({ examples: [50] }),
+            ),
+          sourceToken: SourceTokenAddress.check(z.describe('TIP-20 token the swap spends.')),
+        })
+        .check(
+          z.refine((request) => request.sourceToken !== request.destinationToken, {
+            error: 'Source and destination tokens must differ.',
+          }),
+          z.describe('Request for an executable quote from the configured exchange providers.'),
         ),
-        destinationToken: DestinationTokenAddress.check(
-          z.describe('TIP-20 token the swap receives.'),
-        ),
-        mode: z
-          .enum(['exactSource', 'exactDestination'])
-          .check(
-            z.describe('Which side of the swap keeps the requested amount exact.'),
-            z.meta({ examples: ['exactSource'] }),
-          ),
-        slippageBps: z
-          .number()
-          .check(
-            z.int(),
-            z.gte(0),
-            z.lt(10_000),
-            z.describe('Allowed execution slippage in basis points, where 100 is 1%.'),
-            z.meta({ examples: [50] }),
-          ),
-        sourceToken: SourceTokenAddress.check(z.describe('TIP-20 token the swap spends.')),
-      })
-      .check(
-        z.refine((request) => request.sourceToken !== request.destinationToken, {
-          error: 'Source and destination tokens must differ.',
-        }),
-        z.describe('Request for an executable quote from the configured exchange providers.'),
-      )
+      'CreateExchangeQuoteRequest',
+    )
 
     /** One call in the unsigned Tempo transaction plan. */
-    export const Call = z
-      .object({
-        data: Schema.Hex.check(
-          z.describe('ABI-encoded call data.'),
-          z.meta({ examples: ['0x095ea7b3'] }),
-        ),
-        to: Schema.Address.check(
-          z.describe('Contract or precompile that receives the call.'),
-          z.meta({ examples: [Addresses.stablecoinDex] }),
-        ),
-        value: Schema.Quantity.check(
-          z.describe('Native token value sent with the call.'),
-          z.meta({ examples: ['0x0'] }),
-        ),
-      })
-      .check(z.describe('One unsigned call in the Tempo transaction plan.'))
+    export const Call = OpenApi.component(
+      z
+        .object({
+          data: Schema.Hex.check(
+            z.describe('ABI-encoded call data.'),
+            z.meta({ examples: ['0x095ea7b3'] }),
+          ),
+          to: Schema.Address.check(
+            z.describe('Contract or precompile that receives the call.'),
+            z.meta({ examples: [Addresses.stablecoinDex] }),
+          ),
+          value: Schema.Quantity.check(
+            z.describe('Native token value sent with the call.'),
+            z.meta({ examples: ['0x0'] }),
+          ),
+        })
+        .check(z.describe('One unsigned call in the Tempo transaction plan.')),
+      'ExchangeQuoteCall',
+    )
 
     const QuoteToken = Schema.describe(
       z.partial(z.omit(Tokens.schema.Token, { id: true }), {
@@ -358,117 +372,138 @@ export namespace schema {
       'A token referenced by an exchange quote, with RPC metadata and optional enrichments.',
     )
 
-    const DestinationToken = z.extend(QuoteToken, {
-      address: DestinationTokenAddress.check(z.describe('TIP-20 token the swap receives.')),
-    })
+    const DestinationToken = OpenApi.component(
+      Schema.describe(
+        z.extend(QuoteToken, {
+          address: DestinationTokenAddress.check(z.describe('TIP-20 token the swap receives.')),
+        }),
+        'The token received by an exchange quote.',
+      ),
+      'ExchangeQuoteDestinationToken',
+    )
 
-    const SourceToken = z.extend(QuoteToken, {
-      address: SourceTokenAddress.check(z.describe('TIP-20 token the swap spends.')),
-    })
+    const SourceToken = OpenApi.component(
+      Schema.describe(
+        z.extend(QuoteToken, {
+          address: SourceTokenAddress.check(z.describe('TIP-20 token the swap spends.')),
+        }),
+        'The token spent by an exchange quote.',
+      ),
+      'ExchangeQuoteSourceToken',
+    )
 
-    export const Transaction = z
-      .object({
-        calls: z.array(Call).check(
-          z.minLength(1),
-          z.describe('Calls to execute in order.'),
-          z.meta({
-            examples: [
-              [
-                {
-                  data: exampleApprovalCall.data,
-                  to: exampleApprovalCall.to,
-                  value: '0x0',
-                },
-                { data: exampleSwapCall.data, to: exampleSwapCall.to, value: '0x0' },
+    export const Transaction = OpenApi.component(
+      z
+        .object({
+          calls: z.array(Call).check(
+            z.minLength(1),
+            z.describe('Calls to execute in order.'),
+            z.meta({
+              examples: [
+                [
+                  {
+                    data: exampleApprovalCall.data,
+                    to: exampleApprovalCall.to,
+                    value: '0x0',
+                  },
+                  { data: exampleSwapCall.data, to: exampleSwapCall.to, value: '0x0' },
+                ],
               ],
-            ],
-          }),
-        ),
-        chainId: Schema.ChainId.check(z.describe('Tempo chain where these calls execute.')),
-      })
-      .check(z.describe('Unsigned Tempo transaction plan.'))
+            }),
+          ),
+          chainId: Schema.ChainId.check(z.describe('Tempo chain where these calls execute.')),
+        })
+        .check(z.describe('Unsigned Tempo transaction plan.')),
+      'ExchangeQuoteTransaction',
+    )
 
     /** Response-level valuation rate provenance. */
-    export const Meta = z
-      .object({
-        valuation: z
-          .optional(Valuation.schema.Pricing)
-          .check(
-            z.describe(
-              'Rate provenance for amount valuations. Present when conversion rates were consulted.',
+    export const Meta = OpenApi.component(
+      z
+        .object({
+          valuation: z
+            .optional(Valuation.schema.Pricing)
+            .check(
+              z.describe(
+                'Rate provenance for amount valuations. Present when conversion rates were consulted.',
+              ),
             ),
-          ),
-      })
-      .check(z.describe('Response-level resources attached to this quote.'))
+        })
+        .check(z.describe('Response-level resources attached to this quote.')),
+      'ExchangeQuoteMeta',
+    )
 
     /** Provider-neutral EIP-712 payload to sign before finalizing a quote. */
-    export const TypedData = z
-      .object({
-        domain: z.record(z.string(), z.unknown()).check(
-          z.describe('EIP-712 signing domain.'),
-          z.meta({
-            examples: [
-              {
-                chainId: 4217,
-                name: 'Permit2',
-                verifyingContract: '0x000000000022d473030f116ddee9f6b43ac78ba3',
-              },
-            ],
-          }),
-        ),
-        message: z.record(z.string(), z.unknown()).check(
-          z.describe('Values encoded by the primary EIP-712 type.'),
-          z.meta({
-            examples: [
-              {
-                details: {
-                  amount: '1000000',
-                  expiration: '4102444800',
-                  nonce: '0',
-                  token: exampleSourceToken,
+    export const TypedData = OpenApi.component(
+      z
+        .object({
+          domain: z.record(z.string(), z.unknown()).check(
+            z.describe('EIP-712 signing domain.'),
+            z.meta({
+              examples: [
+                {
+                  chainId: 4217,
+                  name: 'Permit2',
+                  verifyingContract: '0x000000000022d473030f116ddee9f6b43ac78ba3',
                 },
-                sigDeadline: '4102444800',
-                spender: '0x1febb76be10aaf3a1402f04e8e835f2c382f7914',
-              },
-            ],
-          }),
-        ),
-        primaryType: z
-          .string()
-          .check(z.minLength(1))
-          .check(z.describe('Root EIP-712 type.'), z.meta({ examples: ['PermitSingle'] })),
-        types: z
-          .record(
-            z.string(),
-            z.array(
-              z.strictObject({
-                name: z.string(),
-                type: z.string(),
-              }),
-            ),
-          )
-          .check(
-            z.describe('EIP-712 type definitions keyed by type name.'),
+              ],
+            }),
+          ),
+          message: z.record(z.string(), z.unknown()).check(
+            z.describe('Values encoded by the primary EIP-712 type.'),
             z.meta({
               examples: [
                 {
-                  PermitDetails: [
-                    { name: 'token', type: 'address' },
-                    { name: 'amount', type: 'uint160' },
-                    { name: 'expiration', type: 'uint48' },
-                    { name: 'nonce', type: 'uint48' },
-                  ],
-                  PermitSingle: [
-                    { name: 'details', type: 'PermitDetails' },
-                    { name: 'spender', type: 'address' },
-                    { name: 'sigDeadline', type: 'uint256' },
-                  ],
+                  details: {
+                    amount: '1000000',
+                    expiration: '4102444800',
+                    nonce: '0',
+                    token: exampleSourceToken,
+                  },
+                  sigDeadline: '4102444800',
+                  spender: '0x1febb76be10aaf3a1402f04e8e835f2c382f7914',
                 },
               ],
             }),
           ),
-      })
-      .check(z.describe('EIP-712 payload the wallet must sign before execution can continue.'))
+          primaryType: z
+            .string()
+            .check(z.minLength(1))
+            .check(z.describe('Root EIP-712 type.'), z.meta({ examples: ['PermitSingle'] })),
+          types: z
+            .record(
+              z.string(),
+              z.array(
+                z.strictObject({
+                  name: z.string(),
+                  type: z.string(),
+                }),
+              ),
+            )
+            .check(
+              z.describe('EIP-712 type definitions keyed by type name.'),
+              z.meta({
+                examples: [
+                  {
+                    PermitDetails: [
+                      { name: 'token', type: 'address' },
+                      { name: 'amount', type: 'uint160' },
+                      { name: 'expiration', type: 'uint48' },
+                      { name: 'nonce', type: 'uint48' },
+                    ],
+                    PermitSingle: [
+                      { name: 'details', type: 'PermitDetails' },
+                      { name: 'spender', type: 'address' },
+                      { name: 'sigDeadline', type: 'uint256' },
+                    ],
+                  },
+                ],
+              }),
+            ),
+        })
+        .check(z.describe('EIP-712 payload the wallet must sign before execution can continue.')),
+      'ExchangeQuoteTypedData',
+    )
 
     const Provider = z
       .string()
@@ -482,24 +517,31 @@ export namespace schema {
       provider: Provider,
     }
 
-    const ApprovalRequired = {
-      approval: z.object({
-        calls: z.array(Call).check(
-          z.minLength(1),
-          z.describe('Approval calls to confirm before requesting a fresh quote.'),
-          z.meta({
-            examples: [
-              [
-                {
-                  data: exampleApprovalCall.data,
-                  to: exampleApprovalCall.to,
-                  value: '0x0',
-                },
+    const Approval = OpenApi.component(
+      z
+        .object({
+          calls: z.array(Call).check(
+            z.minLength(1),
+            z.describe('Approval calls to confirm before requesting a fresh quote.'),
+            z.meta({
+              examples: [
+                [
+                  {
+                    data: exampleApprovalCall.data,
+                    to: exampleApprovalCall.to,
+                    value: '0x0',
+                  },
+                ],
               ],
-            ],
-          }),
-        ),
-      }),
+            }),
+          ),
+        })
+        .check(z.describe('Token approval calls required before requesting a fresh quote.')),
+      'ExchangeQuoteApproval',
+    )
+
+    const ApprovalRequired = {
+      approval: Approval,
       status: z
         .literal('approvalRequired')
         .check(
@@ -536,10 +578,8 @@ export namespace schema {
     }
 
     const ExactSource = {
-      destinationAmount: ValuedAmount.check(z.describe('Quoted destination amount.')),
-      destinationAmountMin: ValuedAmount.check(
-        z.describe('Minimum destination amount after slippage.'),
-      ),
+      destinationAmount: ValuedAmount,
+      destinationAmountMin: ValuedAmount,
       destinationToken: DestinationToken,
       meta: z.optional(Meta).check(z.describe('Valuation rate provenance for this quote.')),
       mode: z
@@ -548,13 +588,13 @@ export namespace schema {
           z.describe('The source amount is fixed and the destination has a minimum.'),
           z.meta({ examples: ['exactSource'] }),
         ),
-      sourceAmount: ValuedAmount.check(z.describe('Exact source amount.')),
-      sourceToken: SourceToken.check(z.describe('Token spent by the swap.')),
+      sourceAmount: ValuedAmount,
+      sourceToken: SourceToken,
     }
 
     const ExactDestination = {
-      destinationAmount: ValuedAmount.check(z.describe('Exact destination amount.')),
-      destinationToken: DestinationToken.check(z.describe('Token received by the swap.')),
+      destinationAmount: ValuedAmount,
+      destinationToken: DestinationToken,
       meta: z.optional(Meta).check(z.describe('Valuation rate provenance for this quote.')),
       mode: z
         .literal('exactDestination')
@@ -562,64 +602,114 @@ export namespace schema {
           z.describe('The destination amount is fixed and the source has a maximum.'),
           z.meta({ examples: ['exactDestination'] }),
         ),
-      sourceAmount: ValuedAmount.check(z.describe('Quoted source amount.')),
-      sourceAmountMax: ValuedAmount.check(z.describe('Maximum source amount after slippage.')),
+      sourceAmount: ValuedAmount,
+      sourceAmountMax: ValuedAmount,
       sourceToken: SourceToken,
     }
 
+    const ExactSourceApprovalRequired = OpenApi.component(
+      z
+        .object({ ...ApprovalRequired, ...ExactSource, ...Quote })
+        .check(z.describe('An exact-source quote that requires token approval.')),
+      'ExchangeQuoteExactSourceApprovalRequired',
+    )
+    const ExactSourceReady = OpenApi.component(
+      z
+        .object({ ...ExactSource, ...Quote, ...Ready })
+        .check(z.describe('An exact-source quote ready to execute.')),
+      'ExchangeQuoteExactSourceReady',
+    )
+    const ExactSourceSignatureRequired = OpenApi.component(
+      z
+        .object({ ...ExactSource, ...Quote, ...SignatureRequired })
+        .check(z.describe('An exact-source quote that requires a signature.')),
+      'ExchangeQuoteExactSourceSignatureRequired',
+    )
+    const ExactDestinationApprovalRequired = OpenApi.component(
+      z
+        .object({ ...ApprovalRequired, ...ExactDestination, ...Quote })
+        .check(z.describe('An exact-destination quote that requires token approval.')),
+      'ExchangeQuoteExactDestinationApprovalRequired',
+    )
+    const ExactDestinationReady = OpenApi.component(
+      z
+        .object({ ...ExactDestination, ...Quote, ...Ready })
+        .check(z.describe('An exact-destination quote ready to execute.')),
+      'ExchangeQuoteExactDestinationReady',
+    )
+    const ExactDestinationSignatureRequired = OpenApi.component(
+      z
+        .object({ ...ExactDestination, ...Quote, ...SignatureRequired })
+        .check(z.describe('An exact-destination quote that requires a signature.')),
+      'ExchangeQuoteExactDestinationSignatureRequired',
+    )
+
     /** Provider-neutral quote and the action needed to execute it. */
-    export const Response = z
-      .union([
-        z.object({ ...ApprovalRequired, ...ExactSource, ...Quote }),
-        z.object({ ...ExactSource, ...Quote, ...Ready }),
-        z.object({ ...ExactSource, ...Quote, ...SignatureRequired }),
-        z.object({ ...ApprovalRequired, ...ExactDestination, ...Quote }),
-        z.object({ ...ExactDestination, ...Quote, ...Ready }),
-        z.object({ ...ExactDestination, ...Quote, ...SignatureRequired }),
-      ])
-      .check(z.describe('Provider-neutral exchange quote with its next execution action.'))
+    export const Response = OpenApi.component(
+      z
+        .union([
+          ExactSourceApprovalRequired,
+          ExactSourceReady,
+          ExactSourceSignatureRequired,
+          ExactDestinationApprovalRequired,
+          ExactDestinationReady,
+          ExactDestinationSignatureRequired,
+        ])
+        .check(z.describe('Provider-neutral exchange quote with its next execution action.')),
+      'ExchangeQuote',
+    )
   }
 
   /** Schemas for finishing a quote after a provider-requested signature. */
   export namespace executeQuote {
     /** Signed continuation request. */
-    export const Request = z.strictObject({
-      account: Schema.Address.check(
-        z.describe('Wallet that signed and will execute the swap.'),
-        z.meta({ examples: ['0x1111111111111111111111111111111111111111'] }),
-      ),
-      continuation: z
-        .string()
-        .check(
-          z.minLength(1),
-          z.maxLength(100_000),
-          z.describe('Opaque state returned by the quote request.'),
-          z.meta({ examples: ['eyJwcm92aWRlciI6InVuaXN3YXAifQ'] }),
-        ),
-      provider: z
-        .string()
-        .check(
-          z.minLength(1),
-          z.describe('Provider that issued the continuation.'),
-          z.meta({ examples: ['uniswap'] }),
-        ),
-      signature: Schema.Hex.check(
-        z.refine((value) => value.length === 132, { error: 'Signature must be 65 bytes.' }),
-        z.describe('65-byte EIP-712 signature requested by the quote.'),
-        z.meta({ examples: [`0x${'11'.repeat(65)}`] }),
-      ),
-    })
+    export const Request = OpenApi.component(
+      z
+        .strictObject({
+          account: Schema.Address.check(
+            z.describe('Wallet that signed and will execute the swap.'),
+            z.meta({ examples: ['0x1111111111111111111111111111111111111111'] }),
+          ),
+          continuation: z
+            .string()
+            .check(
+              z.minLength(1),
+              z.maxLength(100_000),
+              z.describe('Opaque state returned by the quote request.'),
+              z.meta({ examples: ['eyJwcm92aWRlciI6InVuaXN3YXAifQ'] }),
+            ),
+          provider: z
+            .string()
+            .check(
+              z.minLength(1),
+              z.describe('Provider that issued the continuation.'),
+              z.meta({ examples: ['uniswap'] }),
+            ),
+          signature: Schema.Hex.check(
+            z.refine((value) => value.length === 132, { error: 'Signature must be 65 bytes.' }),
+            z.describe('65-byte EIP-712 signature requested by the quote.'),
+            z.meta({ examples: [`0x${'11'.repeat(65)}`] }),
+          ),
+        })
+        .check(z.describe('Request to finalize a provider quote after signing its typed data.')),
+      'FinalizeExchangeQuoteRequest',
+    )
 
     /** Final transaction plan. */
-    export const Response = z.object({
-      provider: z
-        .string()
-        .check(
-          z.describe('Provider that built the transaction.'),
-          z.meta({ examples: ['uniswap'] }),
-        ),
-      transaction: createQuote.Transaction,
-    })
+    export const Response = OpenApi.component(
+      z
+        .object({
+          provider: z
+            .string()
+            .check(
+              z.describe('Provider that built the transaction.'),
+              z.meta({ examples: ['uniswap'] }),
+            ),
+          transaction: createQuote.Transaction,
+        })
+        .check(z.describe('Final unsigned transaction plan for a signed provider quote.')),
+      'FinalizedExchangeQuote',
+    )
   }
 
   /** Schemas for the getPairs operation. */
@@ -671,69 +761,82 @@ export namespace schema {
       )
 
     /** A single trading pair on the stablecoin DEX. */
-    export const Pair = z
-      .object({
-        base: PairToken.check(
-          z.describe('Base token — the asset whose price is quoted in the pair.'),
-        ),
-        blockNumber: z
-          .number()
-          .check(
-            z.int(),
-            z.nonnegative(),
-            z.describe('Block number where the pair was created.'),
-            z.meta({ examples: [23456789] }),
+    export const Pair = OpenApi.component(
+      z
+        .object({
+          base: PairToken,
+          blockNumber: z
+            .number()
+            .check(
+              z.int(),
+              z.nonnegative(),
+              z.describe('Block number where the pair was created.'),
+              z.meta({ examples: [23456789] }),
+            ),
+          id: Schema.Hash.check(
+            z.describe(
+              'Stable API id for this pair; it is the same value as the onchain pair key.',
+            ),
           ),
-        id: Schema.Hash.check(
-          z.describe('Stable API id for this pair; it is the same value as the onchain pair key.'),
-        ),
-        key: Schema.Hash.check(
-          z.describe('Stable onchain pair identifier returned by the DEX precompile as `pairKey`.'),
-        ),
-        liquidity: z
-          .optional(
-            z
-              .string()
-              .check(
-                z.regex(/^\d+$/),
-                z.describe(
-                  'Liquidity signal for the pair: the base-token balance held by the DEX, returned as a decimal integer string in the token’s smallest units. Present only when `sort=liquidity`.',
-                ),
-              ),
-          )
-          .check(
+          key: Schema.Hash.check(
             z.describe(
-              'Liquidity signal for the pair, present only when you request `sort=liquidity`.',
+              'Stable onchain pair identifier returned by the DEX precompile as `pairKey`.',
             ),
-            z.meta({ examples: ['1000000'] }),
           ),
-        quote: PairToken.check(z.describe('Quote token — the asset used to price the base token.')),
-        timestamp: z.iso
-          .datetime()
-          .check(
-            z.describe('Block timestamp when the pair was created.'),
-            z.meta({ examples: ['2024-01-01T00:00:00Z'] }),
+          liquidity: z
+            .optional(
+              z
+                .string()
+                .check(
+                  z.regex(/^\d+$/),
+                  z.describe(
+                    'Liquidity signal for the pair: the base-token balance held by the DEX, returned as a decimal integer string in the token’s smallest units. Present only when `sort=liquidity`.',
+                  ),
+                ),
+            )
+            .check(
+              z.describe(
+                'Liquidity signal for the pair, present only when you request `sort=liquidity`.',
+              ),
+              z.meta({ examples: ['1000000'] }),
+            ),
+          quote: PairToken,
+          timestamp: z.iso
+            .datetime()
+            .check(
+              z.describe('Block timestamp when the pair was created.'),
+              z.meta({ examples: ['2024-01-01T00:00:00Z'] }),
+            ),
+          transactionHash: Schema.Hash.check(
+            z.describe('Transaction hash for the transaction that created the pair.'),
           ),
-        transactionHash: Schema.Hash.check(
-          z.describe('Transaction hash for the transaction that created the pair.'),
-        ),
-      })
-      .check(z.describe('One trading pair on Tempo’s built-in stablecoin exchange.'))
+        })
+        .check(z.describe('One trading pair on Tempo’s built-in stablecoin exchange.')),
+      'ExchangePair',
+    )
+
+    /** Response metadata requested through `include`, such as capped counts. */
+    export const Meta = OpenApi.component(Schema.CountMeta, 'ExchangePairListMeta')
 
     /** Page of trading pairs on the stablecoin DEX, ordered by creation. */
-    export const Response = z
-      .object({
-        data: z.array(Pair).check(z.describe('Trading pairs returned on this page.')),
-        meta: z
-          .optional(Schema.CountMeta)
-          .check(
-            z.describe('Response-level resources requested with `include`, such as `totalCount`.'),
-          ),
-        nextCursor: Schema.NextCursor,
-      })
-      .check(
-        z.describe('A paginated list of trading pairs on Tempo’s built-in stablecoin exchange.'),
-      )
+    export const Response = OpenApi.component(
+      z
+        .object({
+          data: z.array(Pair).check(z.describe('Trading pairs returned on this page.')),
+          meta: z
+            .optional(Meta)
+            .check(
+              z.describe(
+                'Response-level resources requested with `include`, such as `totalCount`.',
+              ),
+            ),
+          nextCursor: Schema.NextCursor,
+        })
+        .check(
+          z.describe('A paginated list of trading pairs on Tempo’s built-in stablecoin exchange.'),
+        ),
+      'ExchangePairList',
+    )
   }
 
   /** Schemas for the getPair operation (single trading pair detail). */
@@ -833,51 +936,52 @@ export namespace schema {
       )
 
     /** One swap-side token with RPC metadata and optional curated fields. */
-    export const SwapSide = Schema.describe(
-      Tokens.schema.TokenReference,
-      'A token referenced by one side of a swap.',
+    export const SwapSide = OpenApi.component(
+      Schema.describe(Tokens.schema.TokenReference, 'A token referenced by one side of a swap.'),
+      'ExchangeSwapToken',
     )
 
     /** A single maker-order fill within a swap, framed from the taker's perspective. */
-    export const Fill = z
-      .object({
-        destinationAmount: ValuedAmount.check(
-          z.describe('Amount the taker received in this fill.'),
-        ),
-        destinationToken: SwapSide.check(z.describe('Token the taker received in this fill.')),
-        logIndex: z
-          .number()
-          .check(
-            z.int(),
-            z.nonnegative(),
-            z.describe('Log index of this fill within its block.'),
-            z.meta({ examples: [0] }),
-          ),
-        maker: Schema.Address.check(z.describe('Maker address whose resting order was filled.')),
-        orderId: Schema.DecimalString.check(
-          z.describe('On-chain maker order id, returned as a decimal string.'),
-        ),
-        partialFill: z
-          .boolean()
-          .check(
-            z.describe('Whether this fill used only part of the maker order.'),
-            z.meta({ examples: [false] }),
-          ),
-        price: z
-          .string()
-          .check(
-            z.regex(/^\d+(\.\d+)?$/),
-            z.describe(
-              'Quote-per-base price at fill time, returned as a fixed-decimal string with 5 decimal places. This value is direction-independent and works well for charts.',
+    export const Fill = OpenApi.component(
+      z
+        .object({
+          destinationAmount: ValuedAmount,
+          destinationToken: SwapSide,
+          logIndex: z
+            .number()
+            .check(
+              z.int(),
+              z.nonnegative(),
+              z.describe('Log index of this fill within its block.'),
+              z.meta({ examples: [0] }),
             ),
-            z.meta({ examples: ['1.00000'] }),
+          maker: Schema.Address.check(z.describe('Maker address whose resting order was filled.')),
+          orderId: Schema.DecimalString.check(
+            z.describe('On-chain maker order id, returned as a decimal string.'),
           ),
-        sourceAmount: ValuedAmount.check(z.describe('Amount the taker sent in this fill.')),
-        sourceToken: SwapSide.check(z.describe('Token the taker sent in this fill.')),
-      })
-      .check(
-        z.describe('One maker-order fill within a swap, described from the taker’s perspective.'),
-      )
+          partialFill: z
+            .boolean()
+            .check(
+              z.describe('Whether this fill used only part of the maker order.'),
+              z.meta({ examples: [false] }),
+            ),
+          price: z
+            .string()
+            .check(
+              z.regex(/^\d+(\.\d+)?$/),
+              z.describe(
+                'Quote-per-base price at fill time, returned as a fixed-decimal string with 5 decimal places. This value is direction-independent and works well for charts.',
+              ),
+              z.meta({ examples: ['1.00000'] }),
+            ),
+          sourceAmount: ValuedAmount,
+          sourceToken: SwapSide,
+        })
+        .check(
+          z.describe('One maker-order fill within a swap, described from the taker’s perspective.'),
+        ),
+      'ExchangeSwapFill',
+    )
 
     /**
      * A single logical taker swap on the stablecoin DEX: every maker-order
@@ -886,81 +990,82 @@ export namespace schema {
      * intermediate token, e.g. pathUSD) are one row; the intermediate hops
      * are visible via `route` and `fills`.
      */
-    export const Swap = z
-      .object({
-        blockNumber: z
-          .number()
-          .check(
-            z.int(),
-            z.nonnegative(),
-            z.describe('Block number where the swap was included.'),
-            z.meta({ examples: [23456789] }),
-          ),
-        destinationAmount: ValuedAmount.check(
-          z.describe('Total amount the taker received in this swap.'),
-        ),
-        destinationToken: SwapSide.check(z.describe('Destination token for the final hop.')),
-        filledAt: z.iso
-          .datetime()
-          .check(
-            z.describe('Block timestamp when the swap was filled onchain.'),
-            z.meta({ examples: ['2024-01-01T00:00:00Z'] }),
-          ),
-        fills: z
-          .array(Fill)
-          .check(
-            z.describe(
-              'Maker-order fills that make up this swap, ordered by execution `logIndex`. Exact-destination swaps can execute hops in reverse, so use `route` for the source-to-destination path.',
+    export const Swap = OpenApi.component(
+      z
+        .object({
+          blockNumber: z
+            .number()
+            .check(
+              z.int(),
+              z.nonnegative(),
+              z.describe('Block number where the swap was included.'),
+              z.meta({ examples: [23456789] }),
             ),
-          ),
-        id: z.string().check(
-          z.describe(
-            'Stable API id built from the lowercase transaction hash and the first fill log index.',
-          ),
-          z.meta({
-            examples: ['0x515801d7f9a5ac705e793e85904c9c69b3f1694b465cc8fb6ba3f0298dc82665-0'],
-          }),
-        ),
-        logIndex: z
-          .number()
-          .check(
-            z.int(),
-            z.nonnegative(),
-            z.describe('Block-wide log index for the swap, taken from its first fill.'),
-            z.meta({ examples: [0] }),
-          ),
-        mode: z
-          .nullable(z.enum(['exactSource', 'exactDestination']))
-          .check(
-            z.describe(
-              'The amount type fixed by the swap call: `exactSource` for `swapExactAmountIn` or `exactDestination` for `swapExactAmountOut`. This is recovered from transaction calldata and is `null` when the swap did not come from a decodable swap call.',
+          destinationAmount: ValuedAmount,
+          destinationToken: SwapSide,
+          filledAt: z.iso
+            .datetime()
+            .check(
+              z.describe('Block timestamp when the swap was filled onchain.'),
+              z.meta({ examples: ['2024-01-01T00:00:00Z'] }),
             ),
-            z.meta({ examples: ['exactSource'] }),
-          ),
-        rate: z
-          .string()
-          .check(
-            z.regex(/^\d+(\.\d+)?$/),
+          fills: z
+            .array(Fill)
+            .check(
+              z.describe(
+                'Maker-order fills that make up this swap, ordered by execution `logIndex`. Exact-destination swaps can execute hops in reverse, so use `route` for the source-to-destination path.',
+              ),
+            ),
+          id: z.string().check(
             z.describe(
-              'Swap-level effective rate, calculated as destination amount divided by source amount from the taker’s perspective and returned with 5 decimal places. Compare it with `1` to see distance from peg.',
+              'Stable API id built from the lowercase transaction hash and the first fill log index.',
             ),
-            z.meta({ examples: ['1.00000'] }),
+            z.meta({
+              examples: ['0x515801d7f9a5ac705e793e85904c9c69b3f1694b465cc8fb6ba3f0298dc82665-0'],
+            }),
           ),
-        route: z
-          .array(Schema.TokenAddress)
-          .check(
-            z.describe(
-              'Token path for the swap, from source through any intermediate tokens to destination. `route.length - 1` is the hop count; two entries means a direct swap.',
+          logIndex: z
+            .number()
+            .check(
+              z.int(),
+              z.nonnegative(),
+              z.describe('Block-wide log index for the swap, taken from its first fill.'),
+              z.meta({ examples: [0] }),
             ),
+          mode: z
+            .nullable(z.enum(['exactSource', 'exactDestination']))
+            .check(
+              z.describe(
+                'The amount type fixed by the swap call: `exactSource` for `swapExactAmountIn` or `exactDestination` for `swapExactAmountOut`. This is recovered from transaction calldata and is `null` when the swap did not come from a decodable swap call.',
+              ),
+              z.meta({ examples: ['exactSource'] }),
+            ),
+          rate: z
+            .string()
+            .check(
+              z.regex(/^\d+(\.\d+)?$/),
+              z.describe(
+                'Swap-level effective rate, calculated as destination amount divided by source amount from the taker’s perspective and returned with 5 decimal places. Compare it with `1` to see distance from peg.',
+              ),
+              z.meta({ examples: ['1.00000'] }),
+            ),
+          route: z
+            .array(Schema.TokenAddress)
+            .check(
+              z.describe(
+                'Token path for the swap, from source through any intermediate tokens to destination. `route.length - 1` is the hop count; two entries means a direct swap.',
+              ),
+            ),
+          sourceAmount: ValuedAmount,
+          sourceToken: SwapSide,
+          taker: Schema.Address.check(z.describe('Taker address that initiated the swap.')),
+          transactionHash: Schema.Hash.check(
+            z.describe('Transaction hash for the transaction containing the swap.'),
           ),
-        sourceAmount: ValuedAmount.check(z.describe('Total amount the taker sent in this swap.')),
-        sourceToken: SwapSide.check(z.describe('Source token for the first hop.')),
-        taker: Schema.Address.check(z.describe('Taker address that initiated the swap.')),
-        transactionHash: Schema.Hash.check(
-          z.describe('Transaction hash for the transaction containing the swap.'),
-        ),
-      })
-      .check(z.describe('One logical taker swap on Tempo’s built-in stablecoin exchange.'))
+        })
+        .check(z.describe('One logical taker swap on Tempo’s built-in stablecoin exchange.')),
+      'ExchangeSwap',
+    )
 
     /**
      * Page of swaps. A row is one logical taker swap — the fills of one
@@ -970,28 +1075,34 @@ export namespace schema {
      * taker may have its rows split across consecutive pages.
      */
     /** Page-level resources: valuation rate provenance. */
-    export const Meta = z
-      .object({
-        valuation: z
-          .optional(Valuation.schema.Pricing)
-          .check(
-            z.describe(
-              'Rate provenance for amount valuations. Present when conversion rates were ' +
-                'consulted; absent when every value was identity-valued or rates were unavailable.',
+    export const Meta = OpenApi.component(
+      z
+        .object({
+          valuation: z
+            .optional(Valuation.schema.Pricing)
+            .check(
+              z.describe(
+                'Rate provenance for amount valuations. Present when conversion rates were ' +
+                  'consulted; absent when every value was identity-valued or rates were unavailable.',
+              ),
             ),
-          ),
-      })
-      .check(z.describe('Page-level resources attached to this response.'))
+        })
+        .check(z.describe('Page-level resources attached to this response.')),
+      'ExchangeSwapListMeta',
+    )
 
-    export const Response = z
-      .object({
-        data: z.array(Swap).check(z.describe('Swaps returned on this page.')),
-        meta: z
-          .optional(Meta)
-          .check(z.describe('Page-level resources, such as valuation rate provenance.')),
-        nextCursor: Schema.NextCursor,
-      })
-      .check(z.describe('A paginated list of swaps on Tempo’s built-in stablecoin exchange.'))
+    export const Response = OpenApi.component(
+      z
+        .object({
+          data: z.array(Swap).check(z.describe('Swaps returned on this page.')),
+          meta: z
+            .optional(Meta)
+            .check(z.describe('Page-level resources, such as valuation rate provenance.')),
+          nextCursor: Schema.NextCursor,
+        })
+        .check(z.describe('A paginated list of swaps on Tempo’s built-in stablecoin exchange.')),
+      'ExchangeSwapList',
+    )
   }
 
   /** Schemas for the getPairOhlc operation (candlestick aggregations). */
@@ -1061,107 +1172,115 @@ export namespace schema {
      * and low are the extrema across all fills in the bucket. Volumes are
      * the sum of per-fill base- and quote-side amounts in base units.
      */
-    export const Bucket = z
-      .object({
-        close: z
-          .string()
-          .check(
-            z.regex(/^\d+(\.\d+)?$/),
-            z.describe(
-              'Close price for the bucket: the latest fill rate, returned with 5 decimal places.',
-            ),
-            z.meta({ examples: ['1.00000'] }),
-          ),
-        fillCount: z
-          .number()
-          .check(
-            z.int(),
-            z.nonnegative(),
-            z.describe('Number of fills included in this bucket.'),
-            z.meta({ examples: [5] }),
-          ),
-        high: z
-          .string()
-          .check(
-            z.regex(/^\d+(\.\d+)?$/),
-            z.describe(
-              'High price for the bucket: the highest fill rate, returned with 5 decimal places.',
-            ),
-            z.meta({ examples: ['1.01000'] }),
-          ),
-        id: z.string().check(
-          z.describe(
-            'Stable API id built from the pair key, candle interval, and bucket start time in Unix seconds.',
-          ),
-          z.meta({
-            examples: [
-              '0x515801d7f9a5ac705e793e85904c9c69b3f1694b465cc8fb6ba3f0298dc82665-1h-1704067200',
-            ],
-          }),
-        ),
-        low: z
-          .string()
-          .check(
-            z.regex(/^\d+(\.\d+)?$/),
-            z.describe(
-              'Low price for the bucket: the lowest fill rate, returned with 5 decimal places.',
+    export const Bucket = OpenApi.component(
+      z
+        .object({
+          close: z
+            .string()
+            .check(
+              z.regex(/^\d+(\.\d+)?$/),
+              z.describe(
+                'Close price for the bucket: the latest fill rate, returned with 5 decimal places.',
+              ),
+              z.meta({ examples: ['1.00000'] }),
             ),
-            z.meta({ examples: ['0.99000'] }),
-          ),
-        open: z
-          .string()
-          .check(
-            z.regex(/^\d+(\.\d+)?$/),
+          fillCount: z
+            .number()
+            .check(
+              z.int(),
+              z.nonnegative(),
+              z.describe('Number of fills included in this bucket.'),
+              z.meta({ examples: [5] }),
+            ),
+          high: z
+            .string()
+            .check(
+              z.regex(/^\d+(\.\d+)?$/),
+              z.describe(
+                'High price for the bucket: the highest fill rate, returned with 5 decimal places.',
+              ),
+              z.meta({ examples: ['1.01000'] }),
+            ),
+          id: z.string().check(
             z.describe(
-              'Open price for the bucket: the earliest fill rate, returned with 5 decimal places.',
+              'Stable API id built from the pair key, candle interval, and bucket start time in Unix seconds.',
             ),
-            z.meta({ examples: ['1.00000'] }),
-          ),
-        timestamp: z.iso
-          .datetime()
-          .check(
-            z.describe('ISO 8601 timestamp for the start of this candle bucket.'),
-            z.meta({ examples: ['2024-01-01T00:00:00Z'] }),
+            z.meta({
+              examples: [
+                '0x515801d7f9a5ac705e793e85904c9c69b3f1694b465cc8fb6ba3f0298dc82665-1h-1704067200',
+              ],
+            }),
           ),
-        volume: z
-          .object({
-            base: Schema.DecimalString.check(
+          low: z
+            .string()
+            .check(
+              z.regex(/^\d+(\.\d+)?$/),
               z.describe(
-                'Total base-side amount filled in this bucket, in the token’s smallest units.',
+                'Low price for the bucket: the lowest fill rate, returned with 5 decimal places.',
               ),
+              z.meta({ examples: ['0.99000'] }),
             ),
-            quote: Schema.DecimalString.check(
+          open: z
+            .string()
+            .check(
+              z.regex(/^\d+(\.\d+)?$/),
               z.describe(
-                'Total quote-side amount filled in this bucket, reconstructed from each fill’s tick and returned in the token’s smallest units.',
+                'Open price for the bucket: the earliest fill rate, returned with 5 decimal places.',
               ),
+              z.meta({ examples: ['1.00000'] }),
             ),
-          })
-          .check(z.describe('Total filled volume in this bucket, split by pair side.')),
-      })
-      .check(z.describe('One OHLC candle bucket for charting a trading pair.'))
+          timestamp: z.iso
+            .datetime()
+            .check(
+              z.describe('ISO 8601 timestamp for the start of this candle bucket.'),
+              z.meta({ examples: ['2024-01-01T00:00:00Z'] }),
+            ),
+          volume: z
+            .object({
+              base: Schema.DecimalString.check(
+                z.describe(
+                  'Total base-side amount filled in this bucket, in the token’s smallest units.',
+                ),
+              ),
+              quote: Schema.DecimalString.check(
+                z.describe(
+                  'Total quote-side amount filled in this bucket, reconstructed from each fill’s tick and returned in the token’s smallest units.',
+                ),
+              ),
+            })
+            .check(z.describe('Total filled volume in this bucket, split by pair side.')),
+        })
+        .check(z.describe('One OHLC candle bucket for charting a trading pair.')),
+      'ExchangeOhlcBucket',
+    )
 
     /** Page of candlestick buckets for a single trading pair. */
-    export const Response = z
-      .object({
-        base: PairToken.check(z.describe('Base side of the trading pair.')),
-        data: z
-          .array(Bucket)
-          .check(
-            z.describe('OHLC candle buckets ordered oldest to newest; empty buckets are omitted.'),
-          ),
-        interval: Interval,
-        quote: PairToken.check(z.describe('Quote side of the trading pair.')),
-        truncated: z
-          .boolean()
-          .check(
-            z.describe(
-              '`true` when the fill scan hit its hard cap, meaning OHLC values were computed from only the most recent fills.',
+    export const Response = OpenApi.component(
+      z
+        .object({
+          base: PairToken,
+          data: z
+            .array(Bucket)
+            .check(
+              z.describe(
+                'OHLC candle buckets ordered oldest to newest; empty buckets are omitted.',
+              ),
             ),
-            z.meta({ examples: [false] }),
-          ),
-        window: Window,
-      })
-      .check(z.describe('OHLC candle data for one trading pair over a rolling time window.'))
+          interval: Interval,
+          quote: PairToken,
+          truncated: z
+            .boolean()
+            .check(
+              z.describe(
+                '`true` when the fill scan hit its hard cap, meaning OHLC values were computed from only the most recent fills.',
+              ),
+              z.meta({ examples: [false] }),
+            ),
+          window: Window,
+        })
+        .check(z.describe('OHLC candle data for one trading pair over a rolling time window.')),
+      'ExchangePairOhlc',
+    )
   }
 
   /** Schemas shared by the order detail and order fills handlers. */
@@ -1177,13 +1296,16 @@ export namespace schema {
       .check(z.describe('Path parameters for routes that look up one order.'))
 
     /** The pair the order is placed against. */
-    export const Pair = Schema.describe(
-      z.object({
-        base: PairToken.check(z.describe('Base side of the pair; the order trades this token.')),
-        key: Schema.Hash.check(z.describe('On-chain key for this `(base, quote)` trading pair.')),
-        quote: PairToken.check(z.describe('Quote side of the trading pair.')),
-      }),
-      'The trading pair the order belongs to.',
+    export const Pair = OpenApi.component(
+      Schema.describe(
+        z.object({
+          base: PairToken,
+          key: Schema.Hash.check(z.describe('On-chain key for this `(base, quote)` trading pair.')),
+          quote: PairToken,
+        }),
+        'The trading pair the order belongs to.',
+      ),
+      'ExchangeOrderPair',
     )
   }
 
@@ -1229,86 +1351,93 @@ export namespace schema {
      * over time and would otherwise force this resource to revalidate on
      * every new fill.
      */
-    export const Response = Schema.describe(
-      z.object({
-        amount: Schema.DecimalString.check(
-          z.describe(
-            'Initial order size, returned as a decimal integer string in base-token smallest units.',
-          ),
-        ),
-        flipTick: z
-          .number()
-          .check(
-            z.int(),
+    export const Response = OpenApi.component(
+      Schema.describe(
+        z.object({
+          amount: Schema.DecimalString.check(
             z.describe(
-              'Replacement `tick` used if this order auto-flips into a counter-order after filling.',
+              'Initial order size, returned as a decimal integer string in base-token smallest units.',
             ),
-            z.meta({ examples: [10] }),
           ),
-        id: Schema.DecimalString.check(
-          z.describe('Stable API id for this order; it is the same value as the onchain order id.'),
-        ),
-        isBid: z
-          .boolean()
-          .check(
-            z.describe(
-              'Order side as a boolean: `true` means the maker buys base, and `false` means the maker sells base.',
+          flipTick: z
+            .number()
+            .check(
+              z.int(),
+              z.describe(
+                'Replacement `tick` used if this order auto-flips into a counter-order after filling.',
+              ),
+              z.meta({ examples: [10] }),
             ),
-            z.meta({ examples: [true] }),
-          ),
-        isFlipOrder: z
-          .boolean()
-          .check(
-            z.describe('Whether this order automatically becomes a counter-order after it fills.'),
-            z.meta({ examples: [false] }),
-          ),
-        maker: Schema.Address.check(z.describe('Maker address that owns the order.')),
-        mode: z
-          .enum(['exactSource', 'exactDestination'])
-          .check(
+          id: Schema.DecimalString.check(
             z.describe(
-              'Taker-perspective mode for the order. `exactSource` applies to maker bids where the taker sells base; `exactDestination` applies to maker asks where the taker buys base.',
+              'Stable API id for this order; it is the same value as the onchain order id.',
             ),
-            z.meta({ examples: ['exactSource'] }),
           ),
-        orderId: Schema.DecimalString.check(
-          z.describe('On-chain order id, returned as a decimal string.'),
-        ),
-        pair: order.Pair,
-        price: z
-          .string()
-          .check(
-            z.regex(/^\d+(\.\d+)?$/),
-            z.describe(
-              'Quote-per-base price implied by `tick`, returned as a fixed-decimal string with 5 decimal places.',
+          isBid: z
+            .boolean()
+            .check(
+              z.describe(
+                'Order side as a boolean: `true` means the maker buys base, and `false` means the maker sells base.',
+              ),
+              z.meta({ examples: [true] }),
             ),
-            z.meta({ examples: ['1.00000'] }),
-          ),
-        rate: z
-          .string()
-          .check(
-            z.regex(/^\d+(\.\d+)?$/),
-            z.describe(
-              'Destination-to-source price ratio, returned as a fixed-decimal string with 5 decimal places.',
+          isFlipOrder: z
+            .boolean()
+            .check(
+              z.describe(
+                'Whether this order automatically becomes a counter-order after it fills.',
+              ),
+              z.meta({ examples: [false] }),
             ),
-            z.meta({ examples: ['1.00000'] }),
-          ),
-        remaining: Schema.DecimalString.check(
-          z.describe(
-            'Unfilled base-side amount still resting on the orderbook, returned as a decimal integer string.',
+          maker: Schema.Address.check(z.describe('Maker address that owns the order.')),
+          mode: z
+            .enum(['exactSource', 'exactDestination'])
+            .check(
+              z.describe(
+                'Taker-perspective mode for the order. `exactSource` applies to maker bids where the taker sells base; `exactDestination` applies to maker asks where the taker buys base.',
+              ),
+              z.meta({ examples: ['exactSource'] }),
+            ),
+          orderId: Schema.DecimalString.check(
+            z.describe('On-chain order id, returned as a decimal string.'),
           ),
-        ),
-        tick: z
-          .number()
-          .check(
-            z.int(),
+          pair: order.Pair,
+          price: z
+            .string()
+            .check(
+              z.regex(/^\d+(\.\d+)?$/),
+              z.describe(
+                'Quote-per-base price implied by `tick`, returned as a fixed-decimal string with 5 decimal places.',
+              ),
+              z.meta({ examples: ['1.00000'] }),
+            ),
+          rate: z
+            .string()
+            .check(
+              z.regex(/^\d+(\.\d+)?$/),
+              z.describe(
+                'Destination-to-source price ratio, returned as a fixed-decimal string with 5 decimal places.',
+              ),
+              z.meta({ examples: ['1.00000'] }),
+            ),
+          remaining: Schema.DecimalString.check(
             z.describe(
-              'On-chain signed tick, scaled by `1/priceScale`; use `price` for the decoded ratio.',
+              'Unfilled base-side amount still resting on the orderbook, returned as a decimal integer string.',
             ),
-            z.meta({ examples: [0] }),
           ),
-      }),
-      'A single DEX order with live onchain state.',
+          tick: z
+            .number()
+            .check(
+              z.int(),
+              z.describe(
+                'On-chain signed tick, scaled by `1/priceScale`; use `price` for the decoded ratio.',
+              ),
+              z.meta({ examples: [0] }),
+            ),
+        }),
+        'A single DEX order with live onchain state.',
+      ),
+      'ExchangeOrder',
     )
   }
 
@@ -1384,8 +1513,8 @@ export namespace schema {
      * Orders for which `remaining <= 0` or that have an `OrderCancelled`
      * event are excluded from the response.
      */
-    export const RestingOrder = z
-      .object({
+    export const RestingOrder = Schema.describe(
+      z.object({
         amount: Schema.DecimalString.check(
           z.describe(
             'Original placed amount, returned as a decimal integer string in base-token smallest units.',
@@ -1461,40 +1590,53 @@ export namespace schema {
         transactionHash: Schema.Hash.check(
           z.describe('Transaction hash for the transaction that placed the order.'),
         ),
-      })
-      .check(z.describe('One resting maker order on Tempo’s built-in stablecoin exchange.'))
+      }),
+      'One resting maker order on Tempo’s built-in stablecoin exchange.',
+    )
 
     /** A resting maker order annotated with the trading pair it belongs to. */
-    export const Order = z
-      .extend(RestingOrder, {
-        pair: order.Pair,
-      })
-      .check(z.describe('A resting maker order plus its trading pair.'))
+    export const Order = OpenApi.component(
+      Schema.describe(
+        z.extend(RestingOrder, {
+          pair: order.Pair,
+        }),
+        'A resting maker order plus its trading pair.',
+      ),
+      'ExchangeRestingOrder',
+    )
+
+    /** Response metadata requested through `include`, such as capped counts. */
+    export const Meta = OpenApi.component(Schema.CountMeta, 'ExchangeOrderListMeta')
 
     /** Page of resting maker orders, each annotated with its trading pair. */
-    export const Response = z
-      .object({
-        data: z.array(Order).check(z.describe('Resting orders returned on this page.')),
-        meta: z
-          .optional(Schema.CountMeta)
-          .check(
-            z.describe('Response-level resources requested with `include`, such as `totalCount`.'),
-          ),
-        nextCursor: Schema.NextCursor,
-        truncated: z
-          .boolean()
-          .check(
-            z.describe(
-              '`true` when the `OrderPlaced` scan hit its hard cap, meaning the resting set was computed from only the most recent placements.',
+    export const Response = OpenApi.component(
+      z
+        .object({
+          data: z.array(Order).check(z.describe('Resting orders returned on this page.')),
+          meta: z
+            .optional(Meta)
+            .check(
+              z.describe(
+                'Response-level resources requested with `include`, such as `totalCount`.',
+              ),
+            ),
+          nextCursor: Schema.NextCursor,
+          truncated: z
+            .boolean()
+            .check(
+              z.describe(
+                '`true` when the `OrderPlaced` scan hit its hard cap, meaning the resting set was computed from only the most recent placements.',
+              ),
+              z.meta({ examples: [false] }),
             ),
-            z.meta({ examples: [false] }),
+        })
+        .check(
+          z.describe(
+            'A paginated list of resting maker orders on Tempo’s built-in stablecoin exchange.',
           ),
-      })
-      .check(
-        z.describe(
-          'A paginated list of resting maker orders on Tempo’s built-in stablecoin exchange.',
         ),
-      )
+      'ExchangeOrderList',
+    )
   }
 
   /** Schemas for the getOrderFills operation. */
@@ -1522,67 +1664,78 @@ export namespace schema {
      * rate are constant across all fills, so they live on the `Order`
      * resource rather than being repeated per row.
      */
-    export const Fill = z
-      .object({
-        amountFilled: Schema.DecimalString.check(
-          z.describe(
-            'Base-side amount filled by this event, returned as a decimal integer string in base-token smallest units.',
+    export const Fill = OpenApi.component(
+      z
+        .object({
+          amountFilled: Schema.DecimalString.check(
+            z.describe(
+              'Base-side amount filled by this event, returned as a decimal integer string in base-token smallest units.',
+            ),
           ),
-        ),
-        blockNumber: z
-          .number()
-          .check(
-            z.int(),
-            z.nonnegative(),
-            z.describe('Block number where the fill was included.'),
-            z.meta({ examples: [23456789] }),
+          blockNumber: z
+            .number()
+            .check(
+              z.int(),
+              z.nonnegative(),
+              z.describe('Block number where the fill was included.'),
+              z.meta({ examples: [23456789] }),
+            ),
+          filledAt: z.iso
+            .datetime()
+            .check(
+              z.describe('Block timestamp when the fill landed onchain.'),
+              z.meta({ examples: ['2024-01-01T00:00:00Z'] }),
+            ),
+          id: z.string().check(
+            z.describe('Stable API id built from the lowercase transaction hash and log index.'),
+            z.meta({
+              examples: ['0x515801d7f9a5ac705e793e85904c9c69b3f1694b465cc8fb6ba3f0298dc82665-0'],
+            }),
           ),
-        filledAt: z.iso
-          .datetime()
-          .check(
-            z.describe('Block timestamp when the fill landed onchain.'),
-            z.meta({ examples: ['2024-01-01T00:00:00Z'] }),
+          logIndex: z
+            .number()
+            .check(
+              z.int(),
+              z.nonnegative(),
+              z.describe('Log index of this fill within its block.'),
+              z.meta({ examples: [0] }),
+            ),
+          orderId: Schema.DecimalString.check(
+            z.describe('On-chain order id, returned as a decimal string.'),
           ),
-        id: z.string().check(
-          z.describe('Stable API id built from the lowercase transaction hash and log index.'),
-          z.meta({
-            examples: ['0x515801d7f9a5ac705e793e85904c9c69b3f1694b465cc8fb6ba3f0298dc82665-0'],
-          }),
-        ),
-        logIndex: z
-          .number()
-          .check(
-            z.int(),
-            z.nonnegative(),
-            z.describe('Log index of this fill within its block.'),
-            z.meta({ examples: [0] }),
+          partialFill: z
+            .boolean()
+            .check(
+              z.describe('Whether this fill used only part of the maker order.'),
+              z.meta({ examples: [false] }),
+            ),
+          taker: Schema.Address.check(
+            z.describe('Taker address that submitted the incoming order.'),
           ),
-        orderId: Schema.DecimalString.check(
-          z.describe('On-chain order id, returned as a decimal string.'),
-        ),
-        partialFill: z
-          .boolean()
-          .check(
-            z.describe('Whether this fill used only part of the maker order.'),
-            z.meta({ examples: [false] }),
+          transactionHash: Schema.Hash.check(
+            z.describe('Transaction hash for the transaction containing the fill.'),
           ),
-        taker: Schema.Address.check(z.describe('Taker address that submitted the incoming order.')),
-        transactionHash: Schema.Hash.check(
-          z.describe('Transaction hash for the transaction containing the fill.'),
-        ),
-      })
-      .check(z.describe('One `OrderFilled` event against this order.'))
+        })
+        .check(z.describe('One `OrderFilled` event against this order.')),
+      'ExchangeOrderFill',
+    )
+
+    /** Response metadata requested through `include`, such as capped counts. */
+    export const Meta = OpenApi.component(Schema.CountMeta, 'ExchangeOrderFillListMeta')
 
     /** Paginated page of fills for one order. */
-    export const Response = z
-      .object({
-        data: z.array(Fill).check(z.describe('Fills returned on this page.')),
-        meta: z
-          .optional(Schema.CountMeta)
-          .check(z.describe('Response-level resources requested with `include`.')),
-        nextCursor: Schema.NextCursor,
-      })
-      .check(z.describe('A paginated list of fill events for one DEX order.'))
+    export const Response = OpenApi.component(
+      z
+        .object({
+          data: z.array(Fill).check(z.describe('Fills returned on this page.')),
+          meta: z
+            .optional(Meta)
+            .check(z.describe('Response-level resources requested with `include`.')),
+          nextCursor: Schema.NextCursor,
+        })
+        .check(z.describe('A paginated list of fill events for one DEX order.')),
+      'ExchangeOrderFillList',
+    )
   }
 
   /** Schemas for the getPairDepth operation (orderbook depth aggregation). */
@@ -1643,60 +1796,70 @@ export namespace schema {
      * side, starting from the best (peg-adjacent) populated tick and walking
      * outward.
      */
-    export const Level = z
-      .object({
-        cumulativeSize: Schema.DecimalString.check(
-          z.describe(
-            'Running sum of `size` from the best populated tick outward to this level, in base-token smallest units.',
+    export const Level = OpenApi.component(
+      z
+        .object({
+          cumulativeSize: Schema.DecimalString.check(
+            z.describe(
+              'Running sum of `size` from the best populated tick outward to this level, in base-token smallest units.',
+            ),
           ),
-        ),
-        id: z.string().check(
-          z.describe('Stable API id built from the pair key, orderbook side, and tick.'),
-          z.meta({
-            examples: ['0x515801d7f9a5ac705e793e85904c9c69b3f1694b465cc8fb6ba3f0298dc82665-bid-0'],
-          }),
-        ),
-        price: z
-          .string()
-          .check(
-            z.regex(/^\d+(\.\d+)?$/),
-            z.describe('Tick converted to a price ratio with 5 decimal places.'),
-            z.meta({ examples: ['1.00000'] }),
+          id: z.string().check(
+            z.describe('Stable API id built from the pair key, orderbook side, and tick.'),
+            z.meta({
+              examples: [
+                '0x515801d7f9a5ac705e793e85904c9c69b3f1694b465cc8fb6ba3f0298dc82665-bid-0',
+              ],
+            }),
           ),
-        size: Schema.DecimalString.check(
-          z.describe('Resting liquidity at this tick level, in base-token smallest units.'),
-        ),
-        tick: z
-          .number()
-          .check(
-            z.int(),
-            z.describe('Signed price tick (`int16`), always a multiple of the DEX tick spacing.'),
-            z.meta({ examples: [0] }),
+          price: z
+            .string()
+            .check(
+              z.regex(/^\d+(\.\d+)?$/),
+              z.describe('Tick converted to a price ratio with 5 decimal places.'),
+              z.meta({ examples: ['1.00000'] }),
+            ),
+          size: Schema.DecimalString.check(
+            z.describe('Resting liquidity at this tick level, in base-token smallest units.'),
           ),
-      })
-      .check(z.describe('One price level in the orderbook depth response.'))
+          tick: z
+            .number()
+            .check(
+              z.int(),
+              z.describe('Signed price tick (`int16`), always a multiple of the DEX tick spacing.'),
+              z.meta({ examples: [0] }),
+            ),
+        })
+        .check(z.describe('One price level in the orderbook depth response.')),
+      'ExchangeDepthLevel',
+    )
 
     /** Orderbook depth (cumulative size per tick) for a single trading pair. */
-    export const Response = z
-      .object({
-        asks: z
-          .array(Level)
-          .check(
-            z.describe(
-              'Ask-side levels, where makers sell base and takers buy it, ordered from best lowest ask outward.',
+    export const Response = OpenApi.component(
+      z
+        .object({
+          asks: z
+            .array(Level)
+            .check(
+              z.describe(
+                'Ask-side levels, where makers sell base and takers buy it, ordered from best lowest ask outward.',
+              ),
             ),
-          ),
-        base: PairToken.check(z.describe('Base side of the trading pair.')),
-        bids: z
-          .array(Level)
-          .check(
-            z.describe(
-              'Bid-side levels, where makers buy base and takers sell it, ordered from best highest bid outward.',
+          base: PairToken,
+          bids: z
+            .array(Level)
+            .check(
+              z.describe(
+                'Bid-side levels, where makers buy base and takers sell it, ordered from best highest bid outward.',
+              ),
             ),
-          ),
-        quote: PairToken.check(z.describe('Quote side of the trading pair.')),
-      })
-      .check(z.describe('Orderbook depth for one trading pair, with cumulative size at each tick.'))
+          quote: PairToken,
+        })
+        .check(
+          z.describe('Orderbook depth for one trading pair, with cumulative size at each tick.'),
+        ),
+      'ExchangePairDepth',
+    )
   }
 }
 
@@ -1740,7 +1903,15 @@ export function exchanges(options: exchanges.Options = {}) {
         operationId: 'createExchangeQuote',
         responses: OpenApi.responses({
           errors: {
-            400: { codes: ['body_invalid', 'query_invalid', 'quote_amount_out_of_range'] },
+            400: {
+              codes: [
+                'body_invalid',
+                'chain_id_invalid',
+                'chain_id_unsupported',
+                'query_invalid',
+                'quote_amount_out_of_range',
+              ],
+            },
             404: {
               codes: ['quote_not_available'],
               description:
@@ -2071,6 +2242,8 @@ export function exchanges(options: exchanges.Options = {}) {
             400: {
               codes: [
                 'body_invalid',
+                'chain_id_invalid',
+                'chain_id_unsupported',
                 'query_invalid',
                 'swap_continuation_invalid',
                 'swap_provider_invalid',
@@ -2166,6 +2339,9 @@ export function exchanges(options: exchanges.Options = {}) {
         operationId: 'getSwaps',
         responses: OpenApi.responses({
           errors: {
+            400: {
+              codes: ['chain_id_invalid', 'chain_id_unsupported', 'query_invalid'],
+            },
             502: 'The indexer or Tempo RPC could not serve the exchange data right now.',
           },
           success: {
@@ -2324,7 +2500,12 @@ export function exchanges(options: exchanges.Options = {}) {
         description: 'List trading pairs available on Tempo’s built-in stablecoin exchange.',
         operationId: 'getPairs',
         responses: OpenApi.responses({
-          errors: { 502: 'The indexer could not serve the exchange data right now.' },
+          errors: {
+            400: {
+              codes: ['chain_id_invalid', 'chain_id_unsupported', 'query_invalid'],
+            },
+            502: 'The indexer could not serve the exchange data right now.',
+          },
           success: {
             description: 'A page of exchange trading pairs.',
             schema: schema.getPairs.Response,
@@ -2438,6 +2619,9 @@ export function exchanges(options: exchanges.Options = {}) {
         operationId: 'getPair',
         responses: OpenApi.responses({
           errors: {
+            400: {
+              codes: ['chain_id_invalid', 'chain_id_unsupported', 'pair_invalid', 'query_invalid'],
+            },
             404: {
               description: 'No exchange pair was found for that base token.',
               codes: ['pair_not_found'],
@@ -2528,6 +2712,9 @@ export function exchanges(options: exchanges.Options = {}) {
         operationId: 'getOrders',
         responses: OpenApi.responses({
           errors: {
+            400: {
+              codes: ['chain_id_invalid', 'chain_id_unsupported', 'query_invalid'],
+            },
             404: {
               description: 'No exchange pair was found for the requested `base` filter.',
               codes: ['pair_not_found'],
@@ -2660,6 +2847,9 @@ export function exchanges(options: exchanges.Options = {}) {
         operationId: 'getOrder',
         responses: OpenApi.responses({
           errors: {
+            400: {
+              codes: ['chain_id_invalid', 'chain_id_unsupported', 'order_invalid', 'query_invalid'],
+            },
             404: {
               description: 'No exchange order was found for that id.',
               codes: ['order_not_found'],
@@ -2768,7 +2958,12 @@ export function exchanges(options: exchanges.Options = {}) {
           'List fills for one order. A fill records an execution against the maker order.',
         operationId: 'getOrderFills',
         responses: OpenApi.responses({
-          errors: { 502: 'The indexer could not serve the exchange data right now.' },
+          errors: {
+            400: {
+              codes: ['chain_id_invalid', 'chain_id_unsupported', 'order_invalid', 'query_invalid'],
+            },
+            502: 'The indexer could not serve the exchange data right now.',
+          },
           success: {
             description: 'A page of fills for one order.',
             schema: schema.getOrderFills.Response,
@@ -2858,6 +3053,9 @@ export function exchanges(options: exchanges.Options = {}) {
         operationId: 'getPairOhlc',
         responses: OpenApi.responses({
           errors: {
+            400: {
+              codes: ['chain_id_invalid', 'chain_id_unsupported', 'pair_invalid', 'query_invalid'],
+            },
             404: {
               description: 'No exchange pair was found for that base token.',
               codes: ['pair_not_found'],
@@ -2967,6 +3165,9 @@ export function exchanges(options: exchanges.Options = {}) {
         operationId: 'getPairDepth',
         responses: OpenApi.responses({
           errors: {
+            400: {
+              codes: ['chain_id_invalid', 'chain_id_unsupported', 'pair_invalid', 'query_invalid'],
+            },
             404: {
               description: 'No exchange pair was found for that base token.',
               codes: ['pair_not_found'],