tapimo 0.10.2 → 0.12.0

package/src/apps/data/routes/fee-amm.ts

@@ -62,32 +62,39 @@ export namespace schema {
    */
   export const PoolToken = Schema.describe(
     z.object({
-      address: Schema.TokenAddress.check(
+      address: Schema.tokenAddress(Tokens.tokenExample.address).check(
         z.describe('TIP-20 token contract address used by this fee pool.'),
       ),
       currency: z
         .optional(z.string())
         .check(
           z.describe('Display currency for the token, when available.'),
-          z.meta({ examples: ['USD'] }),
+          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.'), z.meta({ examples: [6] })),
+        .check(
+          z.describe('Number of decimal places the token uses.'),
+          z.meta({ examples: [Tokens.tokenExample.decimals] }),
+        ),
       logoUri: z.optional(z.string()).check(
-        z.describe('URL for the token logo SVG, when available.'),
+        z.describe('URL for the token logo image, when available.'),
         z.meta({
-          examples: [
-            'https://api.tempo.xyz/data/4217/icons/0x20c0000000000000000000008f5425160ebe5525.svg',
-          ],
+          examples: [Tokens.tokenExample.logoUri],
         }),
       ),
       name: z
         .optional(z.string())
-        .check(z.describe('Human-readable token name.'), z.meta({ examples: ['USD Coin'] })),
+        .check(
+          z.describe('Human-readable token name.'),
+          z.meta({ examples: [Tokens.tokenExample.name] }),
+        ),
       symbol: z
         .optional(z.string())
-        .check(z.describe('Short token ticker symbol.'), z.meta({ examples: ['USDC'] })),
+        .check(
+          z.describe('Short token ticker symbol.'),
+          z.meta({ examples: [Tokens.tokenExample.symbol] }),
+        ),
       verified: z
         .optional(z.boolean())
         .check(
@@ -403,7 +410,7 @@ export function feeAmm() {
             200,
           )
         } catch (cause) {
-          return Response.upstream(c, cause)
+          return Response.upstream(c, cause, { page: query.page })
         }
       },
     )
@@ -498,7 +505,7 @@ export function feeAmm() {
             200,
           )
         } catch (cause) {
-          return Response.upstream(c, cause)
+          return Response.upstream(c, cause, { page: query.page })
         }
       },
     )

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

@@ -594,7 +594,7 @@ export function receipts(options: receipts.Options = {}) {
         } catch (cause) {
           if (cause instanceof Valuation.UnsupportedDenominationError)
             return Response.error(c, { code: 'query_invalid', message: cause.message, status: 400 })
-          return Response.upstream(c, cause)
+          return Response.upstream(c, cause, { page: query.page })
         }
       },
     )

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

@@ -286,6 +286,81 @@ describe('POST /rpc', () => {
     },
   )
 
