fix(store-indexer): reorg gate clears once at boundary, not every replayed block

greptile P1 on mud#9: the reorg fix used Math.max for highWaterBlock, so after a
reorg regressed the block once, EVERY subsequent replayed block stayed below the
frozen peak and re-cleared lastStateById — wiping prior-state accumulated during
the replay, so a training-return-to-IDLE on an already-revealed taru looked like
a first write → false mint once caught up. Track the PREVIOUS block (lastBlock)
instead: regression triggers the clear exactly once at the boundary, then blocks
climb forward without re-clearing. Added a cross-replayed-block test.

tested: 10/10 projector tests (incl. across-replay prior-state) + tsc + eslint clean

Author: Cooops

packages/store-indexer/src/postgres/notificationEventProjector.test.ts

@@ -109,6 +109,20 @@ describe("extractNotifEvents — MINT", () => {
     const ev = extractNotifEvents([statusLog(1n, IDLE)], c, 98);
     expect(ev).toEqual([{ type: "mint", recipient_wallet: OWNER_A, taruchi_id: "1" }]);
   });
+
+  it("preserves prior-state ACROSS replayed blocks — the gate clears once at the boundary, not every block", () => {
+    const c = emptyCaches();
+    extractNotifEvents([coreLog(1n, OWNER_A, 10)], c, 100); // learn owner, lastBlock=100
+    // reorg boundary: block regresses to 98. Reveal re-lands here (first write
+    // since the gate cleared) → mint re-fires. This is the boundary block.
+    expect(extractNotifEvents([statusLog(1n, IDLE)], c, 98)).toEqual([
+      { type: "mint", recipient_wallet: OWNER_A, taruchi_id: "1" },
+    ]);
+    // Next replayed block (99 > 98) climbs forward — must NOT re-clear the gate.
+    // A training-return-to-IDLE on the already-revealed taru must stay silent.
+    // (With the old Math.max bug, 99 < highWater(100) re-cleared → false mint.)
+    expect(extractNotifEvents([statusLog(1n, IDLE)], c, 99)).toEqual([]);
+  });
 });
 
 describe("extractNotifEvents — DUEL (resolves via TourneyResult, not a status splice)", () => {

packages/store-indexer/src/postgres/notificationEventProjector.ts

@@ -96,11 +96,13 @@ export type NotifCaches = {
   duelPlayersById: Map<string, [number, number]>;
   playersById: Map<string, bigint>;
   bracketById: Map<string, number>;
-  /** Highest block processed — used to detect a reorg replay (block regresses).
-   *  The indexer recovers from ReorgError in-process (no restart), so caches
-   *  persist; without this, lastStateById would silence a legit re-revealed
-   *  mint after a reorg. -1 = nothing processed yet. */
-  highWaterBlock: number;
+  /** The previous block processed — used to detect a reorg replay (block
+   *  regresses below it exactly once, at the boundary). NOT a high-water max:
+   *  tracking the last block means subsequent replayed blocks climb forward and
+   *  don't re-trigger the gate clear. The indexer recovers from ReorgError
+   *  in-process (no restart), so caches persist; without this, lastStateById
+   *  would silence a legit re-revealed mint after a reorg. -1 = none yet. */
+  lastBlock: number;
 };
 
 export function emptyCaches(): NotifCaches {
@@ -111,7 +113,7 @@ export function emptyCaches(): NotifCaches {
     duelPlayersById: new Map(),
     playersById: new Map(),
     bracketById: new Map(),
-    highWaterBlock: -1,
+    lastBlock: -1,
   };
 }
 
@@ -132,17 +134,18 @@ export function extractNotifEvents(
   blockNumber: number,
 ): NotifEvent[] {
   // 0) Reorg detection. The indexer recovers from ReorgError in-process and
-  //    re-processes from the common ancestor, so blockNumber regresses. Clear
-  //    the mint-seen gate so a reveal in the replayed range can re-fire — the
-  //    notification_events dedup (same block) absorbs a same-block replay, and
-  //    a genuinely re-mined reveal re-notifying once beats permanent silence.
-  //    Owner/enroll caches are learned facts (taught before the boundary) — keep
-  //    them so replayed resolves can still resolve recipients.
-  if (blockNumber < caches.highWaterBlock) {
-    log.info("reorg replay detected — clearing mint-seen gate", { blockNumber, from: caches.highWaterBlock });
+  //    re-processes from the common ancestor, so blockNumber regresses ONCE at
+  //    the boundary, then climbs again. Clear the mint-seen gate exactly at that
+  //    boundary so a reveal in the replayed range can re-fire — but track the
+  //    PREVIOUS block (not a high-water max), or every replayed block would stay
+  //    below the peak and re-clear the gate on each one, wiping prior-state
+  //    accumulated during the replay (→ false mints once caught up). Owner/enroll
+  //    caches are learned facts (taught before the boundary) — kept either way.
+  if (blockNumber < caches.lastBlock) {
+    log.info("reorg replay detected — clearing mint-seen gate", { blockNumber, from: caches.lastBlock });
     caches.lastStateById.clear();
   }
-  caches.highWaterBlock = Math.max(caches.highWaterBlock, blockNumber);
+  caches.lastBlock = blockNumber;
 
   // 1) Learn owners (TaruchiCore is written at mint/reroll, before any resolve).
   for (const rec of setRecordsFor(logs, TARUCHI_CORE_TABLE_ID)) {