tapimo 0.10.1 → 0.11.0

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/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/tokens.ts

@@ -1228,12 +1228,13 @@ export async function resolveTokens(
   const logos = new Map(logoByAddress)
   const metadataMap = new Map(metadataByAddress)
   const onchainLogos = new Map(
-    includeLogoUri
+    includeLogoUri && options.metadata !== undefined
       ? await Timing.time(c, 'token_logo_uri', () =>
           Promise.all(
             addresses
               .filter(
                 (address) =>
+                  options.metadata?.has(address) === true &&
                   !logos.get(address) &&
                   !snapshot?.byAddress.get(address)?.logoUri &&
                   !metadataMap.get(address)?.logoUri,
@@ -1321,7 +1322,7 @@ function getTokenLogoUri(c: Context<App.Environment>, options: getTokenMetadata.
 
 /**
  * Resolves a token's on-chain metadata (`name`/`symbol`/`decimals`/`currency`/
- * `totalSupply`) via a single `token.getMetadata` RPC, memoized under the shared
+ * `logoUri`/`totalSupply`) via a single `token.getMetadata` RPC, memoized under the shared
  * `token:v1:{chainId}:{address}:metadata` key. Exported so feed enrichers (e.g.
  * `activities`) reuse the same cache entry as the token resource rather than
  * fetching metadata through a parallel path.

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

@@ -30,6 +30,14 @@ QueryBench.bench({
   },
 })
 
+QueryBench.bench({
+  name: 'getTransactions?address&include=receipt',
+  path: {
+    4217: `/v1/transactions?address=${address[4217]}&include=receipt`,
+    42431: `/v1/transactions?address=${address[42431]}&include=receipt`,
+  },
+})
+
 QueryBench.bench({
   name: 'getTransaction',
   path: {

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

@@ -437,10 +437,10 @@ export function transfers(options: transfers.Options = {}) {
           transactionHash: row.transactionHash,
         }))
 
-        // Memo/attribution are opt-in: one `TransferWithMemo` lookup bounded
-        // to the page's transactions resolves both — the decoded text `memo`,
-        // and `attribution` when the memo is a known MPP service fingerprint.
-        if (options.include.includes('memo') && data.length > 0) {
+        const includeCrossToken = options.include.includes('crossToken')
+        const includeMemo = options.include.includes('memo')
+        // Attach memos before cross-token folding changes the matching fields.
+        if (includeMemo && includeCrossToken && data.length > 0) {
           const memoByRow = await memoMap(c, { chainId, rows: data })
           data = data.map((transfer) => {
             const entry = memoByRow.get(
@@ -469,7 +469,7 @@ export function transfers(options: transfers.Options = {}) {
         // own event token is the delivered token), so a `token=` filter matches
         // cross-token rows by their destination token, and each transfer still
         // appears exactly once across pages.
-        if (options.include.includes('crossToken') && data.length > 0) {
+        if (includeCrossToken && data.length > 0) {
           const { fold, suppress } = await crossTokenMap(c, { chainId, rows: data })
           data = data.flatMap((transfer) => {
             const key = eventKey(transfer.transactionHash, transfer.logIndex)
@@ -502,11 +502,17 @@ export function transfers(options: transfers.Options = {}) {
             ]),
           ),
         )
-        const tokensByAddress = new Map<
-          string,
-          Awaited<ReturnType<typeof Tokens.getTokenMetadata>>
-        >()
-        await Timing.time(c, 'tokens', async () => {
+        // Memo and token metadata depend only on the page rows, so resolve
+        // them concurrently when cross-token folding is not requested.
+        const memoPromise =
+          includeMemo && !includeCrossToken && data.length > 0
+            ? memoMap(c, { chainId, rows: data })
+            : undefined
+        const tokensPromise = Timing.time(c, 'tokens', async () => {
+          const tokensByAddress = new Map<
+            string,
+            Awaited<ReturnType<typeof Tokens.getTokenMetadata>>
+          >()
           for (let index = 0; index < uniqueTokens.length; index += tokenReadChunkSize) {
             const group = uniqueTokens.slice(index, index + tokenReadChunkSize)
             const entries = await Promise.all(
@@ -536,7 +542,27 @@ export function transfers(options: transfers.Options = {}) {
             )
             for (const entry of entries) tokensByAddress.set(...entry)
           }
+          return tokensByAddress
         })
+        const [memoByRow, tokensByAddress] = await Promise.all([memoPromise, tokensPromise])
+        if (memoByRow)
+          data = data.map((transfer) => {
+            const entry = memoByRow.get(
+              transferKey(
+                transfer.transactionHash,
+                transfer.sender,
+                transfer.recipient,
+                transfer.sourceToken.amount,
+                transfer.sourceToken.address,
+              ),
+            )
+            if (!entry) return transfer
+            return {
+              ...transfer,
+              ...(entry.attribution ? { attribution: entry.attribution } : {}),
+              ...(entry.memo ? { memo: entry.memo } : {}),
+            }
+          })
 
         // Value each leg via its curated display currency, in the requested
         // denomination.