+  test('keeps RPC method-filter responses out of upstream alerts', async () => {
+    const entries: Log.Entry[] = []
+    const body = {
+      error: { code: -32_601, message: 'method not allowed: tempo_sponsor' },
+      id: null,
+      jsonrpc: '2.0',
+    }
+    const server = await Relay.createServer(
+      RequestListener.fromFetchHandler(() => Response.json(body, { status: 403 })),
+    )
+
+    try {
+      const app = TestApp.create({
+        auth: false,
+        logger: (entry) => void entries.push(entry),
+        rpc: { url: server.url },
+      })
+      const response = await app.fetch(
+        new Request('http://tempo-api.test/rpc', {
+          body: JSON.stringify({ id: 1, jsonrpc: '2.0', method: 'tempo_sponsor' }),
+          method: 'POST',
+        }),
+      )
+
+      expect(response.status).toBe(403)
+      expect(await response.json()).toEqual(body)
+      expect(entries[0]?.provider).toBeUndefined()
+    } finally {
+      await server.closeAsync()
+    }
+  })
+
+  test('attributes RPC authorization responses to the upstream', async () => {
+    const entries: Log.Entry[] = []
+    const server = await Relay.createServer(
+      RequestListener.fromFetchHandler(() =>
+        Response.json(
+          {
+            error: { code: -32_001, message: 'unauthorized: invalid credentials' },
+            id: null,
+            jsonrpc: '2.0',
+          },
+          { status: 403 },
+        ),
+      ),
+    )
+
+    try {
+      const app = TestApp.create({
+        auth: false,
+        logger: (entry) => void entries.push(entry),
+        rpc: { url: server.url },
+      })
+      const response = await app.fetch(
+        new Request('http://tempo-api.test/rpc', {
+          body: JSON.stringify({ id: 1, jsonrpc: '2.0', method: 'eth_chainId' }),
+          method: 'POST',
+        }),
+      )
+
+      expect(response.status).toBe(403)
+      expect(entries[0]).toMatchObject({
+        provider: {
+          chainId: runtime.chainId,
+          failure: 'http',
+          id: 'rpc',
+          operation: 'request',
+          status: 403,
+        },
+      })
+    } finally {
+      await server.closeAsync()
+    }
+  })
+
   test('attributes RPC transport failures to the upstream', async () => {
     const entries: Log.Entry[] = []
     const server = await Relay.createServer(

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

@@ -411,14 +411,14 @@ async function passthrough(
 
   try {
     const response = await fetch(new Request(upstream, init))
-    let body = response.body
+    // Malformed requests and public Zone authentication failures are caused
+    // by caller input, not by the RPC provider.
+    if (!response.ok && !(await isCallerRpcFailure(response, usePublicZoneUrl)))
+      c.set('providerFailure', rpcProviderFailure(response, alertChainId))
 
-    if (!response.ok) {
-      // Malformed requests and public Zone authentication failures are caused
-      // by caller input, not by the RPC provider.
-      if (!isCallerRpcFailure(response.status, usePublicZoneUrl))
-        c.set('providerFailure', rpcProviderFailure(response, alertChainId))
-    } else if (response.status === 200) {
+    // `Response.clone()` replaces the body stream, so capture it after classifying errors.
+    let body = response.body
+    if (response.status === 200) {
       const inspection = await inspectRpcResponse(response)
       body = inspection.body
       if (inspection.result?.ok === false && !(inspection.result.empty && options.notificationOnly))
@@ -455,14 +455,28 @@ async function passthrough(
   }
 }
 
-function isCallerRpcFailure(status: number, usePublicZoneUrl: boolean) {
-  return (
+async function isCallerRpcFailure(response: globalThis.Response, usePublicZoneUrl: boolean) {
+  const { status } = response
+  if (
     status === 400 ||
     status === 413 ||
     status === 415 ||
     status === 422 ||
     (usePublicZoneUrl && (status === 401 || status === 403))
   )
+    return true
+  if (status !== 403) return false
+
+  // Orchestra returns HTTP 403 with JSON-RPC -32601 when its method filter
+  // rejects caller input. Other 403s, including RPC auth failures, stay upstream failures.
+  const body = await response
+    .clone()
+    .json()
+    .catch(() => undefined)
+  const parsed = schema.ResponseBody.safeParse(body)
+  if (!parsed.success) return false
+  const responses = Array.isArray(parsed.data) ? parsed.data : [parsed.data]
+  return responses.every((response) => response.error?.code === -32_601)
 }
 
 declare namespace passthrough {

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

@@ -11,7 +11,7 @@ import * as Schema from '../../../internal/Schema.js'
 import * as Timing from '../../../internal/Timing.js'
 import * as VerifiedTokens from '../../../internal/VerifiedTokens.js'
 import * as Viem from '../../../internal/Viem.js'
-import { getTokenLogo } from './tokens.js'
+import * as Tokens from './tokens.js'
 
 /** Zod schemas owned by the tokenlist resource. */
 export namespace schema {
@@ -26,15 +26,20 @@ export namespace schema {
           z.describe('The Tempo chain ID where this token lives.'),
           z.meta({ examples: [4217] }),
         ),
-      address: Schema.Address.check(z.describe('The TIP-20 token contract address on Tempo.')),
+      address: Schema.tokenAddress(Tokens.tokenExample.address).check(
+        z.describe('The TIP-20 token contract address on Tempo.'),
+      ),
       name: z
         .string()
-        .check(z.describe('The token’s human-readable name.'), z.meta({ examples: ['USD Coin'] })),
+        .check(
+          z.describe('The token’s human-readable name.'),
+          z.meta({ examples: [Tokens.tokenExample.name] }),
+        ),
       symbol: z
         .string()
         .check(
           z.describe('The short ticker symbol wallets and apps show for this token.'),
-          z.meta({ examples: ['USDC'] }),
+          z.meta({ examples: [Tokens.tokenExample.symbol] }),
         ),
       decimals: z
         .number()
@@ -45,14 +50,12 @@ export namespace schema {
           z.describe(
             'The number of decimal places the token uses; Tempo stablecoins typically use 6.',
           ),
-          z.meta({ examples: [6] }),
+          z.meta({ examples: [Tokens.tokenExample.decimals] }),
         ),
       logoURI: z.optional(z.string()).check(
         z.describe('The curated HTTPS URL for this token’s logo image, when one is set.'),
         z.meta({
-          examples: [
-            'https://api.tempo.xyz/data/4217/icons/0x20c0000000000000000000008f5425160ebe5525.svg',
-          ],
+          examples: [Tokens.tokenExample.logoUri],
         }),
       ),
     })
@@ -145,13 +148,12 @@ export function tokenlist() {
             version: { major: 1, minor: 0, patch: 2 },
             tokens: [
               {
-                chainId: 4217,
-                address: '0x20c0000000000000000000000000000000000000',
-                name: 'pathUSD',
-                symbol: 'pathUSD',
-                decimals: 6,
-                logoURI:
-                  'https://api.tempo.xyz/assets/4217/tokens/0x20c0000000000000000000000000000000000000/logo',
+                address: Tokens.tokenExample.address,
+                chainId: Tokens.tokenExampleChainId,
+                decimals: Tokens.tokenExample.decimals,
+                logoURI: Tokens.tokenExample.logoUri,
+                name: Tokens.tokenExample.name,
+                symbol: Tokens.tokenExample.symbol,
               },
             ],
           },
@@ -239,9 +241,10 @@ async function getTokenLogos(
           async (token) =>
             [
               token.address,
-              await getTokenLogo(c, { address: token.address, chainId: options.chainId }).catch(
-                () => undefined,
-              ),
+              await Tokens.getTokenLogo(c, {
+                address: token.address,
+                chainId: options.chainId,
+              }).catch(() => undefined),
             ] as const,
         ),
       )

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

@@ -18,6 +18,35 @@ function app(options: TestApp.create.Options = {}) {
 
 const verifiedTokenCount = 6
 
+describe('OpenAPI', () => {
+  test('uses coherent token responses and canonical asset URLs', async () => {
+    const application = TestApp.create({ auth: false })
+    const spec = (await (await application.request('/openapi.json')).json()) as {
+      paths: Record<
+        string,
+        {
+          get?: {
+            operationId?: string
+            responses?: Record<string, { content?: { 'application/json'?: { example?: unknown } } }>
+          }
+        }
+      >
+    }
+
+    for (const operationId of ['getToken', 'getTokenBySymbol']) {
+      const operation = Object.values(spec.paths).find(
+        (path) => path.get?.operationId === operationId,
+      )
+      expect(operation?.get?.responses?.['200']?.content?.['application/json']?.example).toEqual(
+        Tokens.tokenExample,
+      )
+    }
+
+    const assetUrls = JSON.stringify(spec).match(/https:\/\/api\.tempo\.xyz\/assets\/[^"\\]+/g)
+    expect(new Set(assetUrls)).toEqual(new Set([Tokens.tokenExample.logoUri]))
+  })
+})
+
 describe('GET /tokens', () => {
   test.runIf(runtime.mode === 'testnet')(
     'serves a bounded positional page via `page` (indexed mode)',

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

@@ -4,6 +4,7 @@ import { type Address, ContractFunctionExecutionError } from 'viem'
 import { Abis } from 'viem/tempo'
 import * as z from 'zod/mini'
 
+import * as Assets from '../../../Assets.js'
 import type * as App from '../../../App.js'
 import * as Auth from '../../../internal/Auth.js'
 import * as Cache from '../../../internal/Cache.js'
@@ -20,6 +21,26 @@ import * as Value from '../../../internal/Value.js'
 import * as VerifiedTokens from '../../../internal/VerifiedTokens.js'
 import * as Transactions from './transactions.js'
 
+/** Mainnet chain id used by the coherent token OpenAPI example. */
+export const tokenExampleChainId = 4217
+
+/** Coherent mainnet token metadata used by generated OpenAPI examples. */
+export const tokenExample = {
+  address: '0x20c000000000000000000000b9537d11c60e8b50',
+  currency: 'USD',
+  decimals: 6,
+  id: '0x20c000000000000000000000b9537d11c60e8b50',
+  logoUri: Assets.url({
+    chainId: tokenExampleChainId,
+    origin: 'https://api.tempo.xyz',
+    path: 'icons/0x20c000000000000000000000b9537d11c60e8b50',
+  }),
+  name: 'Bridged USDC (Stargate)',
+  symbol: 'USDC.e',
+  totalSupply: '10850791186630',
+  verified: true,
+} as const
+
 const tokenCreatedSignature =
   'event TokenCreated(address indexed token, string name, string symbol, string currency, address quoteToken, address admin, bytes32 salt)'
 
@@ -53,7 +74,9 @@ export namespace schema {
     /** Path parameters for token metadata requests. */
     export const Params = z
       .object({
-        token: Schema.TokenAddress.check(z.describe('The TIP-20 token contract address on Tempo.')),
+        token: Schema.tokenAddress(tokenExample.address).check(
+          z.describe('The TIP-20 token contract address on Tempo.'),
+        ),
       })
       .check(z.describe('Path parameters for looking up one token’s metadata.'))
 
@@ -86,7 +109,7 @@ export namespace schema {
     /** TIP-20 token metadata returned by token endpoints. */
     export const Response = Schema.describe(
       z.object({
-        address: Schema.TokenAddress.check(
+        address: Schema.tokenAddress(tokenExample.address).check(
           z.describe('The TIP-20 token contract address on Tempo.'),
         ),
         admin: z
@@ -103,7 +126,7 @@ export namespace schema {
             z.describe(
               'The currency label for this token, such as `USD` for USD-denominated stablecoins.',
             ),
-            z.meta({ examples: ['USD'] }),
+            z.meta({ examples: [tokenExample.currency] }),
           ),
         createdAt: z
           .optional(z.iso.datetime())
@@ -122,7 +145,7 @@ export namespace schema {
             z.describe(
               'The number of decimal places the token uses; Tempo stablecoins typically use 6.',
             ),
-            z.meta({ examples: [6] }),
+            z.meta({ examples: [tokenExample.decimals] }),
           ),
         holderCount: z
           .optional(z.number().check(z.int(), z.nonnegative()))
@@ -136,21 +159,19 @@ export namespace schema {
           .string()
           .check(
             z.describe('A stable resource ID for this token, equal to its contract address.'),
-            z.meta({ examples: ['0x20c0000000000000000000008f5425160ebe5525'] }),
+            z.meta({ examples: [tokenExample.id] }),
           ),
         logoUri: z.optional(z.string()).check(
           z.describe('A URL for the token’s logo image, when one is available.'),
           z.meta({
-            examples: [
-              'https://api.tempo.xyz/data/4217/icons/0x20c0000000000000000000008f5425160ebe5525.svg',
-            ],
+            examples: [tokenExample.logoUri],
           }),
         ),
         name: z
           .string()
           .check(
             z.describe('The token’s human-readable name.'),
-            z.meta({ examples: ['USD Coin'] }),
+            z.meta({ examples: [tokenExample.name] }),
           ),
         quoteToken: z
           .optional(Schema.Address)
@@ -164,7 +185,7 @@ export namespace schema {
           .string()
           .check(
             z.describe('The short ticker symbol wallets and apps show for this token.'),
-            z.meta({ examples: ['USDC'] }),
+            z.meta({ examples: [tokenExample.symbol] }),
           ),
         totalSupply: z
           .optional(z.string().check(z.regex(/^\d+$/)))
@@ -172,7 +193,7 @@ export namespace schema {
             z.describe(
               'The token’s total supply as a decimal string in the smallest unit, so large values keep full precision.',
             ),
-            z.meta({ examples: ['1000000000000'] }),
+            z.meta({ examples: [tokenExample.totalSupply] }),
           ),
         transferStats: z
           .optional(
@@ -213,7 +234,7 @@ export namespace schema {
           .boolean()
           .check(
             z.describe('Whether this token is in Tempo’s curated verified token list.'),
-            z.meta({ examples: [true] }),
+            z.meta({ examples: [tokenExample.verified] }),
           ),
       }),
       'Token metadata for a TIP-20 token, including name, symbol, decimals, supply, and optional indexed details.',
@@ -624,7 +645,7 @@ export function tokens() {
             200,
           )
         } catch (cause) {
-          return Response.upstream(c, cause)
+          return Response.upstream(c, cause, { page: query.page })
         }
       },
     )
@@ -653,6 +674,7 @@ export function tokens() {
           },
           success: {
             description: 'Metadata for one TIP-20 token.',
+            example: tokenExample,
             schema: schema.getToken.Response,
           },
         }),
@@ -725,6 +747,7 @@ export function tokens() {
           },
           success: {
             description: 'Metadata for one TIP-20 token.',
+            example: tokenExample,
             schema: schema.getToken.Response,
           },
         }),
@@ -932,7 +955,7 @@ export function tokens() {
             200,
           )
         } catch (cause) {
-          return Response.upstream(c, cause)
+          return Response.upstream(c, cause, { page: query.page })
         }
       },
     )
@@ -1051,7 +1074,7 @@ export function tokens() {
             200,
           )
         } catch (cause) {
-          return Response.upstream(c, cause)
+          return Response.upstream(c, cause, { page: query.page })
         }
       },
     )

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

@@ -687,7 +687,7 @@ export function transactions() {
             200,
           )
         } catch (cause) {
-          return Response.upstream(c, cause)
+          return Response.upstream(c, cause, { page: query.page })
         }
       },
     )

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

@@ -1058,16 +1058,16 @@ describe('GET /transfers', () => {
     expect(empty.data).toEqual([])
   })
 
-  test('keeps the largest positional window within the indexer row limit', async () => {
+  test('accepts the largest positional window', async () => {
     const client = TestApp.client()
     const response = await client.v1.transfers.$get(
-      { query: { limit: '200', order: 'desc', page: '50' } },
+      { query: { limit: '50', order: 'desc', page: '10' } },
       TestApp.auth,
     )
     const page = await TestApp.json(response, Transfers.schema.getTransfers.Response)
 
     expect(response.status).toBe(200)
-    expect(page.data.length).toBeLessThanOrEqual(200)
+    expect(page.data.length).toBeLessThanOrEqual(50)
   })
 })
 

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

@@ -69,14 +69,16 @@ export namespace schema {
   /** A transfer token reference with RPC metadata. Inlined to avoid the `transfers`/`tokens` module cycle. */
   export const SourceToken = z
     .object({
-      address: Schema.TokenAddress.check(z.describe('The TIP-20 token contract address on Tempo.')),
+      address: Schema.tokenAddress(Tokens.tokenExample.address).check(
+        z.describe('The TIP-20 token contract address on Tempo.'),
+      ),
       currency: z
         .string()
         .check(
           z.describe(
             'The currency label for this token, such as `USD` for USD-denominated stablecoins.',
           ),
-          z.meta({ examples: ['USD'] }),
+          z.meta({ examples: [Tokens.tokenExample.currency] }),
         ),
       decimals: z
         .number()
@@ -85,24 +87,25 @@ export namespace schema {
           z.describe(
             'The number of decimal places the token uses; Tempo stablecoins typically use 6.',
           ),
-          z.meta({ examples: [6] }),
+          z.meta({ examples: [Tokens.tokenExample.decimals] }),
         ),
       logoUri: z.optional(z.string()).check(
         z.describe('A URL for the token’s logo image, returned with `include=token.logoUri`.'),
         z.meta({
-          examples: [
-            'https://api.tempo.xyz/data/4217/icons/0x20c0000000000000000000008f5425160ebe5525.svg',
-          ],
+          examples: [Tokens.tokenExample.logoUri],
         }),
       ),
       name: z
         .string()
-        .check(z.describe('The token’s human-readable name.'), z.meta({ examples: ['USD Coin'] })),
+        .check(
+          z.describe('The token’s human-readable name.'),
+          z.meta({ examples: [Tokens.tokenExample.name] }),
+        ),
       symbol: z
         .string()
         .check(
           z.describe('The short ticker symbol wallets and apps show for this token.'),
-          z.meta({ examples: ['USDC'] }),
+          z.meta({ examples: [Tokens.tokenExample.symbol] }),
         ),
       verified: z
         .optional(z.boolean())
@@ -659,7 +662,7 @@ export function transfers(options: transfers.Options = {}) {
       } catch (cause) {
         if (cause instanceof Valuation.UnsupportedDenominationError)
           return Response.error(c, { code: 'query_invalid', message: cause.message, status: 400 })
-        return Response.upstream(c, cause)
+        return Response.upstream(c, cause, { page: options.page })
       }
     },
   )