tapimo 0.7.0 → 0.7.2

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

@@ -1,3 +1,5 @@
+/** @module-tag localnet */
+
 import { Abis, Addresses } from 'viem/tempo'
 
 import * as TestApp from '../../../../test/App.js'
@@ -259,12 +261,8 @@ describe('GET /fee-amm/mints', () => {
     expect(secondResponse.status).toBe(200)
     expect(second.data.length).toBeGreaterThan(0)
     // No overlap across the page boundary, and ordering continues descending.
-    const firstKeys = new Set(
-      first.data.map((mint) => `${mint.blockNumber}:${mint.transactionHash}`),
-    )
-    expect(
-      second.data.every((mint) => !firstKeys.has(`${mint.blockNumber}:${mint.transactionHash}`)),
-    ).toBe(true)
+    const firstIds = new Set(first.data.map(({ id }) => id))
+    expect(second.data.every(({ id }) => !firstIds.has(id))).toBe(true)
     expect(second.data[0]!.blockNumber).toBeLessThanOrEqual(first.data.at(-1)!.blockNumber)
   })
 

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

@@ -44,6 +44,15 @@ const legacyMintTopic = AbiEvent.getSelector(
   'event Mint(address indexed sender, address indexed userToken, address indexed validatorToken, uint256 amountUserToken, uint256 amountValidatorToken, uint256 liquidity)',
 )
 
+// Block windows for the mint feed's page sweep, widened geometrically until
+// the page fills. An unbounded top-K over the FeeManager's mint history sorts
+// every matching row (tens of millions on busy chains) and crosses TIDX's 5s
+// execution cap, so the page query is bounded to a block window anchored at
+// the cursor (or the feed's head/tail block); dense filters fill the first
+// window, and only sparse filters, whose top-K is inherently cheap, fall
+// through to the unbounded query.
+const mintWindowBlocks = [100_000, 1_000_000, 10_000_000]
+
 /** Zod schemas owned by the fee AMM handlers. */
 export namespace schema {
   /**
@@ -765,7 +774,9 @@ declare namespace getPoolReserves {
  * Lists `Mint` logs as a keyset-paginated page on `(block_num, log_idx)`,
  * optionally filtered by the pool's tokens. Runs on ClickHouse: the postgres
  * `logs` table has no topic index, so topic-filtered pages exceed its
- * statement timeout, while ClickHouse serves every filter shape.
+ * statement timeout, while ClickHouse serves every filter shape. The page
+ * query sweeps a widening block window (see `mintWindowBlocks`) so large
+ * chains never top-K sort the full mint history.
  */
 function listMints(c: Context<App.Environment>, options: listMints.Options) {
   const { chainId, limit, order, userToken, validatorToken } = options
@@ -807,17 +818,63 @@ function listMints(c: Context<App.Environment>, options: listMints.Options) {
         // ClickHouse's timezone-less `DateTime` text as *local* time. The
         // alias passes the raw text through so `Value.toIsoDateTime` can
         // apply its UTC normalization instead.
-        const result = await tidx.fetch({
-          chainId,
-          engine: 'clickhouse',
-          query: `
-            SELECT tx_hash, block_num, log_idx, block_timestamp AS block_time, selector, topic1, topic2, topic3, data
-            FROM logs
-            WHERE ${filters.join(' AND ')}
-            ORDER BY block_num ${direction}, log_idx ${direction}
-            LIMIT ${limit + 1}${offset !== undefined ? ` OFFSET ${offset}` : ''}
-          ` as string,
-        })
+        const fetchPage = (where: readonly string[]) =>
+          tidx.fetch({
+            chainId,
+            engine: 'clickhouse',
+            query: `
+              SELECT tx_hash, block_num, log_idx, block_timestamp AS block_time, selector, topic1, topic2, topic3, data
+              FROM logs
+              WHERE ${where.join(' AND ')}
+              ORDER BY block_num ${direction}, log_idx ${direction}
+              LIMIT ${limit + 1}${offset !== undefined ? ` OFFSET ${offset}` : ''}
+            ` as string,
+          })
+
+        // Window anchor: the cursor block when paginating, else the fee
+        // manager's newest (desc) or oldest (asc) log block. The bounds are
+        // shared by every filter shape and staleness only shifts the first
+        // window, so memoize them briefly per chain.
+        const anchor = await (async () => {
+          if (cursor !== undefined) return Number(cursor[0])
+          const bounds = await Store.memoize(
+            async () => {
+              // Dynamic raw-`logs` query, hence the cast. `address` aligns
+              // with the `logs` sort key, so the probe is index-pruned.
+              const result = await tidx.fetch({
+                chainId,
+                engine: 'clickhouse',
+                query:
+                  `SELECT min(block_num) AS lo, max(block_num) AS hi FROM logs WHERE address = '${feeManager}'` as string,
+              })
+              const row = result.rows[0]
+              return {
+                hi: row ? Value.toNumber(row['hi']) : undefined,
+                lo: row ? Value.toNumber(row['lo']) : undefined,
+              }
+            },
+            { key: `feeamm:v1:${chainId}:mints-bounds`, store, ttl: Ttl.minutes(1) },
+          )
+          return order === 'asc' ? bounds.lo : bounds.hi
+        })()
+
+        // Sweep the windows from the anchor: window rows are a prefix of the
+        // requested ordering, so a filled window returns exactly the rows the
+        // unbounded query would.
+        const result = await (async () => {
+          if (anchor !== undefined)
+            for (const window of mintWindowBlocks) {
+              // A window reaching past block 0 no longer bounds the scan.
+              if (order === 'desc' && window >= anchor) break
+              const bound =
+                order === 'asc'
+                  ? `block_num < ${anchor + window}`
+                  : `block_num > ${anchor - window}`
+              const result = await fetchPage([...filters, bound])
+              if (result.rows.length >= limit + 1) return result
+            }
+          return fetchPage(filters)
+        })()
 
         // The next page anchors below the last fetched row's `(block, log_idx)`.
         const page = Cursor.paginate({