tapimo 0.15.1 → 0.18.1

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

@@ -2661,9 +2661,12 @@ export function exchanges(options: exchanges.Options = {}) {
         const chainId = options.chainId ?? c.get('chainId')
 
         try {
-          const pairs = await getPairIndex(c, { chainId })
-          const target = pairs.get(base)
-          if (!target) return pairNotFoundError(c, { base, pairIndex: pairs })
+          const target = await getPairByBase(c, { base, chainId })
+          if (!target)
+            return pairNotFoundError(c, {
+              base,
+              pairIndex: await getPairIndex(c, { chainId }),
+            })
 
           // Token metadata is opt-in: resolve both pair tokens once and spread
           // onto the `base`/`quote` PairToken slots.
@@ -3102,9 +3105,12 @@ export function exchanges(options: exchanges.Options = {}) {
           Cache.setPolicy(c, Cache.policies.state)
 
         try {
-          const pairs = await getPairIndex(c, { chainId })
-          const target = pairs.get(baseAddress)
-          if (!target) return pairNotFoundError(c, { base: baseAddress, pairIndex: pairs })
+          const target = await getPairByBase(c, { base: baseAddress, chainId })
+          if (!target)
+            return pairNotFoundError(c, {
+              base: baseAddress,
+              pairIndex: await getPairIndex(c, { chainId }),
+            })
 
           const result = await getPairOhlc(c, {
             chainId,
@@ -3208,17 +3214,7 @@ export function exchanges(options: exchanges.Options = {}) {
         const chainId = options.chainId ?? c.get('chainId')
 
         try {
-          // 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),
-            },
-          )
+          const target = await getPairByBase(c, { base: baseAddress, chainId })
           if (!target)
             return pairNotFoundError(c, {
               base: baseAddress,
@@ -3603,6 +3599,48 @@ declare namespace getPairsByBase {
   }
 }
 
+/**
+ * Resolves one pair by base address without depending on the bounded pair
+ * index. Successful immutable definitions are cached; misses stay fresh.
+ */
+async function getPairByBase(c: Context<App.Environment>, options: getPairByBase.Options) {
+  const { base, chainId } = options
+  const tidx = c.get('getTidx')(chainId)
+  return Timing.time(c, 'pair_lookup', () =>
+    Store.memoize(
+      async () => {
+        const result = await tidx.fetch({
+          chainId,
+          engine: 'clickhouse',
+          query: `
+            SELECT key, base, quote, tx_hash, block_num, block_timestamp
+            FROM dex_pairs
+            WHERE address = '${stablecoinDex}' AND base = '${base}'
+            ORDER BY block_num ASC, log_idx ASC
+            LIMIT 1
+          ` as string,
+        })
+        const row = result.rows[0]
+        return row ? parsePairRow(row) : undefined
+      },
+      {
+        key: `exchange:v1:${chainId}:pair-by-base:${base}:v2`,
+        store: c.get('store'),
+        ttl: Ttl.minutes(5),
+      },
+    ),
+  )
+}
+
+declare namespace getPairByBase {
+  type Options = {
+    /** Base token address identifying the pair. */
+    base: string
+    /** Chain whose pair table should be queried. */
+    chainId: z.output<typeof Schema.ChainId>
+  }
+}
+
 /**
  * Resolves one pair by its book key with a targeted `dex_pairs` lookup,
  * covering books the bounded pair index ages out of its newest window.
@@ -4846,11 +4884,9 @@ function parseTickSide(value: unknown): { isBid: boolean; tick: number } | undef
  * The candles are aggregated **in ClickHouse**: each bucket folds server-side
  * (open/close by fill position, high/low by executed rate, volume sums and
  * fill counts), so the response covers the entire requested window no matter
- * how many fills it contains — the previous implementation shipped the newest
- * raw fills to the app capped at 1,000, which truncated busy pairs' 7d/30d
- * windows to a few hours. The pair filter still resolves through the
- * OrderPlaced-only `dex_orders` table, so fills of flipped orders remain
- * invisible until order state lands at ingest (the `dex_ohlc_1m` plan).
+ * how many fills it contains. Each fill joins to its state-event history and
+ * selects the latest preceding `OrderPlaced`/`OrderFlipped` log because flip
+ * orders retain their id while changing side and tick.
  *
  * `OrderFilled` only carries the base-token `amountFilled`; the quote-side
  * amount is reconstructed per fill from the order's tick using the DEX's
@@ -4871,13 +4907,14 @@ async function getPairOhlc(c: Context<App.Environment>, options: getPairOhlc.Opt
     new Date(Date.now() - windowMs(window)).toISOString(),
   )
   const bucketMs = intervalMs(interval)
+  const pairTopic = `0x${pair.base.slice(2).padStart(64, '0')}`
 
   return Timing.time(c, 'pair_ohlc', async () => {
     // Taker-perspective rate used only to *select* the high/low fill; the
     // formatted rate string is recomputed in JS from the winning `(tick,
     // isBid)` so it goes through the exact same formatting as open/close.
     const scale = Tick.priceScale
-    const rate = `if(p."isBid" = 1, (${scale} + p.tick) / ${scale}, ${scale} / (${scale} + p.tick))`
+    const rate = `if(r.is_bid_int = 1, (${scale} + r.tick) / ${scale}, ${scale} / (${scale} + r.tick))`
     // UInt256 sums are forced through `toString` so values past 2^53 survive
     // JSON; the `(tick, isBid)` tuples are small integers and need no forcing.
     const result = await tidx.fetch({
@@ -4885,21 +4922,37 @@ async function getPairOhlc(c: Context<App.Environment>, options: getPairOhlc.Opt
       engine: 'clickhouse',
       query: `
         SELECT
-          intDiv(toUnixTimestamp64Milli(f.block_timestamp), ${bucketMs}) AS bucket,
+          intDiv(toUnixTimestamp64Milli(r.block_timestamp), ${bucketMs}) AS bucket,
           count() AS fill_count,
-          toString(sum(f."amountFilled")) AS base_volume,
-          toString(sum(intDiv(f."amountFilled" * toUInt256(${scale} + p.tick), ${scale}))) AS quote_volume,
-          argMin(tuple(p.tick, p."isBid"), tuple(f.block_num, f.log_idx)) AS open_t,
-          argMax(tuple(p.tick, p."isBid"), tuple(f.block_num, f.log_idx)) AS close_t,
-          argMax(tuple(p.tick, p."isBid"), ${rate}) AS high_t,
-          argMin(tuple(p.tick, p."isBid"), ${rate}) AS low_t
-        FROM dex_fills f
-        JOIN dex_orders p ON p."orderId" = f."orderId"
-        WHERE f.address = '${stablecoinDex}'
-          AND f.block_timestamp >= '${fromTimestamp}'
-          AND f."orderId" IN (
-            SELECT p2."orderId" FROM dex_orders p2 WHERE p2.token = '${pair.base}'
-          )
+          toString(sum(r.amount_filled)) AS base_volume,
+          toString(sum(intDiv(r.amount_filled * toUInt256(${scale} + r.tick), ${scale}))) AS quote_volume,
+          argMin(tuple(r.tick, r.is_bid_int), tuple(r.block_num, r.log_idx)) AS open_t,
+          argMax(tuple(r.tick, r.is_bid_int), tuple(r.block_num, r.log_idx)) AS close_t,
+          argMax(tuple(r.tick, r.is_bid_int), ${rate}) AS high_t,
+          argMin(tuple(r.tick, r.is_bid_int), ${rate}) AS low_t
+        FROM (
+          SELECT f.block_timestamp, f.block_num, f.log_idx,
+                 f."amountFilled" AS amount_filled,
+                 argMax(s.tick, (s.block_num, s.log_idx)) AS tick,
+                 argMax(s.is_bid_int, (s.block_num, s.log_idx)) AS is_bid_int
+          FROM dex_fills f
+          INNER JOIN (
+            SELECT
+              reinterpretAsUInt256(reverse(unhex(substring(topic1, 3)))) AS order_id,
+              reinterpretAsInt16(reverse(unhex(substring(data, 191, 4)))) AS tick,
+              data != '' AND substring(data, 130, 1) = '1' AS is_bid_int,
+              block_num,
+              log_idx
+            FROM logs
+            WHERE address = '${stablecoinDex}'
+              AND selector IN ('${orderPlacedTopic}', '${orderFlippedTopic}')
+              AND topic3 = '${pairTopic}'
+          ) AS s ON f."orderId" = s.order_id
+          WHERE f.address = '${stablecoinDex}'
+            AND f.block_timestamp >= '${fromTimestamp}'
+            AND (s.block_num < f.block_num OR (s.block_num = f.block_num AND s.log_idx < f.log_idx))
+          GROUP BY f.block_timestamp, f.block_num, f.log_idx, f."amountFilled"
+        ) AS r
         GROUP BY bucket
         ORDER BY bucket ASC
       ` as string,
@@ -5004,11 +5057,10 @@ const orderCursorTickBias = 32768
  * 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
- * with its pair: the scoped feed reuses the resolved `pair`, the unscoped
- * feed resolves the page's base tokens with one targeted `dex_pairs` lookup
- * (rows whose pair is unknown are dropped).
+ * `remaining` is the latest state event's amount minus subsequent fills;
+ * orders with an `OrderCancelled` event are excluded outright. Each row is
+ * annotated with its pair: the scoped feed reuses the resolved `pair`, the
+ * unscoped feed resolves the page's base tokens with one targeted lookup.
  */
 async function getOrders(c: Context<App.Environment>, options: getOrders.Options) {
   const { chainId, cursor, limit, maker, order, page, pair, side, sort } = options
@@ -5329,9 +5381,10 @@ type RestingOrder = {
 }
 
 /**
- * Loads every resting maker order for a pair: scan `OrderPlaced` filtered by
- * the pair's base token (and optional `maker`), then subtract fills and drop
- * cancelled orders using batched `WHERE "orderId" IN (...)` joins.
+ * Loads every resting maker order for a pair: scan state events filtered by
+ * the pair's base token (and optional `maker`), resolve each order's latest
+ * `OrderPlaced`/`OrderFlipped` generation, then subtract fills after that
+ * generation and drop cancelled orders.
  *
  * Returns the resting set along with a `truncated` flag set when the
  * `OrderPlaced` scan hit `orderScanCap`. Callers surface the flag so
@@ -5349,69 +5402,21 @@ async function loadRestingOrders(
   },
 ): Promise<{ orders: RestingOrder[]; truncated: boolean }> {
   const { base, chainId, maker, scanCap = orderScanCap } = options
-  const tidx = c.get('getTidx')(chainId)
-
-  // Scan window is intentionally newest-first so a `truncated` snapshot still
-  // reflects current market activity rather than ancient placements.
-  const filters = [`address = '${stablecoinDex}'`]
-  if (base !== undefined) filters.push(`token = '${base}'`)
-  if (maker !== undefined) filters.push(`maker = '${maker}'`)
-  const where = `WHERE ${filters.join(' AND ')}`
-
-  // ClickHouse OLAP path: bloom-filter index on `topic1` (and the `token`
-  // string column) handles `WHERE token = '<base>'` and the downstream
-  // `"orderId" IN (...)` joins natively, without the per-row decode cost of
-  // the Postgres `abi_uint(topic1)` fallback.
-  //
-  // `"isBid"` is aliased to a name that is *not* in the OrderPlaced event
-  // signature so tidx.ts's signature-driven result decoder skips it. ClickHouse
-  // serializes booleans as `1`/`0`, but tidx.ts validates `bool` columns with a
-  // strict `z.boolean()` derived from the signature and rejects integer
-  // representations. Aliasing dodges that decoder and lets us coerce
-  // numerically in `parsePlacedRow`.
-  const result = await tidx.fetch({
+  const snapshot = await fetchLatestOrderStates(c, { base, chainId, maker, scanCap })
+  if (snapshot.orders.length === 0) return snapshot
+  const cancelled = await fetchCancelledByIds(c, {
     chainId,
-    engine: 'clickhouse',
-    query: `
-      SELECT "orderId", maker, amount, token, "isBid" AS is_bid_int, tick, tx_hash, block_num, log_idx, block_timestamp
-      FROM dex_orders
-      ${where}
-      ORDER BY block_num DESC, log_idx DESC
-      LIMIT ${scanCap + 1}
-    ` as string,
+    orderIds: snapshot.orders.map((row) => row.orderId),
   })
 
-  const truncated = result.rows.length > scanCap
-  const placedRows = result.rows.slice(0, scanCap)
-  // `dex_orders` can carry duplicate rows per placement; keep the first
-  // (newest) copy so pages emit each order once and a duplicate straddling an
-  // IN-batch boundary can't double-count fills.
-  const placed: RestingOrder[] = []
-  const seen = new Set<string>()
-  for (const row of placedRows) {
-    const parsed = parsePlacedRow(row)
-    if (!parsed || seen.has(parsed.orderId)) continue
-    seen.add(parsed.orderId)
-    placed.push(parsed)
-  }
-  if (placed.length === 0) return { orders: [], truncated }
-
-  const orderIds = placed.map((row) => row.orderId)
-  const [cancelled, fillSums] = await Promise.all([
-    fetchCancelledByIds(c, { chainId, orderIds }),
-    fetchFillSumsByIds(c, { chainId, orderIds }),
-  ])
-
   const orders: RestingOrder[] = []
-  for (const row of placed) {
+  for (const row of snapshot.orders) {
     if (cancelled.has(row.orderId)) continue
-    const filled = fillSums.get(row.orderId) ?? 0n
-    const remaining = BigInt(row.amount) - filled
-    if (remaining <= 0n) continue
-    orders.push({ ...row, remaining: remaining.toString() })
+    if (BigInt(row.remaining) <= 0n) continue
+    orders.push(row)
   }
 
-  return { orders, truncated }
+  return { orders, truncated: snapshot.truncated }
 }
 
 /**
@@ -5594,6 +5599,208 @@ function parsePlacedRow(row: Record<string, unknown>): RestingOrder | undefined
   }
 }
 
+/**
+ * Resolves each scanned order's latest generation from raw state logs and
+ * subtracts only fills after that state event. A fully filled flip generation
+ * therefore resets to the counter-order amount emitted by `OrderFlipped`.
+ */
+async function fetchLatestOrderStates(
+  c: Context<App.Environment>,
+  options: fetchLatestOrderStates.Options,
+): Promise<{ orders: RestingOrder[]; truncated: boolean }> {
+  const { base, chainId, maker, scanCap } = options
+  const tidx = c.get('getTidx')(chainId)
+  let truncated = false
+  const filters = [
+    `address = '${stablecoinDex}'`,
+    `selector IN ('${orderPlacedTopic}', '${orderFlippedTopic}')`,
+  ]
+  if (base !== undefined) filters.push(`topic3 = '0x${base.slice(2).padStart(64, '0')}'`)
+  // Global candidates below already belong to the maker. Keeping topic2 in
+  // that lookup makes the indexer scan a sparse maker instead of indexed IDs.
+  if (base !== undefined && maker !== undefined)
+    filters.push(`topic2 = '0x${maker.slice(2).padStart(64, '0')}'`)
+  let batches = [filters]
+
+  // The global raw-log aggregate is unbounded on hosted TIDX. Bound it to the
+  // newest state events so old placements with recent flips remain candidates.
+  if (base === undefined) {
+    const candidateFilters = [
+      `address = '${stablecoinDex}'`,
+      `selector IN ('${orderPlacedTopic}', '${orderFlippedTopic}')`,
+    ]
+    const candidates = await tidx.fetch({
+      chainId,
+      engine: 'clickhouse',
+      query: `
+        SELECT topic1, topic2
+        FROM logs
+        WHERE ${candidateFilters.join(' AND ')}
+        ORDER BY block_num DESC, log_idx DESC
+        LIMIT ${scanCap + 1}
+      ` as string,
+    })
+    truncated = candidates.rows.length > scanCap
+    const topics = new Set<string>()
+    for (const row of candidates.rows.slice(0, scanCap)) {
+      if (maker !== undefined && row['topic2'] !== `0x${maker.slice(2).padStart(64, '0')}`) continue
+      const topic = Value.toText(row['topic1'])
+      if (topic !== undefined && /^0x[0-9a-fA-F]{64}$/.test(topic)) topics.add(topic)
+    }
+
+    // `logs.topic2` is not a viable hosted-TIDX scan for a sparse maker.
+    // Include its indexed placement window, then resolve current state below.
+    if (maker !== undefined) {
+      const placements = await tidx.fetch({
+        chainId,
+        engine: 'clickhouse',
+        query: `
+          SELECT "orderId"
+          FROM dex_orders
+          WHERE address = '${stablecoinDex}' AND maker = '${maker}'
+          ORDER BY block_num DESC, log_idx DESC
+          LIMIT ${scanCap + 1}
+        ` as string,
+      })
+      truncated ||= placements.rows.length > scanCap
+      for (const row of placements.rows.slice(0, scanCap)) {
+        const orderId = Value.toIntegerString(row['orderId'])
+        if (orderId !== undefined) topics.add(`0x${BigInt(orderId).toString(16).padStart(64, '0')}`)
+      }
+    }
+    if (topics.size === 0) return { orders: [], truncated }
+    // Compact hex avoids oversized GET URLs and TIDX's per-cell SQL scanning
+    // cost. Pad in ClickHouse; batching also bounds maximum-width IDs.
+    const ids = [...topics].map((topic) => `'${BigInt(topic).toString(16)}'`)
+    batches = []
+    for (let i = 0; i < ids.length; i += 512)
+      batches.push([
+        ...filters,
+        `topic1 IN (SELECT concat('0x', leftPad(arrayJoin([${ids.slice(i, i + 512).join(', ')}]), 64, '0')))`,
+      ])
+  }
+
+  const rows: Record<string, unknown>[] = []
+  for (const filters of batches) {
+    const result = await tidx.fetch({
+      chainId,
+      engine: 'clickhouse',
+      // Raw state fields have no signature-backed result schema; every field is validated below.
+      query: `
+      WITH states AS (
+        SELECT topic1,
+               argMax(topic2, (block_num, log_idx)) AS t2,
+               argMax(topic3, (block_num, log_idx)) AS t3,
+               argMax(data, (block_num, log_idx)) AS payload,
+               argMax(tx_hash, (block_num, log_idx)) AS state_tx_hash,
+               argMax(block_num, (block_num, log_idx)) AS state_block_num,
+               argMax(log_idx, (block_num, log_idx)) AS state_log_idx,
+               argMax(block_timestamp, (block_num, log_idx)) AS state_timestamp
+        FROM logs
+        WHERE ${filters.join(' AND ')}
+        GROUP BY topic1
+        ORDER BY state_block_num DESC, state_log_idx DESC
+        LIMIT ${scanCap + 1}
+      )
+      SELECT states.*,
+             toString(sumIf(f."amountFilled",
+               f.block_num > states.state_block_num OR
+               (f.block_num = states.state_block_num AND f.log_idx > states.state_log_idx)
+             )) AS amount_filled
+      FROM states
+      LEFT JOIN dex_fills f
+        ON f.address = '${stablecoinDex}'
+       AND f."orderId" = reinterpretAsUInt256(reverse(unhex(substring(states.topic1, 3))))
+      GROUP BY states.topic1, states.t2, states.t3, states.payload,
+               states.state_tx_hash, states.state_block_num, states.state_log_idx,
+               states.state_timestamp
+      ORDER BY states.state_block_num DESC, states.state_log_idx DESC
+    ` as string,
+    })
+    rows.push(...result.rows)
+  }
+  rows.sort(
+    (a, b) =>
+      Number(b['state_block_num']) - Number(a['state_block_num']) ||
+      Number(b['state_log_idx']) - Number(a['state_log_idx']),
+  )
+  truncated ||= rows.length > scanCap
+  const orders: RestingOrder[] = []
+  for (const row of rows.slice(0, scanCap)) {
+    const state = parseLatestOrderStateRow(row)
+    if (state) orders.push(state)
+  }
+  return { orders, truncated }
+}
+
+declare namespace fetchLatestOrderStates {
+  /** Inputs for resolving current resting-order generations. */
+  type Options = {
+    /** Restrict to one pair's base token; omit for the global feed. */
+    base?: z.output<typeof Schema.TokenAddress> | undefined
+    chainId: z.output<typeof Schema.ChainId>
+    /** Restrict to one maker. */
+    maker?: z.output<typeof Schema.Address> | undefined
+    /** Maximum number of current state rows to return. */
+    scanCap: number
+  }
+}
+
+/** Decodes one latest-state aggregate into a resting-order snapshot row. */
+function parseLatestOrderStateRow(row: Record<string, unknown>): RestingOrder | undefined {
+  const topic1 = Value.toText(row['topic1'])
+  const topic2 = Value.toText(row['t2'])
+  const topic3 = Value.toText(row['t3'])
+  const payload = Value.toText(row['payload'])
+  const filled = Value.toIntegerString(row['amount_filled'])
+  const blockNumber = Value.toNumber(row['state_block_num'])
+  const logIndex = Value.toNumber(row['state_log_idx'])
+  const timestamp = Value.toIsoDateTime(row['state_timestamp'])
+  const transactionHash = Schema.Hash.safeParse(row['state_tx_hash'])
+  const maker = Schema.Address.safeParse(
+    topic2 === undefined ? undefined : `0x${topic2.slice(26).toLowerCase()}`,
+  )
+  const token = Schema.TokenAddress.safeParse(
+    topic3 === undefined ? undefined : `0x${topic3.slice(26).toLowerCase()}`,
+  )
+  if (
+    topic1 === undefined ||
+    !/^0x[0-9a-fA-F]{64}$/.test(topic1) ||
+    topic2 === undefined ||
+    !/^0x[0-9a-fA-F]{64}$/.test(topic2) ||
+    topic3 === undefined ||
+    !/^0x[0-9a-fA-F]{64}$/.test(topic3) ||
+    payload === undefined ||
+    payload.length < 2 + 64 * 3 ||
+    filled === undefined ||
+    blockNumber === undefined ||
+    logIndex === undefined ||
+    timestamp === undefined ||
+    !transactionHash.success ||
+    !maker.success ||
+    !token.success
+  )
+    return undefined
+
+  const amount = BigInt(`0x${payload.slice(2, 66)}`)
+  const tickWord = BigInt(`0x${payload.slice(130, 194)}`)
+  const tick = Number(tickWord >= 2n ** 255n ? tickWord - 2n ** 256n : tickWord)
+  const remaining = amount - BigInt(filled)
+  return {
+    amount: amount.toString(),
+    blockNumber,
+    isBid: BigInt(`0x${payload.slice(66, 130)}`) !== 0n,
+    logIndex,
+    maker: maker.data,
+    orderId: BigInt(topic1).toString(),
+    remaining: remaining.toString(),
+    tick,
+    timestamp,
+    token: token.data,
+    transactionHash: transactionHash.data,
+  }
+}
+
 /**
  * Resolves the set of cancelled `orderId`s in the snapshot window via batched
  * `OrderCancelled WHERE "orderId" IN (...)` queries. Empty input short-circuits

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

@@ -1,11 +1,17 @@
 /** @module-tag localnet */
 
 import { Schema } from 'tapimo/server'
-import { Abis, Addresses } from 'viem/tempo'
+import { Hex } from 'ox'
+import { readContract, sendTransactionSync } from 'viem/actions'
+import { Abis, Actions, Addresses } from 'viem/tempo'
+import * as z from 'zod/mini'
 
 import * as TestApp from '../../../../test/App.js'
 import * as Runtime from '../../../../test/runtime.js'
+import * as Tempo from '../../../../test/Tempo.js'
 import * as TestViem from '../../../../test/Viem.js'
+import type * as Log from '../../../internal/Log.js'
+import * as Tidx from '../../../internal/Tidx.js'
 import * as FeeAmm from './fee-amm.js'
 
 type JsonSchema = {
@@ -30,8 +36,9 @@ type OpenApiDocument = {
 }
 
 /** Validator-side token with live fee-AMM activity on Tempo Moderato. */
+const runtime = Runtime.get()
 const validatorToken =
-  Runtime.get().mode === 'localnet'
+  runtime.mode === 'localnet'
     ? Addresses.pathUsd.toLowerCase()
     : '0x20c0000000000000000000000000000000000001'
 
@@ -236,6 +243,131 @@ describe('OpenAPI', () => {
   })
 })
 
+describe('feeTokenSet', () => {
+  test.runIf(runtime.mode === 'localnet')(
+    'ignores a liquid pool against an unpreferred validator token',
+    async () => {
+      const db = TestApp.database()
+      await TestApp.verifiedSeed(db, runtime.chainId)
+      const account = Tempo.accounts[3]!
+      const client = Tempo.getClient({ account })
+      await Actions.faucet.fundSync(client, { account, timeout: 60_000 })
+      const validators = await readContract(client, {
+        abi: Abis.validatorConfig,
+        address: Addresses.validator,
+        functionName: 'getValidators',
+      })
+      const preferred = await Promise.all(
+        validators
+          .filter((validator) => validator.active)
+          .map((validator) =>
+            readContract(client, {
+              abi: Abis.feeManager,
+              address: Addresses.feeManager,
+              args: [validator.validatorAddress],
+              functionName: 'validatorTokens',
+            }),
+          ),
+      )
+      const readFeeTokens = async () => {
+        const application = TestApp.create({ auth: false, db })
+        application.get('/test/fee-tokens', async (c) =>
+          c.json({ data: Array.from(await FeeAmm.feeTokenSet(c, runtime.chainId)) }),
+        )
+        const response = await application.request('/test/fee-tokens')
+        expect(response.status, await response.clone().text()).toBe(200)
+        return z.object({ data: z.array(Schema.Address) }).parse(await response.json()).data
+      }
+      const initial = await readFeeTokens()
+      const available = (
+        [
+          '0x20c0000000000000000000000000000000000001',
+          '0x20c0000000000000000000000000000000000002',
+          '0x20c0000000000000000000000000000000000003',
+        ] as const
+      ).filter(
+        (address) =>
+          !initial.includes(address) &&
+          !preferred.some((token) => token.toLowerCase() === address.toLowerCase()),
+      )
+      const [userToken, validatorToken] = available
+      if (!userToken || !validatorToken) throw new Error('Need two unpreferred faucet tokens.')
+      const receipt = await sendTransactionSync(client, {
+        account,
+        calls: [
+          Actions.token.approve.call({
+            amount: 100_000n,
+            spender: Addresses.feeManager,
+            token: validatorToken,
+          }),
+          Actions.amm.mint.call({
+            to: account.address,
+            userTokenAddress: userToken,
+            validatorTokenAddress: validatorToken,
+            validatorTokenAmount: 100_000n,
+          }),
+        ],
+      })
+      await waitForTransaction({ hash: receipt.transactionHash })
+
+      expect(await readFeeTokens()).not.toContain(userToken)
+    },
+  )
+
+  test('records an operational failure when eligibility degrades', async () => {
+    const db = TestApp.database()
+    const entries: Log.Entry[] = []
+    await TestApp.verifiedSeed(db, runtime.chainId)
+    const application = TestApp.create({
+      auth: false,
+      db,
+      logger: (entry) => {
+        entries.push(entry)
+      },
+      rpc: { url: () => 'http://127.0.0.1:1' },
+    })
+    application.get('/test/fee-tokens', async (c) => {
+      const data = await FeeAmm.feeTokenSet(c, runtime.chainId).catch(() => undefined)
+      return c.json({ data })
+    })
+
+    const response = await application.request('/test/fee-tokens')
+
+    expect(response.status).toBe(200)
+    expect(entries.at(-1)?.providerFailures).toContainEqual({
+      chainId: runtime.chainId,
+      failure: 'unknown',
+      id: 'rpc',
+      operation: 'feeTokenSet',
+    })
+  })
+})
+
+async function waitForTransaction(options: waitForTransaction.Options) {
+  const tidx = Tidx.getClient({
+    chainId: runtime.chainId,
+    tidx: { baseUrl: runtime.tidxUrl },
+  })
+  await vi.waitFor(
+    async () => {
+      const result = await tidx.fetch({
+        chainId: runtime.chainId,
+        query: `SELECT hash FROM txs WHERE hash = '${options.hash.toLowerCase()}'` as string,
+      })
+      expect(result.rows).toHaveLength(1)
+    },
+    { interval: 500, timeout: 120_000 },
+  )
+}
+
+declare namespace waitForTransaction {
+  /** Inputs for waiting until TIDX observes a transaction. */
+  type Options = {
+    /** Transaction hash to observe. */
+    hash: Hex.Hex
+  }
+}
+
 // Skipped: the pools listing runs a ClickHouse `GROUP BY` over every FeeManager
 // `Mint` log, which exceeds the live indexer's 5s execution cap on high-volume
 // chains (testnet) and returns `502`. Re-enable once the aggregate fits the