tapimo 0.10.0 → 0.10.2

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

@@ -2209,20 +2209,22 @@ export function exchanges(options: exchanges.Options = {}) {
             transactionHash: options.transactionHash,
           })
 
-          // `route` spans every swap and fill side, so one lookup resolves each
-          // token once for required RPC metadata and requested curated fields.
-          const tokensByAddress = await Tokens.resolveTokens(c, {
-            addresses: page.data.flatMap((swap) => swap.route),
-            chainId,
-            include: options.include,
-          })
           // Value amounts via their curated display currency; snapshot or rate
           // failures degrade the values to `null`, never the feed.
           const denomination = options['valuation.currency']
-          const snapshot =
+          // Mode, verified-token, and RPC metadata reads depend only on the
+          // assembled page, so overlap them before enriching its rows.
+          const [, snapshot, tokensByAddress] = await Promise.all([
+            resolveSwapModes(c, { chainId, swaps: page.data }),
             denomination !== undefined && page.data.length > 0
-              ? await VerifiedTokens.snapshot(c, chainId).catch(() => undefined)
-              : undefined
+              ? VerifiedTokens.snapshot(c, chainId).catch(() => undefined)
+              : undefined,
+            Tokens.resolveTokens(c, {
+              addresses: page.data.flatMap((swap) => swap.route),
+              chainId,
+              include: options.include,
+            }),
+          ])
           const rates = denomination
             ? await Valuation.ratesFor(c, {
                 currencies: snapshot
@@ -3001,27 +3003,43 @@ export function exchanges(options: exchanges.Options = {}) {
         const chainId = options.chainId ?? c.get('chainId')
 
         try {
-          const pairs = await getPairIndex(c, { chainId })
-          const target = pairs.get(baseAddress)
-          if (!target) return pairNotFoundError(c, { base: baseAddress, pairIndex: pairs })
+          // Pair definitions are immutable after creation, so cache successful
+          // point lookups without making unknown pairs stale.
+          const target = await Store.memoize(
+            async () =>
+              (await getPairsByBase(c, { bases: [baseAddress], chainId })).get(baseAddress),
+            {
+              key: `exchange:v1:${chainId}:pair-by-base:${baseAddress}:v1`,
+              store: c.get('store'),
+              ttl: Ttl.minutes(5),
+            },
+          )
+          if (!target)
+            return pairNotFoundError(c, {
+              base: baseAddress,
+              pairIndex: await getPairIndex(c, { chainId }),
+            })
 
-          const { asks, bids } = await getPairDepth(c, {
-            chainId,
-            levels: options.levels,
-            pair: target,
-          })
+          // Token metadata is opt-in and resolves once per pair onto the top-level
+          // `base`/`quote` slots. Run it alongside the independent depth RPC scan.
+          const [{ asks, bids }, tokensByAddress] = await Promise.all([
+            getPairDepth(c, {
+              chainId,
+              levels: options.levels,
+              pair: target,
+            }),
+            options.include.includes('tokens')
+              ? Tokens.resolveTokens(c, {
+                  addresses: [target.base, target.quote],
+                  chainId,
+                  include: tokenFields,
+                })
+              : undefined,
+          ])
 
-          // Token metadata is opt-in. Resolve once per pair and spread onto the
-          // top-level `base`/`quote` PairToken slots. The Level rows carry no
-          // token references so no per-row enrichment is needed.
           let base: z.output<typeof schema.PairToken> = { address: target.base }
           let quote: z.output<typeof schema.PairToken> = { address: target.quote }
-          if (options.include.includes('tokens')) {
-            const tokensByAddress = await Tokens.resolveTokens(c, {
-              addresses: [target.base, target.quote],
-              chainId,
-              include: tokenFields,
-            })
+          if (tokensByAddress) {
             const baseMeta = tokensByAddress.get(target.base)
             const quoteMeta = tokensByAddress.get(target.quote)
             if (baseMeta) base = { ...base, ...baseMeta }
@@ -3536,9 +3554,9 @@ async function getSwaps(c: Context<App.Environment>, options: getSwaps.Options)
   // the head page.
   const cursor = cursorToken ? Cursor.decode(cursorToken, ['int', 'int', 'int']) : undefined
 
-  // Inclusive `dex_fills` block range bounding one grouped batch (see
-  // `swapWindowBlocks`).
-  type BlockWindow = { hi: number; lo: number }
+  // `dex_fills` block window bounding one grouped batch (see
+  // `swapWindowBlocks`); the head variant derives its lower bound in SQL.
+  type BlockWindow = { hi: number; lo: number } | 'indexedHead'
 
   // Row-level predicates (constant within a group) prune before aggregation.
   // These are batch-invariant; the cursor's per-batch block bound is added in
@@ -3600,6 +3618,12 @@ async function getSwaps(c: Context<App.Environment>, options: getSwaps.Options)
     // the group timestamp.
     const fetchGroups = (activeCursor: typeof cursor, batchLimit: number, window: BlockWindow) => {
       const { having, where } = withCursorSql(activeCursor)
+      const windowFilters =
+        window === 'indexedHead'
+          ? [
+              `f.block_num >= greatest(toInt128((SELECT max(num) FROM blocks)) - ${swapWindowBlocks - 1}, toInt128(0))`,
+            ]
+          : [`f.block_num >= ${window.lo}`, `f.block_num <= ${window.hi}`]
       return tidx.fetch({
         chainId,
         engine: 'clickhouse',
@@ -3609,7 +3633,7 @@ async function getSwaps(c: Context<App.Environment>, options: getSwaps.Options)
                groupArray(tuple(f.log_idx, toString(f."orderId"), f.maker,
                                 toString(f."amountFilled"), f."partialFill")) AS fills
         FROM dex_fills f
-        WHERE ${[...where, `f.block_num >= ${window.lo}`, `f.block_num <= ${window.hi}`].join(' AND ')}
+        WHERE ${[...where, ...windowFilters].join(' AND ')}
         GROUP BY f.block_num, f.tx_hash, f.taker
         ${having}
         ORDER BY block_num ${direction}, first_idx ${direction}
@@ -3667,19 +3691,16 @@ async function getSwaps(c: Context<App.Environment>, options: getSwaps.Options)
         }),
       )
 
-      // Each fill's book quote: from a targeted `dex_pairs` lookup of this
-      // batch's bases when indexed, else the base token's on-chain
-      // `quoteToken()` — some books predate the indexer's `PairCreated`
-      // decode (genesis system books) and have no `dex_pairs` row.
+      // Each fill's book quote comes back with its order state when indexed;
+      // otherwise read the base token's on-chain `quoteToken()` — some books
+      // predate the indexer's `PairCreated` decode (genesis system books).
       const bases = [
         ...new Set([...states.values()].flatMap((events) => events.map((event) => event.token))),
       ]
-      const pairs = await getPairsByBase(c, { bases, chainId })
       const quoteByBase = new Map<string, z.output<typeof Schema.TokenAddress>>()
-      for (const bookBase of bases) {
-        const indexed = pairs.get(bookBase)
-        if (indexed) quoteByBase.set(bookBase, indexed.quote)
-      }
+      for (const events of states.values())
+        for (const event of events)
+          if (event.quoteToken !== undefined) quoteByBase.set(event.token, event.quoteToken)
       const fallback = await Timing.time(c, 'swap_quotes', () =>
         resolveBookQuotes(c, {
           bases: bases.filter((bookBase) => !quoteByBase.has(bookBase)),
@@ -3763,7 +3784,12 @@ async function getSwaps(c: Context<App.Environment>, options: getSwaps.Options)
       return row ? Value.toNumber(row['block_num']) : undefined
     }
 
-    type ScanBounds = BlockWindow & { firstMatchingBlock?: number | undefined }
+    type ScanBounds = {
+      firstMatchingBlock?: number | undefined
+      firstWindow?: 'indexedHead' | undefined
+      hi: number
+      lo: number
+    }
     const bounds: ScanBounds | undefined = await Timing.time(c, 'swap_bounds', async () => {
       if (selective) {
         const firstMatchingBlock = await findMatchingBlock(cursorBlock)
@@ -3775,6 +3801,17 @@ async function getSwaps(c: Context<App.Environment>, options: getSwaps.Options)
             }
           : undefined
       }
+      // The newest unfiltered page can derive its 100k-block lower bound from
+      // `blocks` inside the grouped query, avoiding a separate TIDX request.
+      if (
+        order === 'desc' &&
+        cursorBlock === undefined &&
+        fromBlock === undefined &&
+        fromTimestamp === undefined &&
+        toBlock === undefined &&
+        toTimestamp === undefined
+      )
+        return { firstWindow: 'indexedHead', hi: Number.MAX_SAFE_INTEGER, lo: 0 }
       const result = await tidx.fetch({
         chainId,
         engine: 'clickhouse',
@@ -3802,7 +3839,8 @@ async function getSwaps(c: Context<App.Environment>, options: getSwaps.Options)
       let activeCursor = cursor
 
       // Selective scans jump to the next populated block through a bounded
-      // lookup. Unfiltered scans retain the fixed-stride min/max sweep.
+      // lookup. Unfiltered scans retain the fixed-stride min/max sweep after
+      // the newest page's indexed-head window.
       const windowFrom = async (
         anchor: number | undefined,
         knownMatchingBlock?: number,
@@ -3821,13 +3859,20 @@ async function getSwaps(c: Context<App.Environment>, options: getSwaps.Options)
           : undefined
       }
 
-      let window = await windowFrom(cursorBlock, bounds.firstMatchingBlock)
+      let window: BlockWindow | undefined =
+        bounds.firstWindow ?? (await windowFrom(cursorBlock, bounds.firstMatchingBlock))
 
       // Slide to the next disjoint window away from the newest block and reset
       // the cursor: every row in the next window is already past the cursor
       // anchor in the requested order, so no anchor refinement is needed.
-      const slideWindow = async () => {
+      const slideWindow = async (indexedHeadAnchor?: number) => {
         activeCursor = undefined
+        if (window === 'indexedHead') {
+          const matchingBlock = await findMatchingBlock(indexedHeadAnchor)
+          window =
+            matchingBlock === undefined ? undefined : await windowFrom(matchingBlock, matchingBlock)
+          return
+        }
         window =
           window === undefined
             ? undefined
@@ -3863,7 +3908,7 @@ async function getSwaps(c: Context<App.Environment>, options: getSwaps.Options)
         // A short batch exhausts this window; a full one may leave more groups
         // in it, so advance the keyset cursor and re-query the same window.
         if (!fetchedFull) {
-          await slideWindow()
+          await slideWindow(order === 'desc' ? tail.blockNumber - 1 : tail.blockNumber + 1)
           continue
         }
         const next = cursorAfterWholeGroup(tail)
@@ -3896,13 +3941,7 @@ async function getSwaps(c: Context<App.Environment>, options: getSwaps.Options)
           ])
         : null
 
-    const data = pageRows.map((candidate) => candidate.swap)
-    // Recover each swap's `mode` from transaction calldata — deferred to here
-    // so the candidate scan never pays the `txs` lookup for rows beyond the
-    // page. Best-effort: a failed lookup leaves `mode: null`.
-    await resolveSwapModes(c, { chainId, swaps: data })
-
-    return { data, nextCursor }
+    return { data: pageRows.map((candidate) => candidate.swap), nextCursor }
   })
 }
 
@@ -4054,6 +4093,8 @@ declare namespace parseGroupRow {
  * history compressed to the latest event (`argMax`, sentinel position
  * `(-1, -1)` so it sorts first) plus every raw in-page event, so an order
  * that flips between two of its page fills resolves each fill correctly.
+ * The same query attaches each book's indexed quote token, avoiding a second
+ * TIDX request; callers retain an RPC fallback for books absent from the index.
  * `logs` is sorted by `(address, selector, block_num, log_idx)` with a
  * `topic1` bloom index, so both halves are pruned range reads. Returned
  * per-order event lists are position-sorted.
@@ -4078,16 +4119,27 @@ export async function resolveOrderStates(
     chainId,
     engine: 'clickhouse',
     query: `
-      SELECT topic1, argMax(topic3, (block_num, log_idx)) AS t3,
-             argMax(data, (block_num, log_idx)) AS payload,
-             toInt64(-1) AS bn, toInt32(-1) AS li
-      FROM logs
-      WHERE ${eventFilter} AND block_num < ${minBlock}
-      GROUP BY topic1
-      UNION ALL
-      SELECT topic1, topic3 AS t3, data AS payload, block_num AS bn, log_idx AS li
-      FROM logs
-      WHERE ${eventFilter} AND block_num >= ${minBlock} AND block_num <= ${maxBlock}
+      WITH states AS (
+        SELECT topic1, argMax(topic3, (block_num, log_idx)) AS t3,
+               argMax(data, (block_num, log_idx)) AS payload,
+               toInt64(-1) AS bn, toInt32(-1) AS li
+        FROM logs
+        WHERE ${eventFilter} AND block_num < ${minBlock}
+        GROUP BY topic1
+        UNION ALL
+        SELECT topic1, topic3 AS t3, data AS payload, block_num AS bn, log_idx AS li
+        FROM logs
+        WHERE ${eventFilter} AND block_num >= ${minBlock} AND block_num <= ${maxBlock}
+      )
+      SELECT states.*, pairs.quote AS quote_token
+      FROM states
+      LEFT JOIN (
+        -- Preserve the oldest-pair rule without sorting the complete table.
+        SELECT base, argMin(quote, (block_num, log_idx)) AS quote
+        FROM dex_pairs
+        WHERE address = '${stablecoinDex}'
+        GROUP BY base
+      ) AS pairs ON pairs.base = concat('0x', lower(substring(states.t3, 27)))
     ` as string,
   })
 
@@ -4123,6 +4175,8 @@ declare namespace resolveOrderStates {
     isBid: boolean
     /** Event log index, or `-1` for the baseline. */
     logIndex: number
+    /** Indexed quote token for the state's book, when available. */
+    quoteToken?: z.output<typeof Schema.TokenAddress> | undefined
     /** Signed price tick at this state. */
     tick: number
     /** Book base token (lowercase address). */
@@ -4144,6 +4198,7 @@ function parseStateRow(
   const payload = Value.toText(row['payload'])
   const blockNumber = Value.toNumber(row['bn'])
   const logIndex = Value.toNumber(row['li'])
+  const quoteToken = Schema.TokenAddress.safeParse(row['quote_token'])
   if (
     topic1 === undefined ||
     !/^0x[0-9a-fA-F]{64}$/.test(topic1) ||
@@ -4166,6 +4221,7 @@ function parseStateRow(
       blockNumber,
       isBid,
       logIndex,
+      ...(quoteToken.success ? { quoteToken: quoteToken.data } : {}),
       tick,
       token: `0x${topic3.slice(26).toLowerCase()}`,
     },
@@ -4718,15 +4774,10 @@ const globalOrderScanCap = 2000
 
 /**
  * Batch size for `OrderCancelled` / `OrderFilled` `WHERE "orderId" IN (...)`
- * lookups. ClickHouse evaluates the IN-list against the `topic1` bloom-filter
- * index after the TIDX pushdown rewrite re-encodes each literal (see
- * `tempoxyz/ak47` commit `273d88d`); very large lists still inflate SQL parse
- * cost, but each batch is also an independent transient-error round trip, so
- * 1000 balances parse cost against keeping the batch count (and thus the
- * failure surface) low — a typical pair snapshot still resolves in one trip and
- * the capped global feed in ~two.
+ * lookups. A 2000-ID batch uses indexed state paths while native fill
+ * aggregation keeps the response below SQL and result limits.
  */
-const orderInBatchSize = 1000
+const orderInBatchSize = 2000
 
 /**
  * Signed-int16 bias used to encode `tick` in the cursor as a non-negative
@@ -4745,8 +4796,8 @@ const orderCursorTickBias = 32768
  * when scoped (string column with a bloom-filter index on `topic1`), and the
  * fill / cancellation joins use `WHERE "orderId" IN (...)` against the same
  * index. The decoded `tick` column has no ClickHouse index, so tick sort is
- * still applied app-side. Aggregation also runs in the app because
- * indexer-side `SUM(...)` over decoded columns is currently unreliable.
+ * still applied app-side. ClickHouse aggregates fills per order before the
+ * app computes each remaining amount.
  *
  * `remaining = OrderPlaced.amount - sum(OrderFilled.amountFilled)`; orders
  * with an `OrderCancelled` event are excluded outright. Each row is annotated
@@ -5012,7 +5063,7 @@ declare namespace getPairDepth {
     chainId: z.output<typeof Schema.ChainId>
     /** Maximum number of non-empty levels to keep per side, in best-first order. */
     levels: number
-    pair: getPairs.Row
+    pair: getPairsByBase.Pair
   }
 }
 
@@ -5362,7 +5413,7 @@ async function fetchCancelledByIds(
       query: `
         SELECT "orderId"
         FROM OrderCancelled
-        WHERE "orderId" IN (${batch.join(', ')})
+        WHERE address = '${stablecoinDex}' AND "orderId" IN (${batch.join(', ')})
       `,
       signatures: [orderCancelledSignature],
     })
@@ -5375,10 +5426,9 @@ async function fetchCancelledByIds(
 }
 
 /**
- * Sums `amountFilled` per `orderId` across all matching `OrderFilled` rows in
- * the snapshot window via batched `WHERE "orderId" IN (...)` queries. Each
- * placement may have many partial fills, so the loader sums them in the app
- * (indexer-side `SUM(...)` over decoded columns is currently unreliable).
+ * Sums `amountFilled` per `orderId` across all matching native `dex_fills`
+ * rows in the snapshot window via batched `WHERE "orderId" IN (...)` queries.
+ * Native aggregation bounds results, and stringification preserves UInt256 precision through JSON parsing.
  */
 async function fetchFillSumsByIds(
   c: Context<App.Environment>,
@@ -5396,17 +5446,19 @@ async function fetchFillSumsByIds(
     const result = await tidx.fetch({
       chainId,
       engine: 'clickhouse',
+      // Dynamic order IDs prevent signature-backed row inference; each aggregate is validated below before use.
       query: `
-        SELECT "orderId", "amountFilled"
+        SELECT "orderId", toString(sum("amountFilled")) AS amount_filled
         FROM dex_fills
-        WHERE "orderId" IN (${batch.join(', ')})
+        WHERE address = '${stablecoinDex}' AND "orderId" IN (${batch.join(', ')})
+        GROUP BY "orderId"
       ` as string,
     })
     for (const row of result.rows) {
       const id = Value.toIntegerString(row['orderId'])
-      const filled = Value.toIntegerString(row['amountFilled'])
+      const filled = Value.toIntegerString(row['amount_filled'])
       if (id === undefined || filled === undefined) continue
-      sums.set(id, (sums.get(id) ?? 0n) + BigInt(filled))
+      sums.set(id, BigInt(filled))
     }
   }
   return sums

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

@@ -0,0 +1,13 @@
+import * as QueryBench from '../../../../test/QueryBench.js'
+
+QueryBench.bench({
+  name: 'getFeeAmmPools',
+  path: '/v1/fee-amm/pools',
+  queries: ['include=token.logoUri', 'include=token.verified'],
+})
+
+QueryBench.bench({
+  name: 'getFeeAmmMints',
+  path: '/v1/fee-amm/mints',
+  queries: ['include=totalCount'],
+})

package/src/apps/data/routes/indexer.bench.ts

@@ -0,0 +1,8 @@
+import * as QueryBench from '../../../../test/QueryBench.js'
+
+const sql = 'SELECT num, hash FROM blocks ORDER BY num DESC LIMIT 1'
+
+QueryBench.bench({
+  name: 'indexerQuery',
+  path: `/v1/indexer/query?sql=${encodeURIComponent(sql)}`,
+})

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

@@ -150,7 +150,7 @@ describe('GET /indexer/query', () => {
       const client = TestApp.client()
       const response = await client.v1.indexer.query.$get(
         { query: { sql: 'select 1', chainId } },
-        TestApp.auth,
+        { headers: { 'x-api-key': TestApp.key.token } },
       )
 
       expect(response.status).toMatchInlineSnapshot(`200`)
@@ -161,6 +161,7 @@ describe('GET /indexer/query', () => {
       // Tempo API enforces the documented execution bounds upstream even when the
       // caller omits them.
       const upstream = new URL((fetch.mock.calls[0]![0] as Request).url)
+      expect((fetch.mock.calls[0]![0] as Request).headers.get('x-api-key')).toBeNull()
       expect(upstream.searchParams.get('timeout_ms')).toMatchInlineSnapshot(`"5000"`)
       expect(upstream.searchParams.get('limit')).toMatchInlineSnapshot(`"10000"`)
     } finally {

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

@@ -23,10 +23,11 @@ const strippedHeaders = new Set([
   'keep-alive',
   'proxy-authorization',
   'te',
+  'tempo-api-key',
   'trailer',
   'transfer-encoding',
   'upgrade',
-  'tempo-api-key',
+  'x-api-key',
   ZoneRpcAuthentication.headerName.toLowerCase(),
 ])
 
@@ -63,7 +64,7 @@ export namespace schema {
           z.meta({ examples: [1] }),
         ),
       engine: z
-        .optional(z.enum(['postgres', 'clickhouse']))
+        .optional(z.enum(['postgres', 'clickhouse', 'tiered']))
         .check(
           z.describe('Indexer engine that ran the query.'),
           z.meta({ examples: ['postgres'] }),

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

@@ -0,0 +1,39 @@
+import * as QueryBench from '../../../../test/QueryBench.js'
+
+const hash = {
+  4217: '0x7f98e4b2bf4d1444b257526f7dd294ac3480d73cd91f723bf0df6062d1ba1c82',
+  42431: '0x1c8ccebb169f863b72388cc057fcecee240032eb7d2c64aa6f6fb8e5a60d3f9a',
+} as const
+
+const address = {
+  4217: '0xc24357119432595a547cb2c1e41c51d753645519',
+  42431: '0x15496d3123afb2cfadc0ac068eadd11d0f8ae799',
+} as const
+
+QueryBench.bench({
+  name: 'getReceipts',
+  path: '/v1/transactions/receipts',
+  queries: [
+    'include=feeToken.logoUri',
+    'include=feeToken.verified',
+    'include=totalCount',
+    'valuation.currency=USD',
+  ],
+})
+
+QueryBench.bench({
+  name: 'getReceipts?address&include=totalCount',
+  path: {
+    4217: `/v1/transactions/receipts?address=${address[4217]}&include=totalCount`,
+    42431: `/v1/transactions/receipts?address=${address[42431]}&include=totalCount`,
+  },
+})
+
+QueryBench.bench({
+  name: 'getReceipt',
+  path: {
+    4217: `/v1/transactions/${hash[4217]}/receipt`,
+    42431: `/v1/transactions/${hash[42431]}/receipt`,
+  },
+  queries: ['include=feeToken.logoUri', 'include=feeToken.verified', 'valuation.currency=USD'],
+})

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

@@ -976,9 +976,10 @@ function countFilters(options: countReceipts.Options): string[] {
 
 /**
  * Capped total count of receipts matching the same filters as the page. The
- * address scope reuses the page's `UNION` workaround (`receipts` indexes `from`
- * but not `to`, so the `to` side resolves hashes via the `txs` index), counting
- * the deduped keyset so self-receipts (`from = to`) aren't double-counted.
+ * address scope reuses the page's `UNION` workaround. Fee-payer filters make a
+ * direct `receipts.to` predicate selective; otherwise the `to` side resolves
+ * hashes via the `txs` index. The deduped keyset avoids double-counting
+ * self-receipts (`from = to`).
  * `totalCountCapped: true` is a lower bound — at least {@link Schema.countCap} matches.
  */
 export function countReceipts(
@@ -995,10 +996,11 @@ export function countReceipts(
         let query: string
         if (address !== undefined) {
           const fromWhere = [`"from" = '${address}'`, ...filters].join(' AND ')
-          const toWhere = [
-            `tx_hash IN (SELECT hash FROM txs WHERE "to" = '${address}')`,
-            ...filters,
-          ].join(' AND ')
+          const toPredicate =
+            options.feePayer !== undefined
+              ? `"to" = '${address}'`
+              : `tx_hash IN (SELECT hash FROM txs WHERE "to" = '${address}')`
+          const toWhere = [toPredicate, ...filters].join(' AND ')
           query = `
             SELECT count(*) AS total
             FROM (
@@ -1069,13 +1071,13 @@ export async function embedReceipts(
   const { chainId, include, rows } = options
   const found = new Map<string, humanizeReceipt.Output>()
 
-  // Only mined rows can have a receipt; their block numbers also feed the
-  // block bound the `logs` lookup requires.
-  const blocks: number[] = []
+  // Only mined rows can have a receipt; their block numbers also constrain the
+  // `logs` lookup to the page's exact blocks.
+  const blocks = new Set<number>()
   const hashes = new Set<string>()
   for (const row of rows) {
     if (row.blockNumber === null) continue
-    blocks.push(row.blockNumber)
+    blocks.add(row.blockNumber)
     hashes.add(row.hash.toLowerCase())
   }
   if (hashes.size === 0) return new Map()
@@ -1086,8 +1088,8 @@ export async function embedReceipts(
   // Raw-table queries (no signature-decoded CTE), so the inline SQL is cast to
   // `string`. The receipts lookup needs no block bound (`receipts.tx_hash` is
   // indexed — see the `sideQuery` comment in `getReceipts`); the logs lookup
-  // REQUIRES one: `logs` is sorted by block position, so a bare `tx_hash IN`
-  // scans to genesis (see `blockBound` in `transfers.ts`).
+  // uses the page's exact blocks so sparse transaction pages do not scan every
+  // block between their oldest and newest rows.
   const [receipts_result, logs_result] = await Timing.time(c, 'receipts_embed', () =>
     Promise.all([
       options.receipts
@@ -1100,7 +1102,7 @@ export async function embedReceipts(
       tidx.fetch({
         chainId,
         query:
-          `SELECT tx_hash, block_num, tx_idx, log_idx, address, selector, topic1, topic2, topic3, data, block_timestamp FROM logs WHERE block_num BETWEEN ${Math.min(...blocks)} AND ${Math.max(...blocks)} AND tx_hash IN (${inList}) ORDER BY block_num ASC, log_idx ASC` as string,
+          `SELECT tx_hash, block_num, tx_idx, log_idx, address, selector, topic1, topic2, topic3, data, block_timestamp FROM logs WHERE block_num IN (${[...blocks].join(', ')}) AND tx_hash IN (${inList}) ORDER BY block_num ASC, log_idx ASC` as string,
       }),
     ]),
   )

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

@@ -0,0 +1,14 @@
+import * as QueryBench from '../../../../test/QueryBench.js'
+
+QueryBench.bench({
+  body: {
+    id: 1,
+    jsonrpc: '2.0',
+    method: 'eth_blockNumber',
+    params: [],
+  },
+  chainId: false,
+  method: 'POST',
+  name: 'rpcRequest',
+  path: { 4217: '/rpc/mainnet', 42431: '/rpc/testnet' },
+})

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

@@ -53,6 +53,30 @@ function zoneToken() {
 }
 
 describe('POST /rpc', () => {
+  test('allows 20 public requests per second', async () => {
+    vi.useFakeTimers({ now: new Date('2026-08-12T00:00:00.000Z') })
+    try {
+      const app = TestApp.create()
+      const request = () =>
+        app.request('/rpc', {
+          body: JSON.stringify({ id: 1, jsonrpc: '2.0', method: 'tempo_blockNumber' }),
+          method: 'POST',
+        })
+      const responses = await Promise.all(
+        Array.from({ length: 21 }, () => Promise.resolve(request())),
+      )
+      const limited = responses.find((response) => response.status === 429)!
+
+      expect(responses.filter((response) => response.status === 401)).toHaveLength(20)
+      expect(limited.headers.get('RateLimit-Limit')).toBe('20')
+
+      vi.advanceTimersByTime(1_000)
+      expect((await Promise.resolve(request())).status).toBe(401)
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
   test('routes by principal: a resolver sees the request principal and routes accordingly', async () => {
     const fetch = mockRpc()
     // A resolver that routes API-key principals to the private upstream and
@@ -113,6 +137,7 @@ describe('POST /rpc', () => {
             'content-type': 'application/json',
             cookie: 'session=secret',
             'tempo-api-key': 'caller-key',
+            'x-api-key': 'legacy-caller-key',
             'x-authorization-token': 'zone-secret',
             'x-client-trace': 'trace_test',
           },
@@ -139,6 +164,7 @@ describe('POST /rpc', () => {
       expect(call.headers['authorization']).toMatchInlineSnapshot(`"Basic cnBjOnNlY3JldA=="`)
       expect(call.headers['cookie']).toMatchInlineSnapshot(`null`)
       expect(call.headers['tempo-api-key']).toMatchInlineSnapshot(`null`)
+      expect(call.headers['x-api-key']).toBeNull()
       expect(call.headers['x-authorization-token']).toBeNull()
       expect(call.headers['x-client-trace']).toMatchInlineSnapshot(`"trace_test"`)
     } finally {
@@ -1156,6 +1182,7 @@ function mockRpc() {
         authorization: request.headers.get('authorization'),
         cookie: request.headers.get('cookie'),
         'tempo-api-key': request.headers.get('tempo-api-key'),
+        'x-api-key': request.headers.get('x-api-key'),
         'x-authorization-token': request.headers.get('x-authorization-token'),
         'x-client-trace': request.headers.get('x-client-trace'),
       },

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

@@ -26,6 +26,7 @@ const strippedHeaders = new Set([
   'trailer',
   'transfer-encoding',
   'upgrade',
+  'x-api-key',
   ZoneRpcAuthentication.headerName.toLowerCase(),
 ])
 
@@ -163,7 +164,10 @@ export namespace schema {
 export function rpc() {
   return new Hono<App.Environment>().post(
     '/rpc/:chain{(mainnet|testnet|[0-9]+)}?',
-    Auth.policy({ apiKey: { scopes: ['data:read'] }, public: true }),
+    Auth.policy({
+      apiKey: { scopes: ['data:read'] },
+      public: { rateLimit: { limit: 20, period: 'second' } },
+    }),
     OpenApi.describeRoute({
       description:
         'Sends a single or batch Ethereum JSON-RPC request directly to Tempo. Use `/rpc/testnet`, `/rpc/mainnet`, or `/rpc/:chain` to choose a chain. Zone read scopes permit read-only methods; Zone write scopes also permit signed transaction broadcasts. A Zone token in `X-Authorization-Token` is forwarded to the authenticated Zone RPC. This passthrough is not part of the stable API contract and is supported on a best-effort basis only. It has no compatibility, latency, availability, or data-freshness guarantees, and breaking changes may happen with limited notice.',