perf(wotoken-yield,es-address-yield): prefetch day rates in one parallel batch

The per-day pass awaited getR (previewRedeem / accRewardPerShare) sequentially — one RPC
round-trip per transfer block and per day-end, the cold-run bottleneck. Now every block
that needs a rate (transfers + each day-end, via the new dayEndBlocks helper) is fetched
up front with a single Promise.all, which the RPC client coalesces into batched eth_calls.

Rates are stored in the existing in-memory rCache Map and read back from it, so this holds
one RPC per block per batch with or without the server RPC cache — it does not rely on
RPC caching to avoid duplicate calls. Output-preserving: the ES launch window reproduces
the exact same checksum (f3e9b04d…) as the pre-prefetch runs, zero errors.

Author: apexearth

src/templates/exponential-staking/es-address-yield.ts

@@ -1,7 +1,7 @@
 import * as abi from '@abi/exponential-staking'
 import { ESAddressYield } from '@model'
 import { Block, Context, EvmBatchProcessor, Processor, logFilter } from '@originprotocol/squid-utils'
-import { DayBoundaryCarry, forEachBlockByDay } from '@utils/for-each-block-by-day'
+import { DayBoundaryCarry, dayEndBlocks, forEachBlockByDay } from '@utils/for-each-block-by-day'
 
 // xOGN is a MasterChef-style accumulator: previewRewards(user) == balanceOf(user) *
 // (accRewardPerShare - rewardDebtPerShare(user)) / 1e12. So accRewardPerShare is scaled by 1e12 and a
@@ -146,6 +146,19 @@ export const createESAddressYieldProcessor = ({
         changedYieldRows.set(row.id, row)
       }
 
+      // Pre-warm the accRewardPerShare cache in one parallel batch (the RPC client coalesces these
+      // into batched eth_calls): every block that needs R — those with a stake/unstake, plus each
+      // day-end — is fetched concurrently so the sequential per-day pass below never blocks on a
+      // round-trip.
+      const rBlocks = new Map<number, Block>()
+      for (const block of ctx.blocks) {
+        if (block.logs.some((log) => stakeFilter.matches(log) || unstakeFilter.matches(log))) {
+          rBlocks.set(block.header.height, block)
+        }
+      }
+      for (const block of dayEndBlocks(ctx, dayCarry)) rBlocks.set(block.header.height, block)
+      await Promise.all([...rBlocks.values()].map((block) => getR(block).catch(() => undefined)))
+
       // Deterministic per-day accrual: stake/unstake checkpoint at exact event time; each day's pure
       // reward accrual is closed out once, at that day's true last block (`onDayEnd`), regardless of
       // how blocks are batched. At the chain head the current day is also swept for freshness.

src/templates/wotoken-yield/wotoken-yield.ts

@@ -2,7 +2,7 @@ import * as wotokenAbi from '@abi/woeth'
 import { WOTokenAddressYield } from '@model'
 import { Block, Context, EvmBatchProcessor, Processor, logFilter } from '@originprotocol/squid-utils'
 import { ADDRESS_ZERO } from '@utils/addresses'
-import { DayBoundaryCarry, forEachBlockByDay } from '@utils/for-each-block-by-day'
+import { DayBoundaryCarry, dayEndBlocks, forEachBlockByDay } from '@utils/for-each-block-by-day'
 
 const ONE = 10n ** 18n
 
@@ -174,6 +174,18 @@ export const createWOTokenYieldProcessor = ({
         changedYieldRows.set(row.id, row)
       }
 
+      // Pre-warm the rate cache in one parallel batch (the RPC client coalesces these into batched
+      // eth_calls): every block that needs R — those with a wrapped transfer, plus each day-end — is
+      // fetched concurrently so the sequential per-day pass below never blocks on a round-trip.
+      // Best-effort — a pre-init revert on the empty vault is ignored and simply skipped by onDayEnd's
+      // active-holder guard.
+      const rBlocks = new Map<number, Block>()
+      for (const block of ctx.blocks) {
+        if (block.logs.some((log) => transferFilter.matches(log))) rBlocks.set(block.header.height, block)
+      }
+      for (const block of dayEndBlocks(ctx, dayCarry)) rBlocks.set(block.header.height, block)
+      await Promise.all([...rBlocks.values()].map((block) => getR(block).catch(() => undefined)))
+
       // Deterministic per-day accrual: transfers checkpoint at exact event time; each day's pure
       // share-appreciation is closed out once, at that day's true last block (`onDayEnd`), regardless
       // of how blocks are batched. At the chain head the current day is also swept for freshness.

src/utils/for-each-block-by-day.ts

@@ -20,6 +20,23 @@ export interface DayBoundaryCarry {
  *
  * `carry` must persist across batches: declare it once at processor scope.
  */
+/**
+ * The blocks `forEachBlockByDay` will treat as day-ends this batch — pure, and does not mutate
+ * `carry`. Use it to pre-warm any per-block RPC (e.g. an on-chain rate read) for all day-ends in one
+ * parallel batch before the sequential per-day pass, so `onDayEnd` never blocks on a round-trip.
+ */
+export const dayEndBlocks = (ctx: Context, carry: DayBoundaryCarry): Block[] => {
+  const blocks = ctx.blocks
+  const ends: Block[] = []
+  for (let i = 0; i < blocks.length; i++) {
+    const prev = i === 0 ? carry.lastBlock : blocks[i - 1]
+    if (prev && utcDate(prev) !== utcDate(blocks[i])) ends.push(prev)
+  }
+  // At the chain head the current (incomplete) day is swept at the latest block for live freshness.
+  if (ctx.isHead && blocks.length > 0) ends.push(blocks[blocks.length - 1])
+  return ends
+}
+
 export const forEachBlockByDay = async (
   ctx: Context,
   carry: DayBoundaryCarry,
@@ -28,20 +45,22 @@ export const forEachBlockByDay = async (
     onDayEnd: (dayEndBlock: Block) => Promise<void>
   },
 ) => {
+  // Compute day-ends up front (shared with `dayEndBlocks` so prefetch and this loop never drift).
+  const endHeights = new Set(dayEndBlocks(ctx, carry).map((b) => b.header.height))
   const blocks = ctx.blocks
   for (let i = 0; i < blocks.length; i++) {
     const block = blocks[i]
     const prev = i === 0 ? carry.lastBlock : blocks[i - 1]
     // A new UTC day has started, so `prev` was the previous day's last block — finalize it there.
-    if (prev && utcDate(prev) !== utcDate(block)) {
+    if (prev && endHeights.has(prev.header.height) && utcDate(prev) !== utcDate(block)) {
       await handlers.onDayEnd(prev)
     }
     await handlers.onBlock(block)
   }
   if (blocks.length > 0) {
     const tail = blocks[blocks.length - 1]
+    // The head-tail day-end (current day, live freshness) has no following block to trigger it above.
+    if (endHeights.has(tail.header.height)) await handlers.onDayEnd(tail)
     carry.lastBlock = tail
-    // At the chain head the current day is incomplete; sweep the latest block for live freshness.
-    if (ctx.isHead) await handlers.onDayEnd(tail)
   }
 }