tapimo 0.10.1 → 0.10.2

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

@@ -375,9 +375,7 @@ export function addresses(options: addresses.Options = {}) {
             ),
           )
           const client = c.get('getClient')(chainId)
-          const caller = c.get('zones').has(chainId)
-            ? (await client.zone.getZoneInfo()).sequencers[0]
-            : undefined
+          const caller = c.get('zones').has(chainId) ? address : undefined
           const [balance, feeTokens, snapshot, resolvedToken] = await Promise.all([
             Timing.time(c, 'balance_rpc', async () => {
               const call = Actions.token.getBalance.call(client, {
@@ -516,9 +514,7 @@ async function getAddressBalances(
   const correctedPromise = holdingsPromise.then(async (holdings) => {
     if (holdings.length === 0) return []
     const client = c.get('getClient')(chainId)
-    const caller = c.get('zones').has(chainId)
-      ? (await client.zone.getZoneInfo()).sequencers[0]
-      : undefined
+    const caller = c.get('zones').has(chainId) ? address : undefined
     return Timing.time(c, 'balances_rpc', async () => {
       // Concurrent reads enter viem's shared batch window and become one
       // deployless multicall. A failed read fails the request rather than serving

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

@@ -2034,6 +2034,8 @@ export async function listVaults(c: Context<App.Environment>, options: listVault
     core_EarnVaults.list(db, { chainId: options.chainId }),
     VerifiedTokens.snapshot(c, options.chainId),
   ])
+  const include = vaultInclude(options)
+  const apyByVault = new Map<string, EarnRates.Apy | null>()
   const registry = new Map(records.map((record) => [record.vaultAddress.toLowerCase(), record]))
   const decoded = options.cursor ? Cursor.decode(options.cursor, ['int', 'int']) : undefined
   let position = decoded
@@ -2062,22 +2064,44 @@ export async function listVaults(c: Context<App.Environment>, options: listVault
     }
     scanned += page.items.length
 
-    const discovered = await Promise.all(
-      page.items.map(async (item) => {
-        const record = registry.get(item.vaultAddress.toLowerCase())
-        try {
-          const discovery = await resolveVaultDiscovery(c, {
+    const apyVaults =
+      apyByVault.size === 0 &&
+      include.includes('apy') &&
+      options.capability.length === 0 &&
+      options['engine.type'] === undefined
+        ? page.items
+            .slice(0, options.limit - matches.length)
+            .map(({ vaultAddress }) => vaultAddress)
+        : []
+    // Rate boundaries and historical quotes depend only on candidate addresses,
+    // so the unfiltered page can resolve them alongside live vault discovery.
+    const [discovered, prefetchedApy] = await Promise.all([
+      Promise.all(
+        page.items.map(async (item) => {
+          const record = registry.get(item.vaultAddress.toLowerCase())
+          try {
+            const discovery = await resolveVaultDiscovery(c, {
+              chainId: options.chainId,
+              include: discoveryInclude(options),
+              vaultAddress: item.vaultAddress,
+            })
+            return { discovery, position: item.position, record }
+          } catch (cause) {
+            if (!record && isIncompatible(cause)) return undefined
+            throw cause
+          }
+        }),
+      ),
+      apyVaults.length > 0
+        ? resolvePageApy(c, {
             chainId: options.chainId,
-            include: discoveryInclude(options),
-            vaultAddress: item.vaultAddress,
+            include,
+            vaults: apyVaults,
+            window: options['apy.window'],
           })
-          return { discovery, position: item.position, record }
-        } catch (cause) {
-          if (!record && isIncompatible(cause)) return undefined
-          throw cause
-        }
-      }),
-    )
+        : undefined,
+    ])
+    for (const [vault, apy] of prefetchedApy ?? []) apyByVault.set(vault, apy)
     for (const match of discovered) {
       if (!match || !matchesVaultFilters(match.discovery, options)) continue
       matches.push(match)
@@ -2089,17 +2113,25 @@ export async function listVaults(c: Context<App.Environment>, options: listVault
 
   const page = matches.slice(0, options.limit)
   const discoveries = page.map(({ discovery }) => discovery)
-  const include = vaultInclude(options)
-  const [apy, rates, tokens] = await Promise.all([
-    resolvePageApy(c, {
-      chainId: options.chainId,
-      discoveries,
-      include,
-      window: options['apy.window'],
-    }),
+  const missingApyVaults = include.includes('apy')
+    ? discoveries.flatMap(({ vaultAddress }) =>
+        apyByVault.has(vaultAddress.toLowerCase()) ? [] : [vaultAddress],
+      )
+    : []
+  const [missingApy, rates, tokens] = await Promise.all([
+    missingApyVaults.length > 0
+      ? resolvePageApy(c, {
+          chainId: options.chainId,
+          include,
+          vaults: missingApyVaults,
+          window: options['apy.window'],
+        })
+      : undefined,
     resolvePageRates(c, { discoveries, include, oracle: options.oracle, snapshot }),
     resolvePageTokens(c, { chainId: options.chainId, discoveries, include, snapshot }),
   ])
+  for (const [vault, apy] of missingApy ?? []) apyByVault.set(vault, apy)
+  const apy = include.includes('apy') ? apyByVault : undefined
   const data = page.map((match) =>
     resolveVault(c, { ...match, apy, include, rates, snapshot, tokens }),
   )
@@ -2181,8 +2213,8 @@ export async function listVerifiedVaults(
   const [apy, rates, tokens] = await Promise.all([
     resolvePageApy(c, {
       chainId: options.chainId,
-      discoveries,
       include,
+      vaults: discoveries.map(({ vaultAddress }) => vaultAddress),
       window: options['apy.window'],
     }),
     resolvePageRates(c, { discoveries, include, oracle: options.oracle, snapshot }),
@@ -2503,8 +2535,8 @@ export async function getVault(c: Context<App.Environment>, options: getVault.Op
     const [apy, rates, tokens] = await Promise.all([
       resolvePageApy(c, {
         chainId: options.chainId,
-        discoveries,
         include,
+        vaults: discoveries.map(({ vaultAddress }) => vaultAddress),
         window: options['apy.window'],
       }),
       resolvePageRates(c, { discoveries, include, oracle: options.oracle, snapshot }),
@@ -2616,7 +2648,7 @@ function resolvePageApy(c: Context<App.Environment>, options: resolvePageApy.Opt
       getClient: c.get('getClient'),
       getTidx: c.get('getTidx'),
       store: c.get('store'),
-      vaults: options.discoveries.map(({ vaultAddress }) => vaultAddress),
+      vaults: options.vaults,
       window: options.window,
     }),
   )
@@ -2625,8 +2657,8 @@ function resolvePageApy(c: Context<App.Environment>, options: resolvePageApy.Opt
 declare namespace resolvePageApy {
   type Options = {
     chainId: z.output<typeof Schema.ChainId>
-    discoveries: readonly EarnVaults.Discovery[]
     include: z.output<typeof schema.getEarnVault.Query>['include']
+    vaults: readonly z.output<typeof Schema.Address>[]
     window: z.output<typeof schema.getEarnVault.Query>['apy.window']
   }
 }
@@ -2837,7 +2869,7 @@ async function queryDeployments(
   c: Context<App.Environment>,
   options: queryDeployments.Options,
 ): Promise<queryDeployments.Result> {
-  const filters = ['deployment_rank = 1']
+  const filters: string[] = []
   if (options.asset) filters.push(`lower(asset) = '${options.asset.toLowerCase()}'`)
   if (options.cursor)
     filters.push(
@@ -2855,7 +2887,7 @@ async function queryDeployments(
       ]),
     )
 
-  // ClickHouse supports ordering and windowing over decoded event CTEs.
+  // Deduplicate before outer filters so every vault is filtered by its latest deployment.
   const result = await c
     .get('getTidx')(options.chainId)
     .fetch({
@@ -2868,14 +2900,12 @@ async function queryDeployments(
           "earnVault",
           asset,
           block_num,
-          log_idx,
-          row_number() OVER (
-            PARTITION BY lower("earnVault")
-            ORDER BY block_num DESC, log_idx DESC
-          ) AS deployment_rank
+          log_idx
         FROM EarnStackDeployed
+        ORDER BY block_num DESC, log_idx DESC
+        LIMIT 1 BY lower("earnVault")
       )
-      WHERE ${filters.join(' AND ')}
+      ${filters.length > 0 ? `WHERE ${filters.join(' AND ')}` : ''}
       ORDER BY block_num DESC, log_idx DESC
       LIMIT ${options.limit + 1}
     ` as string,

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

@@ -531,7 +531,7 @@ describe('GET /exchange/orders?base=… (pair-scoped orders)', () => {
 })
 
 describe('GET /exchange/pairs/:base/depth', () => {
-  test('returns orderbook depth for a real pair', async () => {
+  test('returns orderbook depth when token metadata is requested', async () => {
     const client = TestApp.client()
     const pairsResponse = await client.v1.exchange.pairs.$get(
       { query: { limit: '5' } },
@@ -547,21 +547,25 @@ describe('GET /exchange/pairs/:base/depth', () => {
     // throttles the multicall response.
     let body: z.output<typeof Exchanges.schema.getPairDepth.Response> | null = null
     let pair: (typeof pairs.data)[number] | null = null
+    let timing: string | null = null
     for (const candidate of pairs.data) {
       const response = await client.v1.exchange.pairs[':base'].depth.$get(
-        { param: { base: candidate.base.address }, query: {} },
+        { param: { base: candidate.base.address }, query: { include: 'tokens' } },
         TestApp.auth,
       )
       if (response.status === 502) return
       expect(response.status).toBe(200)
       body = await TestApp.json(response, Exchanges.schema.getPairDepth.Response)
       pair = candidate
+      timing = response.headers.get('server-timing')
       if (body.bids.length > 0 || body.asks.length > 0) break
     }
     if (!body || !pair) return
 
     expect(body.base.address).toBe(pair.base.address)
     expect(body.quote.address).toBe(pair.quote.address)
+    expect(timing).toContain('pair_lookup;dur=')
+    expect(timing).not.toContain('pair_index;dur=')
 
     // Asks are emitted lowest-tick first (best ask outward); bids are
     // emitted highest-tick first (best bid outward). Per-row `cumulativeSize`
@@ -689,9 +693,9 @@ describe('GET /exchange/swaps', () => {
     const response = await client.v1.exchange.swaps.$get({ query: { limit: '10' } }, TestApp.auth)
     expect(response.status).toBe(200)
     const body = await TestApp.json(response, Exchanges.schema.getSwaps.Response)
+    expect(body.data.length).toBeGreaterThan(0)
     expect(body.data.length).toBeLessThanOrEqual(10)
     expect(response.headers.get('server-timing')).not.toContain('valuation_rates;dur=')
-    if (body.data.length === 0) return
 
     for (const swap of body.data) {
       expect(swap.taker).toMatch(/^0x[0-9a-f]{40}$/)
@@ -827,6 +831,7 @@ describe('GET /exchange/swaps', () => {
       TestApp.auth,
     )
     expect(response.status).toBe(200)
+    expect(response.headers.get('server-timing')).not.toContain('token_logo_uri;dur=')
     const body = await TestApp.json(response, Exchanges.schema.getSwaps.Response)
     if (body.data.length === 0) return
 

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