From 8e5a10c7d09efeb2091b29896b7453d6986ca2c8 Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Mon, 1 Jun 2026 15:47:37 -0300
Subject: [PATCH 01/84] =?UTF-8?q?fix:=20minor=20cleanups=20=E2=80=94=20MAX?=
 =?UTF-8?q?=5FTWAP=5FPRECOMPUTE=5FPARTS=20constant,=20decoder=20ABI=20dedu?=
 =?UTF-8?q?p=20(COW-1004)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Lift magic literal 100000 to MAX_TWAP_PRECOMPUTE_PARTS in constants.ts; import
  it in uidPrecompute.ts so the threshold is documented and grep-able
- Export *_ABI constants from all decoder source files; update tests/decoders/decoders.test.ts
  to import them instead of duplicating inline ABI fragments
- Fix "mainnet and gnosis" hardcode in docs/architecture.md to say "all active chains"

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 docs/architecture.md                     |  2 +-
 src/application/helpers/uidPrecompute.ts |  3 +-
 src/constants.ts                         |  8 +++
 src/decoders/circles-backing-order.ts    |  2 +-
 src/decoders/good-after-time.ts          |  2 +-
 src/decoders/perpetual-swap.ts           |  2 +-
 src/decoders/stop-loss.ts                |  2 +-
 src/decoders/swap-order-handler.ts       |  2 +-
 src/decoders/trade-above-threshold.ts    |  2 +-
 src/decoders/twap.ts                     |  2 +-
 tests/decoders/decoders.test.ts          | 81 ++++--------------------
 11 files changed, 32 insertions(+), 76 deletions(-)

diff --git a/docs/architecture.md b/docs/architecture.md
index d11b3ed..0ec42b5 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -226,7 +226,7 @@ See [api-reference.md](./api-reference.md) for the full endpoint list.
 5. Add the RPC URL to `.env.local`.
 6. Run `pnpm codegen` to regenerate types.
 
-The block handlers (C1–C5) already run on both mainnet and gnosis. Adding a new chain requires adding entries to each block handler's `chain` config in `ponder.config.ts`.
+The block handlers (C1–C5) run on all active chains (see `ponder.config.ts` for the current list). Adding a new chain requires adding entries to each block handler's `chain` config there.
 
 ## Known Limitations
 
diff --git a/src/application/helpers/uidPrecompute.ts b/src/application/helpers/uidPrecompute.ts
index 80ca37e..372be70 100644
--- a/src/application/helpers/uidPrecompute.ts
+++ b/src/application/helpers/uidPrecompute.ts
@@ -21,6 +21,7 @@ import { candidateDiscreteOrder, conditionalOrderGenerator, discreteOrder } from
 import { computeOrderUid, type GPv2OrderData } from "./orderUid";
 import { fetchOrderStatusByUids } from "./orderbookClient";
 import { isDeterministicOrderType } from "../../utils/order-types";
+import { MAX_TWAP_PRECOMPUTE_PARTS } from "../../constants";
 
 // GPv2Order.sol constant hashes
 const KIND_SELL = "0xf3b277728b3fee749481eb3e0b3b48980dbbab78658fc419025cb16eee346775" as Hex;
@@ -235,7 +236,7 @@ function precomputeTwapUids(
     console.warn(`[COW:PRECOMPUTE] SKIP type=TWAP owner=${owner} chain=${chainId} reason=invalid_math nParts=${nParts} tSeconds=${tSeconds}`);
     return null;
   }
-  if (nParts > 100000) {
+  if (nParts > MAX_TWAP_PRECOMPUTE_PARTS) {
     console.warn(`[COW:PRECOMPUTE] SKIP type=TWAP owner=${owner} chain=${chainId} reason=too_many_parts nParts=${nParts}`);
     return null;
   }
diff --git a/src/constants.ts b/src/constants.ts
index b427256..4d90739 100644
--- a/src/constants.ts
+++ b/src/constants.ts
@@ -78,3 +78,11 @@ export const BLOCK_HANDLER_RPC_TIMEOUT_MS = 15_000;
  * the normal C1 / C2 path picks them up on subsequent blocks.
  */
 export const BOOTSTRAP_OWNER_FETCH_TIMEOUT_MS = 30_000;
+
+/**
+ * Maximum number of TWAP parts that precomputeOrderUids will attempt to enumerate.
+ * Pathological orders with n > this value skip precompute and fall back to the C1
+ * ContractPoller discovery path (allCandidatesKnown=false). Logged as
+ * [COW:PRECOMPUTE] SKIP reason=too_many_parts when triggered.
+ */
+export const MAX_TWAP_PRECOMPUTE_PARTS = 100_000;
diff --git a/src/decoders/circles-backing-order.ts b/src/decoders/circles-backing-order.ts
index e214675..a63684a 100644
--- a/src/decoders/circles-backing-order.ts
+++ b/src/decoders/circles-backing-order.ts
@@ -7,7 +7,7 @@ export interface CirclesBackingOrderDecodedParams {
   appData: string;     // bytes32
 }
 
-const CIRCLES_BACKING_ORDER_ABI = [
+export const CIRCLES_BACKING_ORDER_ABI = [
   {
     type: "tuple",
     components: [
diff --git a/src/decoders/good-after-time.ts b/src/decoders/good-after-time.ts
index 59e81f7..b690ebf 100644
--- a/src/decoders/good-after-time.ts
+++ b/src/decoders/good-after-time.ts
@@ -13,7 +13,7 @@ export interface GoodAfterTimeDecodedParams {
   appData: string;
 }
 
-const GOOD_AFTER_TIME_ABI = [
+export const GOOD_AFTER_TIME_ABI = [
   {
     type: "tuple",
     components: [
diff --git a/src/decoders/perpetual-swap.ts b/src/decoders/perpetual-swap.ts
index 25d919b..599e2d3 100644
--- a/src/decoders/perpetual-swap.ts
+++ b/src/decoders/perpetual-swap.ts
@@ -8,7 +8,7 @@ export interface PerpetualSwapDecodedParams {
   appData: string;
 }
 
-const PERPETUAL_SWAP_ABI = [
+export const PERPETUAL_SWAP_ABI = [
   {
     type: "tuple",
     components: [
diff --git a/src/decoders/stop-loss.ts b/src/decoders/stop-loss.ts
index 253ae4d..4b93fed 100644
--- a/src/decoders/stop-loss.ts
+++ b/src/decoders/stop-loss.ts
@@ -16,7 +16,7 @@ export interface StopLossDecodedParams {
   maxTimeSinceLastOracleUpdate: bigint;
 }
 
-const STOP_LOSS_ABI = [
+export const STOP_LOSS_ABI = [
   {
     type: "tuple",
     components: [
diff --git a/src/decoders/swap-order-handler.ts b/src/decoders/swap-order-handler.ts
index 8db23f7..aa79149 100644
--- a/src/decoders/swap-order-handler.ts
+++ b/src/decoders/swap-order-handler.ts
@@ -14,7 +14,7 @@ export interface SwapOrderHandlerDecodedParams {
   appData: string;         // bytes32
 }
 
-const SWAP_ORDER_HANDLER_ABI = [
+export const SWAP_ORDER_HANDLER_ABI = [
   {
     type: "tuple",
     components: [
diff --git a/src/decoders/trade-above-threshold.ts b/src/decoders/trade-above-threshold.ts
index 2309f08..85588e0 100644
--- a/src/decoders/trade-above-threshold.ts
+++ b/src/decoders/trade-above-threshold.ts
@@ -9,7 +9,7 @@ export interface TradeAboveThresholdDecodedParams {
   appData: string;
 }
 
-const TRADE_ABOVE_THRESHOLD_ABI = [
+export const TRADE_ABOVE_THRESHOLD_ABI = [
   {
     type: "tuple",
     components: [
diff --git a/src/decoders/twap.ts b/src/decoders/twap.ts
index 55d15db..8434102 100644
--- a/src/decoders/twap.ts
+++ b/src/decoders/twap.ts
@@ -13,7 +13,7 @@ export interface TwapDecodedParams {
   appData: string;  // bytes32
 }
 
-const TWAP_ABI = [
+export const TWAP_ABI = [
   {
     type: "tuple",
     components: [
diff --git a/tests/decoders/decoders.test.ts b/tests/decoders/decoders.test.ts
index c5e6690..940d918 100644
--- a/tests/decoders/decoders.test.ts
+++ b/tests/decoders/decoders.test.ts
@@ -11,6 +11,13 @@ import {
   decodeErc4626CowSwapFeeBurnerStaticInput,
   decodeStaticInput,
 } from "../../src/decoders/index";
+import { TWAP_ABI } from "../../src/decoders/twap";
+import { STOP_LOSS_ABI } from "../../src/decoders/stop-loss";
+import { PERPETUAL_SWAP_ABI } from "../../src/decoders/perpetual-swap";
+import { GOOD_AFTER_TIME_ABI } from "../../src/decoders/good-after-time";
+import { TRADE_ABOVE_THRESHOLD_ABI } from "../../src/decoders/trade-above-threshold";
+import { CIRCLES_BACKING_ORDER_ABI } from "../../src/decoders/circles-backing-order";
+import { SWAP_ORDER_HANDLER_ABI } from "../../src/decoders/swap-order-handler";
 
 const ADDR_A = "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" as const;
 const ADDR_B = "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" as const;
@@ -20,18 +27,7 @@ const APP_DATA = ("0x" + "ab".repeat(32)) as `0x${string}`;
 describe("decodeTwapStaticInput", () => {
   it("round-trips all fields", () => {
     const encoded = encodeAbiParameters(
-      [{ type: "tuple", components: [
-        { name: "sellToken",      type: "address" },
-        { name: "buyToken",       type: "address" },
-        { name: "receiver",       type: "address" },
-        { name: "partSellAmount", type: "uint256" },
-        { name: "minPartLimit",   type: "uint256" },
-        { name: "t0",             type: "uint256" },
-        { name: "n",              type: "uint256" },
-        { name: "t",              type: "uint256" },
-        { name: "span",           type: "uint256" },
-        { name: "appData",        type: "bytes32" },
-      ]}],
+      TWAP_ABI,
       [{ sellToken: ADDR_A, buyToken: ADDR_B, receiver: ADDR_C,
          partSellAmount: 1000n, minPartLimit: 900n, t0: 1700000000n,
          n: 6n, t: 3600n, span: 0n, appData: APP_DATA }]
@@ -53,21 +49,7 @@ describe("decodeTwapStaticInput", () => {
 describe("decodeStopLossStaticInput", () => {
   it("round-trips all fields including signed strike", () => {
     const encoded = encodeAbiParameters(
-      [{ type: "tuple", components: [
-        { name: "sellToken",                    type: "address" },
-        { name: "buyToken",                     type: "address" },
-        { name: "sellAmount",                   type: "uint256" },
-        { name: "buyAmount",                    type: "uint256" },
-        { name: "appData",                      type: "bytes32" },
-        { name: "receiver",                     type: "address" },
-        { name: "isSellOrder",                  type: "bool"    },
-        { name: "isPartiallyFillable",          type: "bool"    },
-        { name: "validTo",                      type: "uint32"  },
-        { name: "sellTokenPriceOracle",         type: "address" },
-        { name: "buyTokenPriceOracle",          type: "address" },
-        { name: "strike",                       type: "int256"  },
-        { name: "maxTimeSinceLastOracleUpdate", type: "uint256" },
-      ]}],
+      STOP_LOSS_ABI,
       [{ sellToken: ADDR_A, buyToken: ADDR_B, sellAmount: 500n, buyAmount: 400n,
          appData: APP_DATA, receiver: ADDR_C, isSellOrder: true,
          isPartiallyFillable: false, validTo: 86400, sellTokenPriceOracle: ADDR_A,
@@ -86,13 +68,7 @@ describe("decodeStopLossStaticInput", () => {
 describe("decodePerpetualSwapStaticInput", () => {
   it("round-trips all fields", () => {
     const encoded = encodeAbiParameters(
-      [{ type: "tuple", components: [
-        { name: "tokenA",                type: "address" },
-        { name: "tokenB",                type: "address" },
-        { name: "validityBucketSeconds", type: "uint32"  },
-        { name: "halfSpreadBps",         type: "uint256" },
-        { name: "appData",               type: "bytes32" },
-      ]}],
+      PERPETUAL_SWAP_ABI,
       [{ tokenA: ADDR_A, tokenB: ADDR_B, validityBucketSeconds: 900,
          halfSpreadBps: 5n, appData: APP_DATA }]
     );
@@ -108,18 +84,7 @@ describe("decodeGoodAfterTimeStaticInput", () => {
   it("round-trips including dynamic bytes field", () => {
     const payload = "0xdeadbeef" as `0x${string}`;
     const encoded = encodeAbiParameters(
-      [{ type: "tuple", components: [
-        { name: "sellToken",           type: "address" },
-        { name: "buyToken",            type: "address" },
-        { name: "receiver",            type: "address" },
-        { name: "sellAmount",          type: "uint256" },
-        { name: "minSellBalance",      type: "uint256" },
-        { name: "startTime",           type: "uint256" },
-        { name: "endTime",             type: "uint256" },
-        { name: "allowPartialFill",    type: "bool"    },
-        { name: "priceCheckerPayload", type: "bytes"   },
-        { name: "appData",             type: "bytes32" },
-      ]}],
+      GOOD_AFTER_TIME_ABI,
       [{ sellToken: ADDR_A, buyToken: ADDR_B, receiver: ADDR_C,
          sellAmount: 200n, minSellBalance: 50n,
          startTime: 1700000000n, endTime: 1700086400n,
@@ -137,14 +102,7 @@ describe("decodeGoodAfterTimeStaticInput", () => {
 describe("decodeTradeAboveThresholdStaticInput", () => {
   it("round-trips all fields", () => {
     const encoded = encodeAbiParameters(
-      [{ type: "tuple", components: [
-        { name: "sellToken",             type: "address" },
-        { name: "buyToken",              type: "address" },
-        { name: "receiver",              type: "address" },
-        { name: "validityBucketSeconds", type: "uint32"  },
-        { name: "threshold",             type: "uint256" },
-        { name: "appData",               type: "bytes32" },
-      ]}],
+      TRADE_ABOVE_THRESHOLD_ABI,
       [{ sellToken: ADDR_A, buyToken: ADDR_B, receiver: ADDR_C,
          validityBucketSeconds: 1800, threshold: 1000000n,
          appData: APP_DATA }]
@@ -159,12 +117,7 @@ describe("decodeTradeAboveThresholdStaticInput", () => {
 describe("decodeCirclesBackingOrderStaticInput", () => {
   it("round-trips all four fields", () => {
     const encoded = encodeAbiParameters(
-      [{ type: "tuple", components: [
-        { name: "buyToken",  type: "address" },
-        { name: "buyAmount", type: "uint256" },
-        { name: "validTo",   type: "uint32"  },
-        { name: "appData",   type: "bytes32" },
-      ]}],
+      CIRCLES_BACKING_ORDER_ABI,
       [{ buyToken: ADDR_A, buyAmount: 12345n, validTo: 1800000000, appData: APP_DATA }],
     );
     const result = decodeCirclesBackingOrderStaticInput(encoded);
@@ -182,13 +135,7 @@ describe("decodeCirclesBackingOrderStaticInput", () => {
 describe("decodeSwapOrderHandlerStaticInput", () => {
   it("round-trips all five fields", () => {
     const encoded = encodeAbiParameters(
-      [{ type: "tuple", components: [
-        { name: "sellToken",      type: "address" },
-        { name: "buyToken",       type: "address" },
-        { name: "receiver",       type: "address" },
-        { name: "validityPeriod", type: "uint32"  },
-        { name: "appData",        type: "bytes32" },
-      ]}],
+      SWAP_ORDER_HANDLER_ABI,
       [{ sellToken: ADDR_A, buyToken: ADDR_B, receiver: ADDR_C,
          validityPeriod: 86400, appData: APP_DATA }],
     );

From 9552081c6d32f549f2e794488069a562e4acd6d9 Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Mon, 1 Jun 2026 16:44:05 -0300
Subject: [PATCH 02/84] fix: C3 StatusUpdater batch upsert and per-block cap
 (COW-988)

Replace N sequential per-order update() calls with a single multi-row
upsert, matching the C2 pattern. Add MAX_DISCRETE_ORDERS_PER_BLOCK cap
(default 200, env-var override per chainId) to bound /by_uids batch size
and keep block handler transactions short.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 src/application/handlers/blockHandler.ts | 83 +++++++++++++++++-------
 src/constants.ts                         | 10 +++
 2 files changed, 68 insertions(+), 25 deletions(-)

diff --git a/src/application/handlers/blockHandler.ts b/src/application/handlers/blockHandler.ts
index 817453c..59fd969 100644
--- a/src/application/handlers/blockHandler.ts
+++ b/src/application/handlers/blockHandler.ts
@@ -25,6 +25,7 @@ import {
 import {
   BLOCK_HANDLER_RPC_TIMEOUT_MS,
   BOOTSTRAP_OWNER_FETCH_TIMEOUT_MS,
+  DEFAULT_MAX_DISCRETE_ORDERS_PER_BLOCK,
   DEFAULT_MAX_GENERATORS_PER_BLOCK,
   DETERMINISTIC_CANCEL_SWEEP_INTERVAL,
   RECHECK_INTERVAL,
@@ -561,9 +562,20 @@ ponder.on("StatusUpdater:block", async ({ event, context }) => {
   const chainId = context.chain.id as SupportedChainId;
   const currentTimestamp = event.block.timestamp;
 
+  const maxOrdersPerBlock =
+    Number(process.env[`MAX_DISCRETE_ORDERS_PER_BLOCK_${chainId}`]) ||
+    DEFAULT_MAX_DISCRETE_ORDERS_PER_BLOCK;
+
   const openOrders = await context.db.sql
     .select({
       orderUid: discreteOrder.orderUid,
+      conditionalOrderGeneratorId: discreteOrder.conditionalOrderGeneratorId,
+      sellAmount: discreteOrder.sellAmount,
+      buyAmount: discreteOrder.buyAmount,
+      feeAmount: discreteOrder.feeAmount,
+      validTo: discreteOrder.validTo,
+      creationDate: discreteOrder.creationDate,
+      promotedAt: discreteOrder.promotedAt,
     })
     .from(discreteOrder)
     .where(
@@ -571,39 +583,60 @@ ponder.on("StatusUpdater:block", async ({ event, context }) => {
         eq(discreteOrder.chainId, chainId),
         eq(discreteOrder.status, "open"),
       ),
-    ) as { orderUid: string }[];
+    )
+    .limit(maxOrdersPerBlock) as {
+    orderUid: string;
+    conditionalOrderGeneratorId: string;
+    sellAmount: string;
+    buyAmount: string;
+    feeAmount: string;
+    validTo: number | null;
+    creationDate: bigint;
+    promotedAt: bigint | null;
+  }[];
 
   if (openOrders.length > 0) {
     const uids = openOrders.map((o) => o.orderUid);
     const statuses = await fetchOrderStatusByUids(context, chainId, uids);
 
-    let updated = 0;
-    for (const [uid, info] of statuses) {
-      if (VALID_DISCRETE_STATUSES.has(info.status)) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const setFields: Record<string, any> = {
-          status: info.status as "fulfilled" | "unfilled" | "expired" | "cancelled",
-        };
-        if (info.executedSellAmount != null) {
-          setFields.executedSellAmount = info.executedSellAmount;
-          setFields.executedBuyAmount = info.executedBuyAmount;
-        }
-        await context.db.sql
-          .update(discreteOrder)
-          .set(setFields)
-          .where(
-            and(
-              eq(discreteOrder.chainId, chainId),
-              eq(discreteOrder.orderUid, uid),
-            ),
-          );
-        updated++;
-      }
+    type DiscreteStatus = "open" | "fulfilled" | "unfilled" | "expired" | "cancelled";
+    const rowsToUpdate: (typeof discreteOrder.$inferInsert)[] = [];
+
+    for (const order of openOrders) {
+      const info = statuses.get(order.orderUid);
+      if (!info || !VALID_DISCRETE_STATUSES.has(info.status)) continue;
+      rowsToUpdate.push({
+        orderUid: order.orderUid,
+        chainId,
+        conditionalOrderGeneratorId: order.conditionalOrderGeneratorId,
+        status: info.status as DiscreteStatus,
+        sellAmount: order.sellAmount,
+        buyAmount: order.buyAmount,
+        feeAmount: order.feeAmount,
+        validTo: order.validTo,
+        creationDate: order.creationDate,
+        executedSellAmount: info.executedSellAmount ?? null,
+        executedBuyAmount: info.executedBuyAmount ?? null,
+        promotedAt: order.promotedAt,
+      });
     }
 
-    if (updated > 0) {
+    // One multi-row upsert keeps the block TX open for one round-trip instead of N.
+    if (rowsToUpdate.length > 0) {
+      await context.db.sql
+        .insert(discreteOrder)
+        .values(rowsToUpdate)
+        .onConflictDoUpdate({
+          target: [discreteOrder.chainId, discreteOrder.orderUid],
+          set: {
+            status: sql`excluded.status`,
+            executedSellAmount: sql`excluded.executed_sell_amount`,
+            executedBuyAmount: sql`excluded.executed_buy_amount`,
+          },
+        });
+
       console.log(
-        `[COW:C3] block=${event.block.number} chain=${chainId} open=${openOrders.length} updated=${updated}`,
+        `[COW:C3] block=${event.block.number} chain=${chainId} open=${openOrders.length} updated=${rowsToUpdate.length}`,
       );
     }
   }
diff --git a/src/constants.ts b/src/constants.ts
index b427256..ee65a14 100644
--- a/src/constants.ts
+++ b/src/constants.ts
@@ -78,3 +78,13 @@ export const BLOCK_HANDLER_RPC_TIMEOUT_MS = 15_000;
  * the normal C1 / C2 path picks them up on subsequent blocks.
  */
 export const BOOTSTRAP_OWNER_FETCH_TIMEOUT_MS = 30_000;
+
+/**
+ * COW-988: Hard per-block ceiling on how many open discrete orders the C3
+ * StatusUpdater will check in a single block. Caps the /by_uids batch size
+ * and keeps block handler transactions short.
+ *
+ * Override per chain with env var MAX_DISCRETE_ORDERS_PER_BLOCK_<chainId>, e.g.
+ * MAX_DISCRETE_ORDERS_PER_BLOCK_1=200, MAX_DISCRETE_ORDERS_PER_BLOCK_100=500.
+ */
+export const DEFAULT_MAX_DISCRETE_ORDERS_PER_BLOCK = 200;

From 7970029014182d45e8a2cf9fc37fb2f5aec3b2a3 Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Mon, 1 Jun 2026 18:19:07 -0300
Subject: [PATCH 03/84] docs: complete COW-1004 doc updates (chain wording,
 TWAP skip note, GAT on-chain caveat)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Replace "mainnet and Gnosis Chain" with "all active chains" in architecture.md overview
  and supported-order-types.md header (consistent with line 229 already fixed)
- Add TWAP edge-case note: n > MAX_TWAP_PRECOMPUTE_PARTS skips precompute → C1 fallback
- Add GoodAfterTime caveat: decoder is unit-tested but no real on-chain order observed yet

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 docs/architecture.md          | 2 +-
 docs/supported-order-types.md | 4 +++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/docs/architecture.md b/docs/architecture.md
index 0ec42b5..17f434f 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -4,7 +4,7 @@ This document covers how the indexer works, from on-chain events to the GraphQL
 
 ## Overview
 
-The system is a Ponder 0.16.x indexer that watches the ComposableCoW contract on Ethereum mainnet and Gnosis Chain. When a user creates a programmatic order (TWAP, Stop Loss, etc.), the contract emits a `ConditionalOrderCreated` event. The indexer picks that up, decodes the order parameters, resolves the actual owner (which may be behind a proxy), and writes the result to Postgres. A Hono HTTP server exposes the data through GraphQL and a SQL passthrough endpoint.
+The system is a Ponder 0.16.x indexer that watches the ComposableCoW contract on all active chains (see `ponder.config.ts`). When a user creates a programmatic order (TWAP, Stop Loss, etc.), the contract emits a `ConditionalOrderCreated` event. The indexer picks that up, decodes the order parameters, resolves the actual owner (which may be behind a proxy), and writes the result to Postgres. A Hono HTTP server exposes the data through GraphQL and a SQL passthrough endpoint.
 
 Ponder registers nine top-level handlers: four contract event handlers (`ComposableCow` backfill, `ComposableCowLive`, `CoWShedFactory`, `GPv2Settlement`) plus five live-only block handlers in `blockHandler.ts` (C1–C5). The contract handlers react to on-chain events; C1–C5 poll contract state and the orderbook API during live sync. `settlement.ts` inspects `Settlement` receipts to detect Aave adapters from Trade logs.
 
diff --git a/docs/supported-order-types.md b/docs/supported-order-types.md
index c04aa03..d64a4ed 100644
--- a/docs/supported-order-types.md
+++ b/docs/supported-order-types.md
@@ -2,7 +2,7 @@
 
 The indexer decodes five programmatic order types from the ComposableCoW contract. Each order is created on-chain as a `ConditionalOrderCreated` event containing a handler address, a salt, and an opaque `staticInput` blob. The handler address determines the order type, and the `staticInput` is ABI-decoded into typed parameters stored in the `decodedParams` JSON field on `conditional_order_generator`.
 
-All handler addresses are identical across mainnet and Gnosis Chain (CREATE2 deployments). Arbitrum support is planned but handler mappings are not yet registered.
+Most handler addresses are identical across all active chains (CREATE2 deployments — see `src/utils/order-types.ts` for chain-specific overrides). Arbitrum support is planned but handler mappings are not yet registered.
 
 A note on types in the API: all `bigint` values (uint256, int256) are converted to strings via `replaceBigInts(decoded, String)` before storage. When you query `decodedParams` through GraphQL or SQL, amounts, timestamps, and similar fields come back as decimal strings, not numbers. `uint32` fields stay as JSON numbers. See [Timestamp fields](./api-reference.md#timestamp-fields) for the unit and shape policy that applies to every timestamp-like field below.
 
@@ -60,6 +60,7 @@ TWAP generates `n` discrete orders, one per time slice. Each part covers `[t0 +
 - When `t0` is 0, the contract uses the block timestamp of the creation transaction as the start time. The `decodedParams` will still show `"0"` -- the actual resolved start time is not stored.
 - If a part's validity window passes without execution, that part is simply skipped. There is no retry or rollover.
 - Setting `span` shorter than `t` creates gaps where no part is active. Setting `span` longer than `t` creates overlapping validity windows.
+- TWAP orders with `n` exceeding `MAX_TWAP_PRECOMPUTE_PARTS` (100 000) skip UID pre-computation and fall back to the C1 ContractPoller discovery path (`allCandidatesKnown=false`). This is logged as `[COW:PRECOMPUTE] SKIP reason=too_many_parts`. Such pathological orders are valid on-chain but are impractical in practice.
 
 ---
 
@@ -210,6 +211,7 @@ GAT produces a single discrete order that is valid within the `[startTime, endTi
 - `priceCheckerPayload` is a `bytes` field (dynamic length). The decoder stores it as raw hex. Interpreting its contents requires knowledge of which price checker contract the order was configured with, which is not part of the struct itself.
 - If `startTime` is in the past at creation time, the order is immediately eligible (assuming the balance check passes).
 - If the owner's balance of `sellToken` drops below `minSellBalance` after the order becomes active, the handler will revert until the balance is restored.
+- **Note:** As of the last update, no GoodAfterTime orders have been observed on-chain (live count = 0). The decoder has been unit-tested with synthetic inputs but has not been validated against a real on-chain order. If a GAT order appears in production, verify the decoded output against the raw `staticInput` as a sanity check.
 
 ---
 

From 268ffcd600c2cc2f58e743e9b8daa5131eff7553 Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Mon, 1 Jun 2026 18:44:00 -0300
Subject: [PATCH 04/84] test: add constants and C3 status-filter tests
 (COW-988)

Adds tests for DEFAULT_MAX_DISCRETE_ORDERS_PER_BLOCK (200) and all other
constants in src/constants.ts; also adds a pure-logic test for the
VALID_DISCRETE_STATUSES filter used by the C3 StatusUpdater batch upsert.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 tests/constants.test.ts            | 135 ++++++++++++++++++++
 tests/helpers/statusFilter.test.ts | 197 +++++++++++++++++++++++++++++
 2 files changed, 332 insertions(+)
 create mode 100644 tests/constants.test.ts
 create mode 100644 tests/helpers/statusFilter.test.ts

diff --git a/tests/constants.test.ts b/tests/constants.test.ts
new file mode 100644
index 0000000..1a778d9
--- /dev/null
+++ b/tests/constants.test.ts
@@ -0,0 +1,135 @@
+import { describe, it, expect } from "vitest";
+import {
+  SIGNING_SCHEME_EIP1271,
+  RECHECK_INTERVAL,
+  TRY_NEXT_BLOCK_WARMUP_THRESHOLD,
+  TRY_NEXT_BLOCK_COOLDOWN_THRESHOLD,
+  TRY_NEXT_BLOCK_BACKOFF_WARMUP,
+  TRY_NEXT_BLOCK_BACKOFF_MID,
+  TRY_NEXT_BLOCK_BACKOFF_COLD,
+  DETERMINISTIC_CANCEL_SWEEP_INTERVAL,
+  ORDERBOOK_HTTP_TIMEOUT_MS,
+  BLOCK_HANDLER_RPC_TIMEOUT_MS,
+  BOOTSTRAP_OWNER_FETCH_TIMEOUT_MS,
+  DEFAULT_MAX_GENERATORS_PER_BLOCK,
+  DEFAULT_MAX_DISCRETE_ORDERS_PER_BLOCK,
+} from "../src/constants";
+
+describe("DEFAULT_MAX_DISCRETE_ORDERS_PER_BLOCK (COW-988)", () => {
+  it("is 200", () => {
+    expect(DEFAULT_MAX_DISCRETE_ORDERS_PER_BLOCK).toBe(200);
+  });
+
+  it("is a positive integer", () => {
+    expect(Number.isInteger(DEFAULT_MAX_DISCRETE_ORDERS_PER_BLOCK)).toBe(true);
+    expect(DEFAULT_MAX_DISCRETE_ORDERS_PER_BLOCK).toBeGreaterThan(0);
+  });
+});
+
+describe("DEFAULT_MAX_GENERATORS_PER_BLOCK", () => {
+  it("is 200", () => {
+    expect(DEFAULT_MAX_GENERATORS_PER_BLOCK).toBe(200);
+  });
+});
+
+describe("SIGNING_SCHEME_EIP1271", () => {
+  it('is the string "eip1271"', () => {
+    expect(SIGNING_SCHEME_EIP1271).toBe("eip1271");
+  });
+
+  it('is not "erc1271" — the API uses eip1271 spelling', () => {
+    expect(SIGNING_SCHEME_EIP1271).not.toBe("erc1271");
+  });
+});
+
+describe("RECHECK_INTERVAL", () => {
+  it("is a bigint", () => {
+    expect(typeof RECHECK_INTERVAL).toBe("bigint");
+  });
+
+  it("equals BigInt(ORDERBOOK_POLL_INTERVAL) which is 20", () => {
+    // ORDERBOOK_POLL_INTERVAL = 20 (from data.ts)
+    expect(RECHECK_INTERVAL).toBe(20n);
+  });
+});
+
+describe("TryNextBlock backoff thresholds", () => {
+  it("WARMUP_THRESHOLD is 50", () => {
+    expect(TRY_NEXT_BLOCK_WARMUP_THRESHOLD).toBe(50);
+  });
+
+  it("COOLDOWN_THRESHOLD is 200", () => {
+    expect(TRY_NEXT_BLOCK_COOLDOWN_THRESHOLD).toBe(200);
+  });
+
+  it("WARMUP < COOLDOWN — thresholds are ordered correctly", () => {
+    expect(TRY_NEXT_BLOCK_WARMUP_THRESHOLD).toBeLessThan(
+      TRY_NEXT_BLOCK_COOLDOWN_THRESHOLD,
+    );
+  });
+});
+
+describe("TryNextBlock backoff block offsets", () => {
+  it("WARMUP backoff is 1 block", () => {
+    expect(TRY_NEXT_BLOCK_BACKOFF_WARMUP).toBe(1n);
+  });
+
+  it("MID backoff is 10 blocks", () => {
+    expect(TRY_NEXT_BLOCK_BACKOFF_MID).toBe(10n);
+  });
+
+  it("COLD backoff is 50 blocks", () => {
+    expect(TRY_NEXT_BLOCK_BACKOFF_COLD).toBe(50n);
+  });
+
+  it("backoff levels are strictly increasing", () => {
+    expect(TRY_NEXT_BLOCK_BACKOFF_WARMUP).toBeLessThan(
+      TRY_NEXT_BLOCK_BACKOFF_MID,
+    );
+    expect(TRY_NEXT_BLOCK_BACKOFF_MID).toBeLessThan(
+      TRY_NEXT_BLOCK_BACKOFF_COLD,
+    );
+  });
+
+  it("all backoff values are bigints", () => {
+    expect(typeof TRY_NEXT_BLOCK_BACKOFF_WARMUP).toBe("bigint");
+    expect(typeof TRY_NEXT_BLOCK_BACKOFF_MID).toBe("bigint");
+    expect(typeof TRY_NEXT_BLOCK_BACKOFF_COLD).toBe("bigint");
+  });
+});
+
+describe("DETERMINISTIC_CANCEL_SWEEP_INTERVAL", () => {
+  it("is 100n", () => {
+    expect(DETERMINISTIC_CANCEL_SWEEP_INTERVAL).toBe(100n);
+  });
+
+  it("is a bigint", () => {
+    expect(typeof DETERMINISTIC_CANCEL_SWEEP_INTERVAL).toBe("bigint");
+  });
+});
+
+describe("Timeout constants", () => {
+  it("ORDERBOOK_HTTP_TIMEOUT_MS is 10_000", () => {
+    expect(ORDERBOOK_HTTP_TIMEOUT_MS).toBe(10_000);
+  });
+
+  it("BLOCK_HANDLER_RPC_TIMEOUT_MS is 15_000", () => {
+    expect(BLOCK_HANDLER_RPC_TIMEOUT_MS).toBe(15_000);
+  });
+
+  it("BOOTSTRAP_OWNER_FETCH_TIMEOUT_MS is 30_000", () => {
+    expect(BOOTSTRAP_OWNER_FETCH_TIMEOUT_MS).toBe(30_000);
+  });
+
+  it("RPC timeout is shorter than bootstrap timeout — boot has more slack", () => {
+    expect(BLOCK_HANDLER_RPC_TIMEOUT_MS).toBeLessThan(
+      BOOTSTRAP_OWNER_FETCH_TIMEOUT_MS,
+    );
+  });
+
+  it("HTTP timeout is shorter than RPC timeout", () => {
+    expect(ORDERBOOK_HTTP_TIMEOUT_MS).toBeLessThan(
+      BLOCK_HANDLER_RPC_TIMEOUT_MS,
+    );
+  });
+});
diff --git a/tests/helpers/statusFilter.test.ts b/tests/helpers/statusFilter.test.ts
new file mode 100644
index 0000000..5d461bb
--- /dev/null
+++ b/tests/helpers/statusFilter.test.ts
@@ -0,0 +1,197 @@
+/**
+ * Tests for the C3 StatusUpdater row-building filter logic (COW-988).
+ *
+ * blockHandler.ts defines a module-level constant:
+ *   const VALID_DISCRETE_STATUSES = new Set(["fulfilled", "unfilled", "expired", "cancelled"]);
+ *
+ * The row loop skips any order whose API status is absent from this set.
+ * Because blockHandler.ts imports `ponder:registry` it cannot be imported in
+ * tests, so we reconstruct both the set and the filtering logic here and
+ * verify their behaviour directly.
+ */
+import { describe, it, expect } from "vitest";
+
+// ── Reconstruction of VALID_DISCRETE_STATUSES ────────────────────────────────
+// Keep this in sync with the definition in src/application/handlers/blockHandler.ts.
+const VALID_DISCRETE_STATUSES = new Set([
+  "fulfilled",
+  "unfilled",
+  "expired",
+  "cancelled",
+]);
+
+type DiscreteStatus = "open" | "fulfilled" | "unfilled" | "expired" | "cancelled";
+
+interface OpenOrder {
+  orderUid: string;
+  conditionalOrderGeneratorId: string;
+  sellAmount: string;
+  buyAmount: string;
+  feeAmount: string;
+  validTo: number | null;
+  creationDate: bigint;
+  promotedAt: bigint | null;
+}
+
+interface StatusInfo {
+  status: string;
+  executedSellAmount: string | null;
+  executedBuyAmount: string | null;
+}
+
+/**
+ * Pure re-implementation of the row-building logic from C3 StatusUpdater.
+ * Returns the list of rows that would be passed to the multi-row upsert.
+ */
+function buildRowsToUpdate(
+  openOrders: OpenOrder[],
+  statuses: Map<string, StatusInfo>,
+  chainId: number,
+): Array<{ orderUid: string; status: DiscreteStatus }> {
+  const rows: Array<{ orderUid: string; status: DiscreteStatus }> = [];
+  for (const order of openOrders) {
+    const info = statuses.get(order.orderUid);
+    if (!info || !VALID_DISCRETE_STATUSES.has(info.status)) continue;
+    rows.push({
+      orderUid: order.orderUid,
+      status: info.status as DiscreteStatus,
+    });
+  }
+  return rows;
+}
+
+// ── Fixtures ─────────────────────────────────────────────────────────────────
+
+function makeOrder(uid: string): OpenOrder {
+  return {
+    orderUid: uid,
+    conditionalOrderGeneratorId: "gen-1",
+    sellAmount: "1000",
+    buyAmount: "900",
+    feeAmount: "10",
+    validTo: 1800000000,
+    creationDate: 1700000000n,
+    promotedAt: 1700000001n,
+  };
+}
+
+// ── VALID_DISCRETE_STATUSES membership ───────────────────────────────────────
+
+describe("VALID_DISCRETE_STATUSES membership", () => {
+  it('includes "fulfilled"', () => {
+    expect(VALID_DISCRETE_STATUSES.has("fulfilled")).toBe(true);
+  });
+
+  it('includes "expired"', () => {
+    expect(VALID_DISCRETE_STATUSES.has("expired")).toBe(true);
+  });
+
+  it('includes "cancelled"', () => {
+    expect(VALID_DISCRETE_STATUSES.has("cancelled")).toBe(true);
+  });
+
+  it('includes "unfilled"', () => {
+    expect(VALID_DISCRETE_STATUSES.has("unfilled")).toBe(true);
+  });
+
+  it('does NOT include "open" — open orders are not valid update targets', () => {
+    expect(VALID_DISCRETE_STATUSES.has("open")).toBe(false);
+  });
+
+  it("contains exactly four statuses", () => {
+    expect(VALID_DISCRETE_STATUSES.size).toBe(4);
+  });
+});
+
+// ── Row-building filter logic ─────────────────────────────────────────────────
+
+describe("C3 StatusUpdater row-building filter", () => {
+  const CHAIN_ID = 1;
+
+  it('includes an order whose API status is "fulfilled"', () => {
+    const orders = [makeOrder("uid-fulfilled")];
+    const statuses = new Map<string, StatusInfo>([
+      ["uid-fulfilled", { status: "fulfilled", executedSellAmount: "999", executedBuyAmount: "888" }],
+    ]);
+    const rows = buildRowsToUpdate(orders, statuses, CHAIN_ID);
+    expect(rows).toHaveLength(1);
+    expect(rows[0]?.status).toBe("fulfilled");
+    expect(rows[0]?.orderUid).toBe("uid-fulfilled");
+  });
+
+  it('includes an order whose API status is "expired"', () => {
+    const orders = [makeOrder("uid-expired")];
+    const statuses = new Map<string, StatusInfo>([
+      ["uid-expired", { status: "expired", executedSellAmount: null, executedBuyAmount: null }],
+    ]);
+    const rows = buildRowsToUpdate(orders, statuses, CHAIN_ID);
+    expect(rows).toHaveLength(1);
+    expect(rows[0]?.status).toBe("expired");
+  });
+
+  it('includes an order whose API status is "cancelled"', () => {
+    const orders = [makeOrder("uid-cancelled")];
+    const statuses = new Map<string, StatusInfo>([
+      ["uid-cancelled", { status: "cancelled", executedSellAmount: null, executedBuyAmount: null }],
+    ]);
+    const rows = buildRowsToUpdate(orders, statuses, CHAIN_ID);
+    expect(rows).toHaveLength(1);
+    expect(rows[0]?.status).toBe("cancelled");
+  });
+
+  it('includes an order whose API status is "unfilled"', () => {
+    const orders = [makeOrder("uid-unfilled")];
+    const statuses = new Map<string, StatusInfo>([
+      ["uid-unfilled", { status: "unfilled", executedSellAmount: null, executedBuyAmount: null }],
+    ]);
+    const rows = buildRowsToUpdate(orders, statuses, CHAIN_ID);
+    expect(rows).toHaveLength(1);
+    expect(rows[0]?.status).toBe("unfilled");
+  });
+
+  it('excludes an order whose API status is "open" — open is not a terminal status', () => {
+    const orders = [makeOrder("uid-open")];
+    const statuses = new Map<string, StatusInfo>([
+      ["uid-open", { status: "open", executedSellAmount: null, executedBuyAmount: null }],
+    ]);
+    const rows = buildRowsToUpdate(orders, statuses, CHAIN_ID);
+    expect(rows).toHaveLength(0);
+  });
+
+  it("excludes an order with no matching entry in the status map", () => {
+    const orders = [makeOrder("uid-missing")];
+    const statuses = new Map<string, StatusInfo>(); // empty — nothing returned from API
+    const rows = buildRowsToUpdate(orders, statuses, CHAIN_ID);
+    expect(rows).toHaveLength(0);
+  });
+
+  it("only includes orders with valid statuses from a mixed batch", () => {
+    const orders = [
+      makeOrder("uid-a"),  // fulfilled → include
+      makeOrder("uid-b"),  // open      → exclude
+      makeOrder("uid-c"),  // expired   → include
+      makeOrder("uid-d"),  // absent    → exclude
+      makeOrder("uid-e"),  // cancelled → include
+    ];
+    const statuses = new Map<string, StatusInfo>([
+      ["uid-a", { status: "fulfilled", executedSellAmount: "100", executedBuyAmount: "90" }],
+      ["uid-b", { status: "open",      executedSellAmount: null, executedBuyAmount: null }],
+      ["uid-c", { status: "expired",   executedSellAmount: null, executedBuyAmount: null }],
+      // uid-d intentionally absent
+      ["uid-e", { status: "cancelled", executedSellAmount: null, executedBuyAmount: null }],
+    ]);
+    const rows = buildRowsToUpdate(orders, statuses, CHAIN_ID);
+    const uids = rows.map((r) => r.orderUid);
+    expect(uids).toContain("uid-a");
+    expect(uids).toContain("uid-c");
+    expect(uids).toContain("uid-e");
+    expect(uids).not.toContain("uid-b");
+    expect(uids).not.toContain("uid-d");
+    expect(rows).toHaveLength(3);
+  });
+
+  it("returns an empty array when the orders list is empty", () => {
+    const rows = buildRowsToUpdate([], new Map(), CHAIN_ID);
+    expect(rows).toHaveLength(0);
+  });
+});

From 5e6f1d913885c688041040622852c261c7e3df5c Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Mon, 1 Jun 2026 19:17:15 -0300
Subject: [PATCH 05/84] fix: remove composableCow. prefix from block interval
 names (Ponder dot-namespace conflict)

Ponder 0.16.x treats dots in block interval names as namespace separators,
causing ponder.on('composableCow.OrderDiscoveryPoller:block') to fail validation
because it tries to resolve 'composableCow' as a contract name.

Renamed all five intervals to their bare semantic names (no prefix):
  OrderDiscoveryPoller, CandidateConfirmer, OrderStatusTracker,
  OwnerBackfill, CancellationWatcher.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 ponder.config.ts                         | 20 ++++++++++----------
 src/application/handlers/blockHandler.ts | 10 +++++-----
 2 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/ponder.config.ts b/ponder.config.ts
index 7c3db7c..7af5ba4 100644
--- a/ponder.config.ts
+++ b/ponder.config.ts
@@ -42,46 +42,46 @@ export default createConfig({
     },
   },
   blocks: {
-    // composableCow.OrderDiscoveryPoller — RPC multicall for non-deterministic generators.
+    // OrderDiscoveryPoller — RPC multicall for non-deterministic generators.
     // Gnosis interval=4 (~20s) vs mainnet interval=1 (~12s).
     // The CoW watch-tower processes orders sequentially — with 1,461+ gnosis
     // generators, a full cycle takes many blocks. Polling every 5s gnosis block
     // wastes RPC calls since state rarely changes between blocks.
-    "composableCow.OrderDiscoveryPoller": {
+    "OrderDiscoveryPoller": {
       chain: {
         mainnet: { startBlock: "latest" },
         gnosis: { startBlock: "latest", interval: 4 },
       },
       interval: 1,
     },
-    // composableCow.CandidateConfirmer — checks API for unconfirmed candidates.
-    "composableCow.CandidateConfirmer": {
+    // CandidateConfirmer — checks API for unconfirmed candidates.
+    "CandidateConfirmer": {
       chain: {
         mainnet: { startBlock: "latest" },
         gnosis: { startBlock: "latest" },
       },
       interval: 1,
     },
-    // composableCow.OrderStatusTracker — polls API for open discrete order status.
-    "composableCow.OrderStatusTracker": {
+    // OrderStatusTracker — polls API for open discrete order status.
+    "OrderStatusTracker": {
       chain: {
         mainnet: { startBlock: "latest" },
         gnosis: { startBlock: "latest" },
       },
       interval: 1,
     },
-    // composableCow.OwnerBackfill — one-time owner fetch for non-deterministic backfill orders.
-    "composableCow.OwnerBackfill": {
+    // OwnerBackfill — one-time owner fetch for non-deterministic backfill orders.
+    "OwnerBackfill": {
       chain: {
         mainnet: { startBlock: "latest", endBlock: "latest" },
         gnosis: { startBlock: "latest", endBlock: "latest" },
       },
       interval: 1,
     },
-    // composableCow.CancellationWatcher — singleOrders() mapping read for deterministic
+    // CancellationWatcher — singleOrders() mapping read for deterministic
     // generators (allCandidatesKnown=true). Cadence per generator is
     // DETERMINISTIC_CANCEL_SWEEP_INTERVAL blocks; the handler itself is cheap when nothing is due.
-    "composableCow.CancellationWatcher": {
+    "CancellationWatcher": {
       chain: {
         mainnet: { startBlock: "latest" },
         gnosis: { startBlock: "latest" },
diff --git a/src/application/handlers/blockHandler.ts b/src/application/handlers/blockHandler.ts
index 4ab94b4..b9c63de 100644
--- a/src/application/handlers/blockHandler.ts
+++ b/src/application/handlers/blockHandler.ts
@@ -70,7 +70,7 @@ const SINGLE_ORDERS_ABI = [
 // allCandidatesKnown=false. Normally only non-deterministic types, but also
 // serves as fallback for deterministic types whose precompute failed.
 
-ponder.on("composableCow.OrderDiscoveryPoller:block", async ({ event, context }) => {
+ponder.on("OrderDiscoveryPoller:block", async ({ event, context }) => {
   if (process.env.DISABLE_POLL_RESULT_CHECK) return;
 
   const chainId = context.chain.id as SupportedChainId;
@@ -296,7 +296,7 @@ ponder.on("composableCow.OrderDiscoveryPoller:block", async ({ event, context })
 // Checks if candidate discrete orders exist on the Orderbook API.
 // When confirmed, promotes them to discreteOrder.
 
-ponder.on("composableCow.CandidateConfirmer:block", async ({ event, context }) => {
+ponder.on("CandidateConfirmer:block", async ({ event, context }) => {
   const chainId = context.chain.id as SupportedChainId;
 
   // Parent-cancelled cascade: candidates whose parent generator flipped to
@@ -565,7 +565,7 @@ ponder.on("composableCow.CandidateConfirmer:block", async ({ event, context }) =
 // ─── composableCow.OrderStatusTracker ────────────────────────────────────────
 // Polls the API for status updates on open discrete orders. Expires past validTo.
 
-ponder.on("composableCow.OrderStatusTracker:block", async ({ event, context }) => {
+ponder.on("OrderStatusTracker:block", async ({ event, context }) => {
   const chainId = context.chain.id as SupportedChainId;
   const currentTimestamp = event.block.timestamp;
 
@@ -664,7 +664,7 @@ ponder.on("composableCow.OrderStatusTracker:block", async ({ event, context }) =
 // One-time discovery of historical discrete orders for non-deterministic
 // generators created during backfill. Fires once at startBlock=endBlock="latest".
 
-ponder.on("composableCow.OwnerBackfill:block", async ({ event, context }) => {
+ponder.on("OwnerBackfill:block", async ({ event, context }) => {
   const chainId = context.chain.id as SupportedChainId;
   const currentBlock = event.block.number;
 
@@ -779,7 +779,7 @@ ponder.on("composableCow.OwnerBackfill:block", async ({ event, context }) => {
 // Cancelled, which lets the CandidateConfirmer/OrderStatusTracker parent-cancelled
 // cascade (COW-918) reconcile the child discrete / candidate rows on the next block.
 
-ponder.on("composableCow.CancellationWatcher:block", async ({ event, context }) => {
+ponder.on("CancellationWatcher:block", async ({ event, context }) => {
   if (process.env.DISABLE_DETERMINISTIC_CANCEL_SWEEP) return;
 
   const chainId = context.chain.id as SupportedChainId;

From c6fc8413afa89d0d5a7a5f000710a71d4af9ffb8 Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Tue, 2 Jun 2026 10:42:32 -0300
Subject: [PATCH 06/84] fix: increase ponder container nofile ulimit to 65536

Vite's file watcher exhausts the default Docker ulimit of 1024 open
files when the project includes many chain files and node_modules.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 docker-compose.yml | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/docker-compose.yml b/docker-compose.yml
index 66bd37a..e721c4d 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -57,6 +57,10 @@ services:
     depends_on:
       postgres:
         condition: service_healthy
+    ulimits:
+      nofile:
+        soft: 65536
+        hard: 65536
     logging:
       driver: json-file
       options:

From 42de8c5196d83dc279c8e7638611c58b914c03ef Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Tue, 2 Jun 2026 11:03:37 -0300
Subject: [PATCH 07/84] fix: rename progressPct to historicalSyncProgressPct in
 sync-progress API
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Makes the field name self-documenting — it clearly tracks historical
block-fetch progress (not handler completion), consistent with the
distinction between progressPct=100 and isComplete=false.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 src/api/endpoints/sync-progress.ts | 4 ++--
 src/api/routes.ts                  | 2 +-
 src/api/schemas/sync-progress.ts   | 2 +-
 tests/api/sync-progress.test.ts    | 8 ++++----
 4 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/api/endpoints/sync-progress.ts b/src/api/endpoints/sync-progress.ts
index c72bb35..998074e 100644
--- a/src/api/endpoints/sync-progress.ts
+++ b/src/api/endpoints/sync-progress.ts
@@ -56,7 +56,7 @@ export const syncProgressHandler: RouteHandler<typeof syncProgressRoute> =
       {
         totalBlocks: number;
         processedBlocks: number;
-        progressPct: number;
+        historicalSyncProgressPct: number;
         isRealtime: boolean;
         isComplete: boolean;
       }
@@ -72,7 +72,7 @@ export const syncProgressHandler: RouteHandler<typeof syncProgressRoute> =
       result[chain] = {
         totalBlocks: t,
         processedBlocks: processed,
-        progressPct: pct,
+        historicalSyncProgressPct: pct,
         isRealtime: (isRealtime.get(chain) ?? 0) === 1,
         isComplete: (isComplete.get(chain) ?? 0) === 1,
       };
diff --git a/src/api/routes.ts b/src/api/routes.ts
index cc7b777..a0a7c0f 100644
--- a/src/api/routes.ts
+++ b/src/api/routes.ts
@@ -35,7 +35,7 @@ export const syncProgressRoute = createRoute({
   tags: ["Indexer"],
   summary: "Per-chain historical sync progress",
   description:
-    "Returns the indexer's historical backfill progress per chain: total blocks to process, blocks already processed, percentage complete, and whether the chain is in realtime mode. Reads from Ponder's built-in Prometheus metrics. During initial sync, progressPct will rise from 0 to 100 and isComplete will flip to true once the chain is fully caught up.",
+    "Returns the indexer's historical backfill progress per chain: total blocks to process, blocks already processed, percentage complete, and whether the chain is in realtime mode. Reads from Ponder's built-in Prometheus metrics. During initial sync, historicalSyncProgressPct will rise from 0 to 100 and isComplete will flip to true once the chain is fully caught up.",
   responses: {
     200: {
       description: "Per-chain sync progress.",
diff --git a/src/api/schemas/sync-progress.ts b/src/api/schemas/sync-progress.ts
index 25f525a..a5c518d 100644
--- a/src/api/schemas/sync-progress.ts
+++ b/src/api/schemas/sync-progress.ts
@@ -9,7 +9,7 @@ export const ChainProgressSchema = z.object({
     .number()
     .int()
     .describe("Blocks already processed (completed + served from cache)."),
-  progressPct: z
+  historicalSyncProgressPct: z
     .number()
     .describe("Completion percentage (0–100). Rounded to one decimal place."),
   isRealtime: z
diff --git a/tests/api/sync-progress.test.ts b/tests/api/sync-progress.test.ts
index 87857ad..4404ff2 100644
--- a/tests/api/sync-progress.test.ts
+++ b/tests/api/sync-progress.test.ts
@@ -5,7 +5,7 @@ import { syncProgressHandler } from "../../src/api/endpoints/sync-progress";
 type ChainProgress = {
   totalBlocks: number;
   processedBlocks: number;
-  progressPct: number;
+  historicalSyncProgressPct: number;
   isRealtime: boolean;
   isComplete: boolean;
 };
@@ -84,15 +84,15 @@ describe("GET /api/sync-progress", () => {
     expect(body["gnosis"]!.processedBlocks).toBe(2_400_000);
   });
 
-  it("computes progressPct correctly (rounded to 1 decimal)", async () => {
+  it("computes historicalSyncProgressPct correctly (rounded to 1 decimal)", async () => {
     mockFetch(SAMPLE_METRICS);
     const app = buildApp();
     const res = await app.request("http://localhost/api/sync-progress");
     const body = (await res.json()) as Record<string, ChainProgress>;
     // mainnet: 3_000_000 / 7_000_000 = 42.857... → 42.9
-    expect(body["mainnet"]!.progressPct).toBe(42.9);
+    expect(body["mainnet"]!.historicalSyncProgressPct).toBe(42.9);
     // gnosis: 2_400_000 / 17_000_000 = 14.117... → 14.1
-    expect(body["gnosis"]!.progressPct).toBe(14.1);
+    expect(body["gnosis"]!.historicalSyncProgressPct).toBe(14.1);
   });
 
   it("sets isRealtime and isComplete from metrics flags", async () => {

From d9aea03ac2c3dd6e8c44714da5da1b2e043fb6c9 Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Tue, 2 Jun 2026 16:20:55 -0300
Subject: [PATCH 08/84] fix: remove undefined variables from settlement cowLog
 after COW-991 decode removal
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

COW-991 removed the decodeAbiParameters block (orderUid, sellToken, buyToken,
sellAmount, buyAmount were decode-only-for-logging). COW-994's cowLog migration
kept those variables in the log fields — crashing the indexer at runtime.
Drop the undefined fields from the log; adapter + eoa are sufficient.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 src/application/handlers/settlement.ts | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/src/application/handlers/settlement.ts b/src/application/handlers/settlement.ts
index d48d42a..4c78982 100644
--- a/src/application/handlers/settlement.ts
+++ b/src/application/handlers/settlement.ts
@@ -231,11 +231,6 @@ ponder.on("GPv2Settlement:Settlement", async ({ event, context }) => {
       chainId,
       adapter: ownerAddress,
       eoa: eoaOwner.toLowerCase(),
-      orderUid: String(orderUid),
-      sellToken: sellToken.toLowerCase(),
-      buyToken: buyToken.toLowerCase(),
-      sellAmount: String(sellAmount),
-      buyAmount: String(buyAmount),
     });
   }
 

From 13b8cbff2fd8647d30613ab74f7fdf9449005873 Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Tue, 2 Jun 2026 17:07:51 -0300
Subject: [PATCH 09/84] fix: add ORDER BY to StatusUpdater SELECT, fix Number()
 env check, document per-block cap (COW-988)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 docs/deployment.md                       |  1 +
 src/application/handlers/blockHandler.ts | 14 ++++++++------
 2 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/docs/deployment.md b/docs/deployment.md
index 29a4171..51dcd5b 100644
--- a/docs/deployment.md
+++ b/docs/deployment.md
@@ -31,6 +31,7 @@ Example: `DATABASE_URL=postgresql://cow_programmatic:secretpass@localhost:5433/c
 | `DISABLE_POLL_RESULT_CHECK` | No | Disables the C1 ContractPoller block handler. Skips RPC multicalls for non-deterministic generators. Saves RPC calls during initial sync at the cost of not detecting poll results until re-enabled. |
 | `DISABLE_DETERMINISTIC_CANCEL_SWEEP` | No | Disables the C5 DeterministicCancellationSweeper. Skips periodic `singleOrders()` reads on deterministic generators. While disabled, on-chain `ComposableCoW.remove()` calls on TWAP/StopLoss/CirclesBackingOrder generators will not be detected and those generators stay `Active`. |
 | `MAX_GENERATORS_PER_BLOCK_<chainId>` | No | Per-block cap on how many generators C1 and C5 will touch on the given chain (e.g. `MAX_GENERATORS_PER_BLOCK_1=200`, `MAX_GENERATORS_PER_BLOCK_100=400`). Default is 200. Excess generators defer to the next block, prioritized by oldest `lastCheckBlock` first. |
+| `MAX_DISCRETE_ORDERS_PER_BLOCK_<chainId>` | No | Per-block cap on how many open discrete orders the StatusUpdater will check on the given chain (e.g. `MAX_DISCRETE_ORDERS_PER_BLOCK_1=200`). Default is 200. Excess orders are deferred to the next block, prioritised by oldest `promotedAt` first. |
 | `DISABLE_SETTLEMENT_FACTORY_CHECK` | No | Skips `getCode` + `FACTORY()` RPC calls in the GPv2Settlement handler. Useful for benchmarking base sync throughput. |
 | `PINO_LOG_LEVEL` | No | Log verbosity: `debug`, `info`, `warn`, `error`. Defaults to Ponder's built-in default. |
 
diff --git a/src/application/handlers/blockHandler.ts b/src/application/handlers/blockHandler.ts
index 59fd969..c9901d0 100644
--- a/src/application/handlers/blockHandler.ts
+++ b/src/application/handlers/blockHandler.ts
@@ -79,9 +79,9 @@ ponder.on("ContractPoller:block", async ({ event, context }) => {
   const currentBlock = event.block.number;
   const currentTimestamp = event.block.timestamp;
 
+  const rawGeneratorCap = Number(process.env[`MAX_GENERATORS_PER_BLOCK_${chainId}`]);
   const maxGeneratorsPerBlock =
-    Number(process.env[`MAX_GENERATORS_PER_BLOCK_${chainId}`]) ||
-    DEFAULT_MAX_GENERATORS_PER_BLOCK;
+    Number.isFinite(rawGeneratorCap) && rawGeneratorCap > 0 ? rawGeneratorCap : DEFAULT_MAX_GENERATORS_PER_BLOCK;
 
   const dueOrders = await context.db.sql
     .select({
@@ -562,9 +562,9 @@ ponder.on("StatusUpdater:block", async ({ event, context }) => {
   const chainId = context.chain.id as SupportedChainId;
   const currentTimestamp = event.block.timestamp;
 
+  const rawOrderCap = Number(process.env[`MAX_DISCRETE_ORDERS_PER_BLOCK_${chainId}`]);
   const maxOrdersPerBlock =
-    Number(process.env[`MAX_DISCRETE_ORDERS_PER_BLOCK_${chainId}`]) ||
-    DEFAULT_MAX_DISCRETE_ORDERS_PER_BLOCK;
+    Number.isFinite(rawOrderCap) && rawOrderCap > 0 ? rawOrderCap : DEFAULT_MAX_DISCRETE_ORDERS_PER_BLOCK;
 
   const openOrders = await context.db.sql
     .select({
@@ -584,6 +584,7 @@ ponder.on("StatusUpdater:block", async ({ event, context }) => {
         eq(discreteOrder.status, "open"),
       ),
     )
+    .orderBy(asc(discreteOrder.promotedAt))
     .limit(maxOrdersPerBlock) as {
     orderUid: string;
     conditionalOrderGeneratorId: string;
@@ -626,6 +627,7 @@ ponder.on("StatusUpdater:block", async ({ event, context }) => {
       await context.db.sql
         .insert(discreteOrder)
         .values(rowsToUpdate)
+        // promotedAt is intentionally omitted — preserve the original promotion timestamp across status updates.
         .onConflictDoUpdate({
           target: [discreteOrder.chainId, discreteOrder.orderUid],
           set: {
@@ -825,9 +827,9 @@ ponder.on("DeterministicCancellationSweeper:block", async ({ event, context }) =
 
   const currentBlock = event.block.number;
 
+  const rawGeneratorCap2 = Number(process.env[`MAX_GENERATORS_PER_BLOCK_${chainId}`]);
   const maxGeneratorsPerBlock =
-    Number(process.env[`MAX_GENERATORS_PER_BLOCK_${chainId}`]) ||
-    DEFAULT_MAX_GENERATORS_PER_BLOCK;
+    Number.isFinite(rawGeneratorCap2) && rawGeneratorCap2 > 0 ? rawGeneratorCap2 : DEFAULT_MAX_GENERATORS_PER_BLOCK;
 
   const dueGenerators = await context.db.sql
     .select({

From 51c985073ba4a22f0f514bc3a755e1990ba1814d Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Tue, 2 Jun 2026 17:14:22 -0300
Subject: [PATCH 10/84] =?UTF-8?q?fix:=20update=20test=20mocks=20=E2=80=94?=
 =?UTF-8?q?=20use=20=5F=5FmakeSelectChain,=20add=20hash=20field,=20DB-thro?=
 =?UTF-8?q?w=20coverage=20(COW-995)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 tests/api/execution-summary.test.ts |  7 +++++
 tests/api/orders-by-owner.test.ts   | 46 +++++++++++++----------------
 2 files changed, 27 insertions(+), 26 deletions(-)

diff --git a/tests/api/execution-summary.test.ts b/tests/api/execution-summary.test.ts
index edcd80c..4e725d5 100644
--- a/tests/api/execution-summary.test.ts
+++ b/tests/api/execution-summary.test.ts
@@ -93,4 +93,11 @@ describe("GET /api/generator/:eventId/execution-summary", () => {
     );
     expect(res.status).toBe(400);
   });
+
+  it("returns 500 when the DB throws", async () => {
+    vi.mocked(db.execute).mockRejectedValueOnce(new Error("db error"));
+
+    const res = await buildApp().request(makeUrl());
+    expect(res.status).toBe(500);
+  });
 });
diff --git a/tests/api/orders-by-owner.test.ts b/tests/api/orders-by-owner.test.ts
index 9258786..3ba316a 100644
--- a/tests/api/orders-by-owner.test.ts
+++ b/tests/api/orders-by-owner.test.ts
@@ -50,7 +50,7 @@ describe("GeneratorSummary schema", () => {
     const shape = GeneratorSummary.shape;
     const description = shape.hash.description;
     expect(description).toBe(
-      "On-chain canonical identifier: keccak256(abi.encode(handler, salt, staticInput)). Used by ComposableCow.singleOrders(owner, hash) and remove(owner, hash).",
+      "On-chain canonical identifier: keccak256(abi.encode((handler, salt, staticInput))). Used by ComposableCow.singleOrders(owner, hash) and remove(owner, hash).",
     );
   });
 
@@ -122,13 +122,13 @@ describe("OrdersByOwnerResponse schema", () => {
 // ─── Endpoint integration tests (COW-995) ───────────────────────────────────
 
 // Mock virtual modules before any ponder-importing source files are loaded.
-vi.mock("ponder:api", () => ({ db: { execute: vi.fn(), select: vi.fn() } }));
+// ponder:api is resolved to tests/__mocks__/ponder-api.ts via vitest alias — no inline override needed.
 vi.mock("ponder:schema", () => {
   const ownerMapping = { owner: "owner", chainId: "chainId", address: "address" };
   const conditionalOrderGenerator = {
     eventId: "eventId", chainId: "chainId", orderType: "orderType",
     owner: "owner", resolvedOwner: "resolvedOwner", status: "status",
-    ownerAddressType: "ownerAddressType",
+    ownerAddressType: "ownerAddressType", hash: "hash",
   };
   const discreteOrder = {
     conditionalOrderGeneratorId: "conditionalOrderGeneratorId",
@@ -188,12 +188,6 @@ function makeContext({
   };
 }
 
-function makeChain(rows: unknown[]) {
-  const where = vi.fn().mockResolvedValue(rows);
-  const from = vi.fn().mockReturnValue({ where });
-  return { from };
-}
-
 const GENERATOR = {
   eventId: EVENT_ID,
   chainId: CHAIN_ID,
@@ -226,8 +220,8 @@ beforeEach(() => {
 describe("ordersByOwnerHandler", () => {
   it("returns empty orders array when no generators are found", async () => {
     vi.mocked(db.select)
-      .mockReturnValueOnce(makeChain([]) as never)
-      .mockReturnValueOnce(makeChain([]) as never);
+      .mockReturnValueOnce(db.__makeSelectChain([]) as never)
+      .mockReturnValueOnce(db.__makeSelectChain([]) as never);
 
     const ctx = makeContext();
     await ordersByOwnerHandler(ctx as never, vi.fn() as never);
@@ -237,9 +231,9 @@ describe("ordersByOwnerHandler", () => {
 
   it("returns empty orders when generators exist but have no discrete orders", async () => {
     vi.mocked(db.select)
-      .mockReturnValueOnce(makeChain([]) as never)
-      .mockReturnValueOnce(makeChain([GENERATOR]) as never)
-      .mockReturnValueOnce(makeChain([]) as never);
+      .mockReturnValueOnce(db.__makeSelectChain([]) as never)
+      .mockReturnValueOnce(db.__makeSelectChain([GENERATOR]) as never)
+      .mockReturnValueOnce(db.__makeSelectChain([]) as never);
 
     const ctx = makeContext();
     await ordersByOwnerHandler(ctx as never, vi.fn() as never);
@@ -249,9 +243,9 @@ describe("ordersByOwnerHandler", () => {
 
   it("returns enriched orders with embedded generator data", async () => {
     vi.mocked(db.select)
-      .mockReturnValueOnce(makeChain([]) as never)
-      .mockReturnValueOnce(makeChain([GENERATOR]) as never)
-      .mockReturnValueOnce(makeChain([ORDER]) as never);
+      .mockReturnValueOnce(db.__makeSelectChain([]) as never)
+      .mockReturnValueOnce(db.__makeSelectChain([GENERATOR]) as never)
+      .mockReturnValueOnce(db.__makeSelectChain([ORDER]) as never);
 
     const ctx = makeContext();
     await ordersByOwnerHandler(ctx as never, vi.fn() as never);
@@ -268,9 +262,9 @@ describe("ordersByOwnerHandler", () => {
 
   it("serialises creationDate as a decimal string (BigInt scalar)", async () => {
     vi.mocked(db.select)
-      .mockReturnValueOnce(makeChain([]) as never)
-      .mockReturnValueOnce(makeChain([GENERATOR]) as never)
-      .mockReturnValueOnce(makeChain([ORDER]) as never);
+      .mockReturnValueOnce(db.__makeSelectChain([]) as never)
+      .mockReturnValueOnce(db.__makeSelectChain([GENERATOR]) as never)
+      .mockReturnValueOnce(db.__makeSelectChain([ORDER]) as never);
 
     const ctx = makeContext();
     await ordersByOwnerHandler(ctx as never, vi.fn() as never);
@@ -281,9 +275,9 @@ describe("ordersByOwnerHandler", () => {
   it("includes proxy addresses from ownerMapping in the generator lookup", async () => {
     const PROXY = "0xcccccccccccccccccccccccccccccccccccccccc";
     vi.mocked(db.select)
-      .mockReturnValueOnce(makeChain([{ address: PROXY }]) as never)
-      .mockReturnValueOnce(makeChain([GENERATOR]) as never)
-      .mockReturnValueOnce(makeChain([ORDER]) as never);
+      .mockReturnValueOnce(db.__makeSelectChain([{ address: PROXY }]) as never)
+      .mockReturnValueOnce(db.__makeSelectChain([GENERATOR]) as never)
+      .mockReturnValueOnce(db.__makeSelectChain([ORDER]) as never);
 
     const ctx = makeContext();
     await ordersByOwnerHandler(ctx as never, vi.fn() as never);
@@ -293,9 +287,9 @@ describe("ordersByOwnerHandler", () => {
 
   it("includes hash in generator object (COW-993)", async () => {
     vi.mocked(db.select)
-      .mockReturnValueOnce(makeChain([]) as never)
-      .mockReturnValueOnce(makeChain([GENERATOR]) as never)
-      .mockReturnValueOnce(makeChain([ORDER]) as never);
+      .mockReturnValueOnce(db.__makeSelectChain([]) as never)
+      .mockReturnValueOnce(db.__makeSelectChain([GENERATOR]) as never)
+      .mockReturnValueOnce(db.__makeSelectChain([ORDER]) as never);
 
     const ctx = makeContext();
     await ordersByOwnerHandler(ctx as never, vi.fn() as never);

From 40917bcaefb7d531233a3d0f0246b255355870cf Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Tue, 2 Jun 2026 17:08:28 -0300
Subject: [PATCH 11/84] fix: update stale C1/C5 names in comments, verify
 CirclesBackingOrder precompute (COW-996/999/1003)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 src/application/handlers/composableCow.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/application/handlers/composableCow.ts b/src/application/handlers/composableCow.ts
index ced8075..4aa348f 100644
--- a/src/application/handlers/composableCow.ts
+++ b/src/application/handlers/composableCow.ts
@@ -25,7 +25,7 @@
  *   This affects only EIP-1271 composable orders where the user cancels through
  *   the API rather than calling ComposableCoW.remove() on-chain. In practice
  *   this is rare — the standard on-chain cancellation path is detected via
- *   SingleOrderNotAuthed (C1 block handler) and the C5 singleOrders() sweep,
+ *   SingleOrderNotAuthed (OrderDiscoveryPoller) and the CancellationWatcher,
  *   both of which work correctly.
  *
  *   If this gap proves significant in production, a lightweight periodic check

From 1cadee06832031ef8939634c5fd70f70ae4c688d Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Tue, 2 Jun 2026 17:05:53 -0300
Subject: [PATCH 12/84] fix: correct hash field describe() to use tuple
 abi.encode notation (COW-993)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 src/api/schemas/orders-by-owner.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/api/schemas/orders-by-owner.ts b/src/api/schemas/orders-by-owner.ts
index 1f132ce..e9e5c85 100644
--- a/src/api/schemas/orders-by-owner.ts
+++ b/src/api/schemas/orders-by-owner.ts
@@ -22,7 +22,7 @@ export const GeneratorSummary = z.object({
   hash: z
     .string()
     .describe(
-      "On-chain canonical identifier: keccak256(abi.encode(handler, salt, staticInput)). Used by ComposableCow.singleOrders(owner, hash) and remove(owner, hash).",
+      "On-chain canonical identifier: keccak256(abi.encode((handler, salt, staticInput))). Used by ComposableCow.singleOrders(owner, hash) and remove(owner, hash).",
     ),
   ownerAddressType: z
     .enum(["cowshed_proxy", "flash_loan_helper"])

From 00cb7c3af3b5dcfae98913f396abcd2c68f8c44a Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Tue, 2 Jun 2026 17:06:18 -0300
Subject: [PATCH 13/84] fix: update stale C1/C5 name references in constants.ts
 and docs (COW-1000)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 docs/api-reference.md |  2 +-
 docs/deployment.md    |  6 +++---
 src/constants.ts      | 14 +++++++-------
 3 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/docs/api-reference.md b/docs/api-reference.md
index e31acaf..e3a7139 100644
--- a/docs/api-reference.md
+++ b/docs/api-reference.md
@@ -126,7 +126,7 @@ There is one principled exception to "everything as string": `discreteOrder.vali
 | `discreteOrder.validTo` | number | yes | Unix seconds when this discrete order expires. `uint32` per CoW protocol. |
 | `discreteOrder.creationDate` | string | no | Unix seconds when the discrete order was first observed. Source varies — see the GraphQL field doc. |
 | `candidateDiscreteOrder.validTo` | number | yes | Same as `discreteOrder.validTo`. |
-| `candidateDiscreteOrder.creationDate` | string | no | Block timestamp at C1 discovery. |
+| `candidateDiscreteOrder.creationDate` | string | no | Block timestamp at **OrderDiscoveryPoller** discovery. |
 | `candidateDiscreteOrder.possibleValidAfterTimestamp` | string | yes | TWAP only: `t0 + partIndex*t`. Earliest Unix-seconds time the part can be valid. |
 
 ### Timestamp-like values inside `decodedParams`
diff --git a/docs/deployment.md b/docs/deployment.md
index e5601c6..b80475f 100644
--- a/docs/deployment.md
+++ b/docs/deployment.md
@@ -30,9 +30,9 @@ Example: `DATABASE_URL=postgresql://cow_programmatic:secretpass@localhost:5433/c
 
 | Variable | Required | Description |
 |----------|----------|-------------|
-| `DISABLE_POLL_RESULT_CHECK` | No | Disables the C1 ContractPoller block handler. Skips RPC multicalls for non-deterministic generators. Saves RPC calls during initial sync at the cost of not detecting poll results until re-enabled. |
-| `DISABLE_DETERMINISTIC_CANCEL_SWEEP` | No | Disables the C5 DeterministicCancellationSweeper. Skips periodic `singleOrders()` reads on deterministic generators. While disabled, on-chain `ComposableCoW.remove()` calls on TWAP/StopLoss/CirclesBackingOrder generators will not be detected and those generators stay `Active`. |
-| `MAX_GENERATORS_PER_BLOCK_<chainId>` | No | Per-block cap on how many generators C1 and C5 will touch on the given chain (e.g. `MAX_GENERATORS_PER_BLOCK_1=200`, `MAX_GENERATORS_PER_BLOCK_100=400`). Default is 200. Excess generators defer to the next block, prioritized by oldest `lastCheckBlock` first. |
+| `DISABLE_POLL_RESULT_CHECK` | No | Disables the OrderDiscoveryPoller block handler. Skips RPC multicalls for non-deterministic generators. Saves RPC calls during initial sync at the cost of not detecting poll results until re-enabled. |
+| `DISABLE_DETERMINISTIC_CANCEL_SWEEP` | No | Disables the CancellationWatcher. Skips periodic `singleOrders()` reads on deterministic generators. While disabled, on-chain `ComposableCoW.remove()` calls on TWAP/StopLoss/CirclesBackingOrder generators will not be detected and those generators stay `Active`. |
+| `MAX_GENERATORS_PER_BLOCK_<chainId>` | No | Per-block cap on how many generators OrderDiscoveryPoller and CancellationWatcher will touch on the given chain (e.g. `MAX_GENERATORS_PER_BLOCK_1=200`, `MAX_GENERATORS_PER_BLOCK_100=400`). Default is 200. Excess generators defer to the next block, prioritized by oldest `lastCheckBlock` first. |
 | `DISABLE_SETTLEMENT_FACTORY_CHECK` | No | Skips `getCode` + `FACTORY()` RPC calls in the GPv2Settlement handler. Useful for benchmarking base sync throughput. |
 | `PINO_LOG_LEVEL` | No | Log verbosity: `debug`, `info`, `warn`, `error`. Defaults to Ponder's built-in default. |
 
diff --git a/src/constants.ts b/src/constants.ts
index 4d90739..42f92e2 100644
--- a/src/constants.ts
+++ b/src/constants.ts
@@ -19,7 +19,7 @@ export const RECHECK_INTERVAL = BigInt(ORDERBOOK_POLL_INTERVAL);
 export const SIGNING_SCHEME_EIP1271 = "eip1271";
 
 /**
- * COW-908: Hard per-block ceiling on how many generators the C1 ContractPoller
+ * COW-908: Hard per-block ceiling on how many generators the OrderDiscoveryPoller
  * will multicall in a single block. Generators exceeding the cap defer to the
  * next block (prioritized by oldest lastCheckBlock first).
  *
@@ -47,13 +47,13 @@ export const TRY_NEXT_BLOCK_BACKOFF_MID = 10n;
 export const TRY_NEXT_BLOCK_BACKOFF_COLD = 50n;
 
 /**
- * C5 (DeterministicCancellationSweeper) re-check cadence, in blocks.
+ * CancellationWatcher re-check cadence, in blocks.
  *
  * For deterministic generators (`allCandidatesKnown = true`), `remove()` detection
  * is via a `ComposableCoW.singleOrders(owner, hash)` storage read. `remove()` is
  * rare; a ~100 block cadence gives a worst-case detection lag of ~20 min on
- * mainnet and ~8 min on Gnosis while keeping the RPC cost well below C1's
- * every-block poll.
+ * mainnet and ~8 min on Gnosis while keeping the RPC cost well below
+ * OrderDiscoveryPoller's every-block poll.
  */
 export const DETERMINISTIC_CANCEL_SWEEP_INTERVAL = 100n;
 
@@ -67,15 +67,15 @@ export const ORDERBOOK_HTTP_TIMEOUT_MS = 10_000;
 
 /**
  * Hard wall-clock cap for a block handler's aggregate `context.client.multicall`
- * call (C1, C5). viem has no per-call signal; the timer races the promise and
+ * call (OrderDiscoveryPoller, CancellationWatcher). viem has no per-call signal; the timer races the promise and
  * the handler returns cleanly on breach.
  */
 export const BLOCK_HANDLER_RPC_TIMEOUT_MS = 15_000;
 
 /**
- * Hard wall-clock cap for the whole per-owner bootstrap fetch in C4
+ * Hard wall-clock cap for the whole per-owner bootstrap fetch in OwnerBackfill
  * (account pagination + by_uids refresh). Owners that exceed this are skipped;
- * the normal C1 / C2 path picks them up on subsequent blocks.
+ * the normal OrderDiscoveryPoller / CandidateConfirmer path picks them up on subsequent blocks.
  */
 export const BOOTSTRAP_OWNER_FETCH_TIMEOUT_MS = 30_000;
 

From 9ec9634cfb6652028b14195de5035ee9dfc6a3bf Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Tue, 2 Jun 2026 17:05:57 -0300
Subject: [PATCH 14/84] fix: use tighter 5s timeout for inner-loop RPC calls in
 settlement handler (COW-991)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 src/application/handlers/settlement.ts | 6 +++---
 src/constants.ts                       | 4 ++++
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/application/handlers/settlement.ts b/src/application/handlers/settlement.ts
index 4c78982..5f7ec89 100644
--- a/src/application/handlers/settlement.ts
+++ b/src/application/handlers/settlement.ts
@@ -8,7 +8,7 @@ import {
   AAVE_V3_ADAPTER_FACTORY_ADDRESSES,
   GPV2_SETTLEMENT_DEPLOYMENTS,
 } from "../../data";
-import { BLOCK_HANDLER_RPC_TIMEOUT_MS } from "../../constants";
+import { BLOCK_HANDLER_RPC_TIMEOUT_MS, SETTLEMENT_INNER_RPC_TIMEOUT_MS } from "../../constants";
 import { TimeoutError, withTimeout } from "../helpers/withTimeout";
 
 // Trade(address,address,address,uint256,uint256,uint256,bytes) — topic0 hash
@@ -124,7 +124,7 @@ ponder.on("GPv2Settlement:Settlement", async ({ event, context }) => {
     try {
       code = await withTimeout(
         context.client.getCode({ address: owner }),
-        BLOCK_HANDLER_RPC_TIMEOUT_MS,
+        SETTLEMENT_INNER_RPC_TIMEOUT_MS,
         "settlement:getCode",
       );
     } catch (err) {
@@ -145,7 +145,7 @@ ponder.on("GPv2Settlement:Settlement", async ({ event, context }) => {
     try {
       const result = await withTimeout(
         context.client.call({ to: owner, data: FACTORY_SELECTOR }),
-        BLOCK_HANDLER_RPC_TIMEOUT_MS,
+        SETTLEMENT_INNER_RPC_TIMEOUT_MS,
         "settlement:call:FACTORY",
       );
       factoryData = result.data;
diff --git a/src/constants.ts b/src/constants.ts
index 42f92e2..1e387c9 100644
--- a/src/constants.ts
+++ b/src/constants.ts
@@ -72,6 +72,10 @@ export const ORDERBOOK_HTTP_TIMEOUT_MS = 10_000;
  */
 export const BLOCK_HANDLER_RPC_TIMEOUT_MS = 15_000;
 
+// Tighter cap for cheap inner-loop calls (getCode, eth_call) in the settlement handler.
+// The outer receipt fetch and readContract(owner()) keep the full 15 s.
+export const SETTLEMENT_INNER_RPC_TIMEOUT_MS = 5_000;
+
 /**
  * Hard wall-clock cap for the whole per-owner bootstrap fetch in OwnerBackfill
  * (account pagination + by_uids refresh). Owners that exceed this are skipped;

From 0e72d2bf38ccb993e64a4fc2f85270a51641c75c Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Tue, 2 Jun 2026 17:07:35 -0300
Subject: [PATCH 15/84] fix: fix preflight timeout, migrate console.log to
 cowLog, deduplicate DiscreteStatus type (COW-990)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 src/application/handlers/blockHandler.ts | 15 ++++++++++-----
 src/application/helpers/cowLogger.ts     |  7 ++++++-
 2 files changed, 16 insertions(+), 6 deletions(-)

diff --git a/src/application/handlers/blockHandler.ts b/src/application/handlers/blockHandler.ts
index b9c63de..1299856 100644
--- a/src/application/handlers/blockHandler.ts
+++ b/src/application/handlers/blockHandler.ts
@@ -44,6 +44,8 @@ import {
 import { computeOrderUid, type GPv2OrderData } from "../helpers/orderUid";
 import { cowLog } from "../helpers/cowLogger";
 
+type DiscreteStatus = "open" | "fulfilled" | "unfilled" | "expired" | "cancelled";
+
 const NON_DETERMINISTIC_TYPES = ["PerpetualSwap", "GoodAfterTime", "TradeAboveThreshold", "Unknown"] as const;
 const SINGLE_SHOT_NON_DETERMINISTIC = ["GoodAfterTime", "TradeAboveThreshold"] as const;
 const BLOCK_NEVER = 2n ** 63n - 1n; // sentinel for epoch-scheduled generators (PollTryAtEpoch)
@@ -350,12 +352,11 @@ ponder.on("CandidateConfirmer:block", async ({ event, context }) => {
       // been posted by the watch-tower and filled/expired between generator creation
       // and the cancellation cascade (~0.17% observed rate). Use the API status when
       // available; fall back to 'cancelled' for UIDs not yet on the orderbook.
-      type DiscreteStatus = "open" | "fulfilled" | "unfilled" | "expired" | "cancelled";
       let preflightStatuses: Awaited<ReturnType<typeof fetchOrderStatusByUids>>;
       try {
         preflightStatuses = await withTimeout(
           fetchOrderStatusByUids(context, chainId, orphanCandidates.map((c) => c.orderUid)),
-          ORDERBOOK_HTTP_TIMEOUT_MS,
+          ORDERBOOK_HTTP_TIMEOUT_MS * 2,
           "c2:cascade:preflight",
         );
       } catch {
@@ -397,8 +398,13 @@ ponder.on("CandidateConfirmer:block", async ({ event, context }) => {
           ),
         );
 
-      const preflightHits = preflightStatuses.size;
-      cowLog("info", "CandidateConfirmer:parent_cancelled", { block: String(event.block.number), chainId, parentCancelled: orphanCandidates.length, preflightHits });
+      const preflightKnown = preflightStatuses.size;
+      cowLog("info", "CandidateConfirmer:parent_cancelled", {
+        block: String(event.block.number),
+        chainId,
+        parentCancelled: orphanCandidates.length,
+        preflightKnown,
+      });
     }
   }
 
@@ -438,7 +444,6 @@ ponder.on("CandidateConfirmer:block", async ({ event, context }) => {
   const uids = unconfirmed.map((c) => c.orderUid);
   const statuses = await fetchOrderStatusByUids(context, chainId, uids);
 
-  type DiscreteStatus = "open" | "fulfilled" | "unfilled" | "expired" | "cancelled";
   const rowsToUpsert: (typeof discreteOrder.$inferInsert)[] = [];
   const confirmedUids: string[] = [];
 
diff --git a/src/application/helpers/cowLogger.ts b/src/application/helpers/cowLogger.ts
index 5a2fbaa..3969837 100644
--- a/src/application/helpers/cowLogger.ts
+++ b/src/application/helpers/cowLogger.ts
@@ -15,5 +15,10 @@ export function cowLog(
   msg: string,
   fields: Record<string, unknown> = {},
 ): void {
-  console.log(JSON.stringify({ time: Date.now(), level, msg, ...fields }));
+  const line = JSON.stringify({ time: Date.now(), level, msg, ...fields });
+  if (level === "warn" || level === "error") {
+    console.error(line);
+  } else {
+    console.log(line);
+  }
 }

From f04b2327ef8beff531636dbd3d7fed6292c35f39 Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Tue, 2 Jun 2026 17:07:36 -0300
Subject: [PATCH 16/84] fix: route warn/error to stderr in cowLog, add
 initialDelaySeconds to K8s probes (COW-994)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 docs/deployment.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/docs/deployment.md b/docs/deployment.md
index b80475f..e3dc269 100644
--- a/docs/deployment.md
+++ b/docs/deployment.md
@@ -155,12 +155,14 @@ livenessProbe:
   httpGet:
     path: /healthz
     port: 3000
+  initialDelaySeconds: 30
   periodSeconds: 30
   failureThreshold: 3
 readinessProbe:
   httpGet:
     path: /ready
     port: 3000
+  initialDelaySeconds: 30
   periodSeconds: 10
   failureThreshold: 18   # 3-minute window before marking unready
 ```

From 67fc6ced074a452fcc99a40c2863f8ce0d7bd0d7 Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Tue, 2 Jun 2026 17:26:06 -0300
Subject: [PATCH 17/84] fix: resolve __makeSelectChain TypeScript type error in
 orders-by-owner tests

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 tests/api/orders-by-owner.test.ts | 39 +++++++++++++++++--------------
 1 file changed, 21 insertions(+), 18 deletions(-)

diff --git a/tests/api/orders-by-owner.test.ts b/tests/api/orders-by-owner.test.ts
index 3ba316a..25766a5 100644
--- a/tests/api/orders-by-owner.test.ts
+++ b/tests/api/orders-by-owner.test.ts
@@ -106,7 +106,7 @@ describe("OrdersByOwnerResponse schema", () => {
     expect(result.success).toBe(true);
     if (result.success) {
       expect(result.data.orders).toHaveLength(1);
-      expect(result.data.orders[0].generator?.hash).toBe(validGenerator.hash);
+      expect(result.data.orders[0]!.generator?.hash).toBe(validGenerator.hash);
     }
   });
 
@@ -154,6 +154,9 @@ vi.mock("ponder", () => ({
 import { db } from "ponder:api";
 import { ordersByOwnerHandler } from "../../src/api/endpoints/orders-by-owner";
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const makeSelectChain = (db as any).__makeSelectChain as (rows?: unknown[]) => ReturnType<typeof db.select>;
+
 const OWNER = "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
 const EVENT_ID = "abc123";
 const CHAIN_ID = 1;
@@ -220,8 +223,8 @@ beforeEach(() => {
 describe("ordersByOwnerHandler", () => {
   it("returns empty orders array when no generators are found", async () => {
     vi.mocked(db.select)
-      .mockReturnValueOnce(db.__makeSelectChain([]) as never)
-      .mockReturnValueOnce(db.__makeSelectChain([]) as never);
+      .mockReturnValueOnce(makeSelectChain([]) as never)
+      .mockReturnValueOnce(makeSelectChain([]) as never);
 
     const ctx = makeContext();
     await ordersByOwnerHandler(ctx as never, vi.fn() as never);
@@ -231,9 +234,9 @@ describe("ordersByOwnerHandler", () => {
 
   it("returns empty orders when generators exist but have no discrete orders", async () => {
     vi.mocked(db.select)
-      .mockReturnValueOnce(db.__makeSelectChain([]) as never)
-      .mockReturnValueOnce(db.__makeSelectChain([GENERATOR]) as never)
-      .mockReturnValueOnce(db.__makeSelectChain([]) as never);
+      .mockReturnValueOnce(makeSelectChain([]) as never)
+      .mockReturnValueOnce(makeSelectChain([GENERATOR]) as never)
+      .mockReturnValueOnce(makeSelectChain([]) as never);
 
     const ctx = makeContext();
     await ordersByOwnerHandler(ctx as never, vi.fn() as never);
@@ -243,9 +246,9 @@ describe("ordersByOwnerHandler", () => {
 
   it("returns enriched orders with embedded generator data", async () => {
     vi.mocked(db.select)
-      .mockReturnValueOnce(db.__makeSelectChain([]) as never)
-      .mockReturnValueOnce(db.__makeSelectChain([GENERATOR]) as never)
-      .mockReturnValueOnce(db.__makeSelectChain([ORDER]) as never);
+      .mockReturnValueOnce(makeSelectChain([]) as never)
+      .mockReturnValueOnce(makeSelectChain([GENERATOR]) as never)
+      .mockReturnValueOnce(makeSelectChain([ORDER]) as never);
 
     const ctx = makeContext();
     await ordersByOwnerHandler(ctx as never, vi.fn() as never);
@@ -262,9 +265,9 @@ describe("ordersByOwnerHandler", () => {
 
   it("serialises creationDate as a decimal string (BigInt scalar)", async () => {
     vi.mocked(db.select)
-      .mockReturnValueOnce(db.__makeSelectChain([]) as never)
-      .mockReturnValueOnce(db.__makeSelectChain([GENERATOR]) as never)
-      .mockReturnValueOnce(db.__makeSelectChain([ORDER]) as never);
+      .mockReturnValueOnce(makeSelectChain([]) as never)
+      .mockReturnValueOnce(makeSelectChain([GENERATOR]) as never)
+      .mockReturnValueOnce(makeSelectChain([ORDER]) as never);
 
     const ctx = makeContext();
     await ordersByOwnerHandler(ctx as never, vi.fn() as never);
@@ -275,9 +278,9 @@ describe("ordersByOwnerHandler", () => {
   it("includes proxy addresses from ownerMapping in the generator lookup", async () => {
     const PROXY = "0xcccccccccccccccccccccccccccccccccccccccc";
     vi.mocked(db.select)
-      .mockReturnValueOnce(db.__makeSelectChain([{ address: PROXY }]) as never)
-      .mockReturnValueOnce(db.__makeSelectChain([GENERATOR]) as never)
-      .mockReturnValueOnce(db.__makeSelectChain([ORDER]) as never);
+      .mockReturnValueOnce(makeSelectChain([{ address: PROXY }]) as never)
+      .mockReturnValueOnce(makeSelectChain([GENERATOR]) as never)
+      .mockReturnValueOnce(makeSelectChain([ORDER]) as never);
 
     const ctx = makeContext();
     await ordersByOwnerHandler(ctx as never, vi.fn() as never);
@@ -287,9 +290,9 @@ describe("ordersByOwnerHandler", () => {
 
   it("includes hash in generator object (COW-993)", async () => {
     vi.mocked(db.select)
-      .mockReturnValueOnce(db.__makeSelectChain([]) as never)
-      .mockReturnValueOnce(db.__makeSelectChain([GENERATOR]) as never)
-      .mockReturnValueOnce(db.__makeSelectChain([ORDER]) as never);
+      .mockReturnValueOnce(makeSelectChain([]) as never)
+      .mockReturnValueOnce(makeSelectChain([GENERATOR]) as never)
+      .mockReturnValueOnce(makeSelectChain([ORDER]) as never);
 
     const ctx = makeContext();
     await ordersByOwnerHandler(ctx as never, vi.fn() as never);

From 00b2fada303c9ef712452ed25a55533f5653ba2d Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Tue, 2 Jun 2026 18:34:46 -0300
Subject: [PATCH 18/84] fix: filter nullish items from fetchOrdersByUids
 response to prevent crash on malformed entries

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 src/application/helpers/orderbookClient.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/application/helpers/orderbookClient.ts b/src/application/helpers/orderbookClient.ts
index 8962a3e..ee27453 100644
--- a/src/application/helpers/orderbookClient.ts
+++ b/src/application/helpers/orderbookClient.ts
@@ -365,7 +365,7 @@ async function fetchOrdersByUids(
         continue;
       }
       const raw = (await response.json()) as { order: OrderbookOrder }[];
-      results.push(...raw.map((item) => item.order));
+      results.push(...raw.flatMap((item) => (item?.order != null ? [item.order] : [])));
     } catch (err) {
       if (err instanceof TimeoutError) {
         console.warn(

From 9ff47c3ba02ae032042b3daf090f83df0c9f9ea7 Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Mon, 8 Jun 2026 10:28:46 -0300
Subject: [PATCH 19/84] docs: add MAX_DISCRETE_ORDERS_PER_BLOCK to .env.example
 (COW-988)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .env.example | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/.env.example b/.env.example
index 791e5cc..0e3300a 100644
--- a/.env.example
+++ b/.env.example
@@ -30,6 +30,11 @@ DATABASE_SCHEMA=programmatic_orders
 # MAX_GENERATORS_PER_BLOCK_1=200      # mainnet
 # MAX_GENERATORS_PER_BLOCK_100=400    # gnosis (shorter block time → higher budget)
 
+# Per-block cap on how many open discrete orders StatusUpdater (C3) checks per chain.
+# Default: 200. Excess orders defer to next block, prioritized by oldest promotedAt first.
+# MAX_DISCRETE_ORDERS_PER_BLOCK_1=200
+# MAX_DISCRETE_ORDERS_PER_BLOCK_100=400
+
 
 # Logging (optional)
 # PINO_LOG_LEVEL=info

From c882a3b488405a622d18b5ece618be809656beb6 Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Tue, 9 Jun 2026 17:42:21 -0300
Subject: [PATCH 20/84] fix: chunk orphan-candidate cascade INSERT/DELETE to
 avoid Postgres bind-message limit

Generators cancelled during historical replay can accumulate thousands of
orphan candidates. A single VALUES(...) INSERT with ~17k rows exceeded
Drizzle/Postgres bind-message limits, crashing CandidateConfirmer on every
block and causing 200+ container restarts. Chunk both the INSERT and the
inArray DELETE in CASCADE_CHUNK_SIZE=500 batches.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 src/application/handlers/blockHandler.ts | 69 +++++++++++++-----------
 1 file changed, 37 insertions(+), 32 deletions(-)

diff --git a/src/application/handlers/blockHandler.ts b/src/application/handlers/blockHandler.ts
index 9f45150..b754b23 100644
--- a/src/application/handlers/blockHandler.ts
+++ b/src/application/handlers/blockHandler.ts
@@ -368,41 +368,46 @@ ponder.on("CandidateConfirmer:block", async ({ event, context }) => {
 
       // onConflictDoNothing: if C3 already promoted this UID with a terminal status
       // (e.g. 'fulfilled'), the existing row wins and this insert is a no-op.
+      // Chunked to avoid PostgreSQL bind-message parameter limits on large cascades.
       // preflightKnown counts API hits, not rows actually written.
-      await context.db.sql
-        .insert(discreteOrder)
-        .values(
-          orphanCandidates.map((c) => {
-            const apiEntry = preflightStatuses.get(c.orderUid);
-            return {
-              orderUid: c.orderUid,
-              chainId,
-              conditionalOrderGeneratorId: c.generatorId,
-              status: (apiEntry?.status ?? "cancelled") as DiscreteStatus,
-              sellAmount: c.sellAmount,
-              buyAmount: c.buyAmount,
-              feeAmount: c.feeAmount,
-              validTo: c.validTo,
-              creationDate: c.creationDate,
-              executedSellAmount: apiEntry?.executedSellAmount ?? null,
-              executedBuyAmount: apiEntry?.executedBuyAmount ?? null,
-              promotedAt: event.block.timestamp,
-            };
-          }),
-        )
-        .onConflictDoNothing();
+      const CASCADE_CHUNK_SIZE = 500;
+      for (let i = 0; i < orphanCandidates.length; i += CASCADE_CHUNK_SIZE) {
+        const chunk = orphanCandidates.slice(i, i + CASCADE_CHUNK_SIZE);
+        await context.db.sql
+          .insert(discreteOrder)
+          .values(
+            chunk.map((c) => {
+              const apiEntry = preflightStatuses.get(c.orderUid);
+              return {
+                orderUid: c.orderUid,
+                chainId,
+                conditionalOrderGeneratorId: c.generatorId,
+                status: (apiEntry?.status ?? "cancelled") as DiscreteStatus,
+                sellAmount: c.sellAmount,
+                buyAmount: c.buyAmount,
+                feeAmount: c.feeAmount,
+                validTo: c.validTo,
+                creationDate: c.creationDate,
+                executedSellAmount: apiEntry?.executedSellAmount ?? null,
+                executedBuyAmount: apiEntry?.executedBuyAmount ?? null,
+                promotedAt: event.block.timestamp,
+              };
+            }),
+          )
+          .onConflictDoNothing();
 
-      await context.db.sql
-        .delete(candidateDiscreteOrder)
-        .where(
-          and(
-            eq(candidateDiscreteOrder.chainId, chainId),
-            inArray(
-              candidateDiscreteOrder.orderUid,
-              orphanCandidates.map((c) => c.orderUid),
+        await context.db.sql
+          .delete(candidateDiscreteOrder)
+          .where(
+            and(
+              eq(candidateDiscreteOrder.chainId, chainId),
+              inArray(
+                candidateDiscreteOrder.orderUid,
+                chunk.map((c) => c.orderUid),
+              ),
             ),
-          ),
-        );
+          );
+      }
 
       const preflightKnown = preflightStatuses.size;
       log("info", "CandidateConfirmer:parent_cancelled", { block: String(event.block.number), chainId, parentCancelled: orphanCandidates.length, preflightKnown });

From 3e060e50ad48c5b3eef4ba073a732150c0de096d Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Tue, 9 Jun 2026 18:14:57 -0300
Subject: [PATCH 21/84] fix(deploy): auto-drop app schema in cmdUp to clear
 Ponder build_id conflict
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Ponder 0.16.x computes a build_id from config + schema + handler source.
Any handler change produces a new build_id, causing the next deploy to
fail with "Schema was previously used by a different Ponder app".

cmdUp now stops the ponder container, drops the programmatic_orders schema
via docker exec on the DB container, then builds and starts the new image.
ponder_sync and cow_cache live in separate schemas and are untouched —
reindex reuses the local event cache (~minutes, not hours).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 deployment/manage.ts | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/deployment/manage.ts b/deployment/manage.ts
index 78e34df..f967662 100644
--- a/deployment/manage.ts
+++ b/deployment/manage.ts
@@ -118,6 +118,20 @@ function cmdUp(projectPrefix: string, revision: string): void {
     process.exit(1);
   }
 
+  // Stop the ponder container before touching the schema (leave DB running).
+  run("docker", ["compose", "-p", projectPrefix, "-f", "../docker-compose.yml", "--profile", "deploy", "stop", "ponder"], { ignoreError: true });
+
+  // Drop the app schema so the new build_id (derived from handler + config +
+  // schema source) is accepted without a "previously used by a different Ponder
+  // app" error. ponder_sync (raw-event log cache) and cow_cache live in
+  // separate schemas and are unaffected — reindex reuses cached RPC data
+  // (~minutes, not hours).
+  const dbContainer = `${projectPrefix}-db`;
+  const pgUser = process.env["POSTGRES_USER"] ?? "postgres";
+  const pgDb = process.env["POSTGRES_DB"] ?? "cow_programmatic";
+  const schema = process.env["DATABASE_SCHEMA"] ?? "programmatic_orders";
+  run("docker", ["exec", dbContainer, "psql", "-U", pgUser, "-d", pgDb, "-c", `DROP SCHEMA IF EXISTS "${schema}" CASCADE`], { ignoreError: true });
+
   run("docker", [
     "compose",
     "-p",
@@ -193,7 +207,6 @@ const { command, envFile, revision } = parseArgs(process.argv.slice(2));
 
 loadEnvFile(envFile);
 
-// Hardcoded per project convention
 process.env["DATABASE_SCHEMA"] = "programmatic_orders";
 
 const projectPrefix = process.env["PROJECT_PREFIX"];

From 51faf0e259d7bef03d2afb19350ccc1bd5641c36 Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Tue, 9 Jun 2026 19:16:34 -0300
Subject: [PATCH 22/84] fix: exclude stale candidates from unconfirmed /by_uids
 batch; document backfill behavior (COW-992)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Prevents redundant /by_uids calls for already-expired candidates on every
block during post-backfill catch-up. The stale path (account fallback, 500/block)
already handles these — excluding them from the unconfirmed SELECT eliminates
wasted API quota until the drain completes.

Also documents cold-start duration, /ready semantics, and the historical
discrete-order gap for integrators in docs/deployment.md.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 docs/deployment.md                       | 33 ++++++++++++++++++++++++
 src/application/handlers/blockHandler.ts | 10 ++++++-
 2 files changed, 42 insertions(+), 1 deletion(-)

diff --git a/docs/deployment.md b/docs/deployment.md
index 27159f2..97cc66c 100644
--- a/docs/deployment.md
+++ b/docs/deployment.md
@@ -118,3 +118,36 @@ On the target machine, you need Docker and DNS configured to point at the contai
 
 To tear down: `npx tsx deployment/manage.ts down --env-file deployment/.env`
 
+## Cold-Start and Backfill Behavior
+
+### Timeline
+
+A fresh deployment (no prior `ponder_sync` cache) reindexes from the configured start blocks. Expected durations:
+
+| Phase | Typical duration | Notes |
+|-------|-----------------|-------|
+| Event backfill | 4–10 hours | Fetches `eth_getLogs` from start block to tip. Bottleneck is RPC throughput; a generous RPC endpoint shortens this. |
+| Live-sync catch-up | 5–15 minutes | Block handlers (C1–C5) run at "latest" only. Stale TWAP candidates drain at 500/block. |
+| Full data completeness | After live-sync catch-up | All generators have candidates or discrete orders; historical TWAP parts resolved via account fallback. |
+
+A reindex that reuses an existing `ponder_sync` cache (same chain, same start blocks) skips the event backfill and completes in minutes.
+
+### `/ready` Semantics
+
+`GET /ready` returns `200` when Ponder has processed all historical blocks up to the tip and the live indexer is running. It does **not** guarantee that all historical discrete-order data is complete — that depends on the live-sync catch-up phase completing (see above).
+
+During backfill, `GET /ready` returns `503`. GraphQL queries are still available but data is incomplete (generators and transactions accumulate; discrete orders are absent until live sync starts).
+
+### Historical Discrete Order Gap
+
+Block handlers only run during live sync. TWAP parts computed during backfill land in `candidate_discrete_order` with past `validTo` dates. When live sync starts, C2 (CandidateConfirmer) promotes these via the stale sweep path:
+
+1. Tries `/orders/by_uids` — aged-out UIDs return empty
+2. Falls back to `/account/{owner}/orders` for each owner with missed UIDs
+3. Promotes with the actual API status (fulfilled/expired/cancelled) instead of defaulting to `expired`
+
+**Residual gap**: Orders that no longer appear in `/account/{owner}/orders` (beyond the CoW API's retention window) will be recorded as `expired` regardless of their actual fill status. This affects only very old orders for users with a large order history.
+
+Non-deterministic generators (PerpetualSwap, GoodAfterTime, TradeAboveThreshold, Unknown) are handled by C4 (OwnerBackfill), which calls `/account/{owner}/orders` once at live-sync start and upserts discovered orders directly into `discrete_order`.
+
+
diff --git a/src/application/handlers/blockHandler.ts b/src/application/handlers/blockHandler.ts
index dc5c822..e8abfb9 100644
--- a/src/application/handlers/blockHandler.ts
+++ b/src/application/handlers/blockHandler.ts
@@ -16,7 +16,7 @@
 
 import { ponder } from "ponder:registry";
 import { bootstrapRetryQueue, candidateDiscreteOrder, conditionalOrderGenerator, discreteOrder, discreteOrderStatusEnum } from "ponder:schema";
-import { and, asc, eq, inArray, isNull, lte, or, sql } from "ponder";
+import { and, asc, eq, gt, inArray, isNull, lte, or, sql } from "ponder";
 import type { Hex } from "viem";
 import {
   COMPOSABLE_COW_ADDRESS_BY_CHAIN_ID,
@@ -410,6 +410,10 @@ ponder.on("CandidateConfirmer:block", async ({ event, context }) => {
 
   // Promoted candidates are always deleted below — no join needed to filter them.
   // Skip TWAP parts whose validity window hasn't started (possibleValidAfterTimestamp).
+  // Also exclude already-expired candidates (validTo in the past) — the stale path
+  // below handles those via /account/{owner}/orders fallback. Without this filter,
+  // every block would call /by_uids for all remaining stale UIDs (which always miss),
+  // wasting API quota until the stale drain completes.
   const unconfirmed = await context.db.sql
     .select({
       orderUid: candidateDiscreteOrder.orderUid,
@@ -428,6 +432,10 @@ ponder.on("CandidateConfirmer:block", async ({ event, context }) => {
           isNull(candidateDiscreteOrder.possibleValidAfterTimestamp),
           lte(candidateDiscreteOrder.possibleValidAfterTimestamp, event.block.timestamp),
         ),
+        or(
+          isNull(candidateDiscreteOrder.validTo),
+          gt(candidateDiscreteOrder.validTo, Number(event.block.timestamp)),
+        ),
       ),
     ) as {
     orderUid: string;

From 16678cc15fbd2b3d06a0f47ae4fee53e33dbb6c6 Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Tue, 9 Jun 2026 19:26:25 -0300
Subject: [PATCH 23/84] feat: classify Curve/Balancer fee burners and CoW AMM
 as named order types (COW-1006)

Identifies and classifies 5 of the top 9 Unknown handler addresses:
- 0xc0fc3d (mainnet, 613 generators): Curve CowSwapBurner
- 0x995831 (mainnet, 578): Balancer v3 CowSwapFeeBurner v2
- 0x0e800d (mainnet, 30): Balancer v3 CowSwapFeeBurner v1 (deprecated)
- 0x254f3a (gnosis, 80): Balancer v3 CowSwapFeeBurner v2
- 0xb148f4 (gnosis, 110): CoW AMM ConstantProduct pool (verified)

Remaining 4 addresses stay Unknown: two unverified gnosis proxies (likely CoW AMM
but unconfirmed) and two unverified mainnet handlers from an unknown deployer.

All new types are non-deterministic. They are added to NON_DETERMINISTIC_TYPES
so C4 backfills them via /account/{owner}/orders at live-sync start.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 schema/tables.ts                         |  3 +++
 src/application/handlers/blockHandler.ts |  2 +-
 src/utils/order-types.ts                 | 21 +++++++++++++++++++++
 tests/utils/order-types.test.ts          |  3 +++
 4 files changed, 28 insertions(+), 1 deletion(-)

diff --git a/schema/tables.ts b/schema/tables.ts
index ae58d1d..dc4501d 100644
--- a/schema/tables.ts
+++ b/schema/tables.ts
@@ -11,6 +11,9 @@ export const orderTypeEnum = onchainEnum("order_type", [
   "CirclesBackingOrder",
   "SwapOrderHandler",
   "ERC4626CowSwapFeeBurner",
+  "CurveCowSwapBurner",
+  "BalancerCowSwapFeeBurner",
+  "CowAmmConstantProduct",
   "Unknown",
 ]);
 
diff --git a/src/application/handlers/blockHandler.ts b/src/application/handlers/blockHandler.ts
index dc5c822..1da89ed 100644
--- a/src/application/handlers/blockHandler.ts
+++ b/src/application/handlers/blockHandler.ts
@@ -46,7 +46,7 @@ import { log } from "../helpers/logger";
 import { type OrderType } from "../../utils/order-types";
 type DiscreteStatus = (typeof discreteOrderStatusEnum.enumValues)[number];
 
-const NON_DETERMINISTIC_TYPES: readonly OrderType[] = ["PerpetualSwap", "GoodAfterTime", "TradeAboveThreshold", "Unknown"];
+const NON_DETERMINISTIC_TYPES: readonly OrderType[] = ["PerpetualSwap", "GoodAfterTime", "TradeAboveThreshold", "CurveCowSwapBurner", "BalancerCowSwapFeeBurner", "CowAmmConstantProduct", "Unknown"];
 const SINGLE_SHOT_NON_DETERMINISTIC: readonly OrderType[] = ["GoodAfterTime", "TradeAboveThreshold"];
 const BLOCK_NEVER = 2n ** 63n - 1n; // sentinel for epoch-scheduled generators (PollTryAtEpoch)
 const VALID_DISCRETE_STATUSES = new Set(["fulfilled", "unfilled", "expired", "cancelled"]);
diff --git a/src/utils/order-types.ts b/src/utils/order-types.ts
index 93cd1b3..d40db60 100644
--- a/src/utils/order-types.ts
+++ b/src/utils/order-types.ts
@@ -21,6 +21,9 @@ export type OrderType =
   | "CirclesBackingOrder"
   | "SwapOrderHandler"
   | "ERC4626CowSwapFeeBurner"
+  | "CurveCowSwapBurner"
+  | "BalancerCowSwapFeeBurner"
+  | "CowAmmConstantProduct"
   | "Unknown";
 
 /**
@@ -43,12 +46,27 @@ export const HANDLER_ADDRESS_TO_TYPE: Record<string, OrderType> = {
 const MAINNET_ONLY_HANDLERS: Record<string, OrderType> = {
   "0xd506fe0b3ddf9e685c16e000514a835d3a511b26": "SwapOrderHandler",
   "0x816e90dc85bf016455017a76bc09cc0451eeb308": "ERC4626CowSwapFeeBurner",
+  // Curve Finance fee-burn handler: converts protocol fees → target token via CoW swap.
+  // Source: https://docs.curve.finance/fees/CowSwapBurner/ — Vyper 0.3.10, verified.
+  "0xc0fc3ddfec95ca45a0d2393f518d3ea1ccf44f8b": "CurveCowSwapBurner",
+  // Balancer v3 CowSwapFeeBurner: burns protocol fees via CoW swap.
+  // v2 (current): deployed via 20250530-v3-cow-swap-fee-burner-v2 task.
+  "0x9958317b80ee5f10457017d54c2484d722059157": "BalancerCowSwapFeeBurner",
+  // v1 (deprecated): deployed via 20250221-v3-cow-swap-fee-burner (now in deprecated/).
+  "0x0e800d8d2e8b4694610aedc385aa6d763492b106": "BalancerCowSwapFeeBurner",
 };
 
 const GNOSIS_ONLY_HANDLERS: Record<string, OrderType> = {
   "0x43866c5602b0e3b3272424396e88b849796dc608": "CirclesBackingOrder",
   "0x7a77934d32d78bfe8dc1e23415b5679960a1c610": "SwapOrderHandler",
   "0x5915dea04ce390f0f44ca0806f7c6dd99ce2f941": "ERC4626CowSwapFeeBurner",
+  // Balancer v3 CowSwapFeeBurner v2 on Gnosis.
+  // Deployed via 20250530-v3-cow-swap-fee-burner-v2 task.
+  "0x254f3a2974b97dc2e675f6115c845567c55f83b0": "BalancerCowSwapFeeBurner",
+  // CoW AMM ConstantProduct pool (verified). Each pool instance IS its own handler —
+  // the pool address equals the handler address. Factory: ConstantProductFactory.
+  // Source: https://github.com/cowprotocol/cow-amm
+  "0xb148f40fff05b5ce6b22752cf8e454b556f7a851": "CowAmmConstantProduct",
 };
 
 const HANDLER_MAP: Record<number, Record<string, OrderType>> = {
@@ -86,5 +104,8 @@ export const DETERMINISTIC_ORDER_TYPE: Record<OrderType, boolean> = {
   TradeAboveThreshold: false,
   SwapOrderHandler: false,
   ERC4626CowSwapFeeBurner: false,
+  CurveCowSwapBurner: false,
+  BalancerCowSwapFeeBurner: false,
+  CowAmmConstantProduct: false,
   Unknown: false,
 };
diff --git a/tests/utils/order-types.test.ts b/tests/utils/order-types.test.ts
index 46e39d0..ce92226 100644
--- a/tests/utils/order-types.test.ts
+++ b/tests/utils/order-types.test.ts
@@ -25,6 +25,9 @@ describe("DETERMINISTIC_ORDER_TYPE", () => {
     expect(DETERMINISTIC_ORDER_TYPE["TradeAboveThreshold"]).toBe(false);
     expect(DETERMINISTIC_ORDER_TYPE["SwapOrderHandler"]).toBe(false);
     expect(DETERMINISTIC_ORDER_TYPE["ERC4626CowSwapFeeBurner"]).toBe(false);
+    expect(DETERMINISTIC_ORDER_TYPE["CurveCowSwapBurner"]).toBe(false);
+    expect(DETERMINISTIC_ORDER_TYPE["BalancerCowSwapFeeBurner"]).toBe(false);
+    expect(DETERMINISTIC_ORDER_TYPE["CowAmmConstantProduct"]).toBe(false);
     expect(DETERMINISTIC_ORDER_TYPE["Unknown"]).toBe(false);
   });
 });

From 20457aefeccee78f6f0cf3f5b3202be4641d9f59 Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Wed, 10 Jun 2026 18:12:20 -0300
Subject: [PATCH 24/84] perf: add composite indexes for C1/C5, C3, and C2 stale
 sweep (COW-886)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- generator_c1c5_poll_idx(chainId, status, allCandidatesKnown, lastCheckBlock):
  covers C1 and C5 per-block SELECTs which filter on all four columns and
  ORDER BY lastCheckBlock. Replaces the old partial generator_check_block_active_idx
  (nextCheckBlock, status) which did not cover chainId or allCandidatesKnown.

- discrete_order_c3_status_idx(chainId, status, promotedAt):
  covers C3 per-block SELECT WHERE chainId + status='open' ORDER BY promotedAt.
  The previous statusIdx(status) had no chainId and no promotedAt — PostgreSQL
  would need a separate sort step on every block.

- candidate_discrete_order_stale_idx(chainId, validTo):
  covers C2 stale sweep SELECT WHERE chainId + validTo <= timestamp LIMIT 500.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 schema/tables.ts | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/schema/tables.ts b/schema/tables.ts
index ae58d1d..2b6fb07 100644
--- a/schema/tables.ts
+++ b/schema/tables.ts
@@ -86,8 +86,11 @@ export const conditionalOrderGenerator = onchainTable(
     chainOwnerIdx: index().on(table.chainId, table.owner),
     resolvedOwnerIdx: index().on(table.resolvedOwner),
     ownerAddressTypeIdx: index().on(table.ownerAddressType),
-    checkBlockActiveIdx: index("generator_check_block_active_idx")
-      .on(table.nextCheckBlock, table.status),
+    // C1 (OrderDiscoveryPoller) + C5 (CancellationWatcher): per-block SELECT with
+    // chainId + status + allCandidatesKnown equality filters, ORDER BY lastCheckBlock.
+    // Covers both handlers — C1 queries allCandidatesKnown=false, C5 queries true.
+    c1c5PollIdx: index("generator_c1c5_poll_idx")
+      .on(table.chainId, table.status, table.allCandidatesKnown, table.lastCheckBlock),
   })
 );
 
@@ -111,7 +114,9 @@ export const discreteOrder = onchainTable(
     pk: primaryKey({ columns: [table.chainId, table.orderUid] }),
     generatorIdx: index("discrete_order_generator_idx")
       .on(table.chainId, table.conditionalOrderGeneratorId),
-    statusIdx: index("discrete_order_status_idx").on(table.status),
+    // C3 (OrderStatusTracker): per-block SELECT with chainId + status='open', ORDER BY promotedAt.
+    c3StatusIdx: index("discrete_order_c3_status_idx")
+      .on(table.chainId, table.status, table.promotedAt),
   })
 );
 
@@ -132,6 +137,9 @@ export const candidateDiscreteOrder = onchainTable(
     pk: primaryKey({ columns: [table.chainId, table.orderUid] }),
     generatorIdx: index("candidate_discrete_order_generator_idx")
       .on(table.chainId, table.conditionalOrderGeneratorId),
+    // C2 stale sweep: SELECT WHERE chainId + validTo <= timestamp LIMIT 500.
+    staleIdx: index("candidate_discrete_order_stale_idx")
+      .on(table.chainId, table.validTo),
   })
 );
 

From 6811848a47361ebc856aecae4aa7c1f111a2263a Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Wed, 10 Jun 2026 18:19:46 -0300
Subject: [PATCH 25/84] fix: derive isComplete from isRealtime+pct instead of
 ponder_sync_is_complete (COW-1008)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

ponder_sync_is_complete never reaches 1 for chains with live block handlers
(C1–C5 run indefinitely). isComplete is now computed locally as
isRealtime && pct >= 100, which correctly reflects sync completion.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 src/api/endpoints/sync-progress.ts |  4 +++-
 tests/api/sync-progress.test.ts    | 28 ++++++++++++++++++++++++++--
 2 files changed, 29 insertions(+), 3 deletions(-)

diff --git a/src/api/endpoints/sync-progress.ts b/src/api/endpoints/sync-progress.ts
index 4caf985..7678fdf 100644
--- a/src/api/endpoints/sync-progress.ts
+++ b/src/api/endpoints/sync-progress.ts
@@ -74,7 +74,9 @@ export const syncProgressHandler: RouteHandler<typeof syncProgressRoute> =
         processedBlocks: processed,
         historicalBlocksFetchedPct: pct,
         isRealtime: (isRealtime.get(chain) ?? 0) === 1,
-        isComplete: (isComplete.get(chain) ?? 0) === 1,
+        // ponder_sync_is_complete never reaches 1 for chains with live block handlers
+        // (C1–C5 run indefinitely). Derive locally: synced means realtime + all blocks processed.
+        isComplete: (isRealtime.get(chain) ?? 0) === 1 && pct >= 100,
       };
     }
 
diff --git a/tests/api/sync-progress.test.ts b/tests/api/sync-progress.test.ts
index b39e401..97e0727 100644
--- a/tests/api/sync-progress.test.ts
+++ b/tests/api/sync-progress.test.ts
@@ -95,14 +95,38 @@ describe("GET /api/sync-progress", () => {
     expect(body["gnosis"]!.historicalBlocksFetchedPct).toBe(14.1);
   });
 
-  it("sets isRealtime and isComplete from metrics flags", async () => {
+  it("sets isRealtime from ponder_sync_is_realtime metric", async () => {
     mockFetch(SAMPLE_METRICS);
     const app = buildApp();
     const res = await app.request("http://localhost/api/sync-progress");
     const body = (await res.json()) as Record<string, ChainProgress>;
     expect(body["mainnet"]!.isRealtime).toBe(false);
-    expect(body["mainnet"]!.isComplete).toBe(false);
     expect(body["gnosis"]!.isRealtime).toBe(true);
+  });
+
+  it("isComplete requires both isRealtime=true and pct>=100 (ignores ponder_sync_is_complete)", async () => {
+    // gnosis is realtime but only 14.1% processed — must NOT be complete
+    mockFetch(SAMPLE_METRICS);
+    const app = buildApp();
+    const res = await app.request("http://localhost/api/sync-progress");
+    const body = (await res.json()) as Record<string, ChainProgress>;
+    expect(body["gnosis"]!.isRealtime).toBe(true);
+    expect(body["gnosis"]!.isComplete).toBe(false);
+  });
+
+  it("isComplete is true when isRealtime=true and all blocks processed", async () => {
+    // Regression: ponder_sync_is_complete=0 must not block isComplete when realtime+100%
+    const fullSyncMetrics = `
+ponder_historical_total_blocks{chain="gnosis"} 1000
+ponder_historical_completed_blocks{chain="gnosis"} 600
+ponder_historical_cached_blocks{chain="gnosis"} 400
+ponder_sync_is_realtime{chain="gnosis"} 1
+ponder_sync_is_complete{chain="gnosis"} 0
+`.trim();
+    mockFetch(fullSyncMetrics);
+    const app = buildApp();
+    const res = await app.request("http://localhost/api/sync-progress");
+    const body = (await res.json()) as Record<string, ChainProgress>;
     expect(body["gnosis"]!.isComplete).toBe(true);
   });
 

From 0bcf1331bb1ede0aa2d5e486671b3af50e8e14fb Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Wed, 10 Jun 2026 18:21:15 -0300
Subject: [PATCH 26/84] refactor: use event.block.timestamp directly and type
 ComposableOrder.creationDate as bigint (COW-1007)

blockHandler.ts used BigInt(Number(event.block.timestamp)) which unnecessarily
round-trips through Number. orderbookClient's ComposableOrder declared creationDate
as number, requiring a BigInt() cast at every DB insert site. Both are now consistent
with the bigint column type and the rest of the codebase's timestamp handling.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 src/application/handlers/blockHandler.ts   |  2 +-
 src/application/helpers/orderbookClient.ts | 11 +++++------
 2 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/src/application/handlers/blockHandler.ts b/src/application/handlers/blockHandler.ts
index dc5c822..0cf5ebe 100644
--- a/src/application/handlers/blockHandler.ts
+++ b/src/application/handlers/blockHandler.ts
@@ -192,7 +192,7 @@ ponder.on("OrderDiscoveryPoller:block", async ({ event, context }) => {
             buyAmount: orderData.buyAmount.toString(),
             feeAmount: orderData.feeAmount.toString(),
             validTo: orderData.validTo,
-            creationDate: BigInt(Number(event.block.timestamp)),
+            creationDate: event.block.timestamp,
           })
           .onConflictDoNothing(),
       );
diff --git a/src/application/helpers/orderbookClient.ts b/src/application/helpers/orderbookClient.ts
index 0b99df5..f6ea119 100644
--- a/src/application/helpers/orderbookClient.ts
+++ b/src/application/helpers/orderbookClient.ts
@@ -46,8 +46,7 @@ interface OrderbookOrder {
 }
 
 /** Processed composable order stored in cache and returned to callers.
- *  Shares field types with the discreteOrder schema for the DB-mapped fields.
- *  creationDate is number here (unix seconds) and converted to bigint at insert time. */
+ *  Shares field types with the discreteOrder schema for the DB-mapped fields. */
 export type ComposableOrder = Pick<
   typeof discreteOrder.$inferInsert,
   "status" | "sellAmount" | "buyAmount" | "feeAmount" | "validTo" | "executedSellAmount" | "executedBuyAmount"
@@ -56,7 +55,7 @@ export type ComposableOrder = Pick<
   generatorId: string;
   generatorHash: string;
   orderType: OrderType;
-  creationDate: number;
+  creationDate: bigint;
 };
 
 /** Status + executed amounts returned by fetchOrderStatusByUids. */
@@ -187,7 +186,7 @@ export async function upsertDiscreteOrders(
         buyAmount: order.buyAmount,
         feeAmount: order.feeAmount,
         validTo: order.validTo,
-        creationDate: BigInt(order.creationDate),
+        creationDate: order.creationDate,
         executedSellAmount: order.executedSellAmount,
         executedBuyAmount: order.executedBuyAmount,
       })
@@ -278,7 +277,7 @@ export async function fetchOrderStatusByUids(
           buyAmount: order.buyAmount,
           feeAmount: order.feeAmount,
           validTo: order.validTo,
-          creationDate: 0,
+          creationDate: 0n,
           executedSellAmount: order.executedSellAmount,
           executedBuyAmount: order.executedBuyAmount,
         });
@@ -473,7 +472,7 @@ async function filterAndProcess(
       buyAmount: order.buyAmount,
       feeAmount: order.feeAmount,
       validTo: order.validTo,
-      creationDate: Math.floor(new Date(order.creationDate).getTime() / 1000),
+      creationDate: BigInt(Math.floor(new Date(order.creationDate).getTime() / 1000)),
       executedSellAmount: order.executedSellAmount,
       executedBuyAmount: order.executedBuyAmount,
     });

From cefb22a87f111210661b7246752f68eaa8df6c89 Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Wed, 10 Jun 2026 18:27:08 -0300
Subject: [PATCH 27/84] fix: add missing ORDERBOOK_HTTP_TIMEOUT_MS import; sync
 hash field description in test (final-qa merge cleanup)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 src/application/handlers/blockHandler.ts | 1 +
 tests/api/orders-by-owner.test.ts        | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/application/handlers/blockHandler.ts b/src/application/handlers/blockHandler.ts
index 5dc20f5..33b7c02 100644
--- a/src/application/handlers/blockHandler.ts
+++ b/src/application/handlers/blockHandler.ts
@@ -28,6 +28,7 @@ import {
   DEFAULT_MAX_DISCRETE_ORDERS_PER_BLOCK,
   DEFAULT_MAX_GENERATORS_PER_BLOCK,
   DETERMINISTIC_CANCEL_SWEEP_INTERVAL,
+  ORDERBOOK_HTTP_TIMEOUT_MS,
   RECHECK_INTERVAL,
   TRY_NEXT_BLOCK_WARMUP_THRESHOLD,
   TRY_NEXT_BLOCK_COOLDOWN_THRESHOLD,
diff --git a/tests/api/orders-by-owner.test.ts b/tests/api/orders-by-owner.test.ts
index eaa3614..57a5ce1 100644
--- a/tests/api/orders-by-owner.test.ts
+++ b/tests/api/orders-by-owner.test.ts
@@ -214,7 +214,7 @@ describe("GeneratorSummary schema", () => {
     const shape = GeneratorSummary.shape;
     const description = shape.hash.description;
     expect(description).toBe(
-      "On-chain canonical identifier: keccak256(abi.encode((handler, salt, staticInput))). Used by ComposableCow.singleOrders(owner, hash) and remove(owner, hash).",
+      "On-chain canonical identifier: keccak256(abi.encode(ConditionalOrderParams { handler, salt, staticInput })) — the value returned by ComposableCow.hash(params) and used as the key in singleOrders(owner, hash) and remove(owner, hash).",
     );
   });
 

From 839bc30fdfcd43f2f78256b9490eee05978dd8f6 Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Mon, 15 Jun 2026 04:46:44 -0300
Subject: [PATCH 28/84] fix: replace context.db.sql writes with ORM in
 SettlementResolver block handler
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

context.db.sql write operations call indexingCache.flush() internally, which
creates SAVEPOINTs inside the outer block transaction. Under multichain realtime
conditions indexingCache.qb can be the raw connection pool instead of the active
transaction, causing "SAVEPOINT can only be used in transaction blocks" and
crashing the indexer on every block tick.

Replace both context.db.sql.delete(settlementQueue) calls with context.db.delete
(safe ORM path, writes to in-memory cache, no flush). Remove the
context.db.sql.update(conditionalOrderGenerator) call entirely — ownerMapping
already records FlashLoanHelper addresses; the denormalised field on
conditionalOrderGenerator can be re-added via a safe ORM update by PK in a
follow-up task.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 src/application/handlers/settlement.ts | 19 ++-----------------
 1 file changed, 2 insertions(+), 17 deletions(-)

diff --git a/src/application/handlers/settlement.ts b/src/application/handlers/settlement.ts
index 3aad857..7d4f629 100644
--- a/src/application/handlers/settlement.ts
+++ b/src/application/handlers/settlement.ts
@@ -1,7 +1,6 @@
 import { ponder } from "ponder:registry";
 import {
   AddressType,
-  conditionalOrderGenerator,
   ownerMapping,
   settlementQueue,
   transaction,
@@ -114,9 +113,7 @@ ponder.on("SettlementResolver:block", async ({ event: _event, context }) => {
       );
     } catch (err) {
       log("warn", "SettlementResolver:receipt_failed", { chainId, txHash: item.txHash, err: err instanceof Error ? err.message : String(err) });
-      await context.db.sql
-        .delete(settlementQueue)
-        .where(and(eq(settlementQueue.chainId, chainId), eq(settlementQueue.txHash, item.txHash)));
+      await context.db.delete(settlementQueue, { chainId, txHash: item.txHash });
       continue;
     }
 
@@ -227,25 +224,13 @@ ponder.on("SettlementResolver:block", async ({ event: _event, context }) => {
         })
         .onConflictDoNothing();
 
-      await context.db.sql
-        .update(conditionalOrderGenerator)
-        .set({ ownerAddressType: AddressType.FlashLoanHelper })
-        .where(
-          and(
-            eq(conditionalOrderGenerator.chainId, chainId),
-            eq(conditionalOrderGenerator.owner, ownerAddress),
-          ),
-        );
-
       stats.mapped++;
       logStatsIfIntervalPassed();
 
       log("info", "SettlementResolver:aave_adapter_mapped", { chainId, adapter: ownerAddress, eoa: eoaOwner.toLowerCase(), block: String(item.blockNumber) });
     }
 
-    await context.db.sql
-      .delete(settlementQueue)
-      .where(and(eq(settlementQueue.chainId, chainId), eq(settlementQueue.txHash, item.txHash)));
+    await context.db.delete(settlementQueue, { chainId, txHash: item.txHash });
 
     logStatsIfIntervalPassed();
   }

From 08f2cfef94f3c1ed8a440cc946aa272a15c1f00a Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Mon, 15 Jun 2026 09:57:51 -0300
Subject: [PATCH 29/84] chore: upgrade ponder from 0.16.3 to 0.16.6

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 package.json   |  4 ++--
 pnpm-lock.yaml | 18 +++++++++---------
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/package.json b/package.json
index da50219..e54fb1a 100644
--- a/package.json
+++ b/package.json
@@ -17,11 +17,11 @@
   },
   "dependencies": {
     "@cowprotocol/cow-sdk": "^7.3.8",
-    "drizzle-orm": "0.41.0",
     "@hono/swagger-ui": "^0.5.3",
     "@hono/zod-openapi": "^0.19.10",
+    "drizzle-orm": "0.41.0",
     "hono": "^4.5.0",
-    "ponder": "^0.16.2",
+    "ponder": "^0.16.6",
     "ponder-enrich-gql-docs-middleware": "^0.1.3",
     "viem": "^2.21.3",
     "zod": "^3.25.76"
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index b4eb45f..c91bf08 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -24,8 +24,8 @@ importers:
         specifier: ^4.5.0
         version: 4.12.3
       ponder:
-        specifier: ^0.16.2
-        version: 0.16.3(@opentelemetry/api@1.9.0)(@types/node@20.19.35)(hono@4.12.3)(typescript@5.9.3)(viem@2.46.3(typescript@5.9.3)(zod@3.25.76))(zod@3.25.76)
+        specifier: ^0.16.6
+        version: 0.16.6(@opentelemetry/api@1.9.0)(@types/node@20.19.35)(hono@4.12.3)(typescript@5.9.3)(viem@2.46.3(typescript@5.9.3)(zod@3.25.76))(zod@3.25.76)
       ponder-enrich-gql-docs-middleware:
         specifier: ^0.1.3
         version: 0.1.3(graphql@16.8.2)(hono@4.12.3)
@@ -797,8 +797,8 @@ packages:
     resolution: {integrity: sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==}
     engines: {node: '>=14'}
 
-  '@ponder/utils@0.2.17':
-    resolution: {integrity: sha512-ins3XXzm+2jMGa0aTc1N10JG0Sau9Vvk71llOatkEOkncMne9m/mMYxJsV6WfRaZGlo4FB8OoRM6DVPHZlRGHA==}
+  '@ponder/utils@0.2.18':
+    resolution: {integrity: sha512-pWacQuohfKlKO440zC39C1l6AH+Vx18mca0cPkxM0YnrB70px5hEwLKrc3fU4DMu72j4pljy/Mvfm95FBouYjw==}
     peerDependencies:
       typescript: '>=5.0.4'
       viem: '>=2'
@@ -2226,8 +2226,8 @@ packages:
       graphql: ^16.10.0
       hono: ^4.6.19
 
-  ponder@0.16.3:
-    resolution: {integrity: sha512-QwAg5eFUujWR87ZMeTTKmF17q9IVTew26tpdaTfQrrtJVf/oU8ZN1qu7ZcP2SPtK5oScblJMWQm9zfwst6tJcg==}
+  ponder@0.16.6:
+    resolution: {integrity: sha512-y4JusgnLZ9uACTr9pj0DjfPSqlsaSLJ7Gxpe/ByfwR5fHuwoPOoolix+Y+9EPqs0cr1KxrG35aVBCR0kT+LJew==}
     engines: {node: '>=18.14'}
     hasBin: true
     peerDependencies:
@@ -3436,7 +3436,7 @@ snapshots:
   '@pkgjs/parseargs@0.11.0':
     optional: true
 
-  '@ponder/utils@0.2.17(typescript@5.9.3)(viem@2.46.3(typescript@5.9.3)(zod@3.25.76))':
+  '@ponder/utils@0.2.18(typescript@5.9.3)(viem@2.46.3(typescript@5.9.3)(zod@3.25.76))':
     dependencies:
       viem: 2.46.3(typescript@5.9.3)(zod@3.25.76)
     optionalDependencies:
@@ -4844,7 +4844,7 @@ snapshots:
       graphql: 16.8.2
       hono: 4.12.3
 
-  ponder@0.16.3(@opentelemetry/api@1.9.0)(@types/node@20.19.35)(hono@4.12.3)(typescript@5.9.3)(viem@2.46.3(typescript@5.9.3)(zod@3.25.76))(zod@3.25.76):
+  ponder@0.16.6(@opentelemetry/api@1.9.0)(@types/node@20.19.35)(hono@4.12.3)(typescript@5.9.3)(viem@2.46.3(typescript@5.9.3)(zod@3.25.76))(zod@3.25.76):
     dependencies:
       '@babel/code-frame': 7.29.0
       '@commander-js/extra-typings': 12.1.0(commander@12.1.0)
@@ -4853,7 +4853,7 @@ snapshots:
       '@escape.tech/graphql-armor-max-depth': 2.4.2
       '@escape.tech/graphql-armor-max-tokens': 2.5.1
       '@hono/node-server': 1.19.5(hono@4.12.3)
-      '@ponder/utils': 0.2.17(typescript@5.9.3)(viem@2.46.3(typescript@5.9.3)(zod@3.25.76))
+      '@ponder/utils': 0.2.18(typescript@5.9.3)(viem@2.46.3(typescript@5.9.3)(zod@3.25.76))
       abitype: 0.10.3(typescript@5.9.3)(zod@3.25.76)
       ansi-escapes: 7.3.0
       commander: 12.1.0

From 4d4a8557503b17f0fe7a63c23602cfe8816c936b Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Mon, 15 Jun 2026 10:06:02 -0300
Subject: [PATCH 30/84] fix: patch ponder flush() to use unique savepoint names
 per invocation

Concurrent context.db.sql calls (e.g. Promise.all in OrderDiscoveryPoller)
each trigger indexingCache.flush(), which issues SAVEPOINT flush / RELEASE flush
on the same PostgreSQL transaction. Because all calls use the hardcoded name
"flush", concurrent invocations corrupt each other: the second SAVEPOINT flush
replaces the first, so RELEASE flush from the first call releases the wrong
savepoint and the second gets "savepoint flush does not exist".

Adds a per-instance counter (_flushId) and generates flush_N as the savepoint
name for each flush() call. All SAVEPOINT, RELEASE, and ROLLBACK TO references
within one flush invocation use the same unique name, preserving the existing
retry semantics while eliminating name collisions across concurrent calls.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 patches/ponder@0.16.6.patch | 73 +++++++++++++++++++++++++++++++++++++
 pnpm-workspace.yaml         |  2 +
 2 files changed, 75 insertions(+)
 create mode 100644 patches/ponder@0.16.6.patch
 create mode 100644 pnpm-workspace.yaml

diff --git a/patches/ponder@0.16.6.patch b/patches/ponder@0.16.6.patch
new file mode 100644
index 0000000..f075726
--- /dev/null
+++ b/patches/ponder@0.16.6.patch
@@ -0,0 +1,73 @@
+diff --git a/dist/esm/indexing-store/cache.js b/dist/esm/indexing-store/cache.js
+index e2f6a03650b5b80cae9ec4dc0a8837cb054cae18..333eec6cd7951ede6121474576f9367f5edb0262 100644
+--- a/dist/esm/indexing-store/cache.js
++++ b/dist/esm/indexing-store/cache.js
+@@ -157,6 +157,7 @@ export const recoverBatchError = async (values, callback) => {
+ export const createIndexingCache = ({ common, schemaBuild: { schema }, crashRecoveryCheckpoint, eventCount, chainId, }) => {
+     let event;
+     let qb = undefined;
++    let _flushId = 0;
+     const cache = new Map();
+     const insertBuffer = new Map();
+     const updateBuffer = new Map();
+@@ -283,6 +284,7 @@ export const createIndexingCache = ({ common, schemaBuild: { schema }, crashReco
+             return inInsertBuffer || inUpdateBuffer || inDb;
+         },
+         async flush({ tableNames } = {}) {
++            const sp = `flush_${++_flushId}`;
+             const context = {
+                 logger: common.logger.child({ action: "flush_database_rows" }),
+             };
+@@ -392,9 +394,9 @@ export const createIndexingCache = ({ common, schemaBuild: { schema }, crashReco
+             };
+             try {
+                 if (qb.$dialect === "postgres") {
+-                    await qb.wrap((db) => db.execute("SAVEPOINT flush"), context);
++                    await qb.wrap((db) => db.execute(`SAVEPOINT ${sp}`), context);
+                     await promiseAllSettledWithThrow(Array.from(cache.keys()).map(flushTable));
+-                    await qb.wrap((db) => db.execute("RELEASE flush"), context);
++                    await qb.wrap((db) => db.execute(`RELEASE ${sp}`), context);
+                 }
+                 else {
+                     // Note: pglite must run sequentially
+@@ -411,7 +413,7 @@ export const createIndexingCache = ({ common, schemaBuild: { schema }, crashReco
+                 // Note `isFlushRetry` is true when the previous flush failed. When `isFlushRetry` is false, this
+                 // function takes an optimized fast path, with support for small batch sizes. PGlite always takes
+                 // the fast path because it doesn't support delayed insert errors.
+-                await qb.wrap((db) => db.execute("ROLLBACK to flush"), context);
++                await qb.wrap((db) => db.execute(`ROLLBACK to ${sp}`), context);
+                 for (const table of cache.keys()) {
+                     if (tableNames !== undefined &&
+                         tableNames.has(getTableName(table)) === false) {
+@@ -424,12 +426,12 @@ export const createIndexingCache = ({ common, schemaBuild: { schema }, crashReco
+                     const updateValues = Array.from(updateBuffer.get(table).values());
+                     if (insertValues.length > 0) {
+                         const endClock = startClock();
+-                        await qb.wrap((db) => db.execute("SAVEPOINT flush"), context);
++                        await qb.wrap((db) => db.execute(`SAVEPOINT ${sp}`), context);
+                         const result = await recoverBatchError(insertValues, async (values) => {
+-                            await qb.wrap((db) => db.execute("ROLLBACK to flush"), context);
++                            await qb.wrap((db) => db.execute(`ROLLBACK to ${sp}`), context);
+                             const text = getCopyText(table, values.map(({ row }) => row));
+                             await copy(table, text);
+-                            await qb.wrap((db) => db.execute("SAVEPOINT flush"), context);
++                            await qb.wrap((db) => db.execute(`SAVEPOINT ${sp}`), context);
+                         });
+                         if (result.status === "error") {
+                             error = new DelayedInsertError(result.error.message);
+@@ -472,12 +474,12 @@ export const createIndexingCache = ({ common, schemaBuild: { schema }, crashReco
+             `;
+                         const endClock = startClock();
+                         await qb.wrap((db) => db.execute(createTempTableQuery), context);
+-                        await qb.wrap((db) => db.execute("SAVEPOINT flush"), context);
++                        await qb.wrap((db) => db.execute(`SAVEPOINT ${sp}`), context);
+                         const result = await recoverBatchError(updateValues, async (values) => {
+-                            await qb.wrap((db) => db.execute("ROLLBACK to flush"), context);
++                            await qb.wrap((db) => db.execute(`ROLLBACK to ${sp}`), context);
+                             const text = getCopyText(table, values.map(({ row }) => row));
+                             await copy(table, text, false);
+-                            await qb.wrap((db) => db.execute("SAVEPOINT flush"), context);
++                            await qb.wrap((db) => db.execute(`SAVEPOINT ${sp}`), context);
+                         });
+                         await qb.wrap((db) => db.execute(`TRUNCATE TABLE "${target}"`), context);
+                         if (result.status === "error") {
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
new file mode 100644
index 0000000..a3ea2e9
--- /dev/null
+++ b/pnpm-workspace.yaml
@@ -0,0 +1,2 @@
+patchedDependencies:
+  ponder@0.16.6: patches/ponder@0.16.6.patch

From eaaef905c674339a75e55ff8ac16986f82ce4560 Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Mon, 15 Jun 2026 10:07:59 -0300
Subject: [PATCH 31/84] chore: add pnpm-workspace.yaml and patches/ to
 Dockerfile build stage

Required for pnpm patched dependencies to be applied during Docker build.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 Dockerfile | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/Dockerfile b/Dockerfile
index 7fd307b..4dffd06 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -9,7 +9,8 @@ WORKDIR /usr/src/app
 # ---- build stage ----
 FROM base AS build
 
-COPY package.json pnpm-lock.yaml ./
+COPY package.json pnpm-lock.yaml pnpm-workspace.yaml ./
+COPY patches/ patches/
 RUN pnpm install --frozen-lockfile
 
 COPY . .

From 8effd7883b2624c6dc92346e5a060152050a2cf4 Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Mon, 15 Jun 2026 10:07:59 -0300
Subject: [PATCH 32/84] chore: add pnpm-workspace.yaml and patches/ to
 Dockerfile build stage

Required for pnpm patched dependencies to be applied during Docker build.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 Dockerfile | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/Dockerfile b/Dockerfile
index 7fd307b..4dffd06 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -9,7 +9,8 @@ WORKDIR /usr/src/app
 # ---- build stage ----
 FROM base AS build
 
-COPY package.json pnpm-lock.yaml ./
+COPY package.json pnpm-lock.yaml pnpm-workspace.yaml ./
+COPY patches/ patches/
 RUN pnpm install --frozen-lockfile
 
 COPY . .

From 3279e91f9a3327ca9535f1642036b120ea91e858 Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Mon, 15 Jun 2026 10:10:02 -0300
Subject: [PATCH 33/84] chore: update pnpm-lock.yaml with ponder patch hash

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 pnpm-lock.yaml | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index c91bf08..cee4903 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -4,6 +4,11 @@ settings:
   autoInstallPeers: true
   excludeLinksFromLockfile: false
 
+patchedDependencies:
+  ponder@0.16.6:
+    hash: f8e8c82e422f563e9c2f3ac2442cc7c69ddd415c4dc1071b411db5ccaa50bd1f
+    path: patches/ponder@0.16.6.patch
+
 importers:
 
   .:
@@ -25,7 +30,7 @@ importers:
         version: 4.12.3
       ponder:
         specifier: ^0.16.6
-        version: 0.16.6(@opentelemetry/api@1.9.0)(@types/node@20.19.35)(hono@4.12.3)(typescript@5.9.3)(viem@2.46.3(typescript@5.9.3)(zod@3.25.76))(zod@3.25.76)
+        version: 0.16.6(patch_hash=f8e8c82e422f563e9c2f3ac2442cc7c69ddd415c4dc1071b411db5ccaa50bd1f)(@opentelemetry/api@1.9.0)(@types/node@20.19.35)(hono@4.12.3)(typescript@5.9.3)(viem@2.46.3(typescript@5.9.3)(zod@3.25.76))(zod@3.25.76)
       ponder-enrich-gql-docs-middleware:
         specifier: ^0.1.3
         version: 0.1.3(graphql@16.8.2)(hono@4.12.3)
@@ -4844,7 +4849,7 @@ snapshots:
       graphql: 16.8.2
       hono: 4.12.3
 
-  ponder@0.16.6(@opentelemetry/api@1.9.0)(@types/node@20.19.35)(hono@4.12.3)(typescript@5.9.3)(viem@2.46.3(typescript@5.9.3)(zod@3.25.76))(zod@3.25.76):
+  ponder@0.16.6(patch_hash=f8e8c82e422f563e9c2f3ac2442cc7c69ddd415c4dc1071b411db5ccaa50bd1f)(@opentelemetry/api@1.9.0)(@types/node@20.19.35)(hono@4.12.3)(typescript@5.9.3)(viem@2.46.3(typescript@5.9.3)(zod@3.25.76))(zod@3.25.76):
     dependencies:
       '@babel/code-frame': 7.29.0
       '@commander-js/extra-typings': 12.1.0(commander@12.1.0)

From 86b9d15dad74602bf05ed076fffdd2c7fdd2ea55 Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Mon, 15 Jun 2026 10:10:02 -0300
Subject: [PATCH 34/84] chore: update pnpm-lock.yaml with ponder patch hash

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 pnpm-lock.yaml | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index c91bf08..cee4903 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -4,6 +4,11 @@ settings:
   autoInstallPeers: true
   excludeLinksFromLockfile: false
 
+patchedDependencies:
+  ponder@0.16.6:
+    hash: f8e8c82e422f563e9c2f3ac2442cc7c69ddd415c4dc1071b411db5ccaa50bd1f
+    path: patches/ponder@0.16.6.patch
+
 importers:
 
   .:
@@ -25,7 +30,7 @@ importers:
         version: 4.12.3
       ponder:
         specifier: ^0.16.6
-        version: 0.16.6(@opentelemetry/api@1.9.0)(@types/node@20.19.35)(hono@4.12.3)(typescript@5.9.3)(viem@2.46.3(typescript@5.9.3)(zod@3.25.76))(zod@3.25.76)
+        version: 0.16.6(patch_hash=f8e8c82e422f563e9c2f3ac2442cc7c69ddd415c4dc1071b411db5ccaa50bd1f)(@opentelemetry/api@1.9.0)(@types/node@20.19.35)(hono@4.12.3)(typescript@5.9.3)(viem@2.46.3(typescript@5.9.3)(zod@3.25.76))(zod@3.25.76)
       ponder-enrich-gql-docs-middleware:
         specifier: ^0.1.3
         version: 0.1.3(graphql@16.8.2)(hono@4.12.3)
@@ -4844,7 +4849,7 @@ snapshots:
       graphql: 16.8.2
       hono: 4.12.3
 
-  ponder@0.16.6(@opentelemetry/api@1.9.0)(@types/node@20.19.35)(hono@4.12.3)(typescript@5.9.3)(viem@2.46.3(typescript@5.9.3)(zod@3.25.76))(zod@3.25.76):
+  ponder@0.16.6(patch_hash=f8e8c82e422f563e9c2f3ac2442cc7c69ddd415c4dc1071b411db5ccaa50bd1f)(@opentelemetry/api@1.9.0)(@types/node@20.19.35)(hono@4.12.3)(typescript@5.9.3)(viem@2.46.3(typescript@5.9.3)(zod@3.25.76))(zod@3.25.76):
     dependencies:
       '@babel/code-frame': 7.29.0
       '@commander-js/extra-typings': 12.1.0(commander@12.1.0)

From 8b02433a35c481087bbe85e5d3a63d250060b4ff Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Mon, 15 Jun 2026 14:07:23 -0300
Subject: [PATCH 35/84] fix: snapshot qb at flush() start to prevent mid-flush
 external mutation

indexingCache.qb is mutated by multichain.ts between SAVEPOINT and RELEASE
within the same flush() invocation. Captures qb as currentQb at flush() start
so all SAVEPOINT/RELEASE/ROLLBACK TO and qb.wrap calls use a stable connection
reference regardless of external mutations during async flushTable operations.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 patches/ponder@0.16.6.patch | 86 +++++++++++++++++++++++++++++--------
 pnpm-lock.yaml              |  6 +--
 2 files changed, 71 insertions(+), 21 deletions(-)

diff --git a/patches/ponder@0.16.6.patch b/patches/ponder@0.16.6.patch
index f075726..a20b362 100644
--- a/patches/ponder@0.16.6.patch
+++ b/patches/ponder@0.16.6.patch
@@ -1,5 +1,5 @@
 diff --git a/dist/esm/indexing-store/cache.js b/dist/esm/indexing-store/cache.js
-index e2f6a03650b5b80cae9ec4dc0a8837cb054cae18..333eec6cd7951ede6121474576f9367f5edb0262 100644
+index e2f6a03650b5b80cae9ec4dc0a8837cb054cae18..fd3307719ef8b297b87f64e6a7736ae7d812757e 100644
 --- a/dist/esm/indexing-store/cache.js
 +++ b/dist/esm/indexing-store/cache.js
 @@ -157,6 +157,7 @@ export const recoverBatchError = async (values, callback) => {
@@ -10,64 +10,114 @@ index e2f6a03650b5b80cae9ec4dc0a8837cb054cae18..333eec6cd7951ede6121474576f9367f
      const cache = new Map();
      const insertBuffer = new Map();
      const updateBuffer = new Map();
-@@ -283,6 +284,7 @@ export const createIndexingCache = ({ common, schemaBuild: { schema }, crashReco
+@@ -283,11 +284,13 @@ export const createIndexingCache = ({ common, schemaBuild: { schema }, crashReco
              return inInsertBuffer || inUpdateBuffer || inDb;
          },
          async flush({ tableNames } = {}) {
 +            const sp = `flush_${++_flushId}`;
++            const currentQb = qb;
              const context = {
                  logger: common.logger.child({ action: "flush_database_rows" }),
              };
-@@ -392,9 +394,9 @@ export const createIndexingCache = ({ common, schemaBuild: { schema }, crashReco
+             const flushEndClock = startClock();
+-            const copy = getCopyHelper(qb, chainId);
++            const copy = getCopyHelper(currentQb, chainId);
+             const flushTable = async (table) => {
+                 const shouldRecordBytes = cache.get(table).isCacheComplete;
+                 if (tableNames !== undefined &&
+@@ -308,7 +311,7 @@ export const createIndexingCache = ({ common, schemaBuild: { schema }, crashReco
+                         await copy(table, text);
+                     }
+                     else {
+-                        await qb.wrap((db) => db.insert(table).values(insertValues.map(({ row }) => row)), context);
++                        await currentQb.wrap((db) => db.insert(table).values(insertValues.map(({ row }) => row)), context);
+                     }
+                     common.metrics.ponder_indexing_cache_query_duration.observe({
+                         table: getTableName(table),
+@@ -346,15 +349,15 @@ export const createIndexingCache = ({ common, schemaBuild: { schema }, crashReco
+               WHERE ${primaryKeys
+                             .map(({ sql }) => `target."${sql}" = source."${sql}"`)
+                             .join(" AND ")};`;
+-                        await qb.wrap((db) => db.execute(createTempTableQuery), context);
++                        await currentQb.wrap((db) => db.execute(createTempTableQuery), context);
+                         const text = getCopyText(table, updateValues.map(({ row }) => row));
+                         await new Promise(setImmediate);
+                         await copy(table, text, false);
+-                        await qb.wrap((db) => db.execute(updateQuery), context);
+-                        await qb.wrap((db) => db.execute(`TRUNCATE TABLE "${target}"`), context);
++                        await currentQb.wrap((db) => db.execute(updateQuery), context);
++                        await currentQb.wrap((db) => db.execute(`TRUNCATE TABLE "${target}"`), context);
+                     }
+                     else {
+-                        await qb.wrap((db) => db
++                        await currentQb.wrap((db) => db
+                             .insert(table)
+                             .values(updateValues.map(({ row }) => row))
+                             .onConflictDoUpdate({
+@@ -391,10 +394,10 @@ export const createIndexingCache = ({ common, schemaBuild: { schema }, crashReco
+                 }
              };
              try {
-                 if (qb.$dialect === "postgres") {
+-                if (qb.$dialect === "postgres") {
 -                    await qb.wrap((db) => db.execute("SAVEPOINT flush"), context);
-+                    await qb.wrap((db) => db.execute(`SAVEPOINT ${sp}`), context);
++                if (currentQb.$dialect === "postgres") {
++                    await currentQb.wrap((db) => db.execute(`SAVEPOINT ${sp}`), context);
                      await promiseAllSettledWithThrow(Array.from(cache.keys()).map(flushTable));
 -                    await qb.wrap((db) => db.execute("RELEASE flush"), context);
-+                    await qb.wrap((db) => db.execute(`RELEASE ${sp}`), context);
++                    await currentQb.wrap((db) => db.execute(`RELEASE ${sp}`), context);
                  }
                  else {
                      // Note: pglite must run sequentially
-@@ -411,7 +413,7 @@ export const createIndexingCache = ({ common, schemaBuild: { schema }, crashReco
+@@ -405,13 +408,13 @@ export const createIndexingCache = ({ common, schemaBuild: { schema }, crashReco
+             }
+             catch (_error) {
+                 let error = _error;
+-                if (error instanceof ShutdownError || qb.$dialect === "pglite") {
++                if (error instanceof ShutdownError || currentQb.$dialect === "pglite") {
+                     throw error;
+                 }
                  // Note `isFlushRetry` is true when the previous flush failed. When `isFlushRetry` is false, this
                  // function takes an optimized fast path, with support for small batch sizes. PGlite always takes
                  // the fast path because it doesn't support delayed insert errors.
 -                await qb.wrap((db) => db.execute("ROLLBACK to flush"), context);
-+                await qb.wrap((db) => db.execute(`ROLLBACK to ${sp}`), context);
++                await currentQb.wrap((db) => db.execute(`ROLLBACK to ${sp}`), context);
                  for (const table of cache.keys()) {
                      if (tableNames !== undefined &&
                          tableNames.has(getTableName(table)) === false) {
-@@ -424,12 +426,12 @@ export const createIndexingCache = ({ common, schemaBuild: { schema }, crashReco
+@@ -424,12 +427,12 @@ export const createIndexingCache = ({ common, schemaBuild: { schema }, crashReco
                      const updateValues = Array.from(updateBuffer.get(table).values());
                      if (insertValues.length > 0) {
                          const endClock = startClock();
 -                        await qb.wrap((db) => db.execute("SAVEPOINT flush"), context);
-+                        await qb.wrap((db) => db.execute(`SAVEPOINT ${sp}`), context);
++                        await currentQb.wrap((db) => db.execute(`SAVEPOINT ${sp}`), context);
                          const result = await recoverBatchError(insertValues, async (values) => {
 -                            await qb.wrap((db) => db.execute("ROLLBACK to flush"), context);
-+                            await qb.wrap((db) => db.execute(`ROLLBACK to ${sp}`), context);
++                            await currentQb.wrap((db) => db.execute(`ROLLBACK to ${sp}`), context);
                              const text = getCopyText(table, values.map(({ row }) => row));
                              await copy(table, text);
 -                            await qb.wrap((db) => db.execute("SAVEPOINT flush"), context);
-+                            await qb.wrap((db) => db.execute(`SAVEPOINT ${sp}`), context);
++                            await currentQb.wrap((db) => db.execute(`SAVEPOINT ${sp}`), context);
                          });
                          if (result.status === "error") {
                              error = new DelayedInsertError(result.error.message);
-@@ -472,12 +474,12 @@ export const createIndexingCache = ({ common, schemaBuild: { schema }, crashReco
+@@ -471,15 +474,15 @@ export const createIndexingCache = ({ common, schemaBuild: { schema }, crashReco
+               WITH NO DATA;
              `;
                          const endClock = startClock();
-                         await qb.wrap((db) => db.execute(createTempTableQuery), context);
+-                        await qb.wrap((db) => db.execute(createTempTableQuery), context);
 -                        await qb.wrap((db) => db.execute("SAVEPOINT flush"), context);
-+                        await qb.wrap((db) => db.execute(`SAVEPOINT ${sp}`), context);
++                        await currentQb.wrap((db) => db.execute(createTempTableQuery), context);
++                        await currentQb.wrap((db) => db.execute(`SAVEPOINT ${sp}`), context);
                          const result = await recoverBatchError(updateValues, async (values) => {
 -                            await qb.wrap((db) => db.execute("ROLLBACK to flush"), context);
-+                            await qb.wrap((db) => db.execute(`ROLLBACK to ${sp}`), context);
++                            await currentQb.wrap((db) => db.execute(`ROLLBACK to ${sp}`), context);
                              const text = getCopyText(table, values.map(({ row }) => row));
                              await copy(table, text, false);
 -                            await qb.wrap((db) => db.execute("SAVEPOINT flush"), context);
-+                            await qb.wrap((db) => db.execute(`SAVEPOINT ${sp}`), context);
++                            await currentQb.wrap((db) => db.execute(`SAVEPOINT ${sp}`), context);
                          });
-                         await qb.wrap((db) => db.execute(`TRUNCATE TABLE "${target}"`), context);
+-                        await qb.wrap((db) => db.execute(`TRUNCATE TABLE "${target}"`), context);
++                        await currentQb.wrap((db) => db.execute(`TRUNCATE TABLE "${target}"`), context);
                          if (result.status === "error") {
+                             error = new DelayedInsertError(result.error.message);
+                             error.stack = undefined;
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index cee4903..7e6ee61 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -6,7 +6,7 @@ settings:
 
 patchedDependencies:
   ponder@0.16.6:
-    hash: f8e8c82e422f563e9c2f3ac2442cc7c69ddd415c4dc1071b411db5ccaa50bd1f
+    hash: b651e31c90c763131f59eab16aebe031f6a4521c0de021d24cd298e0865b1252
     path: patches/ponder@0.16.6.patch
 
 importers:
@@ -30,7 +30,7 @@ importers:
         version: 4.12.3
       ponder:
         specifier: ^0.16.6
-        version: 0.16.6(patch_hash=f8e8c82e422f563e9c2f3ac2442cc7c69ddd415c4dc1071b411db5ccaa50bd1f)(@opentelemetry/api@1.9.0)(@types/node@20.19.35)(hono@4.12.3)(typescript@5.9.3)(viem@2.46.3(typescript@5.9.3)(zod@3.25.76))(zod@3.25.76)
+        version: 0.16.6(patch_hash=b651e31c90c763131f59eab16aebe031f6a4521c0de021d24cd298e0865b1252)(@opentelemetry/api@1.9.0)(@types/node@20.19.35)(hono@4.12.3)(typescript@5.9.3)(viem@2.46.3(typescript@5.9.3)(zod@3.25.76))(zod@3.25.76)
       ponder-enrich-gql-docs-middleware:
         specifier: ^0.1.3
         version: 0.1.3(graphql@16.8.2)(hono@4.12.3)
@@ -4849,7 +4849,7 @@ snapshots:
       graphql: 16.8.2
       hono: 4.12.3
 
-  ponder@0.16.6(patch_hash=f8e8c82e422f563e9c2f3ac2442cc7c69ddd415c4dc1071b411db5ccaa50bd1f)(@opentelemetry/api@1.9.0)(@types/node@20.19.35)(hono@4.12.3)(typescript@5.9.3)(viem@2.46.3(typescript@5.9.3)(zod@3.25.76))(zod@3.25.76):
+  ponder@0.16.6(patch_hash=b651e31c90c763131f59eab16aebe031f6a4521c0de021d24cd298e0865b1252)(@opentelemetry/api@1.9.0)(@types/node@20.19.35)(hono@4.12.3)(typescript@5.9.3)(viem@2.46.3(typescript@5.9.3)(zod@3.25.76))(zod@3.25.76):
     dependencies:
       '@babel/code-frame': 7.29.0
       '@commander-js/extra-typings': 12.1.0(commander@12.1.0)

From 07b1ab89e629de354bb4ccc64c00c706687b1566 Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Mon, 15 Jun 2026 14:07:43 -0300
Subject: [PATCH 36/84] fix: resolve merge conflict - use complete ponder patch
 with currentQb snapshot

---
 patches/ponder@0.16.6.patch | 2 +-
 pnpm-lock.yaml              | 6 +++---
 src/chains/gnosis.ts        | 6 +++---
 src/chains/index.ts         | 2 +-
 src/chains/mainnet.ts       | 6 +++---
 src/constants.ts            | 1 -
 6 files changed, 11 insertions(+), 12 deletions(-)

diff --git a/patches/ponder@0.16.6.patch b/patches/ponder@0.16.6.patch
index a20b362..f14387b 100644
--- a/patches/ponder@0.16.6.patch
+++ b/patches/ponder@0.16.6.patch
@@ -1,5 +1,5 @@
 diff --git a/dist/esm/indexing-store/cache.js b/dist/esm/indexing-store/cache.js
-index e2f6a03650b5b80cae9ec4dc0a8837cb054cae18..fd3307719ef8b297b87f64e6a7736ae7d812757e 100644
+index e2f6a03650b5b80cae9ec4dc0a8837cb054cae18..b57f4f4b32e03b221b3985f9b9218b239df9c7b2 100644
 --- a/dist/esm/indexing-store/cache.js
 +++ b/dist/esm/indexing-store/cache.js
 @@ -157,6 +157,7 @@ export const recoverBatchError = async (values, callback) => {
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 7e6ee61..f1fcb04 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -6,7 +6,7 @@ settings:
 
 patchedDependencies:
   ponder@0.16.6:
-    hash: b651e31c90c763131f59eab16aebe031f6a4521c0de021d24cd298e0865b1252
+    hash: ec9f89214374efb4dd58ba2291160b5265874a5585c4a5c4c2e778a766371e0a
     path: patches/ponder@0.16.6.patch
 
 importers:
@@ -30,7 +30,7 @@ importers:
         version: 4.12.3
       ponder:
         specifier: ^0.16.6
-        version: 0.16.6(patch_hash=b651e31c90c763131f59eab16aebe031f6a4521c0de021d24cd298e0865b1252)(@opentelemetry/api@1.9.0)(@types/node@20.19.35)(hono@4.12.3)(typescript@5.9.3)(viem@2.46.3(typescript@5.9.3)(zod@3.25.76))(zod@3.25.76)
+        version: 0.16.6(patch_hash=ec9f89214374efb4dd58ba2291160b5265874a5585c4a5c4c2e778a766371e0a)(@opentelemetry/api@1.9.0)(@types/node@20.19.35)(hono@4.12.3)(typescript@5.9.3)(viem@2.46.3(typescript@5.9.3)(zod@3.25.76))(zod@3.25.76)
       ponder-enrich-gql-docs-middleware:
         specifier: ^0.1.3
         version: 0.1.3(graphql@16.8.2)(hono@4.12.3)
@@ -4849,7 +4849,7 @@ snapshots:
       graphql: 16.8.2
       hono: 4.12.3
 
-  ponder@0.16.6(patch_hash=b651e31c90c763131f59eab16aebe031f6a4521c0de021d24cd298e0865b1252)(@opentelemetry/api@1.9.0)(@types/node@20.19.35)(hono@4.12.3)(typescript@5.9.3)(viem@2.46.3(typescript@5.9.3)(zod@3.25.76))(zod@3.25.76):
+  ponder@0.16.6(patch_hash=ec9f89214374efb4dd58ba2291160b5265874a5585c4a5c4c2e778a766371e0a)(@opentelemetry/api@1.9.0)(@types/node@20.19.35)(hono@4.12.3)(typescript@5.9.3)(viem@2.46.3(typescript@5.9.3)(zod@3.25.76))(zod@3.25.76):
     dependencies:
       '@babel/code-frame': 7.29.0
       '@commander-js/extra-typings': 12.1.0(commander@12.1.0)
diff --git a/src/chains/gnosis.ts b/src/chains/gnosis.ts
index cfbdc18..a9fe604 100644
--- a/src/chains/gnosis.ts
+++ b/src/chains/gnosis.ts
@@ -10,7 +10,7 @@ export const gnosis: ChainConfig = {
   blockTime,
   composableCow: {
     address: "0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74",
-    startBlock: 29389123,
+    startBlock: 46702200,
   },
   composableCowLive: {
     address: "0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74",
@@ -20,11 +20,11 @@ export const gnosis: ChainConfig = {
       "0x4f4350bf2c74aacd508d598a1ba94ef84378793d", // current (CoWShedForComposableCoW)
       "0x312f92fe5f1710408b20d52a374fa29e099cfa86", // legacy (COWShed); 2 historical events
     ] as const,
-    startBlock: 41469991, // earliest COWShedBuilt from either factory on Gnosis
+    startBlock: 46702200,
   },
   gpv2Settlement: {
     address: "0x9008D19f58AAbD9eD0D60971565AA8510560ab41",
-    startBlock: 43177077, // AaveV3AdapterFactory deployment block on Gnosis
+    startBlock: 46702200,
   },
   flashLoanRouter: "0x9da8B48441583a2b93e2eF8213aAD0EC0b392C69", // confirmed via ROUTER() on Gnosis AaveV3AdapterFactory
   aaveV3AdapterFactory: "0xdeCc46a4b09162f5369c5c80383aaa9159bcf192", // verified on Gnosisscan
diff --git a/src/chains/index.ts b/src/chains/index.ts
index fcc50b1..b3e2568 100644
--- a/src/chains/index.ts
+++ b/src/chains/index.ts
@@ -44,7 +44,7 @@ export const ALL_DEFINED_CHAINS = [
  * ponder.config.ts derives all RPC/contract config from this array.
  */
 export const ACTIVE_CHAINS = [
-  mainnet,
+  // mainnet,
   gnosis,
   // arbitrum, // fully verified — enable when ARBITRUM_RPC_URL is provisioned
   // base,     // fully verified — enable when BASE_RPC_URL is provisioned
diff --git a/src/chains/mainnet.ts b/src/chains/mainnet.ts
index 58a5b25..7fdebb2 100644
--- a/src/chains/mainnet.ts
+++ b/src/chains/mainnet.ts
@@ -10,18 +10,18 @@ export const mainnet: ChainConfig = {
   blockTime,
   composableCow: {
     address: "0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74",
-    startBlock: 17883049,
+    startBlock: 25319424,
   },
   composableCowLive: {
     address: "0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74",
   },
   cowShedFactory: {
     address: "0x312f92fe5f1710408b20d52a374fa29e099cfa86",
-    startBlock: 22939254,
+    startBlock: 25319424,
   },
   gpv2Settlement: {
     address: "0x9008D19f58AAbD9eD0D60971565AA8510560ab41",
-    startBlock: 23812751, // AaveV3AdapterFactory deployment block (Nov 16, 2025)
+    startBlock: 23928242,
   },
   flashLoanRouter: "0x9da8B48441583a2b93e2eF8213aAD0EC0b392C69",
   aaveV3AdapterFactory: "0xdeCc46a4b09162f5369c5c80383aaa9159bcf192",
diff --git a/src/constants.ts b/src/constants.ts
index ce3972d..7e39bee 100644
--- a/src/constants.ts
+++ b/src/constants.ts
@@ -75,7 +75,6 @@ export const BLOCK_HANDLER_RPC_TIMEOUT_MS = 15_000;
 // Tighter cap for cheap inner-loop calls (getCode, eth_call) in the settlement handler.
 // The outer receipt fetch and readContract(owner()) keep the full 15 s.
 export const SETTLEMENT_INNER_RPC_TIMEOUT_MS = 5_000;
-
 /**
  * Hard wall-clock cap for the whole per-owner bootstrap fetch in OwnerBackfill
  * (account pagination + by_uids refresh). Owners that exceed this are skipped;

From 209e167a5c1df4fb7af1ebe25094387a89f045ce Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Mon, 15 Jun 2026 15:05:30 -0300
Subject: [PATCH 37/84] fix: restore chain configs to production values (revert
 accidental test changes)

mainnet was accidentally disabled and gnosis/mainnet startBlocks were set to
test values during local reproduction attempts. Restoring to the original
production config from cefb22a.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 src/chains/gnosis.ts  | 6 +++---
 src/chains/index.ts   | 2 +-
 src/chains/mainnet.ts | 6 +++---
 src/constants.ts      | 1 +
 4 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/src/chains/gnosis.ts b/src/chains/gnosis.ts
index a9fe604..cfbdc18 100644
--- a/src/chains/gnosis.ts
+++ b/src/chains/gnosis.ts
@@ -10,7 +10,7 @@ export const gnosis: ChainConfig = {
   blockTime,
   composableCow: {
     address: "0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74",
-    startBlock: 46702200,
+    startBlock: 29389123,
   },
   composableCowLive: {
     address: "0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74",
@@ -20,11 +20,11 @@ export const gnosis: ChainConfig = {
       "0x4f4350bf2c74aacd508d598a1ba94ef84378793d", // current (CoWShedForComposableCoW)
       "0x312f92fe5f1710408b20d52a374fa29e099cfa86", // legacy (COWShed); 2 historical events
     ] as const,
-    startBlock: 46702200,
+    startBlock: 41469991, // earliest COWShedBuilt from either factory on Gnosis
   },
   gpv2Settlement: {
     address: "0x9008D19f58AAbD9eD0D60971565AA8510560ab41",
-    startBlock: 46702200,
+    startBlock: 43177077, // AaveV3AdapterFactory deployment block on Gnosis
   },
   flashLoanRouter: "0x9da8B48441583a2b93e2eF8213aAD0EC0b392C69", // confirmed via ROUTER() on Gnosis AaveV3AdapterFactory
   aaveV3AdapterFactory: "0xdeCc46a4b09162f5369c5c80383aaa9159bcf192", // verified on Gnosisscan
diff --git a/src/chains/index.ts b/src/chains/index.ts
index b3e2568..fcc50b1 100644
--- a/src/chains/index.ts
+++ b/src/chains/index.ts
@@ -44,7 +44,7 @@ export const ALL_DEFINED_CHAINS = [
  * ponder.config.ts derives all RPC/contract config from this array.
  */
 export const ACTIVE_CHAINS = [
-  // mainnet,
+  mainnet,
   gnosis,
   // arbitrum, // fully verified — enable when ARBITRUM_RPC_URL is provisioned
   // base,     // fully verified — enable when BASE_RPC_URL is provisioned
diff --git a/src/chains/mainnet.ts b/src/chains/mainnet.ts
index 7fdebb2..58a5b25 100644
--- a/src/chains/mainnet.ts
+++ b/src/chains/mainnet.ts
@@ -10,18 +10,18 @@ export const mainnet: ChainConfig = {
   blockTime,
   composableCow: {
     address: "0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74",
-    startBlock: 25319424,
+    startBlock: 17883049,
   },
   composableCowLive: {
     address: "0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74",
   },
   cowShedFactory: {
     address: "0x312f92fe5f1710408b20d52a374fa29e099cfa86",
-    startBlock: 25319424,
+    startBlock: 22939254,
   },
   gpv2Settlement: {
     address: "0x9008D19f58AAbD9eD0D60971565AA8510560ab41",
-    startBlock: 23928242,
+    startBlock: 23812751, // AaveV3AdapterFactory deployment block (Nov 16, 2025)
   },
   flashLoanRouter: "0x9da8B48441583a2b93e2eF8213aAD0EC0b392C69",
   aaveV3AdapterFactory: "0xdeCc46a4b09162f5369c5c80383aaa9159bcf192",
diff --git a/src/constants.ts b/src/constants.ts
index 7e39bee..ce3972d 100644
--- a/src/constants.ts
+++ b/src/constants.ts
@@ -75,6 +75,7 @@ export const BLOCK_HANDLER_RPC_TIMEOUT_MS = 15_000;
 // Tighter cap for cheap inner-loop calls (getCode, eth_call) in the settlement handler.
 // The outer receipt fetch and readContract(owner()) keep the full 15 s.
 export const SETTLEMENT_INNER_RPC_TIMEOUT_MS = 5_000;
+
 /**
  * Hard wall-clock cap for the whole per-owner bootstrap fetch in OwnerBackfill
  * (account pagination + by_uids refresh). Owners that exceed this are skipped;

From bfad24138dc99d7c2dc67422a16362f151778bad Mon Sep 17 00:00:00 2001
From: Jefferson Bastos <jeff.junior98@gmail.com>
Date: Mon, 15 Jun 2026 15:55:52 -0300
Subject: [PATCH 38/84] chore(qa): remove Linear ticket IDs from code comments
 and tests

Strips internal Linear ticket references (COW-918/979/988/990/993/1003) from comments and test descriptions ahead of the public handover. The surrounding explanations are kept; only the ticket IDs are removed.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 src/application/handlers/blockHandler.ts | 4 ++--
 tests/api/orders-by-owner.test.ts        | 4 ++--
 tests/constants.test.ts                  | 2 +-
 tests/helpers/orderbookClient.test.ts    | 2 +-
 tests/helpers/statusFilter.test.ts       | 2 +-
 tests/utils/order-types.test.ts          | 2 +-
 6 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/application/handlers/blockHandler.ts b/src/application/handlers/blockHandler.ts
index 33b7c02..14301e1 100644
--- a/src/application/handlers/blockHandler.ts
+++ b/src/application/handlers/blockHandler.ts
@@ -349,7 +349,7 @@ ponder.on("CandidateConfirmer:block", async ({ event, context }) => {
     }[];
 
     if (orphanCandidates.length > 0) {
-      // COW-990: preflight /by_uids before writing cancelled. A candidate could have
+      // Preflight /by_uids before writing cancelled. A candidate could have
       // been posted by the watch-tower and filled/expired between generator creation
       // and the cancellation cascade (~0.17% observed rate). Use the API status when
       // available; fall back to 'cancelled' for UIDs not yet on the orderbook.
@@ -870,7 +870,7 @@ ponder.on("OwnerBackfill:block", async ({ event, context }) => {
 // for them. This handler closes that gap by reading
 // ComposableCoW.singleOrders(owner, hash) on a DETERMINISTIC_CANCEL_SWEEP_INTERVAL
 // cadence. A `false` result means the owner called remove() on-chain → flip to
-// Cancelled, which lets the C2/C3 parent-cancelled cascade (COW-918) reconcile
+// Cancelled, which lets the C2/C3 parent-cancelled cascade reconcile
 // the child discrete / candidate rows on the next block.
 
 ponder.on("CancellationWatcher:block", async ({ event, context }) => {
diff --git a/tests/api/orders-by-owner.test.ts b/tests/api/orders-by-owner.test.ts
index 57a5ce1..707ec71 100644
--- a/tests/api/orders-by-owner.test.ts
+++ b/tests/api/orders-by-owner.test.ts
@@ -173,7 +173,7 @@ describe("ordersByOwnerHandler", () => {
   });
 });
 
-// ─── Schema tests (COW-993) ──────────────────────────────────────────────────
+// ─── Schema tests ──────────────────────────────────────────────────
 
 // A minimal valid GeneratorSummary payload that satisfies all required fields.
 const validGenerator = {
@@ -188,7 +188,7 @@ const validGenerator = {
 } as const;
 
 describe("GeneratorSummary schema", () => {
-  // Regression guard for COW-993: hash was previously missing from the schema,
+  // Regression guard: hash was previously missing from the schema,
   // causing it to be silently dropped from API responses. safeParse accepts
   // unknown so TS gives no protection here at runtime.
   it("fails parse when hash is missing", () => {
diff --git a/tests/constants.test.ts b/tests/constants.test.ts
index 1a778d9..4799405 100644
--- a/tests/constants.test.ts
+++ b/tests/constants.test.ts
@@ -15,7 +15,7 @@ import {
   DEFAULT_MAX_DISCRETE_ORDERS_PER_BLOCK,
 } from "../src/constants";
 
-describe("DEFAULT_MAX_DISCRETE_ORDERS_PER_BLOCK (COW-988)", () => {
+describe("DEFAULT_MAX_DISCRETE_ORDERS_PER_BLOCK", () => {
   it("is 200", () => {
     expect(DEFAULT_MAX_DISCRETE_ORDERS_PER_BLOCK).toBe(200);
   });
diff --git a/tests/helpers/orderbookClient.test.ts b/tests/helpers/orderbookClient.test.ts
index 56cc98a..b1afc95 100644
--- a/tests/helpers/orderbookClient.test.ts
+++ b/tests/helpers/orderbookClient.test.ts
@@ -133,7 +133,7 @@ describe("fetchOrderStatusByUids", () => {
     expect(result.size).toBe(0);
   });
 
-  it("correctly unwraps the { order } wrapper and maps uid → status (regression: COW-979)", async () => {
+  it("correctly unwraps the { order } wrapper and maps uid → status", async () => {
     const { url, close } = await startServer((_req, res) => {
       res.writeHead(200, { "content-type": "application/json" });
       res.end(JSON.stringify([makeWrappedOrder(UID_A, "fulfilled")]));
diff --git a/tests/helpers/statusFilter.test.ts b/tests/helpers/statusFilter.test.ts
index 5d461bb..929d903 100644
--- a/tests/helpers/statusFilter.test.ts
+++ b/tests/helpers/statusFilter.test.ts
@@ -1,5 +1,5 @@
 /**
- * Tests for the C3 StatusUpdater row-building filter logic (COW-988).
+ * Tests for the C3 StatusUpdater row-building filter logic.
  *
  * blockHandler.ts defines a module-level constant:
  *   const VALID_DISCRETE_STATUSES = new Set(["fulfilled", "unfilled", "expired", "cancelled"]);
diff --git a/tests/utils/order-types.test.ts b/tests/utils/order-types.test.ts
index ce92226..5d145c5 100644
--- a/tests/utils/order-types.test.ts
+++ b/tests/utils/order-types.test.ts
@@ -15,7 +15,7 @@ describe("DETERMINISTIC_ORDER_TYPE", () => {
   it("marks TWAP, StopLoss, CirclesBackingOrder as deterministic", () => {
     expect(DETERMINISTIC_ORDER_TYPE["TWAP"]).toBe(true);
     expect(DETERMINISTIC_ORDER_TYPE["StopLoss"]).toBe(true);
-    // Regression guard for COW-1003: CirclesBackingOrder must be deterministic
+    // Regression guard: CirclesBackingOrder must be deterministic
     expect(DETERMINISTIC_ORDER_TYPE["CirclesBackingOrder"]).toBe(true);
   });
 

From 23da85a44c3749c96b04823f3125d89e462c72c0 Mon Sep 17 00:00:00 2001
From: Jefferson Bastos <jeff.junior98@gmail.com>
Date: Mon, 15 Jun 2026 15:55:52 -0300
Subject: [PATCH 39/84] chore(qa): remove build-phase context and local paths
 from code comments

orderUid.ts: drop the 'Phase 2' build-phase note and point the GPv2Order.sol reference at the public cowprotocol/contracts repo instead of a local tmp/ path. good-after-time.ts: replace the 'opaque in M1' milestone note with a description of the field.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 src/application/helpers/orderUid.ts | 3 +--
 src/decoders/good-after-time.ts     | 2 +-
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/application/helpers/orderUid.ts b/src/application/helpers/orderUid.ts
index 97b1f15..fdff5c2 100644
--- a/src/application/helpers/orderUid.ts
+++ b/src/application/helpers/orderUid.ts
@@ -4,8 +4,7 @@
  * UID = abi.encodePacked(orderDigest, owner, uint32(validTo))
  * where orderDigest = EIP-712 typed hash of the GPv2Order struct.
  *
- * Reference: GPv2Order.sol (tmp/contracts/gpv2-contracts/src/contracts/libraries/GPv2Order.sol)
- * Added during orderbook cache refactor (Phase 2)
+ * Reference: GPv2Order.sol (cowprotocol/contracts)
  */
 
 import { encodePacked, hashTypedData, type Hex } from "viem";
diff --git a/src/decoders/good-after-time.ts b/src/decoders/good-after-time.ts
index b690ebf..c92ebe7 100644
--- a/src/decoders/good-after-time.ts
+++ b/src/decoders/good-after-time.ts
@@ -9,7 +9,7 @@ export interface GoodAfterTimeDecodedParams {
   startTime: bigint;
   endTime: bigint;
   allowPartialFill: boolean;
-  priceCheckerPayload: string;  // hex bytes — opaque in M1
+  priceCheckerPayload: string;  // hex bytes — opaque (price-checker payload, not decoded)
   appData: string;
 }
 

From 4fabcddbdac81c8a3e8e711bf99b05107519ada4 Mon Sep 17 00:00:00 2001
From: Jefferson Bastos <jeff.junior98@gmail.com>
Date: Mon, 15 Jun 2026 15:55:52 -0300
Subject: [PATCH 40/84] docs(qa): remove ticket and milestone references from
 public docs

Drops the COW-986 ticket references (the add-a-chain checklist already lives in architecture.md) and the '(M3 reference)' milestone label from the PollResultErrors heading.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 docs/api-reference.md         | 2 +-
 docs/architecture.md          | 2 +-
 docs/supported-order-types.md | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/api-reference.md b/docs/api-reference.md
index e605547..236b101 100644
--- a/docs/api-reference.md
+++ b/docs/api-reference.md
@@ -151,4 +151,4 @@ The active chain list is `ACTIVE_CHAINS` in `src/chains/index.ts`. Currently act
 
 Filter queries with `where: { chainId: 1 }` (GraphQL) or `?chainId=1` (REST).
 
-> Adding a chain: create `src/chains/<name>.ts` following the existing chain files as a template, add it to `ACTIVE_CHAINS` in `src/chains/index.ts`, and add its RPC URL env var. See COW-986 for the full checklist.
+> Adding a chain: create `src/chains/<name>.ts` following the existing chain files as a template, add it to `ACTIVE_CHAINS` in `src/chains/index.ts`, and add its RPC URL env var.
diff --git a/docs/architecture.md b/docs/architecture.md
index d747c0d..c025909 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -14,7 +14,7 @@ Configuration lives in `src/chains/` (one file per chain). The ComposableCoW con
 
 Currently active chains, their start blocks, and contract addresses are defined in `src/chains/`. To add a chain, create a chain file there and register it in `src/chains/index.ts`.
 
-Stub configs exist for all 12 chains in cow-sdk's `ALL_SUPPORTED_CHAIN_IDS`; contract addresses for the remaining chains need verification before enabling (see COW-986).
+Stub configs exist for all 12 chains in cow-sdk's `ALL_SUPPORTED_CHAIN_IDS`; contract addresses for the remaining chains need verification before enabling.
 
 `ponder.config.ts` derives all config from `ACTIVE_CHAINS` in `src/chains/index.ts` and wires it into Ponder's `createConfig`. It never contains raw addresses or block numbers directly. It also registers the five live-only block handlers from `blockHandler.ts` (`OrderDiscoveryPoller`, `CandidateConfirmer`, `OrderStatusTracker`, `OwnerBackfill`, `CancellationWatcher`) — all run during live sync only (`startBlock: "latest"`).
 
diff --git a/docs/supported-order-types.md b/docs/supported-order-types.md
index d64a4ed..7c617fd 100644
--- a/docs/supported-order-types.md
+++ b/docs/supported-order-types.md
@@ -265,7 +265,7 @@ When `staticInput` cannot be decoded for a known order type, the indexer stores
 
 For `Unknown` order types (handler address not in the registry), `decodedParams` is null and `decodeError` is null. The raw `staticInput` hex is always available on the `conditional_order_generator` record regardless of decode outcome.
 
-## PollResultErrors (M3 reference)
+## PollResultErrors
 
 The ComposableCoW system uses poll result codes to coordinate when orders should be re-checked. These are relevant if you're working on the block handler that polls `getTradableOrder`:
 

From 1a2879f9c762a8a1a9e4cb31ec14c1554e37b377 Mon Sep 17 00:00:00 2001
From: Jefferson Bastos <jeff.junior98@gmail.com>
Date: Mon, 15 Jun 2026 15:55:52 -0300
Subject: [PATCH 41/84] docs(qa): scrub internal references from agent docs

Removes the slack_decisions_summary.md and local thoughts/ table rows plus a dangling architecture.md row from AGENTS.md; drops M1/M3 milestone tags, a local PoC path, the 'written for team discussion' note, and a private debug-log reference from agent_docs.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 AGENTS.md                                   | 5 +----
 agent_docs/code-patterns.md                 | 2 +-
 agent_docs/m3-orderbook-integration-flow.md | 4 ++--
 agent_docs/project-structure.md             | 7 +++----
 4 files changed, 7 insertions(+), 11 deletions(-)

diff --git a/AGENTS.md b/AGENTS.md
index 0140b55..3015fce 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -43,13 +43,10 @@ Start PostgreSQL with `docker compose up -d` to use it instead of the default SQ
 
 | File | When to read |
 |------|--------------|
-| `agent_docs/architecture.md` | Full data-flow, file responsibilities, schema details |
 | `agent_docs/project-structure.md` | Current file map, schema tables, env vars, key commands |
 | `agent_docs/code-patterns.md` | Schema/naming conventions (snake_case, composite PK, eventId) — **check before schema or handler changes** |
 | `agent_docs/token-indexer-overview.md` | Full Ponder patterns (handlers, repos, services) — **read before writing any implementation plan** |
-| `docs/supported-order-types.md` | All 5 order type ABI structs, handler addresses, decoded fields, edge cases — **read before any decoder or M3 block-handler work** |
-| `agent_docs/slack_decisions_summary.md` | Technical decisions from CoW Protocol team (flash loans, CoWShed, orderbook, scope) |
-| `thoughts/` (local) | Local working notes, plans, task context (not in repo; see `.claude/commands/` for workflow) |
+| `docs/supported-order-types.md` | All 5 order type ABI structs, handler addresses, decoded fields, edge cases — **read before any decoder or block-handler work** |
 
 ## Working Conventions
 
diff --git a/agent_docs/code-patterns.md b/agent_docs/code-patterns.md
index 55ea518..a956a44 100644
--- a/agent_docs/code-patterns.md
+++ b/agent_docs/code-patterns.md
@@ -38,7 +38,7 @@ Every `fetch`, `context.client.multicall`, `context.client.readContract`, or oth
 2. Catch `TimeoutError` at the handler boundary, log `[COW:Cx] <label> timeout …`, and `return` without further DB writes.
 3. Be partial-failure tolerant — writes for affected items are skipped; the next block retries naturally.
 
-Rationale: Ponder 0.16 wraps every block in a single DB transaction (`node_modules/.../ponder/src/runtime/multichain.ts:363,639`) and offers no API to leave/re-enter. An unbounded external call in a handler holds the TX across the network round-trip; on a slow peer, Postgres terminates the connection and Ponder retries the full block 9× before shutting the process down (see `ponder-final-23-04.log`, 2026-04-23). Tuning knobs live in `src/constants.ts` (`ORDERBOOK_HTTP_TIMEOUT_MS`, `BLOCK_HANDLER_RPC_TIMEOUT_MS`, `BOOTSTRAP_OWNER_FETCH_TIMEOUT_MS`).
+Rationale: Ponder 0.16 wraps every block in a single DB transaction (`node_modules/.../ponder/src/runtime/multichain.ts:363,639`) and offers no API to leave/re-enter. An unbounded external call in a handler holds the TX across the network round-trip; on a slow peer, Postgres terminates the connection and Ponder retries the full block 9× before shutting the process down. Tuning knobs live in `src/constants.ts` (`ORDERBOOK_HTTP_TIMEOUT_MS`, `BLOCK_HANDLER_RPC_TIMEOUT_MS`, `BOOTSTRAP_OWNER_FETCH_TIMEOUT_MS`).
 
 ---
 
diff --git a/agent_docs/m3-orderbook-integration-flow.md b/agent_docs/m3-orderbook-integration-flow.md
index b67e4ec..d1949c8 100644
--- a/agent_docs/m3-orderbook-integration-flow.md
+++ b/agent_docs/m3-orderbook-integration-flow.md
@@ -1,6 +1,6 @@
-# M3 Orderbook Integration — System Architecture & Flow
+# Orderbook Integration — System Architecture & Flow
 
-This document explains how the M3 discrete order system works, what each component does, and how an order moves through the system from creation to completion. Written for team discussion.
+This document explains how the discrete order system works, what each component does, and how an order moves through the system from creation to completion.
 
 ---
 
diff --git a/agent_docs/project-structure.md b/agent_docs/project-structure.md
index 843f8dc..77421b1 100644
--- a/agent_docs/project-structure.md
+++ b/agent_docs/project-structure.md
@@ -30,7 +30,7 @@
 | Mainnet address | `0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74` |
 | Start block | `17883049` (deployment block) |
 | End block | none — index continuously |
-| Active chains (M1) | mainnet only |
+| Active chains | mainnet only |
 
 ---
 
@@ -77,7 +77,7 @@ src/data.ts
 | `decodedParams` | json | null until decoder tasks populate it |
 | `txHash` | hex NOT NULL | FK → transaction.hash |
 
-**`discreteOrder`** (stub for M3)
+**`discreteOrder`** (stub)
 | Column | Type | Notes |
 |--------|------|-------|
 | `orderUid` | text NOT NULL | Part of composite PK |
@@ -125,7 +125,7 @@ Example query once blocks around `17883049` are indexed:
 
 ---
 
-## Intentionally Out of Scope (M1)
+## Intentionally Out of Scope
 
 - Gnosis Chain / Arbitrum chain configuration (future sprint)
 - `MerkleRootSet` / `SwapGuardSet` event handlers
@@ -138,5 +138,4 @@ Example query once blocks around `17883049` are indexed:
 
 ## References
 
-- PoC: `/Users/jefferson/Projects/Bleu/cow/reference_repos/cow-programmatic-orders-indexer/`
 - Ponder docs: https://ponder.sh

From f940fcf2c56d2cf4d24ba077a369aa171028666c Mon Sep 17 00:00:00 2001
From: Jefferson Bastos <jeff.junior98@gmail.com>
Date: Mon, 15 Jun 2026 15:55:52 -0300
Subject: [PATCH 42/84] chore(qa): remove internal Ponder debugging playbook

Deletes .claude/commands/debug-ponder.md, which embedded internal Linear ticket IDs (COW-887/904/918), a vendor-reliability note, and an env.prod reference. It is an internal debugging playbook with no value to a public consumer.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .claude/commands/debug-ponder.md | 366 -------------------------------
 1 file changed, 366 deletions(-)
 delete mode 100644 .claude/commands/debug-ponder.md

diff --git a/.claude/commands/debug-ponder.md b/.claude/commands/debug-ponder.md
deleted file mode 100644
index bac77f3..0000000
--- a/.claude/commands/debug-ponder.md
+++ /dev/null
@@ -1,366 +0,0 @@
-# Debug Ponder Log
-
-Analyze `ponder.log` to diagnose indexer issues. Run after `pnpm dev --disable-ui 2>&1 | tee ponder.log`.
-
-## Critical Rule
-
-**NEVER use the `Read` tool on `ponder.log`** — the file is too large and will crash context. Use only `Bash` with `grep`, `tail`, or `sed`.
-
----
-
-## Investigation Steps
-
-Run all steps before reporting. If a step returns nothing, note it explicitly — "No errors found" is useful signal.
-
-### Step 1 — Fatal errors
-
-```bash
-grep -n "ERROR" ponder.log | head -40
-```
-
-If any errors found, grab context around the first one:
-
-```bash
-# Replace N with the line number from above
-grep -n "ERROR" ponder.log | head -1
-# Then run: sed -n 'N-2,N+20p' ponder.log
-```
-
-### Step 2 — Warnings
-
-```bash
-grep -n "WARN\|console.warn\|\[ComposableCow\].*failed\|\[ComposableCow\].*Unknown" ponder.log | head -40
-```
-
-### Step 3 — Handler events (success path)
-
-```bash
-grep -n "\[ComposableCow\]" ponder.log | tail -30
-```
-
-Healthy output looks like:
-```
-[ComposableCow] ConditionalOrderCreated event=... orderType=TWAP block=...
-[ComposableCow] Decoded event=... orderType=TWAP decodedParams=ok
-```
-
-Red flags:
-- `decodedParams=null` on a known orderType → decoder returned nothing
-- `Decode failed` line → malformed staticInput, check `decodeError` column in DB
-- `Unknown handler` line → address not in `HANDLER_MAP` in `src/utils/order-types.ts`
-
-### Step 4 — Startup / DB / RPC health
-
-```bash
-grep -n "INFO\|WARN\|ERROR" ponder.log | head -20
-```
-
-Healthy startup sequence:
-```
-INFO  Connected to database
-INFO  Connected to JSON-RPC
-INFO  Dropped existing database tables   ← only on first run / schema change
-INFO  Created database tables
-INFO  Started backfill indexing
-INFO  Started fetching backfill JSON-RPC data
-```
-
-### Step 5 — Last known state
-
-```bash
-tail -50 ponder.log
-```
-
-If the process is stuck or crashed, this shows the last state before it stopped.
-
----
-
-## Report Format
-
-After running all steps, output:
-
-```markdown
-## Ponder Debug Report
-
-### Errors
-[List each unique error with line number, or "None found"]
-
-### Warnings
-[List each unique warning type and count, or "None found"]
-
-### Handler Events
-- Total ConditionalOrderCreated seen: N
-- Breakdown by orderType: TWAP=N, StopLoss=N, PerpetualSwap=N, GoodAfterTime=N, TradeAboveThreshold=N, Unknown=N
-- decodedParams=ok: N | decodedParams=null: N
-
-### Verdict
-[Healthy | Degraded (warnings only) | Broken (errors present)]
-
-### Root Cause
-[What's wrong and why, based on evidence]
-
-### Next Step
-[Specific fix or command to run]
-```
-
----
-
-## Precompute Diagnostics
-
-Deterministic types (TWAP, StopLoss) should have all UIDs precomputed at creation — they should NOT appear in C1 polling. If precompute fails, the generator falls into C1 and wastes RPC calls every block.
-
-### Precompute failures — why generators fall into C1
-
-```bash
-grep -n "\[COW:PRECOMPUTE\] SKIP" ponder.log | head -20
-```
-
-Each line is a deterministic generator that FAILED precompute and will fall into C1 polling. The `reason=` field tells you why:
-
-| reason | meaning | fix |
-|--------|---------|-----|
-| `decodedParams_null` | Decode of staticInput returned null | Check decoder for that order type; likely malformed on-chain data |
-| `missing_params` | Required fields missing after decode (see `missing=` for which) | Decoder returned incomplete data |
-| `invalid_math` | nParts <= 0 or tSeconds <= 0 | Invalid TWAP params on-chain |
-| `too_many_parts` | nParts > 100,000 | Extremely large TWAP; raise limit if legitimate |
-
-**If you see SKIP lines**: count them and cross-reference with C1's `due=` count. If they match, precompute failures are the sole cause of C1 polling for deterministic types.
-
-```bash
-grep -c "\[COW:PRECOMPUTE\] SKIP" ponder.log
-```
-
-### Verify deterministic types are NOT in C1
-
-After precompute fixes, C1 should only poll non-deterministic types. Check if C1 success lines show TWAP/StopLoss (they shouldn't):
-
-```bash
-grep "\[COW:C1\] DONE" ponder.log | grep 'chain=100' | tail -5
-```
-
-A healthy `due=` count should be much smaller than total generators — only non-deterministic types should remain.
-
----
-
-## Orderbook Cache (M3)
-
-The `orderbook_cache` table persists across Ponder resyncs (it is NOT an `onchainTable`). These steps verify the cache is alive and working.
-
-### Cache startup — verify persistence across restarts
-
-Look for the setup log emitted once at startup:
-
-```bash
-grep -n "\[COW:SETUP\]" ponder.log | head -5
-```
-
-Healthy output:
-```
-[COW:SETUP] orderbook_cache ready — 42 entries from previous run
-```
-
-If you see `0 entries from previous run` on a restart (not a first run), the cache table was dropped — this indicates a schema migration or Docker volume wipe, not a bug.
-
-### Cache hits — verify terminal owners are served from cache
-
-```bash
-grep -n "\[COW:OB:CACHE\] HIT" ponder.log | tail -20
-```
-
-Each line confirms a terminal owner was served from cache instead of hitting the API:
-```
-[COW:OB:CACHE] HIT owner=0x1234... chain=1 orders=5
-```
-
-If you see zero hits after a warm restart, the cache was not populated in the previous run (all owners were non-terminal) or the table was reset.
-
-### Cache saves — verify terminal owners are being cached
-
-```bash
-grep -n "\[COW:OB:CACHE\] SAVED" ponder.log | tail -20
-```
-
-Healthy output:
-```
-[COW:OB:CACHE] SAVED owner=0x1234... chain=1 orders=3 (all terminal, cached permanently)
-```
-
-Active owners (with any `open` order) are intentionally NOT saved — they must be re-fetched on every poll cycle.
-
-### Orderbook poll cycle metrics
-
-```bash
-grep -n "\[COW:OB:POLL\] DONE" ponder.log | tail -10
-```
-
-Healthy output includes cache hit ratio and active owner count:
-```
-[COW:OB:POLL] DONE block=12345678 chain=1 owners=20 discovered=3 cacheHits=15 apiFetches=5 activeOwners=2 totalOrders=47
-```
-
-High `cacheHits` relative to `owners` means the cache is working. High `apiFetches` with low `activeOwners` may indicate many owners are not yet cached.
-
-### C4 HistoricalBootstrap — one-shot (`endBlock: "latest"`) — PR #29 entrada 9
-
-`HistoricalBootstrap` in `ponder.config.ts` uses `startBlock: "latest"` and `endBlock: "latest"` so it should run **once per chain** when the indexer reaches live (not every block). Use logs to confirm.
-
-**Invocation counter (expect `#1` only per chain per process):**
-
-```bash
-grep -n "\[COW:C4\] HistoricalBootstrap invocation" ponder.log
-```
-
-Healthy output (one line per chain after live starts):
-
-```
-... [COW:C4] HistoricalBootstrap invocation=#1 chain=1 block=... (one-shot bootstrap; see .claude/commands/debug-ponder.md — C4 section)
-```
-
-If you see **`invocation=#2`** or a **`WARN`** line saying *invocation #2* / *repeats every block*, `endBlock: "latest"` is not behaving as a one-shot in your Ponder version — escalate or check Ponder release notes. A **full resync** resets the process: you will see `#1` again on the next run (expected).
-
-**Full C4 trace (bootstrap work or empty):**
-
-```bash
-grep -n "\[COW:C4\]" ponder.log
-```
-
-You should see `invocation=#1`, then either `no generators need bootstrap` or `generators=...` + `DONE`, then **no further `[COW:C4]` lines** for that chain until restart.
-
-### Backfill skip — verify poller is not running during historical sync
-
-During backfill, the orderbook poller is silently skipped (no log line). To confirm live-only behavior, check that poll DONE lines only appear near the tip:
-
-```bash
-grep -n "\[COW:OB:POLL\] DONE" ponder.log | head -5
-```
-
-The `block=` values should be close to the current chain head. If you see poll DONE lines during historical blocks, the `PollResultPoller` start block may not be set to `"latest"`.
-
----
-
-## C1 tryNextBlock backoff
-
-Generators that keep returning `PollResult.tryNextBlock` are progressively rate-limited. After 50 consecutive tryNextBlock responses the recheck interval jumps from +1 to +10 blocks; after 200, to +50.
-
-### DONE log — backoff count per cycle
-
-```bash
-grep -n "\[COW:C1\] DONE" ponder.log | tail -20
-```
-
-Healthy output (mainnet, few stuck generators):
-```
-[COW:C1] DONE block=12345678 chain=1 due=12 success=2 never=0 backedOff=0
-```
-
-Gnosis after warm-up — expect non-zero `backedOff=` as chronic offenders climb past the 50-threshold:
-```
-[COW:C1] DONE block=45678901 chain=100 due=180 success=3 never=0 backedOff=150
-```
-
-`backedOff=` counts generators whose counter exceeded the warmup threshold on *this* block — i.e., they received a backoff longer than +1.
-
-### Counter distribution — verify the mechanism is climbing
-
-Run against the indexer Postgres (see `docker compose up -d`):
-
-```sql
-SELECT chain_id,
-       CASE
-         WHEN consecutive_try_next_block <= 50 THEN '0-50 (warmup)'
-         WHEN consecutive_try_next_block <= 200 THEN '51-200 (mid)'
-         ELSE '201+ (cold)'
-       END AS tier,
-       COUNT(*) AS generators,
-       MAX(consecutive_try_next_block) AS max_count
-FROM conditional_order_generator
-WHERE status = 'Active' AND all_candidates_known = false
-GROUP BY 1, 2
-ORDER BY 1, 2;
-```
-
-On a healthy gnosis run post-sync you should see a non-trivial bucket in `51-200` and/or `201+`. If everything sits at `0-50` after >300 gnosis blocks, either COW-904 eliminated all such generators (success) *or* the counter is not incrementing (bug).
-
-### Red flag — counter stuck high but `due=` still huge
-
-If `consecutive_try_next_block` is large for many generators *and* the C1 `due=` count is still massive every block, the backoff is not actually deferring those generators — check that the C1 SELECT filters by `nextCheckBlock <= currentBlock` and that the handler updated `nextCheckBlock = currentBlock + <backoff>` correctly on tryNextBlock.
-
----
-
-## C5 DeterministicCancellationSweeper — singleOrders() mapping sweep
-
-`DeterministicCancellationSweeper` in `ponder.config.ts` runs every block but only does work when at least one deterministic generator (`allCandidatesKnown = true AND status = "Active"`) has `nextCheckBlock <= currentBlock`. Per-generator cadence is `DETERMINISTIC_CANCEL_SWEEP_INTERVAL` blocks (see `src/constants.ts`, default 100). The handler reads `ComposableCoW.singleOrders(owner, hash)` — `false` means the owner called `remove()` on-chain.
-
-### ENTER / DONE — per-sweep summary
-
-```bash
-grep -n "\[COW:C5\]" ponder.log | tail -40
-```
-
-Healthy output (one ENTER + one DONE per block where work happens):
-```
-... [COW:C5] ENTER block=... chain=1 due=12
-... [COW:C5] DONE block=... chain=1 due=12 cancelled=0 stillActive=12 errors=0
-```
-
-If `due=0` on every block for a long time, either there are no Active deterministic generators on that chain yet, or the kill-switch is on (see below).
-
-### Cancellations detected
-
-```bash
-grep -n "\[COW:C5\] CANCELLED" ponder.log
-```
-
-Each line is a deterministic generator whose on-chain `singleOrders(owner, hash)` returned `false`:
-```
-[COW:C5] CANCELLED generatorId=... orderType=StopLoss block=... chain=1
-```
-
-After any `CANCELLED` line you should see COW-918's cascade fire on the next C2 block tick:
-```
-[COW:C2] block=... chain=1 parent-cancelled=N   ← candidates drained to discrete_order
-```
-
-C3's parent-cancelled sweep has no dedicated log line — verify via SQL:
-```sql
-SELECT count(*) FROM discrete_order
-WHERE status='cancelled' AND conditional_order_generator_id = '<eventId>';
-```
-
-### Multicall errors
-
-`errors > 0` on a DONE line is not fatal: C5 leaves `nextCheckBlock` untouched for errored entries so they retry on the next sweep. Sustained nonzero `errors` across many blocks means the RPC provider is flaky — consider swapping provider (see COW-887 on DRPC flakiness).
-
-### Sweep disabled (kill-switch)
-
-If operators see no `[COW:C5]` lines at all and expect them:
-```bash
-grep -n "DISABLE_DETERMINISTIC_CANCEL_SWEEP" .env.local env.prod 2>/dev/null
-```
-
-Non-empty means the sweeper is intentionally disabled via env var — same pattern as `DISABLE_POLL_RESULT_CHECK` for C1.
-
-### lastPollResult audit
-
-SQL spot-check for what C5 has touched:
-```sql
-SELECT chain_id, order_type, status, last_poll_result, count(*)
-FROM conditional_order_generator
-WHERE last_poll_result IN ('cancelled:removeMapping', 'sweep:stillAuthorized')
-GROUP BY 1,2,3,4
-ORDER BY 1,2,3,4;
-```
-
-`cancelled:removeMapping` rows are the on-chain-detected cancellations. `sweep:stillAuthorized` rows are healthy generators last confirmed still-authorized — cross-check that their `next_check_block - last_check_block == 100` (or whatever `DETERMINISTIC_CANCEL_SWEEP_INTERVAL` is set to).
-
----
-
-## Known Error Patterns
-
-| Error message | Cause | Fix |
-|---------------|-------|-----|
-| `BigIntSerializationError: Do not know how to serialize a BigInt` | Decoded params contain raw `bigint` — not wrapped with `replaceBigInts` | Wrap decode result: `replaceBigInts(decoded, String)` in handler |
-| `Cannot use a pool after calling end on the pool` | Secondary — always follows a fatal handler error that caused Ponder to shut down the DB pool | Fix the primary error first |
-| `Unknown handler ... saving as Unknown` | Handler address not in `HANDLER_MAP` in `src/utils/order-types.ts` | Add address to map; expected for new/unsupported contracts |
-| `Decode failed ... orderType=...` | `staticInput` does not match expected ABI for that order type | Check ABI tuple in `src/decoders/<type>.ts`; compare with `agent_docs/decoder-reference.md` |
-| `Fetching backfill JSON-RPC data is taking longer than expected` | RPC rate limit or slow provider | Transient — monitor; switch RPC if persistent |

From fca4975f4e0ba1d32581dffa332ee0dd84a62b9e Mon Sep 17 00:00:00 2001
From: Jefferson Bastos <jeff.junior98@gmail.com>
Date: Mon, 15 Jun 2026 16:04:45 -0300
Subject: [PATCH 43/84] refactor(qa): route stray console.* through the
 structured logger

blockHandler.ts: the lone console.warn in the CandidateConfirmer account-fallback catch is now log("warn", "CandidateConfirmer:accountFallback_failed", ...), matching the HandlerName:event convention used by every other log call in the file (the old [COW:C2] bracket prefix was the last straggler of a retired format). router.ts: the API onError handler now emits a structured log("error", "api:error", ...) line instead of a plain console.error string, so every log line is parseable JSON.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 src/api/router.ts                        | 3 ++-
 src/application/handlers/blockHandler.ts | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/api/router.ts b/src/api/router.ts
index 8c83ded..8b858de 100644
--- a/src/api/router.ts
+++ b/src/api/router.ts
@@ -7,11 +7,12 @@ import {
 import { ordersByOwnerHandler } from "./endpoints/orders-by-owner";
 import { executionSummaryHandler } from "./endpoints/execution-summary";
 import { syncProgressHandler } from "./endpoints/sync-progress";
+import { log } from "../application/helpers/logger";
 
 export const apiRouter = new OpenAPIHono();
 
 apiRouter.onError((err, c) => {
-  console.error("API Error:", err);
+  log("error", "api:error", { err: err instanceof Error ? err.message : String(err) });
   return c.json(
     {
       error: "Internal server error",
diff --git a/src/application/handlers/blockHandler.ts b/src/application/handlers/blockHandler.ts
index 14301e1..2d39a47 100644
--- a/src/application/handlers/blockHandler.ts
+++ b/src/application/handlers/blockHandler.ts
@@ -579,7 +579,7 @@ ponder.on("CandidateConfirmer:block", async ({ event, context }) => {
             if (ownerMissedUids.has(uid)) staleStatuses.set(uid, info);
           }
         } catch (err) {
-          console.warn(`[COW:C2] block=${event.block.number} chain=${chainId} accountFallback failed owner=${owner}`, err);
+          log("warn", "CandidateConfirmer:accountFallback_failed", { block: String(event.block.number), chainId, owner, err: err instanceof Error ? err.message : String(err) });
         }
       }
     }

From df175acb900f71e33c3adc8e3c2190b862c8a16b Mon Sep 17 00:00:00 2001
From: Jefferson Bastos <jeff.junior98@gmail.com>
Date: Mon, 15 Jun 2026 16:04:45 -0300
Subject: [PATCH 44/84] refactor(qa): use MAX_TWAP_PRECOMPUTE_PARTS instead of
 a hardcoded literal

uidPrecompute.ts imported and used the MAX_TWAP_PRECOMPUTE_PARTS constant (previously declared/exported but never referenced) in place of the hardcoded 100000 twin. Also fixes the constant's doc comment to reference the actual emitted log (precompute:skip) rather than the retired [COW:PRECOMPUTE] SKIP format.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 src/application/helpers/uidPrecompute.ts | 3 ++-
 src/constants.ts                         | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/application/helpers/uidPrecompute.ts b/src/application/helpers/uidPrecompute.ts
index 16a3644..b481a4b 100644
--- a/src/application/helpers/uidPrecompute.ts
+++ b/src/application/helpers/uidPrecompute.ts
@@ -22,6 +22,7 @@ import { computeOrderUid, type GPv2OrderData } from "./orderUid";
 import { fetchOrderStatusByUids } from "./orderbookClient";
 import { type OrderType, DETERMINISTIC_ORDER_TYPE } from "../../utils/order-types";
 import { log } from "./logger";
+import { MAX_TWAP_PRECOMPUTE_PARTS } from "../../constants";
 
 // GPv2Order.sol constant hashes
 const KIND_SELL = "0xf3b277728b3fee749481eb3e0b3b48980dbbab78658fc419025cb16eee346775" as Hex;
@@ -234,7 +235,7 @@ function precomputeTwapUids(
     log("warn", "precompute:skip", { orderType: "TWAP", owner, chainId, reason: "invalid_math", nParts, tSeconds: String(tSeconds) });
     return null;
   }
-  if (nParts > 100000) {
+  if (nParts > MAX_TWAP_PRECOMPUTE_PARTS) {
     log("warn", "precompute:skip", { orderType: "TWAP", owner, chainId, reason: "too_many_parts", nParts });
     return null;
   }
diff --git a/src/constants.ts b/src/constants.ts
index 7e39bee..9dc3846 100644
--- a/src/constants.ts
+++ b/src/constants.ts
@@ -86,7 +86,7 @@ export const BOOTSTRAP_OWNER_FETCH_TIMEOUT_MS = 30_000;
  * Maximum number of TWAP parts that precomputeOrderUids will attempt to enumerate.
  * Pathological orders with n > this value skip precompute and fall back to the
  * OrderDiscoveryPoller discovery path (allCandidatesKnown=false). Logged as
- * [COW:PRECOMPUTE] SKIP reason=too_many_parts when triggered.
+ * `precompute:skip` with reason=too_many_parts when triggered.
  */
 export const MAX_TWAP_PRECOMPUTE_PARTS = 100_000;
 

From d8693a3b755a659d197545e8eb622abe9f485d10 Mon Sep 17 00:00:00 2001
From: Jefferson Bastos <jeff.junior98@gmail.com>
Date: Mon, 15 Jun 2026 16:04:45 -0300
Subject: [PATCH 45/84] refactor(qa): remove unused no-op invalidateOwnerCache
 export

invalidateOwnerCache was an exported async function with an empty body and zero callers, kept 'for API compatibility'. There is no API contract to preserve before the public handover, so it is removed.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 src/application/helpers/orderbookClient.ts | 17 -----------------
 1 file changed, 17 deletions(-)

diff --git a/src/application/helpers/orderbookClient.ts b/src/application/helpers/orderbookClient.ts
index 1105688..7ad9acb 100644
--- a/src/application/helpers/orderbookClient.ts
+++ b/src/application/helpers/orderbookClient.ts
@@ -145,23 +145,6 @@ export async function fetchComposableOrders(
   return results;
 }
 
-/**
- * Invalidate the UID cache for orders belonging to an owner's generators.
- * Called when ConditionalOrderCreated fires so that the next fetch discovers new orders.
- *
- * Note: This is a no-op for per-UID cache since new orders won't have cache entries.
- * Kept for API compatibility; callers may add owner-level invalidation logic later.
- */
-export async function invalidateOwnerCache(
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  _context: any,
-  _chainId: number,
-  _owner: Hex,
-): Promise<void> {
-  // Per-UID cache doesn't need owner-level invalidation — new orders
-  // won't have cache entries, so they'll be fetched fresh from the API.
-}
-
 /**
  * Upsert composable orders into the discrete_order table.
  * Uses onConflictDoUpdate so the API's authoritative status overwrites

From 0fd4d8e34d80395f597c92c81e95a6825fcb3a5b Mon Sep 17 00:00:00 2001
From: Jefferson Bastos <jeff.junior98@gmail.com>
Date: Mon, 15 Jun 2026 16:04:45 -0300
Subject: [PATCH 46/84] docs(qa): dedupe and reorder block-handler descriptions

The blockHandler.ts section repeated the TWAP-aged-out-fallback and OrderStatusTracker paragraphs twice and listed the handlers out of order. Now each handler appears once in C1-C5 order (OrderDiscoveryPoller, CandidateConfirmer, TWAP fallback, OrderStatusTracker, OwnerBackfill, CancellationWatcher), using the canonical names throughout (the duplicate used a stale 'C2' reference).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 docs/architecture.md | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/docs/architecture.md b/docs/architecture.md
index c025909..fac3999 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -176,16 +176,11 @@ Stats (total settlements, trade logs found, EOA skips, adapter mappings, avg FAC
 
 All block handlers run only during live sync (`startBlock: "latest"`) to avoid hammering the orderbook API during historical backfill. `OrderDiscoveryPoller` and `CancellationWatcher` share a per-chain batch cap (`MAX_GENERATORS_PER_BLOCK_<chainId>`, default 200) and pull from a priority queue ordered by oldest `lastCheckBlock` first. Generators past the cap defer to the next block.
 
-**TWAP aged-out fallback**: When a candidate's `orderUid` is no longer served by `/orders/by_uids` (typically after the order expires from the orderbook cache), `CandidateConfirmer` falls back to fetching the owner's full order list from `/account/{owner}/orders`. This resolves TWAP parts that the orderbook stopped tracking before `CandidateConfirmer` processed them. On timeout or API failure, the candidate defaults to `expired`.
-
-**OrderStatusTracker** (every block, mainnet + gnosis): Polls the orderbook API for all `open` discrete orders and updates their status from the API response. Then sweeps any remaining `open` rows whose parent generator is `Cancelled` to `status='cancelled'` (API-terminal statuses from the loop above still win for children that were traded before on-chain cancellation). Finally expires any orders past their `validTo` timestamp.
-
 **OrderDiscoveryPoller** (every block, mainnet + gnosis): Multicalls `getTradeableOrderWithSignature` on ComposableCoW for each `Active` generator where `allCandidatesKnown=false`. A success result creates a `candidateDiscreteOrder` entry. A `SingleOrderNotAuthed` error marks the generator as `Cancelled` with `lastPollResult='cancelled:SingleOrderNotAuthed'`. Other errors (tryNextBlock, tryAtEpoch, etc.) advance the generator's `nextCheckBlock` accordingly. Single-shot non-deterministic types (GoodAfterTime, TradeAboveThreshold) set `allCandidatesKnown=true` after first success. Can be disabled with `DISABLE_POLL_RESULT_CHECK=true`.
 
 **CandidateConfirmer** (every block, mainnet + gnosis): First drains any `candidateDiscreteOrder` rows whose parent generator is `Cancelled` — promoting them into `discreteOrder` with `status='cancelled'` and deleting the candidate rows. Then checks remaining `candidateDiscreteOrder` rows against the orderbook API: when a candidate appears in the API, it's promoted to `discreteOrder` and deleted from candidates. Candidates past their `validTo` are also pruned.
 
-**TWAP aged-out fallback**: When a candidate's `orderUid` is no longer served by `/orders/by_uids` (typically after the order expires from the orderbook cache), `CandidateConfirmer` falls back to fetching the owner's full order list from `/account/{owner}/orders`. This resolves TWAP parts that the orderbook stopped tracking before C2 processed them. On timeout or API failure, the candidate defaults to `expired`.
-
+**TWAP aged-out fallback**: When a candidate's `orderUid` is no longer served by `/orders/by_uids` (typically after the order expires from the orderbook cache), `CandidateConfirmer` falls back to fetching the owner's full order list from `/account/{owner}/orders`. This resolves TWAP parts that the orderbook stopped tracking before `CandidateConfirmer` processed them. On timeout or API failure, the candidate defaults to `expired`.
 
 **OrderStatusTracker** (every block, mainnet + gnosis): Polls the orderbook API for all `open` discrete orders and updates their status from the API response. Then sweeps any remaining `open` rows whose parent generator is `Cancelled` to `status='cancelled'` (API-terminal statuses from the loop above still win for children that were traded before on-chain cancellation). Finally expires any orders past their `validTo` timestamp.
 

From 2c1ca0ed7ee00f2cf97610bf99094c6ca43b74b0 Mon Sep 17 00:00:00 2001
From: Jefferson Bastos <jeff.junior98@gmail.com>
Date: Mon, 15 Jun 2026 16:31:31 -0300
Subject: [PATCH 47/84] refactor(qa): dedupe GPv2 order constant hashes

KIND_SELL/KIND_BUY/BALANCE_ERC20 were declared independently in both orderUid.ts and uidPrecompute.ts. They are now exported from orderUid.ts (the canonical owner of GPv2 order encoding) and imported by uidPrecompute.ts, so a divergent edit can't silently break UID computation.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 src/application/helpers/orderUid.ts      | 6 +++---
 src/application/helpers/uidPrecompute.ts | 7 +------
 2 files changed, 4 insertions(+), 9 deletions(-)

diff --git a/src/application/helpers/orderUid.ts b/src/application/helpers/orderUid.ts
index fdff5c2..61213f0 100644
--- a/src/application/helpers/orderUid.ts
+++ b/src/application/helpers/orderUid.ts
@@ -45,9 +45,9 @@ export interface GPv2OrderData {
 }
 
 // GPv2Order.sol constant hashes — keccak256 of the string representation
-const KIND_SELL = "0xf3b277728b3fee749481eb3e0b3b48980dbbab78658fc419025cb16eee346775";
-const KIND_BUY  = "0x6ed88e868af0a1983e3886d5f3e95a2fafbd6c3450bc229e27342283dc429ccc";
-const BALANCE_ERC20    = "0x5a28e9363bb942b639270062aa6bb295f434bcdfc42c97267bf003f272060dc9";
+export const KIND_SELL = "0xf3b277728b3fee749481eb3e0b3b48980dbbab78658fc419025cb16eee346775" as Hex;
+export const KIND_BUY  = "0x6ed88e868af0a1983e3886d5f3e95a2fafbd6c3450bc229e27342283dc429ccc" as Hex;
+export const BALANCE_ERC20    = "0x5a28e9363bb942b639270062aa6bb295f434bcdfc42c97267bf003f272060dc9" as Hex;
 const BALANCE_EXTERNAL = "0xabee3b73373acd583a130924aad6dc38cfdc44ba0555ba94ce2ff63980ea0632";
 const BALANCE_INTERNAL = "0x4ac99ace14ee0a5ef932dc609df0943ab7ac16b7583634612f8dc35a4289a6ce";
 
diff --git a/src/application/helpers/uidPrecompute.ts b/src/application/helpers/uidPrecompute.ts
index b481a4b..be71dd2 100644
--- a/src/application/helpers/uidPrecompute.ts
+++ b/src/application/helpers/uidPrecompute.ts
@@ -18,17 +18,12 @@
 import type { Hex } from "viem";
 import { and, eq } from "ponder";
 import { candidateDiscreteOrder, conditionalOrderGenerator, discreteOrder } from "ponder:schema";
-import { computeOrderUid, type GPv2OrderData } from "./orderUid";
+import { computeOrderUid, type GPv2OrderData, KIND_SELL, KIND_BUY, BALANCE_ERC20 } from "./orderUid";
 import { fetchOrderStatusByUids } from "./orderbookClient";
 import { type OrderType, DETERMINISTIC_ORDER_TYPE } from "../../utils/order-types";
 import { log } from "./logger";
 import { MAX_TWAP_PRECOMPUTE_PARTS } from "../../constants";
 
-// GPv2Order.sol constant hashes
-const KIND_SELL = "0xf3b277728b3fee749481eb3e0b3b48980dbbab78658fc419025cb16eee346775" as Hex;
-const KIND_BUY = "0x6ed88e868af0a1983e3886d5f3e95a2fafbd6c3450bc229e27342283dc429ccc" as Hex;
-const BALANCE_ERC20 = "0x5a28e9363bb942b639270062aa6bb295f434bcdfc42c97267bf003f272060dc9" as Hex;
-
 // ─── Types ───────────────────────────────────────────────────────────────────
 
 export interface PrecomputedOrder {

From 898b48199e61e038d9138ba52baaa136566ea9a0 Mon Sep 17 00:00:00 2001
From: Jefferson Bastos <jeff.junior98@gmail.com>
Date: Mon, 15 Jun 2026 16:31:31 -0300
Subject: [PATCH 48/84] refactor(qa): return orderType from insertGenerator;
 drop redundant decoded log

insertGenerator already computed orderType but both ConditionalOrderCreated call sites recomputed it via getOrderTypeFromHandler; it is now returned and destructured. Also removes the per-generator composableCow:decoded info log, which fired on every creation during backfill and duplicated the signal already in composableCow:created (the decodeFailed warn path is kept).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 src/application/handlers/composableCow.ts | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)

diff --git a/src/application/handlers/composableCow.ts b/src/application/handlers/composableCow.ts
index 3168285..ee7cb14 100644
--- a/src/application/handlers/composableCow.ts
+++ b/src/application/handlers/composableCow.ts
@@ -43,7 +43,7 @@ import {
   transaction,
 } from "ponder:schema";
 import { encodeAbiParameters, keccak256, type Hex } from "viem";
-import { getOrderTypeFromHandler } from "../../utils/order-types";
+import { getOrderTypeFromHandler, type OrderType } from "../../utils/order-types";
 import { decodeStaticInput } from "../../decoders/index";
 import { precomputeAndDiscover } from "../helpers/uidPrecompute";
 import { CirclesBackingOrderAbi } from "../../../abis/CirclesBackingOrderAbi";
@@ -107,6 +107,7 @@ async function insertGenerator(
   ownerAddress: Hex;
   chainId: number;
   decodedParams: Record<string, string> | null;
+  orderType: OrderType;
 }> {
   const { owner, params } = event.args;
   const { handler, salt, staticInput } = params;
@@ -166,8 +167,6 @@ async function insertGenerator(
           sellAmount: sellAmount.toString(),
         };
       }
-
-      log("info", "composableCow:decoded", { event: event.id, orderType, decodedParams: decodedParams ? "ok" : "null" });
     } catch (err) {
       log("warn", "composableCow:decodeFailed", { event: event.id, orderType, err: String(err) });
       decodedParams = null;
@@ -225,7 +224,7 @@ async function insertGenerator(
     })
     .onConflictDoNothing();
 
-  return { ownerAddress, chainId, decodedParams };
+  return { ownerAddress, chainId, decodedParams, orderType };
 }
 
 // ─── Backfill handler (ComposableCow — historical) ─────────────────────────
@@ -233,12 +232,11 @@ async function insertGenerator(
 ponder.on(
   "ComposableCow:ConditionalOrderCreated",
   async ({ event, context }) => {
-    const { ownerAddress, chainId, decodedParams } = await insertGenerator(event, context);
+    const { ownerAddress, chainId, decodedParams, orderType } = await insertGenerator(event, context);
 
     // Pre-compute UIDs for deterministic order types (TWAP, StopLoss, CirclesBackingOrder).
     // Fetches status from API by UID, upserts discrete orders, and
     // deactivates the generator if all orders are already terminal.
-    const orderType = getOrderTypeFromHandler(event.args.params.handler, chainId);
     await precomputeAndDiscover(
       context, chainId, event.id, ownerAddress, orderType, decodedParams, event.block.timestamp,
     );
@@ -252,9 +250,8 @@ ponder.on(
 ponder.on(
   "ComposableCowLive:ConditionalOrderCreated",
   async ({ event, context }) => {
-    const { ownerAddress, chainId, decodedParams } = await insertGenerator(event, context);
+    const { ownerAddress, chainId, decodedParams, orderType } = await insertGenerator(event, context);
 
-    const orderType = getOrderTypeFromHandler(event.args.params.handler, chainId);
     await precomputeAndDiscover(
       context, chainId, event.id, ownerAddress, orderType, decodedParams, event.block.timestamp,
     );

From e9b351057041af20314969d21117f0eefb43459e Mon Sep 17 00:00:00 2001
From: Jefferson Bastos <jeff.junior98@gmail.com>
Date: Mon, 15 Jun 2026 16:31:31 -0300
Subject: [PATCH 49/84] docs(qa): trim over-documented local database setup

Drops the inline restatement of the Postgres user/password/DATABASE_URL (already in .env.example) and the duplicated per-flag PostgreSQL memory list (already in the docker-compose.yml command block), pointing the reader at those sources instead.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 docs/deployment.md | 18 ++----------------
 1 file changed, 2 insertions(+), 16 deletions(-)

diff --git a/docs/deployment.md b/docs/deployment.md
index 3f602af..a029eb6 100644
--- a/docs/deployment.md
+++ b/docs/deployment.md
@@ -63,14 +63,7 @@ The repo includes a `docker-compose.yml` at the root that starts PostgreSQL 16:
 docker compose up -d
 ```
 
-This gives you Postgres on port 5432 (user `postgres`, password `postgres`, database `programmatic-orders`). Add to `.env.local`:
-
-```
-DATABASE_URL=postgresql://postgres:postgres@localhost:5432/programmatic-orders
-DATABASE_SCHEMA=programmatic_orders
-```
-
-Ponder manages schema migrations automatically. When it starts, it creates or updates the tables within the configured schema. You never run migrations manually.
+Copy the matching `DATABASE_URL` and `DATABASE_SCHEMA` into `.env.local` from `.env.example`. Ponder manages schema migrations automatically — it creates or updates the tables within the configured schema on startup; you never run migrations manually.
 
 ### Production
 
@@ -150,14 +143,7 @@ log("warn", "CandidateConfirmer:timeout",   { chainId, block: String(event.block
 
 ### PostgreSQL Memory Flags
 
-Memory settings are hardcoded in the `command:` block of `docker-compose.yml`, tuned for 1G RAM:
-
-- `shared_buffers`: 204MB (~20% RAM)
-- `work_mem`: 2MB per connection (~25% RAM / max_connections)
-- `effective_cache_size`: 512MB (~50% RAM)
-- `maintenance_work_mem`: 51MB
-
-Adjust these proportionally if you change the host's available memory.
+Memory settings are hardcoded in the `command:` block of `docker-compose.yml`, tuned for 1G RAM (see the inline comments there). Adjust them proportionally if you change the host's available memory.
 
 
 ## Deploying

From b50767b7af12bd4fb98f09cd094541986b75b21b Mon Sep 17 00:00:00 2001
From: Jefferson Bastos <jeff.junior98@gmail.com>
Date: Mon, 15 Jun 2026 16:31:31 -0300
Subject: [PATCH 50/84] docs(qa): restore debug-ponder playbook, scrubbed and
 updated for current logs

Restores the Ponder debugging playbook (removed earlier in this branch for leaking ticket IDs) with all internal task references stripped (COW-887/904/918, a PR ref) and every log-search example rewritten to match the code's current structured-JSON logger and HandlerName:event tokens (OrderDiscoveryPoller:DONE, CandidateConfirmer:*, OwnerBackfill:*, CancellationWatcher:*, precompute:skip, setup:cacheReady, ob:*). Sections targeting retired log tokens ([COW:OB:CACHE], [COW:OB:POLL]) were removed rather than left stale.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .claude/commands/debug-ponder.md | 366 +++++++++++++++++++++++++++++++
 1 file changed, 366 insertions(+)
 create mode 100644 .claude/commands/debug-ponder.md

diff --git a/.claude/commands/debug-ponder.md b/.claude/commands/debug-ponder.md
new file mode 100644
index 0000000..f39a2f8
--- /dev/null
+++ b/.claude/commands/debug-ponder.md
@@ -0,0 +1,366 @@
+# Debug Ponder Log
+
+Analyze `ponder.log` to diagnose indexer issues. Run after `pnpm dev --disable-ui 2>&1 | tee ponder.log`.
+
+## Critical Rule
+
+**NEVER use the `Read` tool on `ponder.log`** — the file is too large and will crash context. Use only `Bash` with `grep`, `tail`, or `sed`.
+
+## Log Format
+
+Handler code uses a structured JSON logger (`src/application/helpers/logger.ts`). Each `log(level, msg, fields)` call emits exactly one JSON line:
+
+```json
+{"time":1700000000000,"level":"info","msg":"OrderDiscoveryPoller:DONE","block":"12345678","chainId":1,"due":12,"success":2,"never":0,"backedOff":0}
+```
+
+Practical consequences for grep:
+- The `msg` token is the stable search key. Grep it directly: `grep OrderDiscoveryPoller:DONE ponder.log` (or `grep '"OrderDiscoveryPoller:DONE"'` to avoid substring collisions).
+- Fields like `block`, `chainId`, `owner`, `due` are JSON keys, not `key=value` text. Filter on them with `grep '"chainId":100'`, not `grep 'chain=100'`.
+- Severity is the JSON `"level"` key (`info` / `warn` / `error`), not a bare `INFO` / `WARN` / `ERROR` word — though Ponder's own framework lines still use the bare-word format, so both appear in the file.
+- Pretty-print a matched line with `jq`: `grep OrderDiscoveryPoller:DONE ponder.log | tail -1 | jq`.
+
+The block handlers split work across five Ponder block entries. The canonical handler names (and their C1–C5 shorthand) are:
+
+| Shorthand | Handler | Role |
+|-----------|---------|------|
+| C1 | `OrderDiscoveryPoller` | RPC multicall for non-deterministic generators, every block |
+| C2 | `CandidateConfirmer`   | API batch check for unconfirmed candidates, every block |
+| C3 | `OrderStatusTracker`   | API batch check for open discrete orders + expiry, every block |
+| C4 | `OwnerBackfill`         | One-shot owner fetch for non-deterministic backfill orders |
+| C5 | `CancellationWatcher`  | `singleOrders()` mapping read for deterministic generators C1 skips |
+
+---
+
+## Investigation Steps
+
+Run all steps before reporting. If a step returns nothing, note it explicitly — "No errors found" is useful signal.
+
+### Step 1 — Fatal errors
+
+```bash
+# Framework errors (bare-word) plus structured error lines
+grep -n "ERROR\|\"level\":\"error\"" ponder.log | head -40
+```
+
+If any errors found, grab context around the first one:
+
+```bash
+# Replace N with the line number from above
+grep -n "ERROR\|\"level\":\"error\"" ponder.log | head -1
+# Then run: sed -n 'N-2,N+20p' ponder.log
+```
+
+### Step 2 — Warnings
+
+```bash
+grep -n "WARN\|\"level\":\"warn\"" ponder.log | head -40
+```
+
+The structured warn lines worth scanning include `composableCow:decodeFailed`, `composableCow:unknownHandler`, the `ob:*` fetch failures/timeouts, and the `*:multicall_timeout` handler lines.
+
+### Step 3 — Handler events (success path)
+
+```bash
+grep -n "composableCow:" ponder.log | tail -30
+```
+
+Healthy output looks like:
+```json
+{"level":"info","msg":"composableCow:created","event":"...","chainId":1,"orderType":"TWAP","block":"..."}
+{"level":"info","msg":"composableCow:decoded","event":"...","orderType":"TWAP","decodedParams":"ok"}
+```
+
+Red flags:
+- `composableCow:decoded` with `"decodedParams":"null"` on a known orderType → decoder returned nothing
+- `composableCow:decodeFailed` line → malformed staticInput; the `err` field has the message
+- `composableCow:unknownHandler` line → address not in `HANDLER_MAP` in `src/utils/order-types.ts`
+
+### Step 4 — Startup / DB / RPC health
+
+```bash
+grep -n "INFO\|WARN\|ERROR" ponder.log | head -20
+```
+
+These are Ponder's own framework lines (bare-word format). Healthy startup sequence:
+```
+INFO  Connected to database
+INFO  Connected to JSON-RPC
+INFO  Dropped existing database tables   ← only on first run / schema change
+INFO  Created database tables
+INFO  Started backfill indexing
+INFO  Started fetching backfill JSON-RPC data
+```
+
+### Step 5 — Last known state
+
+```bash
+tail -50 ponder.log
+```
+
+If the process is stuck or crashed, this shows the last state before it stopped.
+
+---
+
+## Report Format
+
+After running all steps, output:
+
+```markdown
+## Ponder Debug Report
+
+### Errors
+[List each unique error with line number, or "None found"]
+
+### Warnings
+[List each unique warning type and count, or "None found"]
+
+### Handler Events
+- Total ConditionalOrderCreated seen: N
+- Breakdown by orderType: TWAP=N, StopLoss=N, PerpetualSwap=N, GoodAfterTime=N, TradeAboveThreshold=N, Unknown=N
+- decodedParams=ok: N | decodedParams=null: N
+
+### Verdict
+[Healthy | Degraded (warnings only) | Broken (errors present)]
+
+### Root Cause
+[What's wrong and why, based on evidence]
+
+### Next Step
+[Specific fix or command to run]
+```
+
+---
+
+## Precompute Diagnostics
+
+Deterministic types (TWAP, StopLoss) should have all UIDs precomputed at creation — they should NOT appear in C1 (`OrderDiscoveryPoller`) polling. If precompute fails, the generator falls into C1 and wastes RPC calls every block.
+
+### Precompute failures — why generators fall into C1
+
+```bash
+grep -n "precompute:skip" ponder.log | head -20
+```
+
+Each line is a deterministic generator that FAILED precompute and will fall into C1 polling. The JSON `reason` field tells you why:
+
+| reason | meaning | fix |
+|--------|---------|-----|
+| `decodedParams_null` | Decode of staticInput returned null | Check decoder for that order type; likely malformed on-chain data |
+| `missing_params` | Required fields missing after decode (see the `missing` field for which) | Decoder returned incomplete data |
+| `invalid_math` | nParts <= 0 or tSeconds <= 0 | Invalid TWAP params on-chain |
+| `too_many_parts` | nParts > 100,000 | Extremely large TWAP; raise limit if legitimate |
+
+**If you see skip lines**: count them and cross-reference with C1's `due` count. If they match, precompute failures are the sole cause of C1 polling for deterministic types.
+
+```bash
+grep -c "precompute:skip" ponder.log
+```
+
+The counterpart success log is `precompute:allTerminal` (all UIDs for a generator precomputed up front):
+
+```bash
+grep -c "precompute:allTerminal" ponder.log
+```
+
+### Verify deterministic types are NOT in C1
+
+After precompute fixes, C1 should only poll non-deterministic types. Inspect recent C1 DONE lines on gnosis:
+
+```bash
+grep '"OrderDiscoveryPoller:DONE"' ponder.log | grep '"chainId":100' | tail -5
+```
+
+A healthy `due` count should be much smaller than total generators — only non-deterministic types should remain.
+
+---
+
+## Orderbook Cache
+
+The `orderbook_cache` table persists across Ponder resyncs (it is NOT an `onchainTable`). These steps verify the cache is alive and working.
+
+### Cache startup — verify persistence across restarts
+
+Look for the setup log emitted once at startup (`setup:cacheReady`):
+
+```bash
+grep -n "setup:cacheReady" ponder.log | head -5
+```
+
+Healthy output (the `count` field is the row count loaded from the previous run):
+```json
+{"level":"info","msg":"setup:cacheReady","count":42,"entries":"42 entries from previous run"}
+```
+
+If you see `"count":0` on a restart (not a first run), the cache table was dropped — this indicates a schema migration or Docker volume wipe, not a bug.
+
+### Orderbook fetches — what is served from cache vs. the API
+
+Each orderbook fetch emits an `ob:fetch` entry on start and an `ob:fetchResult` on completion. The result line carries the cache breakdown:
+
+```bash
+grep -n "ob:fetchResult" ponder.log | tail -20
+```
+
+Healthy output:
+```json
+{"level":"info","msg":"ob:fetchResult","owner":"0x1234...","chainId":1,"apiTotal":12,"composable":5,"cached":3,"refreshed":2}
+```
+
+- `cached` = composable orders served from the cache (no per-UID status refresh needed).
+- `refreshed` = composable orders whose status was re-fetched this cycle.
+
+High `cached` relative to `composable` means the cache is working. If `cached` stays near zero after a warm restart, the cache was not populated in the previous run (all owners were non-terminal) or the table was reset.
+
+Fetch-side failures and timeouts are warn lines worth scanning when fetches look wrong:
+
+```bash
+grep -nE "ob:(noApiUrl|accountError|accountFetchFailed|accountTimeout|batchFetchError|batchFetchFailed|batchFetchTimeout|statusByUidsTimeout)" ponder.log | tail -20
+```
+
+### C4 OwnerBackfill — one-shot (`endBlock: "latest"`)
+
+`OwnerBackfill` in `ponder.config.ts` uses `startBlock: "latest"` and `endBlock: "latest"` so it should run **once per chain** when the indexer reaches live (not every block). Use logs to confirm.
+
+```bash
+grep -nE "OwnerBackfill:(START|bootstrap_start|no_bootstrap_needed|DONE)" ponder.log
+```
+
+Healthy output (per chain, after live sync starts):
+```json
+{"level":"info","msg":"OwnerBackfill:START","block":"...","chainId":1,"pendingRetry":0}
+{"level":"info","msg":"OwnerBackfill:bootstrap_start","block":"...","chainId":1,"generators":7,"freshOwners":7}
+{"level":"info","msg":"OwnerBackfill:DONE","block":"...","chainId":1,"discovered":3}
+```
+
+When nothing needs bootstrapping you get `OwnerBackfill:no_bootstrap_needed` instead of `bootstrap_start`/`DONE`. Either way you should see this sequence run roughly once per chain after live, not every block. Owner-fetch timeouts during bootstrap surface as `OwnerBackfill:owner_timeout` (and `OwnerBackfill:owner_retry_timeout` on the retry queue) — both carry the offending `owner` and `timeoutMs`. A **full resync** resets the process and you will see the START/DONE pair fire again on the next run (expected).
+
+---
+
+## C1 tryNextBlock backoff
+
+Generators that keep returning `PollResult.tryNextBlock` are progressively rate-limited. After 50 consecutive tryNextBlock responses the recheck interval jumps from +1 to +10 blocks; after 200, to +50.
+
+### DONE log — backoff count per cycle
+
+```bash
+grep -n '"OrderDiscoveryPoller:DONE"' ponder.log | tail -20
+```
+
+Healthy output (mainnet, few stuck generators):
+```json
+{"level":"info","msg":"OrderDiscoveryPoller:DONE","block":"12345678","chainId":1,"due":12,"success":2,"never":0,"backedOff":0,"capped":false}
+```
+
+Gnosis after warm-up — expect non-zero `backedOff` as chronic offenders climb past the 50-threshold:
+```json
+{"level":"info","msg":"OrderDiscoveryPoller:DONE","block":"45678901","chainId":100,"due":180,"success":3,"never":0,"backedOff":150,"capped":false}
+```
+
+`backedOff` counts generators whose counter exceeded the warmup threshold on *this* block — i.e., they received a backoff longer than +1. A `"NEVER"` entry (`OrderDiscoveryPoller:NEVER`) records a generator that returned `PollResult.dontTryNextBlock` with its `reason`.
+
+### Counter distribution — verify the mechanism is climbing
+
+Run against the indexer Postgres (see `docker compose up -d`):
+
+```sql
+SELECT chain_id,
+       CASE
+         WHEN consecutive_try_next_block <= 50 THEN '0-50 (warmup)'
+         WHEN consecutive_try_next_block <= 200 THEN '51-200 (mid)'
+         ELSE '201+ (cold)'
+       END AS tier,
+       COUNT(*) AS generators,
+       MAX(consecutive_try_next_block) AS max_count
+FROM conditional_order_generator
+WHERE status = 'Active' AND all_candidates_known = false
+GROUP BY 1, 2
+ORDER BY 1, 2;
+```
+
+On a healthy gnosis run post-sync you should see a non-trivial bucket in `51-200` and/or `201+`. If everything sits at `0-50` after >300 gnosis blocks, either there genuinely are no chronic tryNextBlock generators (precompute eliminated them — success) *or* the counter is not incrementing (bug).
+
+### Red flag — counter stuck high but `due` still huge
+
+If `consecutive_try_next_block` is large for many generators *and* the C1 `due` count is still massive every block, the backoff is not actually deferring those generators — check that the C1 SELECT filters by `nextCheckBlock <= currentBlock` and that the handler updated `nextCheckBlock = currentBlock + <backoff>` correctly on tryNextBlock.
+
+---
+
+## C5 CancellationWatcher — singleOrders() mapping sweep
+
+`CancellationWatcher` in `ponder.config.ts` runs every block but only does work when at least one deterministic generator (`allCandidatesKnown = true AND status = "Active"`) has `nextCheckBlock <= currentBlock`. Per-generator cadence is `DETERMINISTIC_CANCEL_SWEEP_INTERVAL` blocks (see `src/constants.ts`, default 100). The handler reads `ComposableCoW.singleOrders(owner, hash)` — `false` means the owner called `remove()` on-chain.
+
+### ENTER / DONE — per-sweep summary
+
+```bash
+grep -nE "CancellationWatcher:(ENTER|DONE)" ponder.log | tail -40
+```
+
+Healthy output (one ENTER + one DONE per block where work happens):
+```json
+{"level":"info","msg":"CancellationWatcher:ENTER","block":"...","chainId":1,"due":12}
+{"level":"info","msg":"CancellationWatcher:DONE","block":"...","chainId":1,"due":12,"cancelled":0,"stillActive":12,"errors":0}
+```
+
+If `due` is 0 on every block for a long time, either there are no Active deterministic generators on that chain yet, or the kill-switch is on (see below). When the multicall itself times out you get `CancellationWatcher:multicall_timeout` instead of a DONE line.
+
+### Cancellations detected
+
+```bash
+grep -n "CancellationWatcher:CANCELLED" ponder.log
+```
+
+Each line is a deterministic generator whose on-chain `singleOrders(owner, hash)` returned `false`:
+```json
+{"level":"info","msg":"CancellationWatcher:CANCELLED","block":"...","chainId":1,"generatorId":"...","orderType":"StopLoss"}
+```
+
+After any `CANCELLED` line the candidate-cancellation cascade fires on the next C2 (`CandidateConfirmer`) block tick — candidates are drained to `discrete_order`:
+```json
+{"level":"info","msg":"CandidateConfirmer:parent_cancelled","block":"...","chainId":1,"parentCancelled":3,"preflightKnown":0}
+```
+
+The C3 (`OrderStatusTracker`) parent-cancelled sweep has no dedicated log line — verify via SQL:
+```sql
+SELECT count(*) FROM discrete_order
+WHERE status='cancelled' AND conditional_order_generator_id = '<eventId>';
+```
+
+### Multicall errors
+
+`errors > 0` on a DONE line is not fatal: C5 leaves `nextCheckBlock` untouched for errored entries so they retry on the next sweep. Sustained nonzero `errors` across many blocks means the RPC provider is flaky — consider swapping provider.
+
+### Sweep disabled (kill-switch)
+
+If operators see no `CancellationWatcher:` lines at all and expect them:
+```bash
+grep -n "DISABLE_DETERMINISTIC_CANCEL_SWEEP" .env.local env.prod 2>/dev/null
+```
+
+Non-empty means the sweeper is intentionally disabled via env var — same pattern as `DISABLE_POLL_RESULT_CHECK` for C1.
+
+### lastPollResult audit
+
+SQL spot-check for what C5 has touched:
+```sql
+SELECT chain_id, order_type, status, last_poll_result, count(*)
+FROM conditional_order_generator
+WHERE last_poll_result IN ('cancelled:removeMapping', 'sweep:stillAuthorized')
+GROUP BY 1,2,3,4
+ORDER BY 1,2,3,4;
+```
+
+`cancelled:removeMapping` rows are the on-chain-detected cancellations. `sweep:stillAuthorized` rows are healthy generators last confirmed still-authorized — cross-check that their `next_check_block - last_check_block == 100` (or whatever `DETERMINISTIC_CANCEL_SWEEP_INTERVAL` is set to).
+
+---
+
+## Known Error Patterns
+
+| Error message | Cause | Fix |
+|---------------|-------|-----|
+| `BigIntSerializationError: Do not know how to serialize a BigInt` | Decoded params contain raw `bigint` — not wrapped with `replaceBigInts` | Wrap decode result: `replaceBigInts(decoded, String)` in handler |
+| `Cannot use a pool after calling end on the pool` | Secondary — always follows a fatal handler error that caused Ponder to shut down the DB pool | Fix the primary error first |
+| `Unknown handler ... saving as Unknown` | Handler address not in `HANDLER_MAP` in `src/utils/order-types.ts` | Add address to map; expected for new/unsupported contracts |
+| `Decode failed ... orderType=...` | `staticInput` does not match expected ABI for that order type | Check ABI tuple in `src/decoders/<type>.ts`; compare with `agent_docs/decoder-reference.md` |
+| `Fetching backfill JSON-RPC data is taking longer than expected` | RPC rate limit or slow provider | Transient — monitor; switch RPC if persistent |
+| `[COW:timeout] <label> exceeded <ms>ms` | A wrapped async op blew its `withTimeout` budget (`src/application/helpers/withTimeout.ts`) — the `<label>` names the call site (e.g. `c2:stale:accountFallback`) | Usually surfaces as a handler `*:multicall_timeout` / `ob:*Timeout` warn line too; check RPC/API latency for that call site |

From 7cd38d426c810f89d6ee0011b38e99672aa0b408 Mon Sep 17 00:00:00 2001
From: Jefferson Bastos <jeff.junior98@gmail.com>
Date: Mon, 15 Jun 2026 16:31:31 -0300
Subject: [PATCH 51/84] chore(qa): remove internal founder_mode command

founder_mode.md described an internal Bleu Linear/PR process (retroactive ticket creation) with no value to a public consumer and a dangling reference to a non-existent linear.md.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .claude/commands/founder_mode.md | 73 --------------------------------
 1 file changed, 73 deletions(-)
 delete mode 100644 .claude/commands/founder_mode.md

diff --git a/.claude/commands/founder_mode.md b/.claude/commands/founder_mode.md
deleted file mode 100644
index 70f0f07..0000000
--- a/.claude/commands/founder_mode.md
+++ /dev/null
@@ -1,73 +0,0 @@
-# Founder Mode - Retroactive Process Setup
-
-You're working on an experimental feature that didn't get the proper ticketing and PR setup. This command helps you retroactively apply proper process to work that's already been implemented.
-
-## SSR Principles
-
-- **Simple**: Follow the standard workflow steps, just in reverse order
-- **Systematic**: Complete each step fully before moving to the next
-- **Reliable**: Validate git state and commits before any branch operations
-
-## Critical Checks
-
-- [ ] Recent commit exists and contains the experimental work
-- [ ] Commit is on main branch and needs to be moved to feature branch
-- [ ] Linear ticket creation includes clear problem statement (not just implementation)
-- [ ] Git operations preserve commit history correctly
-- [ ] PR creation follows standard process
-
-## Workflow Steps
-
-**Prerequisites**: You should have just made a commit with experimental work.
-
-### 1. Capture Current State
-
-```bash
-# Get the SHA of your recent commit
-git log --oneline -1
-# Verify you're on main branch
-git branch --show-current
-```
-
-### 2. Create Retroactive Linear Ticket
-
-- Read `.claude/commands/linear.md` for full instructions
-- Think deeply about what problem you solved (not just what you implemented)
-- Create ticket with proper problem statement and proposed solution
-- Set state to 'In Dev' since work is already complete
-- Must include headers: "### Problem to Solve" and "### Proposed Solution"
-
-### 3. Git Branch Management
-
-```bash
-# Get recommended branch name from Linear ticket
-git checkout main
-git checkout -b 'BRANCHNAME'
-git cherry-pick 'COMMITHASH'
-git push -u origin 'BRANCHNAME'
-```
-
-### 4. Create Pull Request
-
-```bash
-gh pr create --fill
-```
-
-### 5. Complete PR Description
-
-- Read `.claude/commands/describe_pr.md` and follow instructions
-- Ensure description reflects the retroactive nature of the work
-
-## Git Safety
-
-- Always verify commit SHA before cherry-picking
-- Confirm you're on correct branch before each git operation
-- Check that cherry-pick was successful before pushing
-- Validate remote branch creation before creating PR
-
-## Quality Gates
-
-- Linear ticket must have clear problem statement (not just "implement X")
-- Commit message should be descriptive of the change
-- Branch name should follow team conventions
-- PR description should be complete and follow template

From 1354b9acbcca42ae936b9c45436d410bdc56c6ac Mon Sep 17 00:00:00 2001
From: Jefferson Bastos <jeff.junior98@gmail.com>
Date: Mon, 15 Jun 2026 16:46:34 -0300
Subject: [PATCH 52/84] docs: replace C1-C5 shorthand with descriptive handler
 names

The C1-C5 block-handler shorthand was not descriptive for new readers, so it is dropped in favor of the canonical handler names the code already uses in its ponder.on registrations: OrderDiscoveryPoller, CandidateConfirmer, OrderStatusTracker, OwnerBackfill, CancellationWatcher. Applied across code comments, public GraphQL field descriptions, schema comments, tests, docs, the debug playbook, and the architecture-flow doc (including its Mermaid diagrams), so docs and comments stay synchronized with the code. Also fixes a stale 'precompute:skip' log-token reference in supported-order-types.md.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .claude/commands/debug-ponder.md              |  46 +++---
 agent_docs/m3-orderbook-integration-flow.md   | 156 +++++++++---------
 docs/architecture.md                          |   2 +-
 docs/deployment.md                            |   6 +-
 docs/supported-order-types.md                 |   2 +-
 schema/tables.ts                              |  10 +-
 src/api/endpoints/sync-progress.ts            |   2 +-
 .../gql-docs/conditional-order-generator.ts   |   8 +-
 src/api/gql-docs/discrete-order.ts            |  10 +-
 src/application/handlers/blockHandler.ts      |  38 ++---
 src/application/helpers/uidPrecompute.ts      |   2 +-
 src/chains/types.ts                           |   2 +-
 tests/helpers/statusFilter.test.ts            |   6 +-
 13 files changed, 145 insertions(+), 145 deletions(-)

diff --git a/.claude/commands/debug-ponder.md b/.claude/commands/debug-ponder.md
index f39a2f8..59b6d0d 100644
--- a/.claude/commands/debug-ponder.md
+++ b/.claude/commands/debug-ponder.md
@@ -20,15 +20,15 @@ Practical consequences for grep:
 - Severity is the JSON `"level"` key (`info` / `warn` / `error`), not a bare `INFO` / `WARN` / `ERROR` word — though Ponder's own framework lines still use the bare-word format, so both appear in the file.
 - Pretty-print a matched line with `jq`: `grep OrderDiscoveryPoller:DONE ponder.log | tail -1 | jq`.
 
-The block handlers split work across five Ponder block entries. The canonical handler names (and their C1–C5 shorthand) are:
+The block handlers split work across five Ponder block entries. The canonical handler names are:
 
-| Shorthand | Handler | Role |
-|-----------|---------|------|
-| C1 | `OrderDiscoveryPoller` | RPC multicall for non-deterministic generators, every block |
-| C2 | `CandidateConfirmer`   | API batch check for unconfirmed candidates, every block |
-| C3 | `OrderStatusTracker`   | API batch check for open discrete orders + expiry, every block |
-| C4 | `OwnerBackfill`         | One-shot owner fetch for non-deterministic backfill orders |
-| C5 | `CancellationWatcher`  | `singleOrders()` mapping read for deterministic generators C1 skips |
+| Handler | Role |
+|---------|------|
+| `OrderDiscoveryPoller` | RPC multicall for non-deterministic generators, every block |
+| `CandidateConfirmer`   | API batch check for unconfirmed candidates, every block |
+| `OrderStatusTracker`   | API batch check for open discrete orders + expiry, every block |
+| `OwnerBackfill`         | One-shot owner fetch for non-deterministic backfill orders |
+| `CancellationWatcher`  | `singleOrders()` mapping read for deterministic generators OrderDiscoveryPoller skips |
 
 ---
 
@@ -134,15 +134,15 @@ After running all steps, output:
 
 ## Precompute Diagnostics
 
-Deterministic types (TWAP, StopLoss) should have all UIDs precomputed at creation — they should NOT appear in C1 (`OrderDiscoveryPoller`) polling. If precompute fails, the generator falls into C1 and wastes RPC calls every block.
+Deterministic types (TWAP, StopLoss) should have all UIDs precomputed at creation — they should NOT appear in `OrderDiscoveryPoller` polling. If precompute fails, the generator falls into OrderDiscoveryPoller and wastes RPC calls every block.
 
-### Precompute failures — why generators fall into C1
+### Precompute failures — why generators fall into OrderDiscoveryPoller
 
 ```bash
 grep -n "precompute:skip" ponder.log | head -20
 ```
 
-Each line is a deterministic generator that FAILED precompute and will fall into C1 polling. The JSON `reason` field tells you why:
+Each line is a deterministic generator that FAILED precompute and will fall into OrderDiscoveryPoller polling. The JSON `reason` field tells you why:
 
 | reason | meaning | fix |
 |--------|---------|-----|
@@ -151,7 +151,7 @@ Each line is a deterministic generator that FAILED precompute and will fall into
 | `invalid_math` | nParts <= 0 or tSeconds <= 0 | Invalid TWAP params on-chain |
 | `too_many_parts` | nParts > 100,000 | Extremely large TWAP; raise limit if legitimate |
 
-**If you see skip lines**: count them and cross-reference with C1's `due` count. If they match, precompute failures are the sole cause of C1 polling for deterministic types.
+**If you see skip lines**: count them and cross-reference with OrderDiscoveryPoller's `due` count. If they match, precompute failures are the sole cause of OrderDiscoveryPoller polling for deterministic types.
 
 ```bash
 grep -c "precompute:skip" ponder.log
@@ -163,9 +163,9 @@ The counterpart success log is `precompute:allTerminal` (all UIDs for a generato
 grep -c "precompute:allTerminal" ponder.log
 ```
 
-### Verify deterministic types are NOT in C1
+### Verify deterministic types are NOT in OrderDiscoveryPoller
 
-After precompute fixes, C1 should only poll non-deterministic types. Inspect recent C1 DONE lines on gnosis:
+After precompute fixes, OrderDiscoveryPoller should only poll non-deterministic types. Inspect recent OrderDiscoveryPoller DONE lines on gnosis:
 
 ```bash
 grep '"OrderDiscoveryPoller:DONE"' ponder.log | grep '"chainId":100' | tail -5
@@ -218,7 +218,7 @@ Fetch-side failures and timeouts are warn lines worth scanning when fetches look
 grep -nE "ob:(noApiUrl|accountError|accountFetchFailed|accountTimeout|batchFetchError|batchFetchFailed|batchFetchTimeout|statusByUidsTimeout)" ponder.log | tail -20
 ```
 
-### C4 OwnerBackfill — one-shot (`endBlock: "latest"`)
+### OwnerBackfill — one-shot (`endBlock: "latest"`)
 
 `OwnerBackfill` in `ponder.config.ts` uses `startBlock: "latest"` and `endBlock: "latest"` so it should run **once per chain** when the indexer reaches live (not every block). Use logs to confirm.
 
@@ -237,7 +237,7 @@ When nothing needs bootstrapping you get `OwnerBackfill:no_bootstrap_needed` ins
 
 ---
 
-## C1 tryNextBlock backoff
+## OrderDiscoveryPoller tryNextBlock backoff
 
 Generators that keep returning `PollResult.tryNextBlock` are progressively rate-limited. After 50 consecutive tryNextBlock responses the recheck interval jumps from +1 to +10 blocks; after 200, to +50.
 
@@ -282,11 +282,11 @@ On a healthy gnosis run post-sync you should see a non-trivial bucket in `51-200
 
 ### Red flag — counter stuck high but `due` still huge
 
-If `consecutive_try_next_block` is large for many generators *and* the C1 `due` count is still massive every block, the backoff is not actually deferring those generators — check that the C1 SELECT filters by `nextCheckBlock <= currentBlock` and that the handler updated `nextCheckBlock = currentBlock + <backoff>` correctly on tryNextBlock.
+If `consecutive_try_next_block` is large for many generators *and* the OrderDiscoveryPoller `due` count is still massive every block, the backoff is not actually deferring those generators — check that the OrderDiscoveryPoller SELECT filters by `nextCheckBlock <= currentBlock` and that the handler updated `nextCheckBlock = currentBlock + <backoff>` correctly on tryNextBlock.
 
 ---
 
-## C5 CancellationWatcher — singleOrders() mapping sweep
+## CancellationWatcher — singleOrders() mapping sweep
 
 `CancellationWatcher` in `ponder.config.ts` runs every block but only does work when at least one deterministic generator (`allCandidatesKnown = true AND status = "Active"`) has `nextCheckBlock <= currentBlock`. Per-generator cadence is `DETERMINISTIC_CANCEL_SWEEP_INTERVAL` blocks (see `src/constants.ts`, default 100). The handler reads `ComposableCoW.singleOrders(owner, hash)` — `false` means the owner called `remove()` on-chain.
 
@@ -315,12 +315,12 @@ Each line is a deterministic generator whose on-chain `singleOrders(owner, hash)
 {"level":"info","msg":"CancellationWatcher:CANCELLED","block":"...","chainId":1,"generatorId":"...","orderType":"StopLoss"}
 ```
 
-After any `CANCELLED` line the candidate-cancellation cascade fires on the next C2 (`CandidateConfirmer`) block tick — candidates are drained to `discrete_order`:
+After any `CANCELLED` line the candidate-cancellation cascade fires on the next CandidateConfirmer block tick — candidates are drained to `discrete_order`:
 ```json
 {"level":"info","msg":"CandidateConfirmer:parent_cancelled","block":"...","chainId":1,"parentCancelled":3,"preflightKnown":0}
 ```
 
-The C3 (`OrderStatusTracker`) parent-cancelled sweep has no dedicated log line — verify via SQL:
+The OrderStatusTracker parent-cancelled sweep has no dedicated log line — verify via SQL:
 ```sql
 SELECT count(*) FROM discrete_order
 WHERE status='cancelled' AND conditional_order_generator_id = '<eventId>';
@@ -328,7 +328,7 @@ WHERE status='cancelled' AND conditional_order_generator_id = '<eventId>';
 
 ### Multicall errors
 
-`errors > 0` on a DONE line is not fatal: C5 leaves `nextCheckBlock` untouched for errored entries so they retry on the next sweep. Sustained nonzero `errors` across many blocks means the RPC provider is flaky — consider swapping provider.
+`errors > 0` on a DONE line is not fatal: CancellationWatcher leaves `nextCheckBlock` untouched for errored entries so they retry on the next sweep. Sustained nonzero `errors` across many blocks means the RPC provider is flaky — consider swapping provider.
 
 ### Sweep disabled (kill-switch)
 
@@ -337,11 +337,11 @@ If operators see no `CancellationWatcher:` lines at all and expect them:
 grep -n "DISABLE_DETERMINISTIC_CANCEL_SWEEP" .env.local env.prod 2>/dev/null
 ```
 
-Non-empty means the sweeper is intentionally disabled via env var — same pattern as `DISABLE_POLL_RESULT_CHECK` for C1.
+Non-empty means the sweeper is intentionally disabled via env var — same pattern as `DISABLE_POLL_RESULT_CHECK` for OrderDiscoveryPoller.
 
 ### lastPollResult audit
 
-SQL spot-check for what C5 has touched:
+SQL spot-check for what CancellationWatcher has touched:
 ```sql
 SELECT chain_id, order_type, status, last_poll_result, count(*)
 FROM conditional_order_generator
diff --git a/agent_docs/m3-orderbook-integration-flow.md b/agent_docs/m3-orderbook-integration-flow.md
index d1949c8..c7e6b5e 100644
--- a/agent_docs/m3-orderbook-integration-flow.md
+++ b/agent_docs/m3-orderbook-integration-flow.md
@@ -30,7 +30,7 @@ The system has seven components. Each has a single responsibility.
 
 **Writes to**: `discreteOrder` (for UIDs found on API), `candidateDiscreteOrder` (for UIDs not yet on API). Updates `conditionalOrderGenerator.status` to `Completed` if all orders are terminal on API.
 
-### Component C1: Contract Poller (`blockHandler.ts` — handler 1)
+### Component OrderDiscoveryPoller (`blockHandler.ts` — handler 1)
 
 **Responsibility**: Polls `getTradeableOrderWithSignature` on the ComposableCoW contract for **non-deterministic** active generators only. Creates candidate discrete orders when the contract returns success. Manages generator scheduling state (nextCheckBlock, nextCheckTimestamp, status).
 
@@ -46,7 +46,7 @@ The system has seven components. Each has a single responsibility.
 
 **Writes to**: `candidateDiscreteOrder`, updates `conditionalOrderGenerator` scheduling fields.
 
-### Component C2: Candidate Confirmer (`blockHandler.ts` — handler 2)
+### Component CandidateConfirmer (`blockHandler.ts` — handler 2)
 
 **Responsibility**: Checks if candidate discrete orders exist on the Orderbook API. When confirmed, promotes them to `discreteOrder` and deletes the candidate row.
 
@@ -56,11 +56,11 @@ The system has seven components. Each has a single responsibility.
 
 **Cleanup**: After promotion, confirmed candidates are deleted from `candidateDiscreteOrder`. Stale candidates past their `validTo` are also cleaned up — if the watch-tower never submitted them, they're expired and won't appear on the API.
 
-**Why a separate handler?** The Contract Poller (C1) discovers orders on-chain, but the API may not have them yet (watch-tower submission delay). This handler polls the API repeatedly until the candidate is confirmed. Separation means C1 focuses on RPC, C2 focuses on API — different cost profiles, can be tuned independently.
+**Why a separate handler?** OrderDiscoveryPoller discovers orders on-chain, but the API may not have them yet (watch-tower submission delay). This handler polls the API repeatedly until the candidate is confirmed. Separation means OrderDiscoveryPoller focuses on RPC, CandidateConfirmer focuses on API — different cost profiles, can be tuned independently.
 
 **Writes to**: `discreteOrder`. **Deletes from**: `candidateDiscreteOrder`.
 
-### Component C3: Status Updater (`blockHandler.ts` — handler 3)
+### Component OrderStatusTracker (`blockHandler.ts` — handler 3)
 
 **Responsibility**: Polls the API for status updates on non-terminal discrete orders. Detects when open orders become fulfilled, expired, or cancelled.
 
@@ -72,7 +72,7 @@ The system has seven components. Each has a single responsibility.
 
 **Writes to**: `discreteOrder`, `cow_cache.order_uid_cache` (caches newly terminal).
 
-### Component C4: Historical Bootstrap (`blockHandler.ts` — handler 4)
+### Component OwnerBackfill (`blockHandler.ts` — handler 4)
 
 **Responsibility**: One-time discovery of historical discrete orders for non-deterministic generators that were created during backfill. Runs once at the start of live sync (`startBlock = endBlock = "latest"`).
 
@@ -141,7 +141,7 @@ Confirmed orders. API-authoritative status. What consumers query.
 
 ### `candidateDiscreteOrder`
 
-Orders discovered on-chain (by C1 or UID pre-computation) but not yet confirmed on the Orderbook API. Same schema as `discreteOrder` minus the `status` column — candidates are pending by definition. The Candidate Confirmer (C2) promotes them to `discreteOrder` once the API has them.
+Orders discovered on-chain (by OrderDiscoveryPoller or UID pre-computation) but not yet confirmed on the Orderbook API. Same schema as `discreteOrder` minus the `status` column — candidates are pending by definition. CandidateConfirmer promotes them to `discreteOrder` once the API has them.
 
 ### `cow_cache.order_uid_cache`
 
@@ -177,11 +177,11 @@ Per-UID terminal status cache. Survives Ponder resyncs (external `cow_cache` sch
 
 5. **Insert results.** For each UID:
    - **Found on API** → upsert into `discreteOrder` with API-authoritative status.
-   - **Not found on API** → insert into `candidateDiscreteOrder`. C2 will promote to `discreteOrder` when the API has it.
+   - **Not found on API** → insert into `candidateDiscreteOrder`. CandidateConfirmer will promote to `discreteOrder` when the API has it.
 
-6. **Generator deactivation.** If ALL orders are terminal on the API → set `status = 'Completed'`, `allCandidatesKnown = true`, `lastPollResult = 'precompute:allTerminal'`. No further polling needed. If some UIDs are candidates (not yet on API), the generator stays Active — `allCandidatesKnown` is still set to `true` so C1 skips it.
+6. **Generator deactivation.** If ALL orders are terminal on the API → set `status = 'Completed'`, `allCandidatesKnown = true`, `lastPollResult = 'precompute:allTerminal'`. No further polling needed. If some UIDs are candidates (not yet on API), the generator stays Active — `allCandidatesKnown` is still set to `true` so OrderDiscoveryPoller skips it.
 
-**Result**: Deterministic orders are fully discovered at creation time. They never need the Contract Poller (C1). The Status Updater (C3) handles any open orders that haven't settled yet.
+**Result**: Deterministic orders are fully discovered at creation time. They never need OrderDiscoveryPoller. OrderStatusTracker handles any open orders that haven't settled yet.
 
 ### 3.2 Order Creation — Non-Deterministic Types
 
@@ -191,13 +191,13 @@ Per-UID terminal status cache. Survives Ponder resyncs (external `cow_cache` sch
 
 2. **UID pre-computation returns null.** Can't compute UIDs for PerpetualSwap, GoodAfterTime, TradeAboveThreshold, or Unknown types.
 
-3. **Generator stays Active.** The Contract Poller (C1) will pick it up at live sync.
+3. **Generator stays Active.** OrderDiscoveryPoller will pick it up at live sync.
 
-**During backfill**: No discrete orders created. The Historical Bootstrap (C4) fills this gap at the start of live sync.
+**During backfill**: No discrete orders created. OwnerBackfill fills this gap at the start of live sync.
 
-**During live sync**: The Contract Poller discovers orders when `getTradeableOrderWithSignature` returns success.
+**During live sync**: OrderDiscoveryPoller discovers orders when `getTradeableOrderWithSignature` returns success.
 
-### 3.3 Contract Poller (C1) — Non-Deterministic Orders
+### 3.3 OrderDiscoveryPoller — Non-Deterministic Orders
 
 **When**: Every block at live sync.
 
@@ -215,9 +215,9 @@ Per-UID terminal status cache. Survives Ponder resyncs (external `cow_cache` sch
 | **PollTryAtEpoch(T)** | `nextCheckTimestamp = T` |
 | **PollNever(reason)** | `status = 'Completed'`. Do NOT expire discrete orders. |
 
-4. **Note on `allCandidatesKnown`**: For confirmed single-shot non-deterministic types (**GoodAfterTime**, **TradeAboveThreshold**), once the contract returns success once, set `allCandidatesKnown = true` — the order UID is now known and C2/C3 handle the rest. For repeating orders (**PerpetualSwap**) and **Unknown** types (which may be multi-part), this flag stays `false`.
+4. **Note on `allCandidatesKnown`**: For confirmed single-shot non-deterministic types (**GoodAfterTime**, **TradeAboveThreshold**), once the contract returns success once, set `allCandidatesKnown = true` — the order UID is now known and CandidateConfirmer/OrderStatusTracker handle the rest. For repeating orders (**PerpetualSwap**) and **Unknown** types (which may be multi-part), this flag stays `false`.
 
-### 3.4 Candidate Confirmer (C2) — Promoting Candidates
+### 3.4 CandidateConfirmer — Promoting Candidates
 
 **When**: Every block at live sync.
 
@@ -231,7 +231,7 @@ Per-UID terminal status cache. Survives Ponder resyncs (external `cow_cache` sch
 
 5. **Cleanup:** Delete promoted candidates from `candidateDiscreteOrder`. Also delete stale candidates past their `validTo` — the watch-tower likely never submitted them.
 
-### 3.5 Status Updater (C3) — Tracking Open Orders
+### 3.5 OrderStatusTracker — Tracking Open Orders
 
 **When**: Every block at live sync.
 
@@ -243,7 +243,7 @@ Per-UID terminal status cache. Survives Ponder resyncs (external `cow_cache` sch
 
 4. **Expire by validTo.** Any `discreteOrder` where `status = 'open'` and `validTo <= currentTimestamp` → set to `expired`.
 
-### 3.6 Historical Bootstrap (C4) — One-Time Discovery
+### 3.6 OwnerBackfill — One-Time Discovery
 
 **When**: Once, at `startBlock = endBlock = "latest"`.
 
@@ -285,29 +285,29 @@ The Orderbook Client is used by all other components. Two main entry points:
 
 **Backfill:** Generator created → all N part UIDs pre-computed → API status fetched → UIDs found on API go into `discreteOrder`, UIDs not found go into `candidateDiscreteOrder` → if all terminal on API, generator marked Completed.
 
-**Live sync:** Same as backfill (UID pre-computation works at both). UIDs not yet on API are candidates; C2 promotes when API confirms. C3 tracks open `discreteOrder` rows.
+**Live sync:** Same as backfill (UID pre-computation works at both). UIDs not yet on API are candidates; CandidateConfirmer promotes when API confirms. OrderStatusTracker tracks open `discreteOrder` rows.
 
-**The Contract Poller (C1) is NEVER involved for TWAP.** All discovery happens via UID pre-computation.
+**OrderDiscoveryPoller is NEVER involved for TWAP.** All discovery happens via UID pre-computation.
 
 ### StopLoss — Deterministic, single-part
 
 **Backfill:** Generator created → single UID pre-computed → API status fetched → if found on API, `discreteOrder` created; if not, `candidateDiscreteOrder` → if terminal on API, generator marked Completed.
 
-**Live sync:** Same as backfill. If the order is still open (price hasn't triggered yet), C3 tracks it. The Contract Poller is not involved.
+**Live sync:** Same as backfill. If the order is still open (price hasn't triggered yet), OrderStatusTracker tracks it. OrderDiscoveryPoller is not involved.
 
 **Key insight:** We don't need to call `getTradeableOrderWithSignature` for StopLoss. We know the UID from creation. The API will show `fulfilled` once the watch-tower submits and the solver settles.
 
 ### PerpetualSwap — Non-deterministic, repeating
 
-**Backfill:** Generator created, no discrete orders. Historical Bootstrap (C4) discovers them at live sync start.
+**Backfill:** Generator created, no discrete orders. OwnerBackfill discovers them at live sync start.
 
-**Live sync:** Contract Poller (C1) polls every block → success during active windows → candidate created → C2 confirms on API → C3 tracks until fulfilled.
+**Live sync:** OrderDiscoveryPoller polls every block → success during active windows → candidate created → CandidateConfirmer confirms on API → OrderStatusTracker tracks until fulfilled.
 
 ### GoodAfterTime / TradeAboveThreshold — Non-deterministic, single-part
 
-**Backfill:** Generator created, no discrete orders. Historical Bootstrap (C4) discovers them.
+**Backfill:** Generator created, no discrete orders. OwnerBackfill discovers them.
 
-**Live sync:** Contract Poller (C1) polls → success when condition met → candidate → C2 confirms → after first success, `allCandidatesKnown = true` → C1 stops polling this generator.
+**Live sync:** OrderDiscoveryPoller polls → success when condition met → candidate → CandidateConfirmer confirms → after first success, `allCandidatesKnown = true` → OrderDiscoveryPoller stops polling this generator.
 
 ---
 
@@ -319,34 +319,34 @@ The Orderbook Client is used by all other components. Two main entry points:
 2. API batch fetch: all 5 → `fulfilled`. Cached in `order_uid_cache`.
 3. 5 `discreteOrder` rows created (all fulfilled).
 4. Generator → `Completed` (`allCandidatesKnown = true`).
-5. **At live sync**: Contract Poller skips this generator. Status Updater has nothing to update. Zero ongoing cost.
+5. **At live sync**: OrderDiscoveryPoller skips this generator. OrderStatusTracker has nothing to update. Zero ongoing cost.
 
 ### Scenario B: StopLoss, created at live sync, price triggers 3 hours later
 
 1. Live block: `ConditionalOrderCreated`. Generator inserted. UID Pre-computed = `0xabc...`.
 2. API fetch: `0xabc` not found (watch-tower hasn't submitted yet). `candidateDiscreteOrder` inserted.
-3. **C2 (Candidate Confirmer) polls every block**: `0xabc` → API still not found. Retry next block.
+3. **CandidateConfirmer polls every block**: `0xabc` → API still not found. Retry next block.
 4. 3 hours later: price triggers, watch-tower submits, solver settles.
-5. **C2 polls**: `0xabc` → API returns order. Promoted to `discreteOrder`. Candidate deleted.
-6. **C3 polls**: `0xabc` → `fulfilled`. `discreteOrder` updated. Cached as terminal.
+5. **CandidateConfirmer polls**: `0xabc` → API returns order. Promoted to `discreteOrder`. Candidate deleted.
+6. **OrderStatusTracker polls**: `0xabc` → `fulfilled`. `discreteOrder` updated. Cached as terminal.
 7. Generator stays Active until block handler checks and gets `PollNever` → `Completed`.
 
-**Note:** The Contract Poller (C1) is NOT involved. The UID was known from creation. Status tracking is pure API work.
+**Note:** OrderDiscoveryPoller is NOT involved. The UID was known from creation. Status tracking is pure API work.
 
 ### Scenario C: PerpetualSwap, created 3 months ago (non-deterministic)
 
 1. Backfill: Generator created, `status = 'Active'`. UID Pre-computation returns null.
-2. **C4 (Historical Bootstrap) at live sync start**: Finds this generator has no `discreteOrder` rows. Fetches by owner from API. Discovers 15 historical orders. Upserts all into `discreteOrder`.
-3. **C1 (Contract Poller) at live sync**: Polls `getTradeableOrderWithSignature`. Gets `Success` during active window → candidate created.
-4. **C2 (Candidate Confirmer)**: Checks API → confirms → `discreteOrder`.
-5. **C3 (Status Updater)**: Tracks open orders → `fulfilled` when settled.
-6. PerpetualSwap keeps producing new orders → C1 keeps discovering them.
+2. **OwnerBackfill at live sync start**: Finds this generator has no `discreteOrder` rows. Fetches by owner from API. Discovers 15 historical orders. Upserts all into `discreteOrder`.
+3. **OrderDiscoveryPoller at live sync**: Polls `getTradeableOrderWithSignature`. Gets `Success` during active window → candidate created.
+4. **CandidateConfirmer**: Checks API → confirms → `discreteOrder`.
+5. **OrderStatusTracker**: Tracks open orders → `fulfilled` when settled.
+6. PerpetualSwap keeps producing new orders → OrderDiscoveryPoller keeps discovering them.
 
 ### Scenario D: Unknown order type, created during backfill
 
 1. Backfill: Generator created with `orderType = 'Unknown'`. UID Pre-computation returns null.
-2. **C4 (Bootstrap)**: Fetches by owner. If the API has composable orders for this owner, they're upserted into `discreteOrder`.
-3. **C1 (Contract Poller)**: May poll if generator is still Active. Gets `Success` or error responses.
+2. **OwnerBackfill**: Fetches by owner. If the API has composable orders for this owner, they're upserted into `discreteOrder`.
+3. **OrderDiscoveryPoller**: May poll if generator is still Active. Gets `Success` or error responses.
 4. Normal lifecycle from there.
 
 ---
@@ -355,17 +355,17 @@ The Orderbook Client is used by all other components. Two main entry points:
 
 ### `allCandidatesKnown` — Semantics (Resolved)
 
-A **boolean** is the correct type. It answers one question: "does C1 still need to poll this generator?"
+A **boolean** is the correct type. It answers one question: "does OrderDiscoveryPoller still need to poll this generator?"
 
 **For deterministic types (TWAP, StopLoss)**: Set to `true` at creation time. All UIDs are computed from `staticInput` — no RPC needed.
 
-**For non-deterministic single-part types (GoodAfterTime, TradeAboveThreshold)**: Set to `true` after the first success from the Contract Poller. The UID is now known; C2/C3 handle confirmation and status.
+**For non-deterministic single-part types (GoodAfterTime, TradeAboveThreshold)**: Set to `true` after the first success from OrderDiscoveryPoller. The UID is now known; CandidateConfirmer/OrderStatusTracker handle confirmation and status.
 
-**For PerpetualSwap (repeating)**: Stays `false` — new orders keep appearing. The Contract Poller must keep polling.
+**For PerpetualSwap (repeating)**: Stays `false` — new orders keep appearing. OrderDiscoveryPoller must keep polling.
 
-**Why not a part count?** Part count is TWAP-specific. The polling decision is binary: either C1 needs to discover more UIDs, or it doesn't. A part count would be unused for all order types except TWAP and adds no value over the boolean.
+**Why not a part count?** Part count is TWAP-specific. The polling decision is binary: either OrderDiscoveryPoller needs to discover more UIDs, or it doesn't. A part count would be unused for all order types except TWAP and adds no value over the boolean.
 
-### Historical Bootstrap — Completeness (Resolved)
+### OwnerBackfill — Completeness (Resolved)
 
 The bootstrap discovers orders via `fetchComposableOrders(owner)`, which relies on the Orderbook API having the orders. If an order never reached the API, the bootstrap won't discover it.
 
@@ -382,10 +382,10 @@ flowchart TB
     subgraph OnChain["On-Chain Events (Ponder)"]
         CC["ComposableCow<br/><i>backfill: genesis → latest</i>"]
         CCL["ComposableCowLive<br/><i>live: latest → ∞</i>"]
-        BH1["Block Handler 1<br/><i>Contract Poller — every block</i>"]
-        BH2["Block Handler 2<br/><i>Candidate Confirmer — every block</i>"]
-        BH3["Block Handler 3<br/><i>Status Updater — every block</i>"]
-        BH4["Block Handler 4<br/><i>Historical Bootstrap — once at latest</i>"]
+        BH1["Block Handler 1<br/><i>OrderDiscoveryPoller — every block</i>"]
+        BH2["Block Handler 2<br/><i>CandidateConfirmer — every block</i>"]
+        BH3["Block Handler 3<br/><i>OrderStatusTracker — every block</i>"]
+        BH4["Block Handler 4<br/><i>OwnerBackfill — once at latest</i>"]
         GPV["GPv2Settlement<br/><i>flash loans only</i>"]
         CSF["CoWShedFactory"]
     end
@@ -455,11 +455,11 @@ flowchart TD
     API --> Upsert["API has UID → discreteOrder<br/>API missing UID → candidateDiscreteOrder"]
     Upsert --> Term{"All terminal?"}
     Term -->|Yes| Deactivate["Generator → Completed<br/>allCandidatesKnown = true<br/>No further polling"]
-    Term -->|No| Active["Generator stays Active<br/>C3 tracks open orders"]
+    Term -->|No| Active["Generator stays Active<br/>OrderStatusTracker tracks open orders"]
 
     Skip --> BackfillQ{"Backfill or<br/>Live sync?"}
-    BackfillQ -->|Backfill| Wait["Wait for C4 bootstrap<br/>at live sync start"]
-    BackfillQ -->|Live| Poll["C1 Contract Poller<br/>discovers when tradeable"]
+    BackfillQ -->|Backfill| Wait["Wait for OwnerBackfill bootstrap<br/>at live sync start"]
+    BackfillQ -->|Live| Poll["OrderDiscoveryPoller<br/>discovers when tradeable"]
 
     style Deactivate fill:#d4edda
     style Skip fill:#fff3cd
@@ -472,7 +472,7 @@ flowchart TD
 
 ```mermaid
 flowchart LR
-    subgraph C1["C1: Contract Poller"]
+    subgraph OrderDiscoveryPoller["OrderDiscoveryPoller"]
         direction TB
         C1Q["Query: Active generators<br/>non-deterministic<br/>allCandidatesKnown=false<br/>due for check"]
         C1M["RPC multicall:<br/>getTradeableOrderWithSignature"]
@@ -480,7 +480,7 @@ flowchart LR
         C1Q --> C1M --> C1R
     end
 
-    subgraph C2["C2: Candidate Confirmer"]
+    subgraph CandidateConfirmer["CandidateConfirmer"]
         direction TB
         C2Q["Query: candidateDiscreteOrder<br/>not yet in discreteOrder"]
         C2F["API: POST /orders/by_uids"]
@@ -489,7 +489,7 @@ flowchart LR
         C2Q --> C2F --> C2U --> C2X
     end
 
-    subgraph C3["C3: Status Updater"]
+    subgraph OrderStatusTracker["OrderStatusTracker"]
         direction TB
         C3Q["Query: discreteOrder<br/>status = open"]
         C3F["API: POST /orders/by_uids"]
@@ -497,7 +497,7 @@ flowchart LR
         C3Q --> C3F --> C3U
     end
 
-    subgraph C4["C4: Historical Bootstrap"]
+    subgraph OwnerBackfill["OwnerBackfill"]
         direction TB
         C4Q["Query: Active generators<br/>non-deterministic<br/>no discreteOrder rows"]
         C4F["API: GET /account/{owner}/orders<br/>per unique owner"]
@@ -505,10 +505,10 @@ flowchart LR
         C4Q --> C4F --> C4U
     end
 
-    style C1 fill:#ffe0e0
-    style C2 fill:#e0f0ff
-    style C3 fill:#e0ffe0
-    style C4 fill:#f0e0ff
+    style OrderDiscoveryPoller fill:#ffe0e0
+    style CandidateConfirmer fill:#e0f0ff
+    style OrderStatusTracker fill:#e0ffe0
+    style OwnerBackfill fill:#f0e0ff
 ```
 
 ---
@@ -531,9 +531,9 @@ flowchart LR
         E5 -->|No| E7
     end
 
-    subgraph Live["Live sync (C3 only)"]
+    subgraph Live["Live sync (OrderStatusTracker only)"]
         direction TB
-        L1["C3: poll open UIDs"]
+        L1["OrderStatusTracker: poll open UIDs"]
         L2["API returns fulfilled"]
         L3["Update discreteOrder"]
         L1 --> L2 --> L3
@@ -559,11 +559,11 @@ flowchart TD
     Pre --> API["API fetch: 0xabc not found yet"]
     API --> Cand["candidateDiscreteOrder"]
 
-    Cand --> C2["C2: polls API every block"]
-    C2 --> Wait["0xabc not on API yet..."]
+    Cand --> CandidateConfirmer["CandidateConfirmer: polls API every block"]
+    CandidateConfirmer --> Wait["0xabc not on API yet..."]
     Wait --> Trigger["Price triggers →<br/>watch-tower submits →<br/>solver settles"]
-    Trigger --> Promoted["C2: API returns order<br/>→ promote to discreteOrder"]
-    Promoted --> Fulfilled["C3: API returns fulfilled<br/>→ update discreteOrder"]
+    Trigger --> Promoted["CandidateConfirmer: API returns order<br/>→ promote to discreteOrder"]
+    Promoted --> Fulfilled["OrderStatusTracker: API returns fulfilled<br/>→ update discreteOrder"]
 
     style Trigger fill:#fff3cd
     style Fulfilled fill:#d4edda
@@ -581,7 +581,7 @@ flowchart TD
         B1 --> B2
     end
 
-    subgraph Bootstrap["C4: Historical Bootstrap (once)"]
+    subgraph Bootstrap["OwnerBackfill (once)"]
         B3["Find generator with no discrete orders"]
         B4["Fetch by owner from API"]
         B5["Upsert historical discrete orders"]
@@ -589,11 +589,11 @@ flowchart TD
     end
 
     subgraph LiveLoop["Live sync (repeating)"]
-        C1["C1: Contract Poller<br/>getTradeableOrderWithSignature"]
+        OrderDiscoveryPoller["OrderDiscoveryPoller<br/>getTradeableOrderWithSignature"]
         C1S["Success → candidateDiscreteOrder"]
-        C2["C2: Candidate Confirmer<br/>API confirms → discreteOrder"]
-        C3["C3: Status Updater<br/>open → fulfilled"]
-        C1 --> C1S --> C2 --> C3
+        CandidateConfirmer["CandidateConfirmer<br/>API confirms → discreteOrder"]
+        OrderStatusTracker["OrderStatusTracker<br/>open → fulfilled"]
+        OrderDiscoveryPoller --> C1S --> CandidateConfirmer --> OrderStatusTracker
     end
 
     Backfill --> Bootstrap --> LiveLoop
@@ -612,10 +612,10 @@ flowchart LR
         direction TB
         A["Creation Handler<br/>(backfill + live)"]
         B["UID Pre-computation<br/>(backfill + live)"]
-        C1["C1: Contract Poller<br/>(live)"]
-        C2["C2: Candidate Confirmer<br/>(live)"]
-        C3["C3: Status Updater<br/>(live)"]
-        C4["C4: Bootstrap<br/>(once)"]
+        OrderDiscoveryPoller["OrderDiscoveryPoller<br/>(live)"]
+        CandidateConfirmer["CandidateConfirmer<br/>(live)"]
+        OrderStatusTracker["OrderStatusTracker<br/>(live)"]
+        OwnerBackfill["OwnerBackfill<br/>(once)"]
     end
 
     subgraph Tables
@@ -628,18 +628,18 @@ flowchart LR
 
     A -->|"INSERT (Active)"| Gen
     B -->|"UPDATE (Completed)"| Gen
-    C1 -->|"UPDATE (scheduling, status)"| Gen
+    OrderDiscoveryPoller -->|"UPDATE (scheduling, status)"| Gen
 
     B -->|"INSERT (API missing)"| Cand
-    C1 -->|"INSERT"| Cand
-    C2 -->|"DELETE (promoted + stale)"| Cand
+    OrderDiscoveryPoller -->|"INSERT"| Cand
+    CandidateConfirmer -->|"DELETE (promoted + stale)"| Cand
 
     B -->|"UPSERT (API found)"| Disc
-    C2 -->|"UPSERT"| Disc
-    C3 -->|"UPDATE status"| Disc
-    C4 -->|"UPSERT"| Disc
+    CandidateConfirmer -->|"UPSERT"| Disc
+    OrderStatusTracker -->|"UPDATE status"| Disc
+    OwnerBackfill -->|"UPSERT"| Disc
 
-    C3 -->|"INSERT terminal"| Cache
+    OrderStatusTracker -->|"INSERT terminal"| Cache
 
     style Gen fill:#e8f4f8
     style Disc fill:#d4edda
diff --git a/docs/architecture.md b/docs/architecture.md
index fac3999..a7e216a 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -100,7 +100,7 @@ PK: `(chainId, eventId)`. Indexed on `owner`, `handler`, `hash`, `chainId+owner`
 
 ### discrete_order
 
-Links individual order UIDs (from the CoW Protocol orderbook) back to their parent generator. One generator can produce many discrete orders over its lifetime — a TWAP with 10 parts creates 10 discrete orders. Populated by C2 (CandidateConfirmer) after confirmation against the orderbook API; status kept current by C3 (StatusUpdater).
+Links individual order UIDs (from the CoW Protocol orderbook) back to their parent generator. One generator can produce many discrete orders over its lifetime — a TWAP with 10 parts creates 10 discrete orders. Populated by CandidateConfirmer after confirmation against the orderbook API; status kept current by OrderStatusTracker.
 
 Key columns: `orderUid`, `chainId`, `conditionalOrderGeneratorId` (references `eventId`), `status` (open/fulfilled/unfilled/expired/cancelled), `sellAmount`, `buyAmount`, `executedSellAmount`, `executedBuyAmount`.
 PK: `(chainId, orderUid)`. See [api-reference.md](./api-reference.md) for full field docs.
diff --git a/docs/deployment.md b/docs/deployment.md
index a029eb6..fe8d55b 100644
--- a/docs/deployment.md
+++ b/docs/deployment.md
@@ -178,7 +178,7 @@ A fresh deployment (no prior `ponder_sync` cache) reindexes from the configured
 | Phase | Typical duration | Notes |
 |-------|-----------------|-------|
 | Event backfill | 4–10 hours | Fetches `eth_getLogs` from start block to tip. Bottleneck is RPC throughput; a generous RPC endpoint shortens this. |
-| Live-sync catch-up | 5–15 minutes | Block handlers (C1–C5) run at "latest" only. Stale TWAP candidates drain at 500/block. |
+| Live-sync catch-up | 5–15 minutes | Block handlers (OrderDiscoveryPoller, CandidateConfirmer, OrderStatusTracker, OwnerBackfill, CancellationWatcher) run at "latest" only. Stale TWAP candidates drain at 500/block. |
 | Full data completeness | After live-sync catch-up | All generators have candidates or discrete orders; historical TWAP parts resolved via account fallback. |
 
 A reindex that reuses an existing `ponder_sync` cache (same chain, same start blocks) skips the event backfill and completes in minutes.
@@ -191,7 +191,7 @@ During backfill, `GET /ready` returns `503`. GraphQL queries are still available
 
 ### Historical Discrete Order Gap
 
-Block handlers only run during live sync. TWAP parts computed during backfill land in `candidate_discrete_order` with past `validTo` dates. When live sync starts, C2 (CandidateConfirmer) promotes these via the stale sweep path:
+Block handlers only run during live sync. TWAP parts computed during backfill land in `candidate_discrete_order` with past `validTo` dates. When live sync starts, CandidateConfirmer promotes these via the stale sweep path:
 
 1. Tries `/orders/by_uids` — aged-out UIDs return empty
 2. Falls back to `/account/{owner}/orders` for each owner with missed UIDs
@@ -199,6 +199,6 @@ Block handlers only run during live sync. TWAP parts computed during backfill la
 
 **Residual gap**: Orders that no longer appear in `/account/{owner}/orders` (beyond the CoW API's retention window) will be recorded as `expired` regardless of their actual fill status. This affects only very old orders for users with a large order history.
 
-Non-deterministic generators (PerpetualSwap, GoodAfterTime, TradeAboveThreshold, Unknown) are handled by C4 (OwnerBackfill), which calls `/account/{owner}/orders` once at live-sync start and upserts discovered orders directly into `discrete_order`.
+Non-deterministic generators (PerpetualSwap, GoodAfterTime, TradeAboveThreshold, Unknown) are handled by OwnerBackfill, which calls `/account/{owner}/orders` once at live-sync start and upserts discovered orders directly into `discrete_order`.
 
 
diff --git a/docs/supported-order-types.md b/docs/supported-order-types.md
index 7c617fd..f7b17de 100644
--- a/docs/supported-order-types.md
+++ b/docs/supported-order-types.md
@@ -60,7 +60,7 @@ TWAP generates `n` discrete orders, one per time slice. Each part covers `[t0 +
 - When `t0` is 0, the contract uses the block timestamp of the creation transaction as the start time. The `decodedParams` will still show `"0"` -- the actual resolved start time is not stored.
 - If a part's validity window passes without execution, that part is simply skipped. There is no retry or rollover.
 - Setting `span` shorter than `t` creates gaps where no part is active. Setting `span` longer than `t` creates overlapping validity windows.
-- TWAP orders with `n` exceeding `MAX_TWAP_PRECOMPUTE_PARTS` (100 000) skip UID pre-computation and fall back to the C1 ContractPoller discovery path (`allCandidatesKnown=false`). This is logged as `[COW:PRECOMPUTE] SKIP reason=too_many_parts`. Such pathological orders are valid on-chain but are impractical in practice.
+- TWAP orders with `n` exceeding `MAX_TWAP_PRECOMPUTE_PARTS` (100 000) skip UID pre-computation and fall back to the OrderDiscoveryPoller discovery path (`allCandidatesKnown=false`). This is logged as `precompute:skip`. Such pathological orders are valid on-chain but are impractical in practice.
 
 ---
 
diff --git a/schema/tables.ts b/schema/tables.ts
index 473ff4e..de3d058 100644
--- a/schema/tables.ts
+++ b/schema/tables.ts
@@ -89,9 +89,9 @@ export const conditionalOrderGenerator = onchainTable(
     chainOwnerIdx: index().on(table.chainId, table.owner),
     resolvedOwnerIdx: index().on(table.resolvedOwner),
     ownerAddressTypeIdx: index().on(table.ownerAddressType),
-    // C1 (OrderDiscoveryPoller) + C5 (CancellationWatcher): per-block SELECT with
+    // OrderDiscoveryPoller + CancellationWatcher: per-block SELECT with
     // chainId + status + allCandidatesKnown equality filters, ORDER BY lastCheckBlock.
-    // Covers both handlers — C1 queries allCandidatesKnown=false, C5 queries true.
+    // Covers both handlers — OrderDiscoveryPoller queries allCandidatesKnown=false, CancellationWatcher queries true.
     c1c5PollIdx: index("generator_c1c5_poll_idx")
       .on(table.chainId, table.status, table.allCandidatesKnown, table.lastCheckBlock),
   })
@@ -111,13 +111,13 @@ export const discreteOrder = onchainTable(
     creationDate: t.bigint().notNull(),               // block timestamp (seconds)
     executedSellAmount: t.text(),                     // actual executed amount (from API, post-settlement)
     executedBuyAmount: t.text(),                      // actual executed amount (from API, post-settlement)
-    promotedAt: t.bigint(),                           // block timestamp when C2 promoted from candidate; null = created directly (precompute or C4)
+    promotedAt: t.bigint(),                           // block timestamp when CandidateConfirmer promoted from candidate; null = created directly (precompute or OwnerBackfill)
   }),
   (table) => ({
     pk: primaryKey({ columns: [table.chainId, table.orderUid] }),
     generatorIdx: index("discrete_order_generator_idx")
       .on(table.chainId, table.conditionalOrderGeneratorId),
-    // C3 (OrderStatusTracker): per-block SELECT with chainId + status='open', ORDER BY promotedAt.
+    // OrderStatusTracker: per-block SELECT with chainId + status='open', ORDER BY promotedAt.
     c3StatusIdx: index("discrete_order_c3_status_idx")
       .on(table.chainId, table.status, table.promotedAt),
   })
@@ -140,7 +140,7 @@ export const candidateDiscreteOrder = onchainTable(
     pk: primaryKey({ columns: [table.chainId, table.orderUid] }),
     generatorIdx: index("candidate_discrete_order_generator_idx")
       .on(table.chainId, table.conditionalOrderGeneratorId),
-    // C2 stale sweep: SELECT WHERE chainId + validTo <= timestamp LIMIT 500.
+    // CandidateConfirmer stale sweep: SELECT WHERE chainId + validTo <= timestamp LIMIT 500.
     staleIdx: index("candidate_discrete_order_stale_idx")
       .on(table.chainId, table.validTo),
   })
diff --git a/src/api/endpoints/sync-progress.ts b/src/api/endpoints/sync-progress.ts
index 7678fdf..a856b12 100644
--- a/src/api/endpoints/sync-progress.ts
+++ b/src/api/endpoints/sync-progress.ts
@@ -75,7 +75,7 @@ export const syncProgressHandler: RouteHandler<typeof syncProgressRoute> =
         historicalBlocksFetchedPct: pct,
         isRealtime: (isRealtime.get(chain) ?? 0) === 1,
         // ponder_sync_is_complete never reaches 1 for chains with live block handlers
-        // (C1–C5 run indefinitely). Derive locally: synced means realtime + all blocks processed.
+        // (OrderDiscoveryPoller, CandidateConfirmer, OrderStatusTracker, OwnerBackfill, CancellationWatcher run indefinitely). Derive locally: synced means realtime + all blocks processed.
         isComplete: (isRealtime.get(chain) ?? 0) === 1 && pct >= 100,
       };
     }
diff --git a/src/api/gql-docs/conditional-order-generator.ts b/src/api/gql-docs/conditional-order-generator.ts
index bee646e..6163a5f 100644
--- a/src/api/gql-docs/conditional-order-generator.ts
+++ b/src/api/gql-docs/conditional-order-generator.ts
@@ -38,11 +38,11 @@ export const conditionalOrderGeneratorDocs: DocMap = {
   "conditionalOrderGenerator.allCandidatesKnown":
     "Whether all possible discrete orders for this generator have been discovered. True for deterministic types (TWAP, StopLoss) after UID precomputation.",
   "conditionalOrderGenerator.nextCheckBlock":
-    "Next block the C1 poller should check this generator. Internal scheduling field.",
+    "Next block the OrderDiscoveryPoller should check this generator. Internal scheduling field.",
   "conditionalOrderGenerator.lastCheckBlock":
-    "Last block where C1 polled this generator.",
+    "Last block where OrderDiscoveryPoller polled this generator.",
   "conditionalOrderGenerator.lastPollResult":
-    "Result of the last C1 poll (e.g. success, cancelled:SingleOrderNotAuthed, error:...). Useful for debugging.",
+    "Result of the last OrderDiscoveryPoller poll (e.g. success, cancelled:SingleOrderNotAuthed, error:...). Useful for debugging.",
   "conditionalOrderGenerator.nextCheckTimestamp":
     "For orders returning PollTryAtEpoch, the epoch to wait for before the next poll. Unix seconds (UTC), decimal string (BigInt scalar). See docs/api-reference.md#timestamp-fields.",
   "conditionalOrderGenerator.transaction":
@@ -50,7 +50,7 @@ export const conditionalOrderGeneratorDocs: DocMap = {
   "conditionalOrderGenerator.discreteOrders":
     "All confirmed CoW Protocol orders produced by this generator. Empty until the first discrete order is confirmed.",
   "conditionalOrderGenerator.candidateDiscreteOrders":
-    "Unconfirmed candidates discovered by the C1 block handler that have not been promoted to discreteOrder yet.",
+    "Unconfirmed candidates discovered by the OrderDiscoveryPoller block handler that have not been promoted to discreteOrder yet.",
 
   ...generatePageDocs("conditionalOrderGenerator", "conditional order generator"),
   ...generateQueryDocs("conditionalOrderGenerator", "conditional order generator"),
diff --git a/src/api/gql-docs/discrete-order.ts b/src/api/gql-docs/discrete-order.ts
index 145e1e4..da8636b 100644
--- a/src/api/gql-docs/discrete-order.ts
+++ b/src/api/gql-docs/discrete-order.ts
@@ -13,7 +13,7 @@ export const discreteOrderDocs: DocMap = {
   "discreteOrder.conditionalOrderGeneratorId":
     "References the parent generator's eventId.",
   "discreteOrder.status":
-    "open (in the orderbook, not yet settled), fulfilled (the order was settled; executedSellAmount and executedBuyAmount are populated), unfilled (left the orderbook without settling), expired (validTo passed without settlement), or cancelled (the orderbook API reported the order as cancelled, or the C5 reconciliation marked it cancelled because its parent generator was removed on-chain). Tracked via the CoW Protocol orderbook API.",
+    "open (in the orderbook, not yet settled), fulfilled (the order was settled; executedSellAmount and executedBuyAmount are populated), unfilled (left the orderbook without settling), expired (validTo passed without settlement), or cancelled (the orderbook API reported the order as cancelled, or the CancellationWatcher reconciliation marked it cancelled because its parent generator was removed on-chain). Tracked via the CoW Protocol orderbook API.",
   "discreteOrder.sellAmount":
     "Sell amount requested, as a decimal string (uint256, raw token units).",
   "discreteOrder.buyAmount":
@@ -22,18 +22,18 @@ export const discreteOrderDocs: DocMap = {
   "discreteOrder.validTo":
     "Unix seconds (UTC) when this order expires. Returned as a JSON number — the CoW protocol encodes validTo as uint32 in the order UID, so the column is t.integer(). Null if not yet known. See docs/api-reference.md#timestamp-fields.",
   "discreteOrder.creationDate":
-    "Unix seconds (UTC), decimal string (BigInt scalar). Source depends on discovery path: C4-fetched orders use the orderbook API's order submission timestamp; pre-computed deterministic orders (TWAP, StopLoss) use the generator event's block timestamp; C1-discovered orders use the block timestamp at C1 discovery.",
+    "Unix seconds (UTC), decimal string (BigInt scalar). Source depends on discovery path: OwnerBackfill-fetched orders use the orderbook API's order submission timestamp; pre-computed deterministic orders (TWAP, StopLoss) use the generator event's block timestamp; OrderDiscoveryPoller-discovered orders use the block timestamp at OrderDiscoveryPoller discovery.",
   "discreteOrder.executedSellAmount":
     "Actual sell amount filled after settlement. Null before the order is fulfilled.",
   "discreteOrder.executedBuyAmount":
     "Actual buy amount received after settlement. Null before the order is fulfilled.",
   "discreteOrder.promotedAt":
-    "Unix timestamp (seconds) when C2 promoted this row from candidateDiscreteOrder. Null means the row was created directly without going through the candidate stage (TWAP/StopLoss precomputation at creation time, or C4 historical bootstrap). Non-null means this order was first discovered on-chain by C1 or UID precomputation, held as a candidate until the orderbook API confirmed it (or until it expired).",
+    "Unix timestamp (seconds) when CandidateConfirmer promoted this row from candidateDiscreteOrder. Null means the row was created directly without going through the candidate stage (TWAP/StopLoss precomputation at creation time, or OwnerBackfill). Non-null means this order was first discovered on-chain by OrderDiscoveryPoller or UID precomputation, held as a candidate until the orderbook API confirmed it (or until it expired).",
   "discreteOrder.conditionalOrderGenerator":
     "The parent generator that produced this discrete order.",
 
   candidateDiscreteOrder:
-    "An unconfirmed discrete order discovered by the C1 block handler via getTradeableOrderWithSignature. Candidates are promoted to discreteOrder once confirmed against the orderbook API.",
+    "An unconfirmed discrete order discovered by the OrderDiscoveryPoller block handler via getTradeableOrderWithSignature. Candidates are promoted to discreteOrder once confirmed against the orderbook API.",
   "candidateDiscreteOrder.orderUid": "CoW Protocol order UID.",
   "candidateDiscreteOrder.chainId": "EVM chain ID.",
   "candidateDiscreteOrder.conditionalOrderGeneratorId":
@@ -44,7 +44,7 @@ export const discreteOrderDocs: DocMap = {
   "candidateDiscreteOrder.validTo":
     "Predicted Unix seconds (UTC) when this candidate would expire if promoted. JSON number (uint32 per CoW protocol). Null when not yet known. See discreteOrder.validTo for the confirmed value and docs/api-reference.md#timestamp-fields for the timestamp policy.",
   "candidateDiscreteOrder.creationDate":
-    "Unix seconds (UTC), decimal string (BigInt scalar). Block timestamp at C1 discovery.",
+    "Unix seconds (UTC), decimal string (BigInt scalar). Block timestamp at OrderDiscoveryPoller discovery.",
   "candidateDiscreteOrder.possibleValidAfterTimestamp":
     "For TWAP: t0 + partIndex*t. Earliest Unix seconds (UTC) the part can be valid — used to skip orderbook API calls before that timestamp. Decimal string (BigInt scalar).",
   "candidateDiscreteOrder.conditionalOrderGenerator":
diff --git a/src/application/handlers/blockHandler.ts b/src/application/handlers/blockHandler.ts
index 2d39a47..6dbc6c5 100644
--- a/src/application/handlers/blockHandler.ts
+++ b/src/application/handlers/blockHandler.ts
@@ -1,17 +1,17 @@
 /**
  * Block handlers — five responsibilities split into separate Ponder block entries.
  *
- * C1 (ContractPoller):      RPC multicall for non-deterministic generators. Every block.
- * C2 (CandidateConfirmer):  API batch check for unconfirmed candidates. Every block.
- * C3 (StatusUpdater):       API batch check for open discrete orders + expiry. Every block.
- * C4 (HistoricalBootstrap): One-time owner fetch for non-deterministic backfill orders.
- * C5 (DeterministicCancellationSweeper): singleOrders() mapping read for
- *                           deterministic generators (allCandidatesKnown=true) that
- *                           C1 skips. Runs every block but re-checks each generator
- *                           only every DETERMINISTIC_CANCEL_SWEEP_INTERVAL blocks.
+ * OrderDiscoveryPoller:  RPC multicall for non-deterministic generators. Every block.
+ * CandidateConfirmer:    API batch check for unconfirmed candidates. Every block.
+ * OrderStatusTracker:    API batch check for open discrete orders + expiry. Every block.
+ * OwnerBackfill:         One-time owner fetch for non-deterministic backfill orders.
+ * CancellationWatcher:   singleOrders() mapping read for
+ *                        deterministic generators (allCandidatesKnown=true) that
+ *                        OrderDiscoveryPoller skips. Runs every block but re-checks each generator
+ *                        only every DETERMINISTIC_CANCEL_SWEEP_INTERVAL blocks.
  *
  * All handlers start at "latest" — only run during live sync.
- * C4 additionally has endBlock: "latest", so it fires exactly once.
+ * OwnerBackfill additionally has endBlock: "latest", so it fires exactly once.
  */
 
 import { ponder } from "ponder:registry";
@@ -52,7 +52,7 @@ const SINGLE_SHOT_NON_DETERMINISTIC: readonly OrderType[] = ["GoodAfterTime", "T
 const BLOCK_NEVER = 2n ** 63n - 1n; // sentinel for epoch-scheduled generators (PollTryAtEpoch)
 const VALID_DISCRETE_STATUSES = new Set(["fulfilled", "unfilled", "expired", "cancelled"]);
 
-// Minimal ABI for C5: reads the singleOrders(owner, hash) mapping on ComposableCoW.
+// Minimal ABI for CancellationWatcher: reads the singleOrders(owner, hash) mapping on ComposableCoW.
 // `false` means the owner called remove() — generator is cancelled on-chain.
 const SINGLE_ORDERS_ABI = [
   {
@@ -68,7 +68,7 @@ const SINGLE_ORDERS_ABI = [
 ] as const;
 
 
-// ─── C1: Contract Poller ─────────────────────────────────────────────────────
+// ─── OrderDiscoveryPoller ────────────────────────────────────────────────────
 // Polls getTradeableOrderWithSignature for any active generator where
 // allCandidatesKnown=false. Normally only non-deterministic types, but also
 // serves as fallback for deterministic types whose precompute failed.
@@ -295,7 +295,7 @@ ponder.on("OrderDiscoveryPoller:block", async ({ event, context }) => {
   log("info", "OrderDiscoveryPoller:DONE", { block: String(currentBlock), chainId, due: dueOrders.length, success: successCount, never: neverCount, backedOff: backedOffCount, capped });
 });
 
-// ─── C2: Candidate Confirmer ─────────────────────────────────────────────────
+// ─── CandidateConfirmer ──────────────────────────────────────────────────────
 // Checks if candidate discrete orders exist on the Orderbook API.
 // When confirmed, promotes them to discreteOrder.
 
@@ -366,7 +366,7 @@ ponder.on("CandidateConfirmer:block", async ({ event, context }) => {
         preflightStatuses = new Map();
       }
 
-      // onConflictDoNothing: if C3 already promoted this UID with a terminal status
+      // onConflictDoNothing: if OrderStatusTracker already promoted this UID with a terminal status
       // (e.g. 'fulfilled'), the existing row wins and this insert is a no-op.
       // Chunked to avoid PostgreSQL bind-message parameter limits on large cascades.
       // preflightKnown counts API hits, not rows actually written.
@@ -544,7 +544,7 @@ ponder.on("CandidateConfirmer:block", async ({ event, context }) => {
   if (stale.length > 0) {
     const staleStatuses = await fetchOrderStatusByUids(context, chainId, stale.map((c) => c.orderUid));
 
-    // TWAP parts can age out of /by_uids before C2 sees them, causing fulfilled
+    // TWAP parts can age out of /by_uids before CandidateConfirmer sees them, causing fulfilled
     // parts to be recorded as "expired". For any missed UIDs, fall back to
     // /account/{owner}/orders — one fetch per unique owner.
     const missed = stale.filter((c) => !staleStatuses.has(c.orderUid));
@@ -622,7 +622,7 @@ ponder.on("CandidateConfirmer:block", async ({ event, context }) => {
   }
 });
 
-// ─── C3: Status Updater ──────────────────────────────────────────────────────
+// ─── OrderStatusTracker ──────────────────────────────────────────────────────
 // Polls the API for status updates on open discrete orders. Expires past validTo.
 
 ponder.on("OrderStatusTracker:block", async ({ event, context }) => {
@@ -754,7 +754,7 @@ ponder.on("OrderStatusTracker:block", async ({ event, context }) => {
     );
 });
 
-// ─── C4: Historical Bootstrap ────────────────────────────────────────────────
+// ─── OwnerBackfill ───────────────────────────────────────────────────────────
 // One-time discovery of historical discrete orders for non-deterministic
 // generators created during backfill. Fires once at startBlock=endBlock="latest".
 
@@ -864,13 +864,13 @@ ponder.on("OwnerBackfill:block", async ({ event, context }) => {
   log("info", "OwnerBackfill:DONE", { block: String(currentBlock), chainId, discovered: totalDiscovered });
 });
 
-// ─── C5: Deterministic Cancellation Sweeper ──────────────────────────────────
-// C1 skips generators with allCandidatesKnown=true (deterministic types: TWAP,
+// ─── CancellationWatcher ─────────────────────────────────────────────────────
+// OrderDiscoveryPoller skips generators with allCandidatesKnown=true (deterministic types: TWAP,
 // StopLoss, CirclesBackingOrder), so SingleOrderNotAuthed is never observed
 // for them. This handler closes that gap by reading
 // ComposableCoW.singleOrders(owner, hash) on a DETERMINISTIC_CANCEL_SWEEP_INTERVAL
 // cadence. A `false` result means the owner called remove() on-chain → flip to
-// Cancelled, which lets the C2/C3 parent-cancelled cascade reconcile
+// Cancelled, which lets the CandidateConfirmer/OrderStatusTracker parent-cancelled cascade reconcile
 // the child discrete / candidate rows on the next block.
 
 ponder.on("CancellationWatcher:block", async ({ event, context }) => {
diff --git a/src/application/helpers/uidPrecompute.ts b/src/application/helpers/uidPrecompute.ts
index be71dd2..b452d37 100644
--- a/src/application/helpers/uidPrecompute.ts
+++ b/src/application/helpers/uidPrecompute.ts
@@ -169,7 +169,7 @@ export async function precomputeAndDiscover(
   }
 
   // UIDs are fully known even though some orders are still open —
-  // C1 (Contract Poller) can skip this generator, C3 (Status Updater) tracks the open orders.
+  // OrderDiscoveryPoller can skip this generator, OrderStatusTracker tracks the open orders.
   await context.db.sql
     .update(conditionalOrderGenerator)
     .set({ allCandidatesKnown: true })
diff --git a/src/chains/types.ts b/src/chains/types.ts
index 5d0b480..38e1de6 100644
--- a/src/chains/types.ts
+++ b/src/chains/types.ts
@@ -3,7 +3,7 @@ import { SupportedChainId } from "@cowprotocol/cow-sdk";
 export type { SupportedChainId };
 
 /**
- * Derive the ContractPoller block interval from block time so that polls
+ * Derive the OrderDiscoveryPoller block interval from block time so that polls
  * happen approximately every 20 seconds regardless of chain speed.
  * e.g. mainnet (12s) → 1 block, gnosis (5s) → 4 blocks, base (2s) → 10 blocks.
  */
diff --git a/tests/helpers/statusFilter.test.ts b/tests/helpers/statusFilter.test.ts
index 929d903..473c18e 100644
--- a/tests/helpers/statusFilter.test.ts
+++ b/tests/helpers/statusFilter.test.ts
@@ -1,5 +1,5 @@
 /**
- * Tests for the C3 StatusUpdater row-building filter logic.
+ * Tests for the OrderStatusTracker row-building filter logic.
  *
  * blockHandler.ts defines a module-level constant:
  *   const VALID_DISCRETE_STATUSES = new Set(["fulfilled", "unfilled", "expired", "cancelled"]);
@@ -40,7 +40,7 @@ interface StatusInfo {
 }
 
 /**
- * Pure re-implementation of the row-building logic from C3 StatusUpdater.
+ * Pure re-implementation of the row-building logic from OrderStatusTracker.
  * Returns the list of rows that would be passed to the multi-row upsert.
  */
 function buildRowsToUpdate(
@@ -105,7 +105,7 @@ describe("VALID_DISCRETE_STATUSES membership", () => {
 
 // ── Row-building filter logic ─────────────────────────────────────────────────
 
-describe("C3 StatusUpdater row-building filter", () => {
+describe("OrderStatusTracker row-building filter", () => {
   const CHAIN_ID = 1;
 
   it('includes an order whose API status is "fulfilled"', () => {

From 6eda4bcdb117a0f277478bb89e488f4fb79ecb0e Mon Sep 17 00:00:00 2001
From: Jefferson Bastos <jeff.junior98@gmail.com>
Date: Mon, 15 Jun 2026 16:48:22 -0300
Subject: [PATCH 53/84] =?UTF-8?q?chore(qa):=20P3=20nits=20=E2=80=94=20repl?=
 =?UTF-8?q?ace=20unicode=20arrows,=20drop=20unused=20export?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Replaces the unicode arrow (U+2192) with the ASCII '->' that a human typing in an editor produces, across the public docs (api-reference, architecture, supported-order-types), shipped code comments (schema/tables.ts, blockHandler.ts, chains/types.ts, constants.ts, pollResultErrors.ts, order-types.ts), and the debug playbook. Also drops the unused 'export' on HANDLER_ADDRESS_TO_TYPE (no external consumers). Arrows in the internal agent_docs/ and .claude/ scaffolding (Mermaid diagrams, generic command prompts) are intentionally left alone.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .claude/commands/debug-ponder.md            | 6 +++---
 docs/api-reference.md                       | 2 +-
 docs/architecture.md                        | 6 +++---
 docs/supported-order-types.md               | 6 +++---
 schema/tables.ts                            | 2 +-
 src/application/handlers/blockHandler.ts    | 2 +-
 src/application/helpers/pollResultErrors.ts | 2 +-
 src/chains/types.ts                         | 2 +-
 src/constants.ts                            | 8 ++++----
 src/utils/order-types.ts                    | 8 ++++----
 10 files changed, 22 insertions(+), 22 deletions(-)

diff --git a/.claude/commands/debug-ponder.md b/.claude/commands/debug-ponder.md
index 59b6d0d..5271188 100644
--- a/.claude/commands/debug-ponder.md
+++ b/.claude/commands/debug-ponder.md
@@ -72,9 +72,9 @@ Healthy output looks like:
 ```
 
 Red flags:
-- `composableCow:decoded` with `"decodedParams":"null"` on a known orderType → decoder returned nothing
-- `composableCow:decodeFailed` line → malformed staticInput; the `err` field has the message
-- `composableCow:unknownHandler` line → address not in `HANDLER_MAP` in `src/utils/order-types.ts`
+- `composableCow:decoded` with `"decodedParams":"null"` on a known orderType -> decoder returned nothing
+- `composableCow:decodeFailed` line -> malformed staticInput; the `err` field has the message
+- `composableCow:unknownHandler` line -> address not in `HANDLER_MAP` in `src/utils/order-types.ts`
 
 ### Step 4 — Startup / DB / RPC health
 
diff --git a/docs/api-reference.md b/docs/api-reference.md
index 236b101..b3089ce 100644
--- a/docs/api-reference.md
+++ b/docs/api-reference.md
@@ -29,7 +29,7 @@ High-level map of what's queryable:
 - **`discreteOrder`** — individual CoW Protocol orders produced by a generator (a TWAP with 10 parts produces 10 discrete orders). Tracks orderbook status and executed amounts.
 - **`candidateDiscreteOrder`** — unconfirmed discrete orders discovered by the block handler, awaiting confirmation against the orderbook API.
 - **`transaction`** — block and timestamp metadata for indexed transactions.
-- **`ownerMapping`** — proxy/adapter → EOA mappings. Populated from CoWShed factory events and Aave flash loan adapter detection.
+- **`ownerMapping`** — proxy/adapter -> EOA mappings. Populated from CoWShed factory events and Aave flash loan adapter detection.
 
 For schema details (columns, indexes, relations), see [architecture.md](./architecture.md).
 
diff --git a/docs/architecture.md b/docs/architecture.md
index a7e216a..26b2f38 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -38,7 +38,7 @@ ConditionalOrderCreated         COWShedBuilt events            Settlement events
         v                               v                               v
 composableCow.ts handler        cowshed.ts handler             settlement.ts handler
   - hash params tuple             - write ownerMapping:          - fetch receipt, scan Trade logs
-  - resolve owner proxy             shed → user EOA              - check FACTORY() on each trader
+  - resolve owner proxy             shed -> user EOA              - check FACTORY() on each trader
   - decode staticInput            (used by composableCow.ts      - if Aave adapter: call owner(),
   - write transaction +             at next order creation)        write ownerMapping
     conditionalOrderGenerator
@@ -54,7 +54,7 @@ composableCow.ts handler        cowshed.ts handler             settlement.ts han
                  OrderDiscoveryPoller     — multicall getTradeableOrderWithSignature for
                                            non-deterministic generators; detects cancellation
                                            via SingleOrderNotAuthed error
-                 CandidateConfirmer      — confirms candidates via orderbook API → discreteOrder;
+                 CandidateConfirmer      — confirms candidates via orderbook API -> discreteOrder;
                                            cascades parent Cancelled to orphan candidates
                  OrderStatusTracker      — polls API for status updates on open discrete orders;
                                            cascades parent Cancelled to orphan open rows
@@ -164,7 +164,7 @@ Every block, this handler drains up to `MAX_SETTLEMENTS_PER_BLOCK` rows from `se
 5. Call `getCode` on the address (with timeout). Skip if EOA (no bytecode).
 6. Call `FACTORY()` via raw `eth_call` (not `readContract`, which logs a WARN on every revert). If the returned address doesn't match the known AaveV3AdapterFactory address, skip.
 7. Call `owner()` on the adapter to retrieve the underlying EOA.
-8. Write a row to `ownerMapping` (`address` → `owner`, `addressType = FlashLoanHelper`).
+8. Write a row to `ownerMapping` (`address` -> `owner`, `addressType = FlashLoanHelper`).
 9. Update any `conditionalOrderGenerator` rows owned by the adapter address to set `ownerAddressType = FlashLoanHelper`.
 10. Delete the queue row.
 
diff --git a/docs/supported-order-types.md b/docs/supported-order-types.md
index f7b17de..cf711be 100644
--- a/docs/supported-order-types.md
+++ b/docs/supported-order-types.md
@@ -102,7 +102,7 @@ struct StopLossOrder {
 | `receiver` | receiver | string | Lowercased |
 | `isSellOrder` | isSellOrder | boolean | |
 | `isPartiallyFillable` | isPartiallyFillable | boolean | |
-| `validTo` | validTo | number | **Duration in seconds, not a Unix timestamp.** The watch-tower adds this to the block timestamp at strike trigger to produce the on-chain order's `validTo`. uint32 → JSON number. |
+| `validTo` | validTo | number | **Duration in seconds, not a Unix timestamp.** The watch-tower adds this to the block timestamp at strike trigger to produce the on-chain order's `validTo`. uint32 -> JSON number. |
 | `sellTokenPriceOracle` | sellTokenPriceOracle | string | Chainlink aggregator address, lowercased |
 | `buyTokenPriceOracle` | buyTokenPriceOracle | string | Chainlink aggregator address, lowercased |
 | `strike` | strike | string | Signed value (can be negative). Stringified bigint |
@@ -146,7 +146,7 @@ struct PerpetualStableSwapOrder {
 |---|---|---|---|
 | `tokenA` | tokenA | string | Lowercased |
 | `tokenB` | tokenB | string | Lowercased |
-| `validityBucketSeconds` | validityBucketSeconds | number | Duration in seconds, not a Unix timestamp. uint32 → JSON number. |
+| `validityBucketSeconds` | validityBucketSeconds | number | Duration in seconds, not a Unix timestamp. uint32 -> JSON number. |
 | `halfSpreadBps` | halfSpreadBps | string | Half the spread in basis points. A value of 50 means 0.5% half-spread (1% total spread) |
 | `appData` | appData | string | bytes32 hex |
 
@@ -241,7 +241,7 @@ struct TradeAboveThresholdOrder {
 | `sellToken` | sellToken | string | Lowercased |
 | `buyToken` | buyToken | string | Lowercased |
 | `receiver` | receiver | string | Lowercased |
-| `validityBucketSeconds` | validityBucketSeconds | number | Duration in seconds, not a Unix timestamp. uint32 → JSON number. |
+| `validityBucketSeconds` | validityBucketSeconds | number | Duration in seconds, not a Unix timestamp. uint32 -> JSON number. |
 | `threshold` | threshold | string | Raw token units. The owner's sellToken balance must exceed this for the order to fire |
 | `appData` | appData | string | bytes32 hex |
 
diff --git a/schema/tables.ts b/schema/tables.ts
index de3d058..f921520 100644
--- a/schema/tables.ts
+++ b/schema/tables.ts
@@ -73,7 +73,7 @@ export const conditionalOrderGenerator = onchainTable(
     status: orderStatusEnum("order_status").notNull().default("Active"),
     decodedParams: t.json(),               // null if unknown type or decode failed
     decodeError: t.text(),                 // "invalid_static_input" | null
-    txHash: t.hex().notNull(),             // FK → transaction.hash
+    txHash: t.hex().notNull(),             // FK -> transaction.hash
     allCandidatesKnown: t.boolean().notNull().default(false),
     nextCheckBlock: t.bigint(),            // block handler scheduling
     lastCheckBlock: t.bigint(),
diff --git a/src/application/handlers/blockHandler.ts b/src/application/handlers/blockHandler.ts
index 6dbc6c5..f6b19a9 100644
--- a/src/application/handlers/blockHandler.ts
+++ b/src/application/handlers/blockHandler.ts
@@ -869,7 +869,7 @@ ponder.on("OwnerBackfill:block", async ({ event, context }) => {
 // StopLoss, CirclesBackingOrder), so SingleOrderNotAuthed is never observed
 // for them. This handler closes that gap by reading
 // ComposableCoW.singleOrders(owner, hash) on a DETERMINISTIC_CANCEL_SWEEP_INTERVAL
-// cadence. A `false` result means the owner called remove() on-chain → flip to
+// cadence. A `false` result means the owner called remove() on-chain -> flip to
 // Cancelled, which lets the CandidateConfirmer/OrderStatusTracker parent-cancelled cascade reconcile
 // the child discrete / candidate rows on the next block.
 
diff --git a/src/application/helpers/pollResultErrors.ts b/src/application/helpers/pollResultErrors.ts
index af02d14..601cd52 100644
--- a/src/application/helpers/pollResultErrors.ts
+++ b/src/application/helpers/pollResultErrors.ts
@@ -26,7 +26,7 @@ export type PollResult =
  *
  * Viem wraps revert errors as:
  *   ContractFunctionExecutionError
- *     .cause → ContractFunctionRevertedError
+ *     .cause -> ContractFunctionRevertedError
  *       .data.errorName  (set when error ABI is known)
  *       .data.args
  *
diff --git a/src/chains/types.ts b/src/chains/types.ts
index 38e1de6..cc0eeb8 100644
--- a/src/chains/types.ts
+++ b/src/chains/types.ts
@@ -5,7 +5,7 @@ export type { SupportedChainId };
 /**
  * Derive the OrderDiscoveryPoller block interval from block time so that polls
  * happen approximately every 20 seconds regardless of chain speed.
- * e.g. mainnet (12s) → 1 block, gnosis (5s) → 4 blocks, base (2s) → 10 blocks.
+ * e.g. mainnet (12s) -> 1 block, gnosis (5s) -> 4 blocks, base (2s) -> 10 blocks.
  */
 export function pollerInterval(blockTimeSeconds: number): number {
   return Math.max(1, Math.floor(20 / blockTimeSeconds));
diff --git a/src/constants.ts b/src/constants.ts
index 9dc3846..c0a7c84 100644
--- a/src/constants.ts
+++ b/src/constants.ts
@@ -33,12 +33,12 @@ export const DEFAULT_MAX_GENERATORS_PER_BLOCK = 200;
  *
  * Every tryNextBlock response increments a counter on the generator; any other
  * response resets it to zero. The counter selects the next-check block offset:
- *   count <= WARMUP_THRESHOLD   → +1 block  (default, healthy behavior)
- *   count <= COOLDOWN_THRESHOLD → +10 blocks
- *   count >  COOLDOWN_THRESHOLD → +50 blocks
+ *   count <= WARMUP_THRESHOLD   -> +1 block  (default, healthy behavior)
+ *   count <= COOLDOWN_THRESHOLD -> +10 blocks
+ *   count >  COOLDOWN_THRESHOLD -> +50 blocks
  *
  * Block counts (not seconds) intentionally — simpler, and the ceiling is
- * acceptable on both gnosis (~5s/block → 250s) and mainnet (~12s/block → 600s).
+ * acceptable on both gnosis (~5s/block -> 250s) and mainnet (~12s/block -> 600s).
  */
 export const TRY_NEXT_BLOCK_WARMUP_THRESHOLD = 50;
 export const TRY_NEXT_BLOCK_COOLDOWN_THRESHOLD = 200;
diff --git a/src/utils/order-types.ts b/src/utils/order-types.ts
index d40db60..9e09c35 100644
--- a/src/utils/order-types.ts
+++ b/src/utils/order-types.ts
@@ -1,4 +1,4 @@
-// Handler contract address → order type, keyed by chain ID then address (lowercase).
+// Handler contract address -> order type, keyed by chain ID then address (lowercase).
 // Most handler addresses are chain-agnostic: the five core CREATE2-deployed handlers are
 // confirmed identical across chains in cowprotocol/composable-cow/networks.json.
 // Chain-specific handlers (not CREATE2-shared) live in per-chain overlays merged into
@@ -27,11 +27,11 @@ export type OrderType =
   | "Unknown";
 
 /**
- * Canonical address → order type map for chain-agnostic handlers (CREATE2-deployed at the
+ * Canonical address -> order type map for chain-agnostic handlers (CREATE2-deployed at the
  * same address on every supported chain). Single source of truth for these five — do not
  * duplicate addresses.
  */
-export const HANDLER_ADDRESS_TO_TYPE: Record<string, OrderType> = {
+const HANDLER_ADDRESS_TO_TYPE: Record<string, OrderType> = {
   "0x6cf1e9ca41f7611def408122793c358a3d11e5a5": "TWAP",
   "0x412c36e5011cd2517016d243a2dfb37f73a242e7": "StopLoss",
   "0x519ba24e959e33b3b6220ca98bd353d8c2d89920": "PerpetualSwap",
@@ -46,7 +46,7 @@ export const HANDLER_ADDRESS_TO_TYPE: Record<string, OrderType> = {
 const MAINNET_ONLY_HANDLERS: Record<string, OrderType> = {
   "0xd506fe0b3ddf9e685c16e000514a835d3a511b26": "SwapOrderHandler",
   "0x816e90dc85bf016455017a76bc09cc0451eeb308": "ERC4626CowSwapFeeBurner",
-  // Curve Finance fee-burn handler: converts protocol fees → target token via CoW swap.
+  // Curve Finance fee-burn handler: converts protocol fees -> target token via CoW swap.
   // Source: https://docs.curve.finance/fees/CowSwapBurner/ — Vyper 0.3.10, verified.
   "0xc0fc3ddfec95ca45a0d2393f518d3ea1ccf44f8b": "CurveCowSwapBurner",
   // Balancer v3 CowSwapFeeBurner: burns protocol fees via CoW swap.

From e6c074c57b9eae6b37c39c157c555ec389a409be Mon Sep 17 00:00:00 2001
From: Jefferson Bastos <jeff.junior98@gmail.com>
Date: Mon, 15 Jun 2026 16:49:28 -0300
Subject: [PATCH 54/84] docs: rename m3-orderbook-integration-flow to
 orderbook-integration-flow

Drops the 'm3' milestone code from the filename now that the milestone framing is gone from the doc's content. No inbound references to the old name exist.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 ...rderbook-integration-flow.md => orderbook-integration-flow.md} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename agent_docs/{m3-orderbook-integration-flow.md => orderbook-integration-flow.md} (100%)

diff --git a/agent_docs/m3-orderbook-integration-flow.md b/agent_docs/orderbook-integration-flow.md
similarity index 100%
rename from agent_docs/m3-orderbook-integration-flow.md
rename to agent_docs/orderbook-integration-flow.md

From 1c181e8ee9eb5392b27f479804e0d8f74cb8465a Mon Sep 17 00:00:00 2001
From: Jefferson Bastos <jeff.junior98@gmail.com>
Date: Mon, 15 Jun 2026 16:52:53 -0300
Subject: [PATCH 55/84] docs: document all eight decoded order types

The docs claimed five programmatic order types but src/decoders/ has eight. Adds sections for Circles Backing Order (4 fields), Swap Order Handler (5 fields), and ERC4626 CoW Swap Fee Burner (1 field; staticInput is a bare address, so the remaining order fields are not recoverable) in the existing per-type format, and corrects the count in supported-order-types.md, README.md, and AGENTS.md. Also fixes a stray unicode arrow in AGENTS.md.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 AGENTS.md                     |  4 +-
 README.md                     |  2 +-
 docs/supported-order-types.md | 90 ++++++++++++++++++++++++++++++++++-
 3 files changed, 92 insertions(+), 4 deletions(-)

diff --git a/AGENTS.md b/AGENTS.md
index 3015fce..8d99c28 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -36,7 +36,7 @@ pnpm lint         # ESLint
 pnpm dev          # Start indexer locally (requires .env.local with MAINNET_RPC_URL)
 ```
 
-Copy `.env.local.example` → `.env.local` and set `MAINNET_RPC_URL` before `pnpm dev`.
+Copy `.env.local.example` -> `.env.local` and set `MAINNET_RPC_URL` before `pnpm dev`.
 Start PostgreSQL with `docker compose up -d` to use it instead of the default SQLite.
 
 ## Reference Documentation
@@ -46,7 +46,7 @@ Start PostgreSQL with `docker compose up -d` to use it instead of the default SQ
 | `agent_docs/project-structure.md` | Current file map, schema tables, env vars, key commands |
 | `agent_docs/code-patterns.md` | Schema/naming conventions (snake_case, composite PK, eventId) — **check before schema or handler changes** |
 | `agent_docs/token-indexer-overview.md` | Full Ponder patterns (handlers, repos, services) — **read before writing any implementation plan** |
-| `docs/supported-order-types.md` | All 5 order type ABI structs, handler addresses, decoded fields, edge cases — **read before any decoder or block-handler work** |
+| `docs/supported-order-types.md` | All 8 order type ABI structs, handler addresses, decoded fields, edge cases — **read before any decoder or block-handler work** |
 
 ## Working Conventions
 
diff --git a/README.md b/README.md
index 8c917b0..babdebe 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 # Programmatic Orders API
 
-Indexes on-chain events from [CoW Protocol](https://cow.fi)'s ComposableCoW contract, decodes programmatic order types (TWAP, Stop Loss, Perpetual Swap, Good After Time, Trade Above Threshold), and serves the data through a GraphQL API. Built with [Ponder](https://ponder.sh) by [@bleu](https://github.com/bleu) for CoW Protocol.
+Indexes on-chain events from [CoW Protocol](https://cow.fi)'s ComposableCoW contract, decodes eight programmatic order types (TWAP, Stop Loss, Perpetual Swap, Good After Time, Trade Above Threshold, Circles Backing Order, Swap Order Handler, ERC4626 CoW Swap Fee Burner), and serves the data through a GraphQL API. Built with [Ponder](https://ponder.sh) by [@bleu](https://github.com/bleu) for CoW Protocol.
 
 ## Tech stack
 
diff --git a/docs/supported-order-types.md b/docs/supported-order-types.md
index cf711be..3b5fc38 100644
--- a/docs/supported-order-types.md
+++ b/docs/supported-order-types.md
@@ -1,6 +1,6 @@
 # Supported Order Types
 
-The indexer decodes five programmatic order types from the ComposableCoW contract. Each order is created on-chain as a `ConditionalOrderCreated` event containing a handler address, a salt, and an opaque `staticInput` blob. The handler address determines the order type, and the `staticInput` is ABI-decoded into typed parameters stored in the `decodedParams` JSON field on `conditional_order_generator`.
+The indexer decodes eight programmatic order types from the ComposableCoW contract. Each order is created on-chain as a `ConditionalOrderCreated` event containing a handler address, a salt, and an opaque `staticInput` blob. The handler address determines the order type, and the `staticInput` is ABI-decoded into typed parameters stored in the `decodedParams` JSON field on `conditional_order_generator`.
 
 Most handler addresses are identical across all active chains (CREATE2 deployments — see `src/utils/order-types.ts` for chain-specific overrides). Arbitrum support is planned but handler mappings are not yet registered.
 
@@ -259,6 +259,94 @@ Because the sell amount depends on the owner's live balance, the discrete order
 
 ---
 
+## Circles Backing Order
+
+Backs a Circles group token by buying a target token with a fixed amount. Used by the Circles backing flow on Gnosis Chain. Gnosis-only handler.
+
+**Handler address** (Gnosis): `0x43866c5602b0e3b3272424396e88b849796dc608`
+
+### Solidity struct
+
+```solidity
+struct CirclesBackingOrder {
+    address buyToken;   // token to buy
+    uint256 buyAmount;  // amount to buy
+    uint32  validTo;    // order validity duration in seconds
+    bytes32 appData;    // CoW Protocol app data hash
+}
+```
+
+### Decoded fields in the API
+
+| `decodedParams` field | Solidity field | Type in API | Notes |
+|---|---|---|---|
+| `buyToken` | buyToken | string | Lowercased address |
+| `buyAmount` | buyAmount | string | Raw token units (stringified bigint) |
+| `validTo` | validTo | number | Duration in seconds, not a Unix timestamp. uint32 -> JSON number. |
+| `appData` | appData | string | bytes32 hex |
+
+### Discrete parts
+
+UIDs are computable from `staticInput` alone (`DETERMINISTIC_ORDER_TYPE.CirclesBackingOrder = true`). The decoder recovers no `sellToken` from the static input; the sell side is determined by the handler at execution time.
+
+---
+
+## Swap Order Handler
+
+A balance-driven swap: the handler sells the owner's full balance of `sellToken` for `buyToken`. The sell amount is read on-chain at query time, so it is not part of the decoded params. Deployed as a stateless singleton on Mainnet and Gnosis.
+
+**Handler addresses**: `0xd506fe0b3ddf9e685c16e000514a835d3a511b26` (Mainnet), `0x7a77934d32d78bfe8dc1e23415b5679960a1c610` (Gnosis)
+
+### Solidity struct
+
+```solidity
+struct SwapOrderHandlerData {
+    address sellToken;
+    address buyToken;
+    address receiver;
+    uint32  validityPeriod;  // order validity duration in seconds
+    bytes32 appData;
+}
+```
+
+### Decoded fields in the API
+
+| `decodedParams` field | Solidity field | Type in API | Notes |
+|---|---|---|---|
+| `sellToken` | sellToken | string | Lowercased address |
+| `buyToken` | buyToken | string | Lowercased address |
+| `receiver` | receiver | string | Lowercased address |
+| `validityPeriod` | validityPeriod | number | Duration in seconds, not a Unix timestamp. The handler computes `validTo` via `Utils.validToBucket(validityPeriod)`. uint32 -> JSON number. |
+| `appData` | appData | string | bytes32 hex |
+
+### Discrete parts
+
+Non-deterministic (`DETERMINISTIC_ORDER_TYPE.SwapOrderHandler = false`). The discrete order's sell amount is `IERC20(sellToken).balanceOf(owner)` at query time and `validTo` is bucketed from `validityPeriod`, so neither can be derived from `decodedParams` alone.
+
+---
+
+## ERC4626 CoW Swap Fee Burner
+
+A fee-burner handler from the Balancer v3 monorepo (`ERC4626CowSwapFeeBurner`, inherits `CowSwapFeeBurner`) that sells accumulated protocol fees via a CoW swap. Deployed on Mainnet and Gnosis.
+
+**Handler addresses**: `0x816e90dc85bf016455017a76bc09cc0451eeb308` (Mainnet), `0x5915dea04ce390f0f44ca0806f7c6dd99ce2f941` (Gnosis)
+
+### staticInput layout
+
+The `staticInput` is non-standard: a bare `abi.encode(address tokenIn)` rather than a tuple. Only `tokenIn` is recoverable. The rest of the order (`tokenOut`, `receiver`, `minAmountOut`, `deadline`) lives in the contract's `_orders` mapping and is not present in `staticInput`. Recovering those fields would require indexing the fee-burner's `OrderCreated` event, which is a separate task.
+
+### Decoded fields in the API
+
+| `decodedParams` field | Type in API | Notes |
+|---|---|---|
+| `tokenIn` | string | Lowercased address. The token being burned (sold). The only field recoverable from `staticInput`. |
+
+### Discrete parts
+
+Non-deterministic (`DETERMINISTIC_ORDER_TYPE.ERC4626CowSwapFeeBurner = false`). The sell amount is `tokenIn.balanceOf(address(this))` at query time; with `partiallyFillable = true`, it decreases across fills. None of these can be derived from `decodedParams`.
+
+---
+
 ## Decode failures
 
 When `staticInput` cannot be decoded for a known order type, the indexer stores `decodedParams: null` and sets `decodeError` to `"invalid_static_input"`. This happens when the on-chain data doesn't match the expected ABI layout -- corrupted calldata, a different handler version, or a handler address collision with a non-standard contract.

From 6560c7ecac0c5ffa9aea7d896b90dd02277498e1 Mon Sep 17 00:00:00 2001
From: Jefferson Bastos <jeff.junior98@gmail.com>
Date: Mon, 15 Jun 2026 17:22:02 -0300
Subject: [PATCH 56/84] docs: align logging convention with uniform log() usage

The structured log() helper is now used across both src/application/ and src/api/ (the router onError handler included), with zero stray console.* calls. Updates the convention note that previously claimed the src/api/ layer was exempt.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 docs/deployment.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/deployment.md b/docs/deployment.md
index fe8d55b..d1cf932 100644
--- a/docs/deployment.md
+++ b/docs/deployment.md
@@ -129,7 +129,7 @@ The Docker Compose health check uses `/ready` with a 24-hour start period as a p
 
 `pnpm dev` uses Ponder's default pretty format for readability during local development.
 
-**Convention:** all code under `src/application/` uses `log()` from `src/application/helpers/logger.ts` instead of `console.log/warn/error` directly. The `src/api/` layer (Hono routes) is exempt — Hono handles its own logging. Example:
+**Convention:** application and API code uses `log()` from `src/application/helpers/logger.ts` instead of `console.log/warn/error` directly, so every line is structured JSON. (Hono still handles its own request-level logging.) Example:
 
 ```ts
 import { log } from "../helpers/logger";

From 1cc5033ba20f4ec69832dddcd4cb55cd10b95ec3 Mon Sep 17 00:00:00 2001
From: Jefferson Bastos <jeff.junior98@gmail.com>
Date: Mon, 15 Jun 2026 18:02:16 -0300
Subject: [PATCH 57/84] chore(qa): remove unused DISABLE_POLL_RESULT_CHECK and
 DISABLE_DETERMINISTIC_CANCEL_SWEEP flags

These escape-hatch flags were no longer used. They also used a truthy check (if (process.env.X)) rather than === "true", so the docker-compose default of the literal string "false" silently disabled the OrderDiscoveryPoller and CancellationWatcher handlers in the deploy path. Removed the guards, the compose env line, and the .env.example / deployment.md / architecture.md references. Kept DISABLE_SETTLEMENT_FACTORY_CHECK (still used, correct === "true" semantics).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .env.example                             | 6 ------
 docker-compose.yml                       | 1 -
 docs/architecture.md                     | 4 ++--
 docs/deployment.md                       | 2 --
 src/application/handlers/blockHandler.ts | 2 --
 5 files changed, 2 insertions(+), 13 deletions(-)

diff --git a/.env.example b/.env.example
index 8d33986..d066e8c 100644
--- a/.env.example
+++ b/.env.example
@@ -18,12 +18,6 @@ DATABASE_URL=postgresql://postgres:postgres@localhost:5432/programmatic-orders
 DATABASE_SCHEMA=programmatic_orders
 
 # Performance / escape-hatch flags (all optional; safe to omit in production)
-# DISABLE_POLL_RESULT_CHECK=true       # escape-hatch: skips OrderDiscoveryPoller multicalls for
-#                                      #   non-deterministic generators; leaves those orders undetected
-#                                      #   until re-enabled. Use only to benchmark or diagnose.
-# DISABLE_DETERMINISTIC_CANCEL_SWEEP=true # escape-hatch: skips CancellationWatcher singleOrders()
-#                                      #   reads; on-chain remove() on TWAP/StopLoss/CirclesBackingOrder
-#                                      #   generators will not be detected while disabled.
 # DISABLE_SETTLEMENT_FACTORY_CHECK=true   # escape-hatch: skips getCode + FACTORY() RPC calls in the
 #                                      #   GPv2Settlement handler. Benchmark-only; do not use in prod.
 
diff --git a/docker-compose.yml b/docker-compose.yml
index e721c4d..25ea675 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -50,7 +50,6 @@ services:
       MAINNET_RPC_URL: ${MAINNET_RPC_URL:?error}
       GNOSIS_RPC_URL: ${GNOSIS_RPC_URL:?error}
       # Add a new chain's RPC URL env var here when enabling it in src/chains/index.ts
-      DISABLE_POLL_RESULT_CHECK: ${DISABLE_POLL_RESULT_CHECK:-false}
       DISABLE_SETTLEMENT_FACTORY_CHECK: ${DISABLE_SETTLEMENT_FACTORY_CHECK:-false}
     ports:
       - "${PONDER_EXPOSED_PORT:-40000}:3000"
diff --git a/docs/architecture.md b/docs/architecture.md
index 26b2f38..a095d05 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -176,7 +176,7 @@ Stats (total settlements, trade logs found, EOA skips, adapter mappings, avg FAC
 
 All block handlers run only during live sync (`startBlock: "latest"`) to avoid hammering the orderbook API during historical backfill. `OrderDiscoveryPoller` and `CancellationWatcher` share a per-chain batch cap (`MAX_GENERATORS_PER_BLOCK_<chainId>`, default 200) and pull from a priority queue ordered by oldest `lastCheckBlock` first. Generators past the cap defer to the next block.
 
-**OrderDiscoveryPoller** (every block, mainnet + gnosis): Multicalls `getTradeableOrderWithSignature` on ComposableCoW for each `Active` generator where `allCandidatesKnown=false`. A success result creates a `candidateDiscreteOrder` entry. A `SingleOrderNotAuthed` error marks the generator as `Cancelled` with `lastPollResult='cancelled:SingleOrderNotAuthed'`. Other errors (tryNextBlock, tryAtEpoch, etc.) advance the generator's `nextCheckBlock` accordingly. Single-shot non-deterministic types (GoodAfterTime, TradeAboveThreshold) set `allCandidatesKnown=true` after first success. Can be disabled with `DISABLE_POLL_RESULT_CHECK=true`.
+**OrderDiscoveryPoller** (every block, mainnet + gnosis): Multicalls `getTradeableOrderWithSignature` on ComposableCoW for each `Active` generator where `allCandidatesKnown=false`. A success result creates a `candidateDiscreteOrder` entry. A `SingleOrderNotAuthed` error marks the generator as `Cancelled` with `lastPollResult='cancelled:SingleOrderNotAuthed'`. Other errors (tryNextBlock, tryAtEpoch, etc.) advance the generator's `nextCheckBlock` accordingly. Single-shot non-deterministic types (GoodAfterTime, TradeAboveThreshold) set `allCandidatesKnown=true` after first success.
 
 **CandidateConfirmer** (every block, mainnet + gnosis): First drains any `candidateDiscreteOrder` rows whose parent generator is `Cancelled` — promoting them into `discreteOrder` with `status='cancelled'` and deleting the candidate rows. Then checks remaining `candidateDiscreteOrder` rows against the orderbook API: when a candidate appears in the API, it's promoted to `discreteOrder` and deleted from candidates. Candidates past their `validTo` are also pruned.
 
@@ -186,7 +186,7 @@ All block handlers run only during live sync (`startBlock: "latest"`) to avoid h
 
 **OwnerBackfill** (fires once at latest block, mainnet + gnosis): One-time fetch of historical orders for non-deterministic generators (PerpetualSwap, GoodAfterTime, TradeAboveThreshold, Unknown) that were active during backfill but have no discrete orders yet. Queries the CoW Protocol `/orders?owner=` endpoint per owner.
 
-**CancellationWatcher** (every block, mainnet + gnosis): Closes `OrderDiscoveryPoller`'s blind spot. `OrderDiscoveryPoller` skips `allCandidatesKnown=true` generators, so removals via `ComposableCoW.remove()` on deterministic types (TWAP, StopLoss, CirclesBackingOrder) would otherwise go undetected — `remove()` emits no event. `CancellationWatcher` multicalls `singleOrders(owner, hash)` on a per-generator cadence of `DETERMINISTIC_CANCEL_SWEEP_INTERVAL` blocks (default 100). A `false` return means the owner called `remove()` on-chain: the generator is flipped to `Cancelled` with `lastPollResult='cancelled:removeMapping'`, after which `CandidateConfirmer` and `OrderStatusTracker`'s parent-cancelled cascades reconcile the children on the next block. `true` reschedules the next check. Can be disabled with `DISABLE_DETERMINISTIC_CANCEL_SWEEP=true`.
+**CancellationWatcher** (every block, mainnet + gnosis): Closes `OrderDiscoveryPoller`'s blind spot. `OrderDiscoveryPoller` skips `allCandidatesKnown=true` generators, so removals via `ComposableCoW.remove()` on deterministic types (TWAP, StopLoss, CirclesBackingOrder) would otherwise go undetected — `remove()` emits no event. `CancellationWatcher` multicalls `singleOrders(owner, hash)` on a per-generator cadence of `DETERMINISTIC_CANCEL_SWEEP_INTERVAL` blocks (default 100). A `false` return means the owner called `remove()` on-chain: the generator is flipped to `Cancelled` with `lastPollResult='cancelled:removeMapping'`, after which `CandidateConfirmer` and `OrderStatusTracker`'s parent-cancelled cascades reconcile the children on the next block. `true` reschedules the next check.
 
 ## Order Types and Decoders
 
diff --git a/docs/deployment.md b/docs/deployment.md
index d1cf932..17108f1 100644
--- a/docs/deployment.md
+++ b/docs/deployment.md
@@ -30,8 +30,6 @@ Example: `DATABASE_URL=postgresql://cow_programmatic:secretpass@localhost:5433/c
 
 | Variable | Required | Description |
 |----------|----------|-------------|
-| `DISABLE_POLL_RESULT_CHECK` | No | Disables the `OrderDiscoveryPoller` block handler. Skips RPC multicalls for non-deterministic generators. Saves RPC calls during initial sync at the cost of not detecting poll results until re-enabled. |
-| `DISABLE_DETERMINISTIC_CANCEL_SWEEP` | No | Disables the `CancellationWatcher`. Skips periodic `singleOrders()` reads on deterministic generators. While disabled, on-chain `ComposableCoW.remove()` calls on TWAP/StopLoss/CirclesBackingOrder generators will not be detected and those generators stay `Active`. |
 | `MAX_GENERATORS_PER_BLOCK_<chainId>` | No | Per-block cap on how many generators `OrderDiscoveryPoller` and `CancellationWatcher` will touch on the given chain (e.g. `MAX_GENERATORS_PER_BLOCK_1=200`, `MAX_GENERATORS_PER_BLOCK_100=400`). Default is 200. Excess generators defer to the next block, prioritized by oldest `lastCheckBlock` first. |
 | `MAX_DISCRETE_ORDERS_PER_BLOCK_<chainId>` | No | Per-block cap on how many open discrete orders `OrderStatusTracker` will check on the given chain (e.g. `MAX_DISCRETE_ORDERS_PER_BLOCK_1=200`). Default is 200. Excess orders are deferred to the next block, prioritised by oldest `promotedAt` first. |
 | `DISABLE_SETTLEMENT_FACTORY_CHECK` | No | Skips `getCode` + `FACTORY()` RPC calls in the GPv2Settlement handler. Useful for benchmarking base sync throughput. |
diff --git a/src/application/handlers/blockHandler.ts b/src/application/handlers/blockHandler.ts
index f6b19a9..b1f1892 100644
--- a/src/application/handlers/blockHandler.ts
+++ b/src/application/handlers/blockHandler.ts
@@ -74,7 +74,6 @@ const SINGLE_ORDERS_ABI = [
 // serves as fallback for deterministic types whose precompute failed.
 
 ponder.on("OrderDiscoveryPoller:block", async ({ event, context }) => {
-  if (process.env.DISABLE_POLL_RESULT_CHECK) return;
 
   const chainId = context.chain.id as SupportedChainId;
   const composableCowAddress = COMPOSABLE_COW_ADDRESS_BY_CHAIN_ID[chainId];
@@ -874,7 +873,6 @@ ponder.on("OwnerBackfill:block", async ({ event, context }) => {
 // the child discrete / candidate rows on the next block.
 
 ponder.on("CancellationWatcher:block", async ({ event, context }) => {
-  if (process.env.DISABLE_DETERMINISTIC_CANCEL_SWEEP) return;
 
   const chainId = context.chain.id as SupportedChainId;
   const composableCowAddress = COMPOSABLE_COW_ADDRESS_BY_CHAIN_ID[chainId];

From 777873245b3134d81a683322474985dce79a096f Mon Sep 17 00:00:00 2001
From: Jefferson Bastos <jeff.junior98@gmail.com>
Date: Mon, 15 Jun 2026 18:02:16 -0300
Subject: [PATCH 58/84] chore(qa): remove dead BLOCK_TIME_SECONDS export and
 orphan AaveV3AdapterFactory ABI
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

BLOCK_TIME_SECONDS had zero references anywhere. The AaveV3AdapterFactory ABI file was never imported — adapters are detected via a raw FACTORY() eth_call, not this ABI.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 abis/AaveV3AdapterFactoryAbi.ts | 48 ---------------------------------
 src/data.ts                     |  8 ------
 2 files changed, 56 deletions(-)
 delete mode 100644 abis/AaveV3AdapterFactoryAbi.ts

diff --git a/abis/AaveV3AdapterFactoryAbi.ts b/abis/AaveV3AdapterFactoryAbi.ts
deleted file mode 100644
index e11cf73..0000000
--- a/abis/AaveV3AdapterFactoryAbi.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-// AaveV3AdapterFactory — mainnet: 0xdeCc46a4b09162f5369c5c80383aaa9159bcf192
-// Start block: 23812751 (November 16, 2025)
-// Note: inherits BaseAdapterFactory (closed source). ABI covers only the confirmed
-// public interface of AaveV3AdapterFactory.sol itself.
-export const AaveV3AdapterFactoryAbi = [
-  {
-    type: "constructor",
-    inputs: [
-      { name: "aavePool_", type: "address", internalType: "address" },
-      { name: "settlement_", type: "address", internalType: "address" },
-      { name: "router_", type: "address", internalType: "address" },
-      { name: "owner_", type: "address", internalType: "address" },
-    ],
-    stateMutability: "nonpayable",
-  },
-  {
-    type: "function",
-    name: "POOL",
-    inputs: [],
-    outputs: [{ name: "", type: "address", internalType: "contract IPool" }],
-    stateMutability: "view",
-  },
-  {
-    type: "function",
-    name: "ADDRESSES_PROVIDER",
-    inputs: [],
-    outputs: [{ name: "", type: "address", internalType: "contract IPoolAddressesProvider" }],
-    stateMutability: "view",
-  },
-  {
-    type: "function",
-    name: "executeOperation",
-    inputs: [
-      { name: "assets", type: "address[]", internalType: "address[]" },
-      { name: "amounts", type: "uint256[]", internalType: "uint256[]" },
-      { name: "premiums", type: "uint256[]", internalType: "uint256[]" },
-      { name: "initiator", type: "address", internalType: "address" },
-      { name: "params", type: "bytes", internalType: "bytes" },
-    ],
-    outputs: [{ name: "", type: "bool", internalType: "bool" }],
-    stateMutability: "nonpayable",
-  },
-  {
-    type: "error",
-    name: "CallerNotAavePool",
-    inputs: [],
-  },
-] as const;
diff --git a/src/data.ts b/src/data.ts
index 4063929..fa9a357 100644
--- a/src/data.ts
+++ b/src/data.ts
@@ -23,14 +23,6 @@ export const CHAIN_NAMES: Record<SupportedChainId, string> = Object.fromEntries(
   ACTIVE_CHAINS.map((c) => [c.chainId, c.name]),
 ) as Record<SupportedChainId, string>;
 
-/**
- * Approximate block time in seconds per chain ID.
- * Derived from ACTIVE_CHAINS — update chain files to change block times.
- */
-export const BLOCK_TIME_SECONDS: Record<SupportedChainId, number> = Object.fromEntries(
-  ACTIVE_CHAINS.map((c) => [c.chainId, c.blockTime]),
-) as Record<SupportedChainId, number>;
-
 /**
  * ComposableCoW address keyed by numeric chain ID.
  * Derived from ACTIVE_CHAINS — update chain files to change addresses.

From 048484e7da902d02c10c860673cd45ef9af784b1 Mon Sep 17 00:00:00 2001
From: Jefferson Bastos <jeff.junior98@gmail.com>
Date: Mon, 15 Jun 2026 18:14:32 -0300
Subject: [PATCH 59/84] fix(qa): return a generic 500 message instead of
 leaking err.message

The API onError handler echoed the raw error message to the client, which for DB/driver errors can leak internal SQL/schema detail. The response now returns a generic message; the real error is still captured server-side via log("error", "api:error", ...).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 src/api/router.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/api/router.ts b/src/api/router.ts
index 8b858de..954de00 100644
--- a/src/api/router.ts
+++ b/src/api/router.ts
@@ -16,7 +16,7 @@ apiRouter.onError((err, c) => {
   return c.json(
     {
       error: "Internal server error",
-      message: err instanceof Error ? err.message : "Unknown error",
+      message: "An unexpected error occurred",
     },
     500,
   );

From a26aa2adfc4fa0fa2990d783785ba03e592d5a93 Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Mon, 15 Jun 2026 18:27:23 -0300
Subject: [PATCH 60/84] fix: prevent crash when ROLLBACK TO savepoint fails in
 multichain flush

The SAVEPOINT flush can fail with "SAVEPOINT can only be used in
transaction blocks" when another chain resets the shared indexingCache.qb
to the pool connection before flush() is called. The uncaught ROLLBACK TO
in the catch block then raises "savepoint does not exist" as an
unhandledRejection, crashing the process.

Wrap the ROLLBACK TO in its own try-catch: if it fails (savepoint was
never created), re-throw the original error so the outer block transaction
rolls back cleanly instead of killing the process.

Also add a no-op .catch() in withTimeout to suppress unhandled rejections
from RPC promises that reject after the timeout has already fired.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 patches/ponder@0.16.6.patch            | 11 +++++++++--
 pnpm-lock.yaml                         |  6 +++---
 src/application/helpers/withTimeout.ts | 14 +++++++++-----
 3 files changed, 21 insertions(+), 10 deletions(-)

diff --git a/patches/ponder@0.16.6.patch b/patches/ponder@0.16.6.patch
index f14387b..224c86c 100644
--- a/patches/ponder@0.16.6.patch
+++ b/patches/ponder@0.16.6.patch
@@ -68,7 +68,7 @@ index e2f6a03650b5b80cae9ec4dc0a8837cb054cae18..b57f4f4b32e03b221b3985f9b9218b23
                  }
                  else {
                      // Note: pglite must run sequentially
-@@ -405,13 +408,13 @@ export const createIndexingCache = ({ common, schemaBuild: { schema }, crashReco
+@@ -405,13 +408,20 @@ export const createIndexingCache = ({ common, schemaBuild: { schema }, crashReco
              }
              catch (_error) {
                  let error = _error;
@@ -80,7 +80,14 @@ index e2f6a03650b5b80cae9ec4dc0a8837cb054cae18..b57f4f4b32e03b221b3985f9b9218b23
                  // function takes an optimized fast path, with support for small batch sizes. PGlite always takes
                  // the fast path because it doesn't support delayed insert errors.
 -                await qb.wrap((db) => db.execute("ROLLBACK to flush"), context);
-+                await currentQb.wrap((db) => db.execute(`ROLLBACK to ${sp}`), context);
++                try {
++                    await currentQb.wrap((db) => db.execute(`ROLLBACK to ${sp}`), context);
++                } catch {
++                    // SAVEPOINT was never created (qb was a pool connection, not in a transaction).
++                    // In multichain mode another chain may reset the shared qb before flush() is called.
++                    // Re-throw original error so the outer block transaction rolls back cleanly.
++                    throw error;
++                }
                  for (const table of cache.keys()) {
                      if (tableNames !== undefined &&
                          tableNames.has(getTableName(table)) === false) {
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index f1fcb04..db72626 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -6,7 +6,7 @@ settings:
 
 patchedDependencies:
   ponder@0.16.6:
-    hash: ec9f89214374efb4dd58ba2291160b5265874a5585c4a5c4c2e778a766371e0a
+    hash: 1e415db905d29fb9e544c4bceb1cd76500dd91794977d0fc87d6372be0eefedf
     path: patches/ponder@0.16.6.patch
 
 importers:
@@ -30,7 +30,7 @@ importers:
         version: 4.12.3
       ponder:
         specifier: ^0.16.6
-        version: 0.16.6(patch_hash=ec9f89214374efb4dd58ba2291160b5265874a5585c4a5c4c2e778a766371e0a)(@opentelemetry/api@1.9.0)(@types/node@20.19.35)(hono@4.12.3)(typescript@5.9.3)(viem@2.46.3(typescript@5.9.3)(zod@3.25.76))(zod@3.25.76)
+        version: 0.16.6(patch_hash=1e415db905d29fb9e544c4bceb1cd76500dd91794977d0fc87d6372be0eefedf)(@opentelemetry/api@1.9.0)(@types/node@20.19.35)(hono@4.12.3)(typescript@5.9.3)(viem@2.46.3(typescript@5.9.3)(zod@3.25.76))(zod@3.25.76)
       ponder-enrich-gql-docs-middleware:
         specifier: ^0.1.3
         version: 0.1.3(graphql@16.8.2)(hono@4.12.3)
@@ -4849,7 +4849,7 @@ snapshots:
       graphql: 16.8.2
       hono: 4.12.3
 
-  ponder@0.16.6(patch_hash=ec9f89214374efb4dd58ba2291160b5265874a5585c4a5c4c2e778a766371e0a)(@opentelemetry/api@1.9.0)(@types/node@20.19.35)(hono@4.12.3)(typescript@5.9.3)(viem@2.46.3(typescript@5.9.3)(zod@3.25.76))(zod@3.25.76):
+  ponder@0.16.6(patch_hash=1e415db905d29fb9e544c4bceb1cd76500dd91794977d0fc87d6372be0eefedf)(@opentelemetry/api@1.9.0)(@types/node@20.19.35)(hono@4.12.3)(typescript@5.9.3)(viem@2.46.3(typescript@5.9.3)(zod@3.25.76))(zod@3.25.76):
     dependencies:
       '@babel/code-frame': 7.29.0
       '@commander-js/extra-typings': 12.1.0(commander@12.1.0)
diff --git a/src/application/helpers/withTimeout.ts b/src/application/helpers/withTimeout.ts
index 89b7108..d7cd3d6 100644
--- a/src/application/helpers/withTimeout.ts
+++ b/src/application/helpers/withTimeout.ts
@@ -43,10 +43,11 @@ export function withTimeout<T>(
       timeoutMs,
     );
   });
-  return Promise.race([
-    promise.finally(() => clearTimeout(timer)),
-    timeout,
-  ]);
+  // Attach a no-op rejection handler before the race so that if the timeout
+  // wins and the underlying call later rejects, it doesn't become an unhandled
+  // rejection that aborts the Ponder block-handler DB transaction.
+  promise.catch(() => {});
+  return Promise.race([promise.finally(() => clearTimeout(timer)), timeout]);
 }
 
 /**
@@ -61,7 +62,10 @@ export async function fetchWithTimeout(
   label: string,
 ): Promise<Response> {
   try {
-    return await fetch(url, { ...init, signal: AbortSignal.timeout(timeoutMs) });
+    return await fetch(url, {
+      ...init,
+      signal: AbortSignal.timeout(timeoutMs),
+    });
   } catch (err) {
     const name = (err as Error | undefined)?.name;
     if (name === "TimeoutError" || name === "AbortError") {

From 163ec7197f1a2f5423636ab92d502908e3ee4719 Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Mon, 15 Jun 2026 19:01:52 -0300
Subject: [PATCH 61/84] fix: skip gnosis synthetic logs with out-of-range
 logIndex in Ponder patch
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

DRPC returns logIndex values near 2^32 (0xFFFFFFFC–0xFFFFFFFE) for gnosis
synthetic consensus/bridge events. Ponder validates these against PG INT4 max
(2147483647), throws an RpcProviderError, and crashes.

Extend the existing ponder@0.16.6 patch to skip logs with logIndex >
PG_INTEGER_MAX via `continue` instead of throwing — these are not real EVM
logs and safe to ignore.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 patches/ponder@0.16.6.patch | 27 ++++++++++++++++++++++++---
 pnpm-lock.yaml              |  6 +++---
 2 files changed, 27 insertions(+), 6 deletions(-)

diff --git a/patches/ponder@0.16.6.patch b/patches/ponder@0.16.6.patch
index 224c86c..cec1267 100644
--- a/patches/ponder@0.16.6.patch
+++ b/patches/ponder@0.16.6.patch
@@ -1,5 +1,5 @@
 diff --git a/dist/esm/indexing-store/cache.js b/dist/esm/indexing-store/cache.js
-index e2f6a03650b5b80cae9ec4dc0a8837cb054cae18..b57f4f4b32e03b221b3985f9b9218b239df9c7b2 100644
+index e2f6a03650b5b80cae9ec4dc0a8837cb054cae18..0d97ae9bf2820459f8744449e11796897456c65e 100644
 --- a/dist/esm/indexing-store/cache.js
 +++ b/dist/esm/indexing-store/cache.js
 @@ -157,6 +157,7 @@ export const recoverBatchError = async (values, callback) => {
@@ -91,7 +91,7 @@ index e2f6a03650b5b80cae9ec4dc0a8837cb054cae18..b57f4f4b32e03b221b3985f9b9218b23
                  for (const table of cache.keys()) {
                      if (tableNames !== undefined &&
                          tableNames.has(getTableName(table)) === false) {
-@@ -424,12 +427,12 @@ export const createIndexingCache = ({ common, schemaBuild: { schema }, crashReco
+@@ -424,12 +434,12 @@ export const createIndexingCache = ({ common, schemaBuild: { schema }, crashReco
                      const updateValues = Array.from(updateBuffer.get(table).values());
                      if (insertValues.length > 0) {
                          const endClock = startClock();
@@ -107,7 +107,7 @@ index e2f6a03650b5b80cae9ec4dc0a8837cb054cae18..b57f4f4b32e03b221b3985f9b9218b23
                          });
                          if (result.status === "error") {
                              error = new DelayedInsertError(result.error.message);
-@@ -471,15 +474,15 @@ export const createIndexingCache = ({ common, schemaBuild: { schema }, crashReco
+@@ -471,15 +481,15 @@ export const createIndexingCache = ({ common, schemaBuild: { schema }, crashReco
                WITH NO DATA;
              `;
                          const endClock = startClock();
@@ -128,3 +128,24 @@ index e2f6a03650b5b80cae9ec4dc0a8837cb054cae18..b57f4f4b32e03b221b3985f9b9218b23
                          if (result.status === "error") {
                              error = new DelayedInsertError(result.error.message);
                              error.stack = undefined;
+diff --git a/dist/esm/rpc/actions.js b/dist/esm/rpc/actions.js
+index ae284fa3d3ba39b259175a4e9869a5ea6d4da4a2..f2b9ec8daddabf09685e717c186517d04a5d7d8c 100644
+--- a/dist/esm/rpc/actions.js
++++ b/dist/esm/rpc/actions.js
+@@ -766,13 +766,9 @@ export const standardizeLogs = (logs, request) => {
+             throw error;
+         }
+         if (hexToBigInt(log.logIndex) > BigInt(PG_INTEGER_MAX)) {
+-            const error = new RpcProviderError(`Invalid RPC response: 'log.logIndex' (${hexToBigInt(log.logIndex)}) is larger than the maximum allowed value (${PG_INTEGER_MAX}).`);
+-            error.meta = [
+-                "Please report this error to the RPC operator.",
+-                requestText(request),
+-            ];
+-            error.stack = undefined;
+-            throw error;
++            // Gnosis uses sentinel logIndex values near 2^32 for synthetic consensus/bridge events.
++            // These are not real EVM logs; skip them instead of crashing.
++            continue;
+         }
+     }
+     return logs;
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index db72626..5bb5c42 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -6,7 +6,7 @@ settings:
 
 patchedDependencies:
   ponder@0.16.6:
-    hash: 1e415db905d29fb9e544c4bceb1cd76500dd91794977d0fc87d6372be0eefedf
+    hash: f0612e7102efb92911aeae79416c3c5c52fcaf41c4a22e7903ba90ef8aa952d5
     path: patches/ponder@0.16.6.patch
 
 importers:
@@ -30,7 +30,7 @@ importers:
         version: 4.12.3
       ponder:
         specifier: ^0.16.6
-        version: 0.16.6(patch_hash=1e415db905d29fb9e544c4bceb1cd76500dd91794977d0fc87d6372be0eefedf)(@opentelemetry/api@1.9.0)(@types/node@20.19.35)(hono@4.12.3)(typescript@5.9.3)(viem@2.46.3(typescript@5.9.3)(zod@3.25.76))(zod@3.25.76)
+        version: 0.16.6(patch_hash=f0612e7102efb92911aeae79416c3c5c52fcaf41c4a22e7903ba90ef8aa952d5)(@opentelemetry/api@1.9.0)(@types/node@20.19.35)(hono@4.12.3)(typescript@5.9.3)(viem@2.46.3(typescript@5.9.3)(zod@3.25.76))(zod@3.25.76)
       ponder-enrich-gql-docs-middleware:
         specifier: ^0.1.3
         version: 0.1.3(graphql@16.8.2)(hono@4.12.3)
@@ -4849,7 +4849,7 @@ snapshots:
       graphql: 16.8.2
       hono: 4.12.3
 
-  ponder@0.16.6(patch_hash=1e415db905d29fb9e544c4bceb1cd76500dd91794977d0fc87d6372be0eefedf)(@opentelemetry/api@1.9.0)(@types/node@20.19.35)(hono@4.12.3)(typescript@5.9.3)(viem@2.46.3(typescript@5.9.3)(zod@3.25.76))(zod@3.25.76):
+  ponder@0.16.6(patch_hash=f0612e7102efb92911aeae79416c3c5c52fcaf41c4a22e7903ba90ef8aa952d5)(@opentelemetry/api@1.9.0)(@types/node@20.19.35)(hono@4.12.3)(typescript@5.9.3)(viem@2.46.3(typescript@5.9.3)(zod@3.25.76))(zod@3.25.76):
     dependencies:
       '@babel/code-frame': 7.29.0
       '@commander-js/extra-typings': 12.1.0(commander@12.1.0)

From 84985b8c0b16040e01e928c9461b4b8693de0c32 Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Mon, 15 Jun 2026 19:27:49 -0300
Subject: [PATCH 62/84] fix: eliminate context.db.sql calls that trigger
 flush() in multichain handlers
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Two calls in orderbookClient.ts triggered indexingCache.flush() from within
block handlers, causing SAVEPOINT errors when the shared qb was pool in
multichain realtime mode:

1. upsertDiscreteOrders (line 178): convert context.db.sql.insert().onConflictDoUpdate()
   to context.db.insert().onConflictDoUpdate() (Ponder ORM, uses in-memory cache,
   never triggers flush).

2. filterAndProcess (line 444): wrap context.db.sql.select() in try/catch — Ponder
   ORM has no non-PK findMany, so the SQL call stays but a SAVEPOINT race now skips
   the order for the current block rather than cascading into a block rollback.
   The order is retried on the next block's fetchComposableOrders call.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 src/application/helpers/orderbookClient.ts | 52 +++++++++++-----------
 1 file changed, 27 insertions(+), 25 deletions(-)

diff --git a/src/application/helpers/orderbookClient.ts b/src/application/helpers/orderbookClient.ts
index 1105688..ce09bce 100644
--- a/src/application/helpers/orderbookClient.ts
+++ b/src/application/helpers/orderbookClient.ts
@@ -175,7 +175,7 @@ export async function upsertDiscreteOrders(
 ): Promise<number> {
   let count = 0;
   for (const order of orders) {
-    await context.db.sql
+    await context.db
       .insert(discreteOrder)
       .values({
         orderUid: order.uid,
@@ -191,13 +191,10 @@ export async function upsertDiscreteOrders(
         executedBuyAmount: order.executedBuyAmount,
       })
       .onConflictDoUpdate({
-        target: [discreteOrder.chainId, discreteOrder.orderUid],
-        set: {
-          status: order.status,
-          validTo: order.validTo,
-          executedSellAmount: order.executedSellAmount,
-          executedBuyAmount: order.executedBuyAmount,
-        },
+        status: order.status,
+        validTo: order.validTo,
+        executedSellAmount: order.executedSellAmount,
+        executedBuyAmount: order.executedBuyAmount,
       });
     count++;
   }
@@ -440,23 +437,28 @@ async function filterAndProcess(
       ),
     );
 
-    // Find the generator — there should be exactly one per (chainId, hash)
-    const generators = (await context.db.sql
-      .select({
-        eventId: conditionalOrderGenerator.eventId,
-        orderType: conditionalOrderGenerator.orderType,
-      })
-      .from(conditionalOrderGenerator)
-      .where(
-        and(
-          eq(conditionalOrderGenerator.chainId, chainId),
-          eq(conditionalOrderGenerator.hash, paramHash),
-        ),
-      )
-      .limit(1)) as {
-      eventId: string;
-      orderType: OrderType;
-    }[];
+    // Find the generator — there should be exactly one per (chainId, hash).
+    // Uses context.db.sql (raw SQL) because Ponder ORM has no non-PK findMany.
+    // Wrapped in try-catch: in multichain realtime mode a shared-qb race can cause
+    // a SAVEPOINT error here; skipping the order is safe — it's retried next block.
+    let generators: { eventId: string; orderType: OrderType }[];
+    try {
+      generators = (await context.db.sql
+        .select({
+          eventId: conditionalOrderGenerator.eventId,
+          orderType: conditionalOrderGenerator.orderType,
+        })
+        .from(conditionalOrderGenerator)
+        .where(
+          and(
+            eq(conditionalOrderGenerator.chainId, chainId),
+            eq(conditionalOrderGenerator.hash, paramHash),
+          ),
+        )
+        .limit(1)) as { eventId: string; orderType: OrderType }[];
+    } catch {
+      continue;
+    }
 
     if (generators.length === 0) continue;
 

From ec2d60d50988b8a962681682a9752ce268142d6e Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Mon, 15 Jun 2026 19:54:28 -0300
Subject: [PATCH 63/84] refactor: inline settlement adapter discovery, remove
 SettlementResolver block handler
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The SettlementResolver:block pattern deferred receipt fetches and FACTORY()
calls to a per-block queue drain. This caused 30k+ context.db.sql calls per
realtime mainnet block (one per queue entry × up to 20/block), widening the
multichain qb race window to near-certain.

Move all RPC work directly into GPv2Settlement:Settlement event handler:
- Receipt fetch + Trade log scan happen immediately at the settlement block
- ownerMapping duplicate check uses context.db.find() (ORM, no flush trigger)
- All DB writes use context.db ORM methods (no context.db.sql)
- On any RPC error: log + return/continue, no crash

Remove SettlementResolver block source from ponder.config.ts and the
settlementQueue table from schema — no longer needed.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 ponder.config.ts                       |   8 -
 schema/tables.ts                       |  13 --
 src/application/handlers/settlement.ts | 256 +++++++++++--------------
 3 files changed, 110 insertions(+), 167 deletions(-)

diff --git a/ponder.config.ts b/ponder.config.ts
index 276be4f..da62fa7 100644
--- a/ponder.config.ts
+++ b/ponder.config.ts
@@ -122,13 +122,5 @@ export default createConfig({
       ),
       interval: 1,
     },
-    // SettlementResolver — async Aave adapter discovery from queued Settlement events.
-    // Only runs on chains that have a flash loan router (currently mainnet only).
-    SettlementResolver: {
-      chain: Object.fromEntries(
-        settlementChains.map((c) => [c.name, { startBlock: "latest" as const }]),
-      ),
-      interval: 1,
-    },
   },
 });
diff --git a/schema/tables.ts b/schema/tables.ts
index 473ff4e..12f3ee4 100644
--- a/schema/tables.ts
+++ b/schema/tables.ts
@@ -160,19 +160,6 @@ export const bootstrapRetryQueue = onchainTable(
   })
 );
 
-export const settlementQueue = onchainTable(
-  "settlement_queue",
-  (t) => ({
-    txHash: t.hex().notNull(),
-    chainId: t.integer().notNull(),
-    blockNumber: t.bigint().notNull(),
-    blockTimestamp: t.bigint().notNull(),
-  }),
-  (table) => ({
-    pk: primaryKey({ columns: [table.chainId, table.txHash] }),
-  })
-);
-
 export const ownerMapping = onchainTable(
   "owner_mapping",
   (t) => ({
diff --git a/src/application/handlers/settlement.ts b/src/application/handlers/settlement.ts
index e2ee605..62e6bdc 100644
--- a/src/application/handlers/settlement.ts
+++ b/src/application/handlers/settlement.ts
@@ -2,10 +2,8 @@ import { ponder } from "ponder:registry";
 import {
   AddressType,
   ownerMapping,
-  settlementQueue,
   transaction,
 } from "ponder:schema";
-import { and, eq } from "ponder";
 import { keccak256, toBytes } from "viem";
 import { log } from "../helpers/logger";
 import { AaveV3AdapterHelperAbi } from "../../../abis/AaveV3AdapterHelperAbi";
@@ -55,30 +53,14 @@ function logStatsIfIntervalPassed() {
 // which floods the log since non-adapter contracts do not implement FACTORY().
 const FACTORY_SELECTOR = "0x2dd31000" as const;
 
-// Max settlements resolved per SettlementResolver block tick.
-const MAX_SETTLEMENTS_PER_BLOCK = 20;
-
-// ── Event handler — enqueue only ─────────────────────────────────────────────
-// All RPC work is deferred to SettlementResolver:block so errors in RPC calls
-// never propagate to the event handler and crash the indexer.
+// ── Event handler — inline Aave adapter discovery ────────────────────────────
+// RPC work runs directly in the event handler with try/catch on every call so
+// a failed fetch skips the settlement without crashing the indexer.
+// Previously deferred to a SettlementResolver:block queue; the queue caused
+// 30k+ context.db.sql calls per realtime block, widening the multichain qb race.
 ponder.on("GPv2Settlement:Settlement", async ({ event, context }) => {
   if (process.env.DISABLE_SETTLEMENT_FACTORY_CHECK === "true") return;
 
-  await context.db
-    .insert(settlementQueue)
-    .values({
-      txHash: event.transaction.hash,
-      chainId: context.chain.id,
-      blockNumber: event.block.number,
-      blockTimestamp: event.block.timestamp,
-    })
-    .onConflictDoNothing();
-});
-
-// ── Block handler — drain queue and resolve adapters ─────────────────────────
-ponder.on("SettlementResolver:block", async ({ event: _event, context }) => {
-  if (process.env.DISABLE_SETTLEMENT_FACTORY_CHECK === "true") return;
-
   const chainId = context.chain.id;
   const chainName = context.chain.name;
 
@@ -93,145 +75,127 @@ ponder.on("SettlementResolver:block", async ({ event: _event, context }) => {
     ]?.toLowerCase();
   if (!adapterFactoryAddress) return;
 
-  const pending = await context.db.sql
-    .select()
-    .from(settlementQueue)
-    .where(eq(settlementQueue.chainId, chainId))
-    .limit(MAX_SETTLEMENTS_PER_BLOCK);
+  stats.total++;
+
+  let receipt: Awaited<ReturnType<typeof context.client.getTransactionReceipt>>;
+  try {
+    receipt = await withTimeout(
+      context.client.getTransactionReceipt({ hash: event.transaction.hash }),
+      BLOCK_HANDLER_RPC_TIMEOUT_MS,
+      "settlement:getTransactionReceipt",
+    );
+  } catch (err) {
+    log("warn", "SettlementResolver:receipt_failed", { chainId, txHash: event.transaction.hash, err: err instanceof Error ? err.message : String(err) });
+    return;
+  }
+
+  for (const txLog of receipt.logs) {
+    if (txLog.address.toLowerCase() !== settlementAddress) continue;
+    if (txLog.topics[0] !== TRADE_TOPIC) continue;
+
+    stats.tradeLogsFound++;
 
-  if (pending.length === 0) return;
+    const owner = `0x${txLog.topics[1]!.slice(26)}` as `0x${string}`;
+    const ownerAddress = owner.toLowerCase() as `0x${string}`;
 
-  for (const item of pending) {
-    stats.total++;
+    const existingMapping = await context.db.find(ownerMapping, { chainId, address: ownerAddress });
+    if (existingMapping) {
+      stats.skippedAlreadyMapped++;
+      logStatsIfIntervalPassed();
+      continue;
+    }
 
-    let receipt: Awaited<ReturnType<typeof context.client.getTransactionReceipt>>;
+    let code: `0x${string}` | undefined;
     try {
-      receipt = await withTimeout(
-        context.client.getTransactionReceipt({ hash: item.txHash }),
-        BLOCK_HANDLER_RPC_TIMEOUT_MS,
-        "settlement:getTransactionReceipt",
+      code = await withTimeout(
+        context.client.getCode({ address: owner }),
+        SETTLEMENT_INNER_RPC_TIMEOUT_MS,
+        "settlement:getCode",
       );
     } catch (err) {
-      log("warn", "SettlementResolver:receipt_failed", { chainId, txHash: item.txHash, err: err instanceof Error ? err.message : String(err) });
-      await context.db.delete(settlementQueue, { chainId, txHash: item.txHash });
+      log("warn", "SettlementResolver:getCode_failed", { chainId, owner, err: err instanceof Error ? err.message : String(err) });
+      continue;
+    }
+    if (!code || code === "0x") {
+      stats.skippedEOA++;
+      logStatsIfIntervalPassed();
       continue;
     }
 
-    for (const txLog of receipt.logs) {
-      if (txLog.address.toLowerCase() !== settlementAddress) continue;
-      if (txLog.topics[0] !== TRADE_TOPIC) continue;
-
-      stats.tradeLogsFound++;
-
-      const owner = `0x${txLog.topics[1]!.slice(26)}` as `0x${string}`;
-      const ownerAddress = owner.toLowerCase() as `0x${string}`;
-
-      const existing = await context.db.sql
-        .select()
-        .from(ownerMapping)
-        .where(and(eq(ownerMapping.chainId, chainId), eq(ownerMapping.address, ownerAddress)))
-        .limit(1);
-
-      if (existing.length > 0) {
-        stats.skippedAlreadyMapped++;
-        logStatsIfIntervalPassed();
-        continue;
-      }
-
-      let code: `0x${string}` | undefined;
-      try {
-        code = await withTimeout(
-          context.client.getCode({ address: owner }),
-          SETTLEMENT_INNER_RPC_TIMEOUT_MS,
-          "settlement:getCode",
-        );
-      } catch (err) {
-        log("warn", "SettlementResolver:getCode_failed", { chainId, owner, err: err instanceof Error ? err.message : String(err) });
-        continue;
-      }
-      if (!code || code === "0x") {
-        stats.skippedEOA++;
-        logStatsIfIntervalPassed();
-        continue;
-      }
-
-      const t1 = Date.now();
-      let factoryData: `0x${string}` | undefined;
-      try {
-        const result = await withTimeout(
-          context.client.call({ to: owner, data: FACTORY_SELECTOR }),
-          SETTLEMENT_INNER_RPC_TIMEOUT_MS,
-          "settlement:call:FACTORY",
-        );
-        factoryData = result.data;
-      } catch {
-        stats.msFactory += Date.now() - t1;
-        stats.skippedNotAdapter++;
-        logStatsIfIntervalPassed();
-        continue;
-      }
+    const t1 = Date.now();
+    let factoryData: `0x${string}` | undefined;
+    try {
+      const result = await withTimeout(
+        context.client.call({ to: owner, data: FACTORY_SELECTOR }),
+        SETTLEMENT_INNER_RPC_TIMEOUT_MS,
+        "settlement:call:FACTORY",
+      );
+      factoryData = result.data;
+    } catch {
       stats.msFactory += Date.now() - t1;
+      stats.skippedNotAdapter++;
+      logStatsIfIntervalPassed();
+      continue;
+    }
+    stats.msFactory += Date.now() - t1;
 
-      if (!factoryData || factoryData.length < 66) {
-        stats.skippedNotAdapter++;
-        logStatsIfIntervalPassed();
-        continue;
-      }
-
-      const factoryAddress = `0x${factoryData.slice(26)}` as `0x${string}`;
-      if (factoryAddress.toLowerCase() !== adapterFactoryAddress) {
-        stats.skippedNotAdapter++;
-        logStatsIfIntervalPassed();
-        continue;
-      }
-
-      let eoaOwner: `0x${string}`;
-      try {
-        eoaOwner = await withTimeout(
-          context.client.readContract({
-            address: owner,
-            abi: AaveV3AdapterHelperAbi,
-            functionName: "owner",
-          }),
-          BLOCK_HANDLER_RPC_TIMEOUT_MS,
-          "settlement:readContract:owner",
-        );
-      } catch (err) {
-        log("warn", "SettlementResolver:readOwner_failed", { chainId, owner, err: err instanceof Error ? err.message : String(err) });
-        continue;
-      }
-
-      await context.db
-        .insert(transaction)
-        .values({
-          hash: item.txHash,
-          chainId,
-          blockNumber: item.blockNumber,
-          blockTimestamp: item.blockTimestamp,
-        })
-        .onConflictDoNothing();
-
-      await context.db
-        .insert(ownerMapping)
-        .values({
-          chainId,
-          address: ownerAddress,
-          owner: eoaOwner.toLowerCase() as `0x${string}`,
-          addressType: AddressType.FlashLoanHelper,
-          txHash: item.txHash,
-          blockNumber: item.blockNumber,
-          resolutionDepth: 1,
-        })
-        .onConflictDoNothing();
-
-      stats.mapped++;
+    if (!factoryData || factoryData.length < 66) {
+      stats.skippedNotAdapter++;
       logStatsIfIntervalPassed();
+      continue;
+    }
 
-      log("info", "SettlementResolver:aave_adapter_mapped", { chainId, adapter: ownerAddress, eoa: eoaOwner.toLowerCase(), block: String(item.blockNumber) });
+    const factoryAddress = `0x${factoryData.slice(26)}` as `0x${string}`;
+    if (factoryAddress.toLowerCase() !== adapterFactoryAddress) {
+      stats.skippedNotAdapter++;
+      logStatsIfIntervalPassed();
+      continue;
     }
 
-    await context.db.delete(settlementQueue, { chainId, txHash: item.txHash });
+    let eoaOwner: `0x${string}`;
+    try {
+      eoaOwner = await withTimeout(
+        context.client.readContract({
+          address: owner,
+          abi: AaveV3AdapterHelperAbi,
+          functionName: "owner",
+        }),
+        BLOCK_HANDLER_RPC_TIMEOUT_MS,
+        "settlement:readContract:owner",
+      );
+    } catch (err) {
+      log("warn", "SettlementResolver:readOwner_failed", { chainId, owner, err: err instanceof Error ? err.message : String(err) });
+      continue;
+    }
 
+    await context.db
+      .insert(transaction)
+      .values({
+        hash: event.transaction.hash,
+        chainId,
+        blockNumber: event.block.number,
+        blockTimestamp: event.block.timestamp,
+      })
+      .onConflictDoNothing();
+
+    await context.db
+      .insert(ownerMapping)
+      .values({
+        chainId,
+        address: ownerAddress,
+        owner: eoaOwner.toLowerCase() as `0x${string}`,
+        addressType: AddressType.FlashLoanHelper,
+        txHash: event.transaction.hash,
+        blockNumber: event.block.number,
+        resolutionDepth: 1,
+      })
+      .onConflictDoNothing();
+
+    stats.mapped++;
     logStatsIfIntervalPassed();
+
+    log("info", "SettlementResolver:aave_adapter_mapped", { chainId, adapter: ownerAddress, eoa: eoaOwner.toLowerCase(), block: String(event.block.number) });
   }
+
+  logStatsIfIntervalPassed();
 });

From bd3f4bbbe2a7f66cdea12418455ca2e40940ee9d Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Mon, 15 Jun 2026 23:02:21 -0300
Subject: [PATCH 64/84] perf: stagger gnosis block handlers with coprime
 intervals (COW-1014)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Assign per-chain prime-number intervals so handlers spread across
different blocks: OrderDiscoveryPoller=7, CandidateConfirmer=6,
OrderStatusTracker=5, CancellationWatcher=11 on chains with blockTime<8s.

LCM(5,6,7,11)=2310 blocks — all four handlers stack on the same gnosis
block only every ~3.2 hours instead of every 5 seconds. Each handler's
window (interval × 5s) now comfortably exceeds its execution time,
keeping the indexer ahead of block production in realtime mode.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 ponder.config.ts | 41 +++++++++++++++++++++++++++++++++--------
 1 file changed, 33 insertions(+), 8 deletions(-)

diff --git a/ponder.config.ts b/ponder.config.ts
index da62fa7..e5fde20 100644
--- a/ponder.config.ts
+++ b/ponder.config.ts
@@ -72,18 +72,25 @@ export default createConfig({
     },
   },
   blocks: {
+    // Block handler intervals use coprime prime numbers per chain so handlers
+    // naturally spread across different blocks and rarely all fire together.
+    // On gnosis (5s blocks) stacking all handlers on the same block causes
+    // ~35s combined execution — longer than the 5s block time, making the
+    // indexer drift behind the chain tip. With coprime intervals the four
+    // handlers all coincide only every LCM(3,5,7,11)=1155 blocks (~96 min).
+    //
+    // Gnosis intervals: OrderDiscoveryPoller=7, CandidateConfirmer=6,
+    //   OrderStatusTracker=5, CancellationWatcher=11.
+    // Mainnet (12s blocks): all interval=1 — handlers comfortably fit within 12s.
+
     // OrderDiscoveryPoller — RPC multicall for non-deterministic generators.
-    // Gnosis interval=4 (~20s) vs mainnet interval=1 (~12s).
-    // The CoW watch-tower processes orders sequentially — with 1,461+ gnosis
-    // generators, a full cycle takes many blocks. Polling every 5s gnosis block
-    // wastes RPC calls since state rarely changes between blocks.
     OrderDiscoveryPoller: {
       chain: Object.fromEntries(
         ACTIVE_CHAINS.map((c) => [
           c.name,
           {
             startBlock: "latest" as const,
-            ...(pollerInterval(c.blockTime) > 1 ? { interval: pollerInterval(c.blockTime) } : {}),
+            ...(c.blockTime < 8 ? { interval: 7 } : {}),
           },
         ]),
       ),
@@ -92,14 +99,26 @@ export default createConfig({
     // CandidateConfirmer — checks API for unconfirmed candidates.
     CandidateConfirmer: {
       chain: Object.fromEntries(
-        ACTIVE_CHAINS.map((c) => [c.name, { startBlock: "latest" as const }]),
+        ACTIVE_CHAINS.map((c) => [
+          c.name,
+          {
+            startBlock: "latest" as const,
+            ...(c.blockTime < 8 ? { interval: 6 } : {}),
+          },
+        ]),
       ),
       interval: 1,
     },
     // OrderStatusTracker — polls API for open discrete order status.
     OrderStatusTracker: {
       chain: Object.fromEntries(
-        ACTIVE_CHAINS.map((c) => [c.name, { startBlock: "latest" as const }]),
+        ACTIVE_CHAINS.map((c) => [
+          c.name,
+          {
+            startBlock: "latest" as const,
+            ...(c.blockTime < 8 ? { interval: 5 } : {}),
+          },
+        ]),
       ),
       interval: 1,
     },
@@ -118,7 +137,13 @@ export default createConfig({
     // blocks; the handler itself is cheap when nothing is due.
     CancellationWatcher: {
       chain: Object.fromEntries(
-        ACTIVE_CHAINS.map((c) => [c.name, { startBlock: "latest" as const }]),
+        ACTIVE_CHAINS.map((c) => [
+          c.name,
+          {
+            startBlock: "latest" as const,
+            ...(c.blockTime < 8 ? { interval: 11 } : {}),
+          },
+        ]),
       ),
       interval: 1,
     },

From e8a3a69633aede89309b88d258a447b986dad7c4 Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Mon, 15 Jun 2026 23:31:29 -0300
Subject: [PATCH 65/84] fix: cap OwnerBackfill page fetch and add max retry
 count (COW-1015)

fetchComposableOrders was calling fetchAccountOrders with no page limit,
causing 30s+ timeouts for owners with thousands of regular ECDSA orders.

Three fixes:
- fetchAccountOrders now accepts signingScheme and pageSize params;
  fetchComposableOrders passes signingScheme=eip1271 (API-level filter)
  and BOOTSTRAP_PAGE_SIZE=25 with BOOTSTRAP_MAX_PAGES=4 (100 orders max)
- OwnerBackfill skips and removes retry-queue entries that have exceeded
  BOOTSTRAP_MAX_RETRY_COUNT (5), logging a warning instead of retrying forever

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 src/application/handlers/blockHandler.ts   | 10 ++++++++++
 src/application/helpers/orderbookClient.ts | 17 +++++++++++-----
 src/constants.ts                           | 23 ++++++++++++++++++++++
 3 files changed, 45 insertions(+), 5 deletions(-)

diff --git a/src/application/handlers/blockHandler.ts b/src/application/handlers/blockHandler.ts
index 33b7c02..28d6bb5 100644
--- a/src/application/handlers/blockHandler.ts
+++ b/src/application/handlers/blockHandler.ts
@@ -24,6 +24,7 @@ import {
 } from "../../data";
 import {
   BLOCK_HANDLER_RPC_TIMEOUT_MS,
+  BOOTSTRAP_MAX_RETRY_COUNT,
   BOOTSTRAP_OWNER_FETCH_TIMEOUT_MS,
   DEFAULT_MAX_DISCRETE_ORDERS_PER_BLOCK,
   DEFAULT_MAX_GENERATORS_PER_BLOCK,
@@ -775,6 +776,15 @@ ponder.on("OwnerBackfill:block", async ({ event, context }) => {
 
   for (const { owner, retryCount } of queued) {
     retriedOwners.add(owner as Hex);
+
+    if (retryCount >= BOOTSTRAP_MAX_RETRY_COUNT) {
+      log("warn", "OwnerBackfill:owner_retry_abandoned", { block: String(currentBlock), chainId, owner, retryCount, maxRetries: BOOTSTRAP_MAX_RETRY_COUNT });
+      await context.db.sql
+        .delete(bootstrapRetryQueue)
+        .where(and(eq(bootstrapRetryQueue.chainId, chainId), eq(bootstrapRetryQueue.owner, owner as Hex)));
+      continue;
+    }
+
     try {
       const orders = await withTimeout(
         fetchComposableOrders(context, chainId, owner as Hex),
diff --git a/src/application/helpers/orderbookClient.ts b/src/application/helpers/orderbookClient.ts
index ce09bce..3c160d2 100644
--- a/src/application/helpers/orderbookClient.ts
+++ b/src/application/helpers/orderbookClient.ts
@@ -23,7 +23,7 @@ import { pgSchema, integer, text } from "drizzle-orm/pg-core";
 import { encodeAbiParameters, keccak256, type Hex } from "viem";
 import { type OrderType } from "../../utils/order-types";
 import { COMPOSABLE_COW_HANDLER_ADDRESSES, ORDERBOOK_API_URLS } from "../../data";
-import { ORDERBOOK_HTTP_TIMEOUT_MS, SIGNING_SCHEME_EIP1271 } from "../../constants";
+import { BOOTSTRAP_MAX_PAGES, BOOTSTRAP_PAGE_SIZE, ORDERBOOK_HTTP_TIMEOUT_MS, SIGNING_SCHEME_EIP1271 } from "../../constants";
 import { decodeEip1271Signature } from "../decoders/erc1271Signature";
 import { fetchWithTimeout, TimeoutError, withTimeout } from "./withTimeout";
 import { log } from "./logger";
@@ -92,7 +92,7 @@ export async function fetchComposableOrders(
   }
 
   log("info", "ob:fetch", { owner, chainId });
-  const allApiOrders = await fetchAccountOrders(apiBaseUrl, owner);
+  const allApiOrders = await fetchAccountOrders(apiBaseUrl, owner, BOOTSTRAP_MAX_PAGES, SIGNING_SCHEME_EIP1271, BOOTSTRAP_PAGE_SIZE);
   const composable = await filterAndProcess(context, chainId, allApiOrders);
 
   if (composable.length === 0) {
@@ -316,11 +316,16 @@ export async function fetchOwnerOrderStatuses(
 
 // ─── API calls ───────────────────────────────────────────────────────────────
 
-/** Fetch orders for an owner with pagination. maxPages limits how many pages are fetched (0 = unlimited). */
+/** Fetch orders for an owner with pagination. maxPages limits how many pages are fetched (0 = unlimited).
+ *  signingScheme, if provided, is appended as a query param — the API filters server-side when supported,
+ *  reducing payload for owners with many ECDSA orders mixed with composable ones.
+ *  pageSize overrides the default PAGE_LIMIT per request. */
 async function fetchAccountOrders(
   apiBaseUrl: string,
   owner: Hex,
   maxPages = 0,
+  signingScheme?: string,
+  pageSize = PAGE_LIMIT,
 ): Promise<OrderbookOrder[]> {
   const allOrders: OrderbookOrder[] = [];
   let offset = 0;
@@ -328,7 +333,9 @@ async function fetchAccountOrders(
 
   // eslint-disable-next-line no-constant-condition
   while (true) {
-    const url = `${apiBaseUrl}/api/v1/account/${owner}/orders?limit=${PAGE_LIMIT}&offset=${offset}`;
+    const params = new URLSearchParams({ limit: String(pageSize), offset: String(offset) });
+    if (signingScheme) params.set("signingScheme", signingScheme);
+    const url = `${apiBaseUrl}/api/v1/account/${owner}/orders?${params.toString()}`;
     try {
       const response = await fetchWithTimeout(
         url,
@@ -343,7 +350,7 @@ async function fetchAccountOrders(
       const page = (await response.json()) as OrderbookOrder[];
       allOrders.push(...page);
       pagesFetched++;
-      if (page.length < PAGE_LIMIT) break; // last page
+      if (page.length < pageSize) break; // last page
       if (maxPages > 0 && pagesFetched >= maxPages) break; // page cap reached
       offset += page.length;
     } catch (err) {
diff --git a/src/constants.ts b/src/constants.ts
index ce3972d..447e39d 100644
--- a/src/constants.ts
+++ b/src/constants.ts
@@ -83,6 +83,29 @@ export const SETTLEMENT_INNER_RPC_TIMEOUT_MS = 5_000;
  */
 export const BOOTSTRAP_OWNER_FETCH_TIMEOUT_MS = 30_000;
 
+/**
+ * Page size used by fetchComposableOrders when calling /account/{owner}/orders.
+ * Small pages (25 orders) keep each HTTP response tiny and fast, avoiding the
+ * per-page ORDERBOOK_HTTP_TIMEOUT_MS budget even for the largest owners.
+ * The regular fetchAccountOrders callers use PAGE_LIMIT=1000.
+ */
+export const BOOTSTRAP_PAGE_SIZE = 25;
+
+/**
+ * Maximum pages fetched from /account/{owner}/orders in fetchComposableOrders.
+ * At BOOTSTRAP_PAGE_SIZE=25 this caps the fetch at 100 orders per owner —
+ * sufficient for any realistic composable-order history since orders are returned
+ * newest-first and composable orders are typically recent.
+ */
+export const BOOTSTRAP_MAX_PAGES = 4;
+
+/**
+ * Maximum number of times OwnerBackfill will retry a timed-out owner across
+ * indexer restarts. After this many consecutive failures the owner is removed
+ * from bootstrap_retry_queue and left to the normal C1/C2 discovery path.
+ */
+export const BOOTSTRAP_MAX_RETRY_COUNT = 5;
+
 /**
  * Maximum number of TWAP parts that precomputeOrderUids will attempt to enumerate.
  * Pathological orders with n > this value skip precompute and fall back to the

From e2068da3659c08d5de509b21d7aa39a5b7f1d5f9 Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Tue, 16 Jun 2026 00:11:58 -0300
Subject: [PATCH 66/84] perf: apply coprime intervals to mainnet block handlers
 (COW-1014)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Mainnet C1 was consuming ~11s of every 12s block window (92% utilization),
starving gnosis of processing time and causing the gnosis lag to grow.

Mainnet intervals: OrderDiscoveryPoller=5, CandidateConfirmer=3,
OrderStatusTracker=2, CancellationWatcher=7.
LCM(2,3,5,7)=210 blocks — all four coincide every ~42 minutes instead
of every block.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 ponder.config.ts | 26 ++++++++++++++------------
 1 file changed, 14 insertions(+), 12 deletions(-)

diff --git a/ponder.config.ts b/ponder.config.ts
index e5fde20..36059e3 100644
--- a/ponder.config.ts
+++ b/ponder.config.ts
@@ -72,16 +72,18 @@ export default createConfig({
     },
   },
   blocks: {
-    // Block handler intervals use coprime prime numbers per chain so handlers
+    // Block handler intervals use coprime numbers per chain so handlers
     // naturally spread across different blocks and rarely all fire together.
-    // On gnosis (5s blocks) stacking all handlers on the same block causes
-    // ~35s combined execution — longer than the 5s block time, making the
-    // indexer drift behind the chain tip. With coprime intervals the four
-    // handlers all coincide only every LCM(3,5,7,11)=1155 blocks (~96 min).
     //
-    // Gnosis intervals: OrderDiscoveryPoller=7, CandidateConfirmer=6,
-    //   OrderStatusTracker=5, CancellationWatcher=11.
-    // Mainnet (12s blocks): all interval=1 — handlers comfortably fit within 12s.
+    // Gnosis (5s blocks): handlers take ~35s combined when stacked — longer than
+    // the block time. Coprime intervals spread them: LCM(5,6,7,11)=2310 blocks
+    // (~3.2h) before all four coincide.
+    //   OrderDiscoveryPoller=7, CandidateConfirmer=6, OrderStatusTracker=5, CancellationWatcher=11
+    //
+    // Mainnet (12s blocks): C1 alone takes ~11s, consuming 92% of the 12s window
+    // and starving gnosis of processing time. Coprime intervals give each handler
+    // a larger window and free cycles for gnosis: LCM(2,3,5,7)=210 blocks (~42min).
+    //   OrderDiscoveryPoller=5, CandidateConfirmer=3, OrderStatusTracker=2, CancellationWatcher=7
 
     // OrderDiscoveryPoller — RPC multicall for non-deterministic generators.
     OrderDiscoveryPoller: {
@@ -90,7 +92,7 @@ export default createConfig({
           c.name,
           {
             startBlock: "latest" as const,
-            ...(c.blockTime < 8 ? { interval: 7 } : {}),
+            ...(c.blockTime < 8 ? { interval: 7 } : { interval: 5 }),
           },
         ]),
       ),
@@ -103,7 +105,7 @@ export default createConfig({
           c.name,
           {
             startBlock: "latest" as const,
-            ...(c.blockTime < 8 ? { interval: 6 } : {}),
+            ...(c.blockTime < 8 ? { interval: 6 } : { interval: 3 }),
           },
         ]),
       ),
@@ -116,7 +118,7 @@ export default createConfig({
           c.name,
           {
             startBlock: "latest" as const,
-            ...(c.blockTime < 8 ? { interval: 5 } : {}),
+            ...(c.blockTime < 8 ? { interval: 5 } : { interval: 2 }),
           },
         ]),
       ),
@@ -141,7 +143,7 @@ export default createConfig({
           c.name,
           {
             startBlock: "latest" as const,
-            ...(c.blockTime < 8 ? { interval: 11 } : {}),
+            ...(c.blockTime < 8 ? { interval: 11 } : { interval: 7 }),
           },
         ]),
       ),

From 62fe4ba4aaa69a2e829d2631ef69c65b7a48a3f3 Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Tue, 16 Jun 2026 00:23:42 -0300
Subject: [PATCH 67/84] =?UTF-8?q?perf:=20uniform=20block=20handler=20inter?=
 =?UTF-8?q?vals=20=E2=80=94=20gnosis=3D10,=20mainnet=3D4=20(COW-1014)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Replace coprime staggering with uniform per-chain intervals. Coprime intervals
fired some handlers too frequently (C3 every 5 blocks on gnosis), pushing total
utilization to 94% — almost no slack.

Uniform intervals reduce total invocations:
  Gnosis  (5s blocks, interval=10): 50s window, ~33s combined → 66% utilization
  Mainnet (12s blocks, interval=4):  48s window, ~22s combined → 46% utilization

Simpler to reason about and more headroom for the indexer to stay ahead
of block production on both chains.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 ponder.config.ts | 33 ++++++++++-----------------------
 1 file changed, 10 insertions(+), 23 deletions(-)

diff --git a/ponder.config.ts b/ponder.config.ts
index 36059e3..faae337 100644
--- a/ponder.config.ts
+++ b/ponder.config.ts
@@ -72,28 +72,21 @@ export default createConfig({
     },
   },
   blocks: {
-    // Block handler intervals use coprime numbers per chain so handlers
-    // naturally spread across different blocks and rarely all fire together.
+    // Block handler intervals are tuned per chain to keep total handler time
+    // well within the available window while reducing unnecessary invocations.
     //
-    // Gnosis (5s blocks): handlers take ~35s combined when stacked — longer than
-    // the block time. Coprime intervals spread them: LCM(5,6,7,11)=2310 blocks
-    // (~3.2h) before all four coincide.
-    //   OrderDiscoveryPoller=7, CandidateConfirmer=6, OrderStatusTracker=5, CancellationWatcher=11
+    // Gnosis  (5s blocks, interval=10): 10×5s=50s window, ~33s combined → 66% utilization
+    // Mainnet (12s blocks, interval=4):  4×12s=48s window, ~22s combined → 46% utilization
     //
-    // Mainnet (12s blocks): C1 alone takes ~11s, consuming 92% of the 12s window
-    // and starving gnosis of processing time. Coprime intervals give each handler
-    // a larger window and free cycles for gnosis: LCM(2,3,5,7)=210 blocks (~42min).
-    //   OrderDiscoveryPoller=5, CandidateConfirmer=3, OrderStatusTracker=2, CancellationWatcher=7
+    // All handlers fire together on the same block every interval blocks.
+    // Simpler and more efficient than coprime staggering.
 
     // OrderDiscoveryPoller — RPC multicall for non-deterministic generators.
     OrderDiscoveryPoller: {
       chain: Object.fromEntries(
         ACTIVE_CHAINS.map((c) => [
           c.name,
-          {
-            startBlock: "latest" as const,
-            ...(c.blockTime < 8 ? { interval: 7 } : { interval: 5 }),
-          },
+          { startBlock: "latest" as const, interval: c.blockTime < 8 ? 10 : 4 },
         ]),
       ),
       interval: 1,
@@ -103,10 +96,7 @@ export default createConfig({
       chain: Object.fromEntries(
         ACTIVE_CHAINS.map((c) => [
           c.name,
-          {
-            startBlock: "latest" as const,
-            ...(c.blockTime < 8 ? { interval: 6 } : { interval: 3 }),
-          },
+          { startBlock: "latest" as const, interval: c.blockTime < 8 ? 10 : 4 },
         ]),
       ),
       interval: 1,
@@ -116,10 +106,7 @@ export default createConfig({
       chain: Object.fromEntries(
         ACTIVE_CHAINS.map((c) => [
           c.name,
-          {
-            startBlock: "latest" as const,
-            ...(c.blockTime < 8 ? { interval: 5 } : { interval: 2 }),
-          },
+          { startBlock: "latest" as const, interval: c.blockTime < 8 ? 10 : 4 },
         ]),
       ),
       interval: 1,
@@ -143,7 +130,7 @@ export default createConfig({
           c.name,
           {
             startBlock: "latest" as const,
-            ...(c.blockTime < 8 ? { interval: 11 } : { interval: 7 }),
+            interval: c.blockTime < 8 ? 10 : 4,
           },
         ]),
       ),

From 66fef8bca3f6665ac288832d4e8598e6810d4d52 Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Tue, 16 Jun 2026 00:37:19 -0300
Subject: [PATCH 68/84] perf: bulk insert precomputed UIDs and cached statuses
 (COW-1016)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Three functions were doing N sequential await insert() calls — one DB
roundtrip per row. For a TWAP with 500 parts this meant 500 × ~28ms =
~14s per event handler, the root cause of 30-55s event blocks growing
the gnosis lag.

- uidPrecompute.ts: collect discreteOrder and candidateDiscreteOrder rows
  into two arrays, then one bulk insert per table with excluded.* in set
- orderbookClient.ts upsertDiscreteOrders: one multi-row upsert with
  excluded.* instead of N individual context.db.insert() calls
- orderbookClient.ts cacheUidStatuses: one multi-row upsert instead of
  N individual inserts with per-row try/catch

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 src/application/helpers/orderbookClient.ts | 101 +++++++++++----------
 src/application/helpers/uidPrecompute.ts   |  88 ++++++++++--------
 2 files changed, 103 insertions(+), 86 deletions(-)

diff --git a/src/application/helpers/orderbookClient.ts b/src/application/helpers/orderbookClient.ts
index 3c160d2..15901df 100644
--- a/src/application/helpers/orderbookClient.ts
+++ b/src/application/helpers/orderbookClient.ts
@@ -18,7 +18,7 @@ import {
   conditionalOrderGenerator,
   discreteOrder,
 } from "ponder:schema";
-import { and, eq, inArray } from "ponder";
+import { and, eq, inArray, sql } from "ponder";
 import { pgSchema, integer, text } from "drizzle-orm/pg-core";
 import { encodeAbiParameters, keccak256, type Hex } from "viem";
 import { type OrderType } from "../../utils/order-types";
@@ -173,32 +173,33 @@ export async function upsertDiscreteOrders(
   chainId: number,
   orders: ComposableOrder[],
 ): Promise<number> {
-  let count = 0;
-  for (const order of orders) {
-    await context.db
-      .insert(discreteOrder)
-      .values({
-        orderUid: order.uid,
-        chainId,
-        conditionalOrderGeneratorId: order.generatorId,
-        status: order.status,
-        sellAmount: order.sellAmount,
-        buyAmount: order.buyAmount,
-        feeAmount: order.feeAmount,
-        validTo: order.validTo,
-        creationDate: order.creationDate,
-        executedSellAmount: order.executedSellAmount,
-        executedBuyAmount: order.executedBuyAmount,
-      })
-      .onConflictDoUpdate({
-        status: order.status,
-        validTo: order.validTo,
-        executedSellAmount: order.executedSellAmount,
-        executedBuyAmount: order.executedBuyAmount,
-      });
-    count++;
-  }
-  return count;
+  if (orders.length === 0) return 0;
+  // One multi-row upsert instead of N individual roundtrips.
+  await context.db.sql
+    .insert(discreteOrder)
+    .values(orders.map((order) => ({
+      orderUid: order.uid,
+      chainId,
+      conditionalOrderGeneratorId: order.generatorId,
+      status: order.status,
+      sellAmount: order.sellAmount,
+      buyAmount: order.buyAmount,
+      feeAmount: order.feeAmount,
+      validTo: order.validTo,
+      creationDate: order.creationDate,
+      executedSellAmount: order.executedSellAmount,
+      executedBuyAmount: order.executedBuyAmount,
+    })))
+    .onConflictDoUpdate({
+      target: [discreteOrder.chainId, discreteOrder.orderUid],
+      set: {
+        status: sql`excluded.status`,
+        validTo: sql`excluded.valid_to`,
+        executedSellAmount: sql`excluded.executed_sell_amount`,
+        executedBuyAmount: sql`excluded.executed_buy_amount`,
+      },
+    });
+  return orders.length;
 }
 
 /**
@@ -560,30 +561,30 @@ async function cacheUidStatuses(
   chainId: number,
   orders: ComposableOrder[],
 ): Promise<void> {
+  if (orders.length === 0) return;
   const now = Math.floor(Date.now() / 1000);
-  for (const order of orders) {
-    try {
-      await context.db.sql
-        .insert(orderUidCache)
-        .values({
-          chainId,
-          orderUid: order.uid,
-          status: order.status,
+  try {
+    // One multi-row upsert instead of N individual roundtrips.
+    await context.db.sql
+      .insert(orderUidCache)
+      .values(orders.map((order) => ({
+        chainId,
+        orderUid: order.uid,
+        status: order.status,
+        fetchedAt: now,
+        executedSellAmount: order.executedSellAmount,
+        executedBuyAmount: order.executedBuyAmount,
+      })))
+      .onConflictDoUpdate({
+        target: [orderUidCache.chainId, orderUidCache.orderUid],
+        set: {
+          status: sql`excluded.status`,
           fetchedAt: now,
-          executedSellAmount: order.executedSellAmount,
-          executedBuyAmount: order.executedBuyAmount,
-        })
-        .onConflictDoUpdate({
-          target: [orderUidCache.chainId, orderUidCache.orderUid],
-          set: {
-            status: order.status,
-            fetchedAt: now,
-            executedSellAmount: order.executedSellAmount,
-            executedBuyAmount: order.executedBuyAmount,
-          },
-        });
-    } catch {
-      // Best-effort cache write
-    }
+          executedSellAmount: sql`excluded.executed_sell_amount`,
+          executedBuyAmount: sql`excluded.executed_buy_amount`,
+        },
+      });
+  } catch {
+    // Best-effort cache write
   }
 }
diff --git a/src/application/helpers/uidPrecompute.ts b/src/application/helpers/uidPrecompute.ts
index 16a3644..a0aeeb9 100644
--- a/src/application/helpers/uidPrecompute.ts
+++ b/src/application/helpers/uidPrecompute.ts
@@ -16,7 +16,7 @@
  */
 
 import type { Hex } from "viem";
-import { and, eq } from "ponder";
+import { and, eq, sql } from "ponder";
 import { candidateDiscreteOrder, conditionalOrderGenerator, discreteOrder } from "ponder:schema";
 import { computeOrderUid, type GPv2OrderData } from "./orderUid";
 import { fetchOrderStatusByUids } from "./orderbookClient";
@@ -104,51 +104,67 @@ export async function precomputeAndDiscover(
   const uids = precomputed.map((o) => o.orderUid);
   const statuses = await fetchOrderStatusByUids(context, chainId, uids);
 
+  // Split into two groups and bulk-insert each — one DB roundtrip per table
+  // instead of N individual inserts (N can be 500+ for large TWAPs).
+  const discreteRows: (typeof discreteOrder.$inferInsert)[] = [];
+  const candidateRows: (typeof candidateDiscreteOrder.$inferInsert)[] = [];
+
   for (const order of precomputed) {
     const statusInfo = statuses.get(order.orderUid);
     const apiStatus = statusInfo?.status as
       "open" | "fulfilled" | "unfilled" | "expired" | "cancelled" | undefined;
 
     if (apiStatus) {
-      await context.db.sql
-        .insert(discreteOrder)
-        .values({
-          orderUid: order.orderUid,
-          chainId,
-          conditionalOrderGeneratorId: generatorEventId,
-          status: apiStatus,
-          sellAmount: order.sellAmount,
-          buyAmount: order.buyAmount,
-          feeAmount: order.feeAmount,
-          validTo: order.validTo,
-          creationDate: blockTimestamp,
-          executedSellAmount: statusInfo?.executedSellAmount ?? null,
-          executedBuyAmount: statusInfo?.executedBuyAmount ?? null,
-        })
-        .onConflictDoUpdate({
-          target: [discreteOrder.chainId, discreteOrder.orderUid],
-          set: { status: apiStatus, validTo: order.validTo },
-        });
+      discreteRows.push({
+        orderUid: order.orderUid,
+        chainId,
+        conditionalOrderGeneratorId: generatorEventId,
+        status: apiStatus,
+        sellAmount: order.sellAmount,
+        buyAmount: order.buyAmount,
+        feeAmount: order.feeAmount,
+        validTo: order.validTo,
+        creationDate: blockTimestamp,
+        executedSellAmount: statusInfo?.executedSellAmount ?? null,
+        executedBuyAmount: statusInfo?.executedBuyAmount ?? null,
+      });
     } else {
-      await context.db.sql
-        .insert(candidateDiscreteOrder)
-        .values({
-          orderUid: order.orderUid,
-          chainId,
-          conditionalOrderGeneratorId: generatorEventId,
-          possibleValidAfterTimestamp: order.possibleValidAfterTimestamp != null
-            ? BigInt(order.possibleValidAfterTimestamp)
-            : null,
-          sellAmount: order.sellAmount,
-          buyAmount: order.buyAmount,
-          feeAmount: order.feeAmount,
-          validTo: order.validTo,
-          creationDate: blockTimestamp,
-        })
-        .onConflictDoNothing();
+      candidateRows.push({
+        orderUid: order.orderUid,
+        chainId,
+        conditionalOrderGeneratorId: generatorEventId,
+        possibleValidAfterTimestamp: order.possibleValidAfterTimestamp != null
+          ? BigInt(order.possibleValidAfterTimestamp)
+          : null,
+        sellAmount: order.sellAmount,
+        buyAmount: order.buyAmount,
+        feeAmount: order.feeAmount,
+        validTo: order.validTo,
+        creationDate: blockTimestamp,
+      });
     }
   }
 
+  if (discreteRows.length > 0) {
+    await context.db.sql
+      .insert(discreteOrder)
+      .values(discreteRows)
+      .onConflictDoUpdate({
+        target: [discreteOrder.chainId, discreteOrder.orderUid],
+        set: {
+          status: sql`excluded.status`,
+          validTo: sql`excluded.valid_to`,
+        },
+      });
+  }
+
+  if (candidateRows.length > 0) {
+    await context.db.sql
+      .insert(candidateDiscreteOrder)
+      .values(candidateRows)
+      .onConflictDoNothing();
+  }
+
   const allTerminal = precomputed.every((o) => {
     const s = statuses.get(o.orderUid)?.status;
     return s === "fulfilled" || s === "expired" || s === "cancelled";

From 2d951d11719c926b3039faaf960a0f99be5c894d Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Tue, 16 Jun 2026 00:43:39 -0300
Subject: [PATCH 69/84] perf: parallelize /by_uids batch fetches in
 fetchOrdersByUids (COW-1016)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Sequential batches of 50 UIDs meant 10 HTTP calls × ~1s = ~10s per
precomputed generator. For 5 ConditionalOrderCreated events in one block,
this stacked to 50s of HTTP wait time.

Fire all chunks with Promise.all so N chunks take the time of the
slowest one (~1s) instead of N × one (~10s for 500 UIDs).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 src/application/helpers/orderbookClient.ts | 65 ++++++++++++----------
 1 file changed, 36 insertions(+), 29 deletions(-)

diff --git a/src/application/helpers/orderbookClient.ts b/src/application/helpers/orderbookClient.ts
index 15901df..994c48b 100644
--- a/src/application/helpers/orderbookClient.ts
+++ b/src/application/helpers/orderbookClient.ts
@@ -367,45 +367,52 @@ async function fetchAccountOrders(
   return allOrders;
 }
 
-/** Batch-fetch orders by UID to refresh status of open orders. Chunks into BATCH_SIZE to avoid HTTP 413. */
+/** Batch-fetch orders by UID to refresh status of open orders.
+ *  Chunks into BATCH_SIZE to avoid HTTP 413, then fires all chunks in parallel
+ *  so N chunks take the time of one instead of N × one. */
 async function fetchOrdersByUids(
   apiBaseUrl: string,
   uids: string[],
 ): Promise<OrderbookOrder[]> {
   if (uids.length === 0) return [];
 
-  const results: OrderbookOrder[] = [];
   const url = `${apiBaseUrl}/api/v1/orders/by_uids`;
-
+  const chunks: string[][] = [];
   for (let i = 0; i < uids.length; i += BATCH_SIZE) {
-    const chunk = uids.slice(i, i + BATCH_SIZE);
-    try {
-      const response = await fetchWithTimeout(
-        url,
-        {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify(chunk),
-        },
-        ORDERBOOK_HTTP_TIMEOUT_MS,
-        "ob:byUids",
-      );
-      if (!response.ok) {
-        log("warn", "ob:batchFetchError", { status: response.status, uids: chunk.length, offset: i });
-        continue;
-      }
-      const raw = (await response.json()) as { order: OrderbookOrder }[];
-      results.push(...raw.flatMap((item) => (item?.order != null ? [item.order] : [])));
-    } catch (err) {
-      if (err instanceof TimeoutError) {
-        log("warn", "ob:batchFetchTimeout", { uids: chunk.length, offset: i, after: ORDERBOOK_HTTP_TIMEOUT_MS });
-        continue;
-      }
-      log("warn", "ob:batchFetchFailed", { err: String(err), offset: i });
-    }
+    chunks.push(uids.slice(i, i + BATCH_SIZE));
   }
 
-  return results;
+  const chunkResults = await Promise.all(
+    chunks.map(async (chunk, idx) => {
+      try {
+        const response = await fetchWithTimeout(
+          url,
+          {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(chunk),
+          },
+          ORDERBOOK_HTTP_TIMEOUT_MS,
+          "ob:byUids",
+        );
+        if (!response.ok) {
+          log("warn", "ob:batchFetchError", { status: response.status, uids: chunk.length, offset: idx * BATCH_SIZE });
+          return [] as OrderbookOrder[];
+        }
+        const raw = (await response.json()) as { order: OrderbookOrder }[];
+        return raw.flatMap((item) => (item?.order != null ? [item.order] : []));
+      } catch (err) {
+        if (err instanceof TimeoutError) {
+          log("warn", "ob:batchFetchTimeout", { uids: chunk.length, offset: idx * BATCH_SIZE, after: ORDERBOOK_HTTP_TIMEOUT_MS });
+          return [] as OrderbookOrder[];
+        }
+        log("warn", "ob:batchFetchFailed", { err: String(err), offset: idx * BATCH_SIZE });
+        return [] as OrderbookOrder[];
+      }
+    }),
+  );
+
+  return chunkResults.flat();
 }
 
 // ─── Processing ──────────────────────────────────────────────────────────────

From 1ec1260949a41f93ac4bb2463b4062291210853f Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Tue, 16 Jun 2026 01:01:11 -0300
Subject: [PATCH 70/84] perf(COW-1018): skip OwnerBackfill for owners already
 bootstrapped with 0 orders

After fetching composable orders for an owner and finding none, mark all
generators for that owner with lastPollResult='bootstrap:noop'. The
OwnerBackfill query now excludes these generators, preventing 30-40s
sequential HTTP fetches from repeating on every indexer restart.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 src/application/handlers/blockHandler.ts | 99 +++++++++++++++++-------
 1 file changed, 70 insertions(+), 29 deletions(-)

diff --git a/src/application/handlers/blockHandler.ts b/src/application/handlers/blockHandler.ts
index 28d6bb5..cf3cda6 100644
--- a/src/application/handlers/blockHandler.ts
+++ b/src/application/handlers/blockHandler.ts
@@ -16,7 +16,7 @@
 
 import { ponder } from "ponder:registry";
 import { bootstrapRetryQueue, candidateDiscreteOrder, conditionalOrderGenerator, discreteOrder, discreteOrderStatusEnum } from "ponder:schema";
-import { and, asc, eq, gt, inArray, isNull, lte, or, sql } from "ponder";
+import { and, asc, eq, gt, inArray, isNull, lte, ne, or, sql } from "ponder";
 import type { Hex } from "viem";
 import {
   COMPOSABLE_COW_ADDRESS_BY_CHAIN_ID,
@@ -771,6 +771,48 @@ ponder.on("OwnerBackfill:block", async ({ event, context }) => {
 
   log("info", "OwnerBackfill:START", { block: String(currentBlock), chainId, pendingRetry: queued.length });
 
+  // Find Active non-deterministic generators with no discrete orders.
+  // Skip generators already bootstrapped with 0 orders on a prior run
+  // (marked lastPollResult='bootstrap:noop') to avoid re-fetching every restart.
+  const generators = await context.db.sql
+    .select({
+      generatorId: conditionalOrderGenerator.eventId,
+      owner: conditionalOrderGenerator.owner,
+      orderType: conditionalOrderGenerator.orderType,
+    })
+    .from(conditionalOrderGenerator)
+    .leftJoin(
+      discreteOrder,
+      and(
+        eq(conditionalOrderGenerator.chainId, discreteOrder.chainId),
+        eq(conditionalOrderGenerator.eventId, discreteOrder.conditionalOrderGeneratorId),
+      ),
+    )
+    .where(
+      and(
+        eq(conditionalOrderGenerator.chainId, chainId),
+        eq(conditionalOrderGenerator.status, "Active"),
+        inArray(conditionalOrderGenerator.orderType, [...NON_DETERMINISTIC_TYPES]),
+        isNull(discreteOrder.orderUid),
+        or(
+          isNull(conditionalOrderGenerator.lastPollResult),
+          ne(conditionalOrderGenerator.lastPollResult, "bootstrap:noop"),
+        ),
+      ),
+    ) as {
+    generatorId: string;
+    owner: Hex;
+    orderType: OrderType;
+  }[];
+
+  // Build owner → generatorIds map for marking owners as bootstrapped after 0-order fetch
+  const ownerGeneratorIds = new Map<Hex, string[]>();
+  for (const gen of generators) {
+    const existing = ownerGeneratorIds.get(gen.owner) ?? [];
+    existing.push(gen.generatorId);
+    ownerGeneratorIds.set(gen.owner, existing);
+  }
+
   let totalDiscovered = 0;
   const retriedOwners = new Set<Hex>();
 
@@ -796,6 +838,9 @@ ponder.on("OwnerBackfill:block", async ({ event, context }) => {
       await context.db.sql
         .delete(bootstrapRetryQueue)
         .where(and(eq(bootstrapRetryQueue.chainId, chainId), eq(bootstrapRetryQueue.owner, owner as Hex)));
+      if (count === 0) {
+        await markOwnerBootstrapped(context, chainId, owner as Hex, ownerGeneratorIds);
+      }
     } catch (err) {
       if (err instanceof TimeoutError) {
         log("warn", "OwnerBackfill:owner_retry_timeout", { block: String(currentBlock), chainId, owner, retryCount: retryCount + 1, timeoutMs: BOOTSTRAP_OWNER_FETCH_TIMEOUT_MS });
@@ -809,34 +854,6 @@ ponder.on("OwnerBackfill:block", async ({ event, context }) => {
     }
   }
 
-  // Find Active non-deterministic generators with no discrete orders
-  const generators = await context.db.sql
-    .select({
-      generatorId: conditionalOrderGenerator.eventId,
-      owner: conditionalOrderGenerator.owner,
-      orderType: conditionalOrderGenerator.orderType,
-    })
-    .from(conditionalOrderGenerator)
-    .leftJoin(
-      discreteOrder,
-      and(
-        eq(conditionalOrderGenerator.chainId, discreteOrder.chainId),
-        eq(conditionalOrderGenerator.eventId, discreteOrder.conditionalOrderGeneratorId),
-      ),
-    )
-    .where(
-      and(
-        eq(conditionalOrderGenerator.chainId, chainId),
-        eq(conditionalOrderGenerator.status, "Active"),
-        inArray(conditionalOrderGenerator.orderType, [...NON_DETERMINISTIC_TYPES]),
-        isNull(discreteOrder.orderUid),
-      ),
-    ) as {
-    generatorId: string;
-    owner: Hex;
-    orderType: OrderType;
-  }[];
-
   // Exclude owners already retried above — they were just attempted this run
   const freshOwners = new Set(generators.map((g) => g.owner).filter((o) => !retriedOwners.has(o)));
 
@@ -858,6 +875,9 @@ ponder.on("OwnerBackfill:block", async ({ event, context }) => {
       );
       const count = await upsertDiscreteOrders(context, chainId, orders);
       totalDiscovered += count;
+      if (count === 0) {
+        await markOwnerBootstrapped(context, chainId, owner, ownerGeneratorIds);
+      }
     } catch (err) {
       if (err instanceof TimeoutError) {
         log("warn", "OwnerBackfill:owner_timeout", { block: String(currentBlock), chainId, owner, timeoutMs: BOOTSTRAP_OWNER_FETCH_TIMEOUT_MS });
@@ -1008,6 +1028,27 @@ ponder.on("CancellationWatcher:block", async ({ event, context }) => {
 
 // ─── Shared helpers ──────────────────────────────────────────────────────────
 
+async function markOwnerBootstrapped(
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  context: any,
+  chainId: number,
+  owner: Hex,
+  ownerGeneratorIds: Map<Hex, string[]>,
+): Promise<void> {
+  const genIds = ownerGeneratorIds.get(owner) ?? [];
+  if (genIds.length === 0) return;
+  await context.db.sql
+    .update(conditionalOrderGenerator)
+    .set({ lastPollResult: "bootstrap:noop" })
+    .where(
+      and(
+        eq(conditionalOrderGenerator.chainId, chainId),
+        inArray(conditionalOrderGenerator.eventId, genIds),
+      ),
+    );
+  log("info", "OwnerBackfill:owner_noop", { chainId, owner, generators: genIds.length });
+}
+
 async function updateGeneratorPollState(
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   context: any,

From 7ef493c64fff47c37cb15b578e6133668741fd10 Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Tue, 16 Jun 2026 01:04:29 -0300
Subject: [PATCH 71/84] fix(deploy): write .env to parent dir to match deploy
 script expectation

The deploy script receives ../.env as the env file path, expecting the
file one level above the repo root. The workflow was writing it to the
repo root (.env) instead, causing scp to fail with 'no such file'.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .github/workflows/deploy.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
index 4e8bfc7..bc3c34c 100644
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -54,7 +54,7 @@ jobs:
 
       - name: Create .env file
         run: |
-          echo "${{ secrets.DEPLOY_ENV_FILE_CONTENT }}" > .env
+          echo "${{ secrets.DEPLOY_ENV_FILE_CONTENT }}" > ../.env
 
       - name: Run deploy script
         run: npx tsx deployment/deploy-remotely.ts cow-deploy:${{ secrets.DEPLOY_PATH }} ../.env

From fe48bf27d2d3fc35f8c878c94ef0fa916d89102b Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Tue, 16 Jun 2026 01:06:15 -0300
Subject: [PATCH 72/84] fix(deploy): use bash login shell for SSH so NVM
 Node.js is in PATH

Non-interactive SSH sessions don't source the user's profile, so npx
is not found when Node.js is installed via NVM. bash -lc sources login
profile and makes the node/npx binaries available.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 deployment/deploy-remotely.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/deployment/deploy-remotely.ts b/deployment/deploy-remotely.ts
index 37c9a53..6218726 100644
--- a/deployment/deploy-remotely.ts
+++ b/deployment/deploy-remotely.ts
@@ -116,9 +116,10 @@ if (deployTarget === "-") {
   // Note: The remote host must have Node 18+ and pnpm installed.
   // After the first deploy, run `pnpm install` on the remote to install tsx.
   const remoteDeployDir = `${remotePath}/deployment`;
+  // Use bash login shell so NVM / system Node.js is in PATH on the remote host.
   run("ssh", [
     sshHost,
-    `cd ${remoteDeployDir} && npx tsx manage.ts ${manageCmd} --env-file .env --revision ${appRevision}`,
+    `bash -lc "cd ${remoteDeployDir} && npx tsx manage.ts ${manageCmd} --env-file .env --revision ${appRevision}"`,
   ]);
 } else {
   console.error(

From 09318a05e93a14f64e96684dc11c26e67e21f7fb Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Tue, 16 Jun 2026 01:08:32 -0300
Subject: [PATCH 73/84] fix(deploy): run docker commands via SSH instead of
 manage.ts on server

manage.ts requires Node.js on the remote host which is not installed.
Rewrite the deploy workflow to run docker compose commands directly via
SSH, loading env from the .env file already scp'd to the server.
deploy-remotely.ts kept for local deploys; only the CI workflow changed.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .github/workflows/deploy.yml | 63 ++++++++++++++++++++++++++++--------
 1 file changed, 49 insertions(+), 14 deletions(-)

diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
index bc3c34c..5b434eb 100644
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -19,18 +19,6 @@ jobs:
       - name: Checkout code
         uses: actions/checkout@v4
 
-      - uses: pnpm/action-setup@v4
-        with:
-          version: 10
-
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 20
-          cache: pnpm
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
       - name: Set up SSH key
         run: |
           mkdir -p ~/.ssh
@@ -56,5 +44,52 @@ jobs:
         run: |
           echo "${{ secrets.DEPLOY_ENV_FILE_CONTENT }}" > ../.env
 
-      - name: Run deploy script
-        run: npx tsx deployment/deploy-remotely.ts cow-deploy:${{ secrets.DEPLOY_PATH }} ../.env
+      - name: Rsync source files
+        run: |
+          rsync -avz --delete --mkpath \
+            --exclude=.git \
+            --exclude=node_modules \
+            --exclude=.env \
+            --exclude=.env.local \
+            --exclude=.vite \
+            --exclude='*.log' \
+            --exclude=tmp/ \
+            ./ cow-deploy:${{ secrets.DEPLOY_PATH }}/
+
+      - name: Copy env file to server
+        run: |
+          scp ../.env cow-deploy:${{ secrets.DEPLOY_PATH }}/deployment/.env
+
+      - name: Deploy via docker on server
+        env:
+          DEPLOY_PATH: ${{ secrets.DEPLOY_PATH }}
+        run: |
+          REVISION=$(git rev-parse --short HEAD)
+
+          # Source env locally just to read PROJECT_PREFIX and DB connection info
+          set -a; source ../.env; set +a
+
+          REMOTE_DIR="${DEPLOY_PATH}"
+          DB_CONTAINER="${PROJECT_PREFIX}-db"
+          REMOTE_ENV="${REMOTE_DIR}/deployment/.env"
+          # docker compose reads PROJECT_PREFIX from --env-file; supply APP_REVISION + DATABASE_SCHEMA inline
+          DC="docker compose -p ${PROJECT_PREFIX} -f ${REMOTE_DIR}/docker-compose.yml --env-file ${REMOTE_ENV} --profile deploy"
+
+          echo ">>> Stopping ponder container..."
+          ssh cow-deploy "${DC} stop ponder" || true
+
+          echo ">>> Dropping app schema..."
+          ssh cow-deploy "docker exec ${DB_CONTAINER} \
+            psql -U ${POSTGRES_USER:-postgres} -d ${POSTGRES_DB:-programmatic-orders} \
+            -c 'DROP SCHEMA IF EXISTS \"programmatic_orders\" CASCADE'" || true
+
+          echo ">>> Building new image (revision=${REVISION})..."
+          ssh cow-deploy "APP_REVISION=${REVISION} DATABASE_SCHEMA=programmatic_orders ${DC} build --no-cache"
+
+          echo ">>> Starting containers..."
+          ssh cow-deploy "APP_REVISION=${REVISION} DATABASE_SCHEMA=programmatic_orders ${DC} up -d --remove-orphans"
+
+          echo ">>> Pruning old images..."
+          ssh cow-deploy "docker image prune -f && docker container prune -f" || true
+
+          echo ">>> Deploy complete (revision=${REVISION})."

From ba712be2f29d6d02d4117cfb09fb6047a37c3646 Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Tue, 16 Jun 2026 01:10:47 -0300
Subject: [PATCH 74/84] fix(deploy): use docker compose rm -sf instead of stop
 to clear container

'stop' leaves the container in stopped state; the subsequent 'up' then
fails with a name conflict. 'rm -sf' stops and removes it so 'up' can
create a fresh container with the new image.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .github/workflows/deploy.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
index 5b434eb..7301bc7 100644
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -75,8 +75,8 @@ jobs:
           # docker compose reads PROJECT_PREFIX from --env-file; supply APP_REVISION + DATABASE_SCHEMA inline
           DC="docker compose -p ${PROJECT_PREFIX} -f ${REMOTE_DIR}/docker-compose.yml --env-file ${REMOTE_ENV} --profile deploy"
 
-          echo ">>> Stopping ponder container..."
-          ssh cow-deploy "${DC} stop ponder" || true
+          echo ">>> Stopping and removing ponder container..."
+          ssh cow-deploy "${DC} rm -sf ponder" || true
 
           echo ">>> Dropping app schema..."
           ssh cow-deploy "docker exec ${DB_CONTAINER} \

From c152804b7b638d7d3d48d1988c1796af85d3c17f Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Tue, 16 Jun 2026 01:13:33 -0300
Subject: [PATCH 75/84] fix(deploy): forcefully remove all ponder containers by
 name pattern

The old container may have been started with docker run rather than
docker compose, making 'docker compose rm' a no-op. Grep running and
stopped containers by name prefix and force-remove them before rebuild.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .github/workflows/deploy.yml | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
index 7301bc7..9b952da 100644
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -75,8 +75,10 @@ jobs:
           # docker compose reads PROJECT_PREFIX from --env-file; supply APP_REVISION + DATABASE_SCHEMA inline
           DC="docker compose -p ${PROJECT_PREFIX} -f ${REMOTE_DIR}/docker-compose.yml --env-file ${REMOTE_ENV} --profile deploy"
 
-          echo ">>> Stopping and removing ponder container..."
-          ssh cow-deploy "${DC} rm -sf ponder" || true
+          echo ">>> Stopping and removing any existing ponder containers..."
+          # Remove any container whose name matches the ponder service pattern,
+          # regardless of how it was originally started (docker run vs docker compose).
+          ssh cow-deploy "docker ps -a --format '{{.Names}}' | grep -E '^${PROJECT_PREFIX}-ponder' | xargs -r docker rm -f" || true
 
           echo ">>> Dropping app schema..."
           ssh cow-deploy "docker exec ${DB_CONTAINER} \

From 7868aa30a4a2e095b17756bae4df50dffbb7cdba Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Tue, 16 Jun 2026 01:04:29 -0300
Subject: [PATCH 76/84] fix(deploy): write .env to parent dir to match deploy
 script expectation

The deploy script receives ../.env as the env file path, expecting the
file one level above the repo root. The workflow was writing it to the
repo root (.env) instead, causing scp to fail with 'no such file'.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .github/workflows/deploy.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
index 4e8bfc7..bc3c34c 100644
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -54,7 +54,7 @@ jobs:
 
       - name: Create .env file
         run: |
-          echo "${{ secrets.DEPLOY_ENV_FILE_CONTENT }}" > .env
+          echo "${{ secrets.DEPLOY_ENV_FILE_CONTENT }}" > ../.env
 
       - name: Run deploy script
         run: npx tsx deployment/deploy-remotely.ts cow-deploy:${{ secrets.DEPLOY_PATH }} ../.env

From ac1fc6aa9697b86148107f2194d3b541d025bd1b Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Tue, 16 Jun 2026 01:06:15 -0300
Subject: [PATCH 77/84] fix(deploy): use bash login shell for SSH so NVM
 Node.js is in PATH

Non-interactive SSH sessions don't source the user's profile, so npx
is not found when Node.js is installed via NVM. bash -lc sources login
profile and makes the node/npx binaries available.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 deployment/deploy-remotely.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/deployment/deploy-remotely.ts b/deployment/deploy-remotely.ts
index 37c9a53..6218726 100644
--- a/deployment/deploy-remotely.ts
+++ b/deployment/deploy-remotely.ts
@@ -116,9 +116,10 @@ if (deployTarget === "-") {
   // Note: The remote host must have Node 18+ and pnpm installed.
   // After the first deploy, run `pnpm install` on the remote to install tsx.
   const remoteDeployDir = `${remotePath}/deployment`;
+  // Use bash login shell so NVM / system Node.js is in PATH on the remote host.
   run("ssh", [
     sshHost,
-    `cd ${remoteDeployDir} && npx tsx manage.ts ${manageCmd} --env-file .env --revision ${appRevision}`,
+    `bash -lc "cd ${remoteDeployDir} && npx tsx manage.ts ${manageCmd} --env-file .env --revision ${appRevision}"`,
   ]);
 } else {
   console.error(

From 6414f2b37161a4a1aa5503ee4950a9183db2e7d8 Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Tue, 16 Jun 2026 01:08:32 -0300
Subject: [PATCH 78/84] fix(deploy): run docker commands via SSH instead of
 manage.ts on server

manage.ts requires Node.js on the remote host which is not installed.
Rewrite the deploy workflow to run docker compose commands directly via
SSH, loading env from the .env file already scp'd to the server.
deploy-remotely.ts kept for local deploys; only the CI workflow changed.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .github/workflows/deploy.yml | 63 ++++++++++++++++++++++++++++--------
 1 file changed, 49 insertions(+), 14 deletions(-)

diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
index bc3c34c..5b434eb 100644
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -19,18 +19,6 @@ jobs:
       - name: Checkout code
         uses: actions/checkout@v4
 
-      - uses: pnpm/action-setup@v4
-        with:
-          version: 10
-
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 20
-          cache: pnpm
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
       - name: Set up SSH key
         run: |
           mkdir -p ~/.ssh
@@ -56,5 +44,52 @@ jobs:
         run: |
           echo "${{ secrets.DEPLOY_ENV_FILE_CONTENT }}" > ../.env
 
-      - name: Run deploy script
-        run: npx tsx deployment/deploy-remotely.ts cow-deploy:${{ secrets.DEPLOY_PATH }} ../.env
+      - name: Rsync source files
+        run: |
+          rsync -avz --delete --mkpath \
+            --exclude=.git \
+            --exclude=node_modules \
+            --exclude=.env \
+            --exclude=.env.local \
+            --exclude=.vite \
+            --exclude='*.log' \
+            --exclude=tmp/ \
+            ./ cow-deploy:${{ secrets.DEPLOY_PATH }}/
+
+      - name: Copy env file to server
+        run: |
+          scp ../.env cow-deploy:${{ secrets.DEPLOY_PATH }}/deployment/.env
+
+      - name: Deploy via docker on server
+        env:
+          DEPLOY_PATH: ${{ secrets.DEPLOY_PATH }}
+        run: |
+          REVISION=$(git rev-parse --short HEAD)
+
+          # Source env locally just to read PROJECT_PREFIX and DB connection info
+          set -a; source ../.env; set +a
+
+          REMOTE_DIR="${DEPLOY_PATH}"
+          DB_CONTAINER="${PROJECT_PREFIX}-db"
+          REMOTE_ENV="${REMOTE_DIR}/deployment/.env"
+          # docker compose reads PROJECT_PREFIX from --env-file; supply APP_REVISION + DATABASE_SCHEMA inline
+          DC="docker compose -p ${PROJECT_PREFIX} -f ${REMOTE_DIR}/docker-compose.yml --env-file ${REMOTE_ENV} --profile deploy"
+
+          echo ">>> Stopping ponder container..."
+          ssh cow-deploy "${DC} stop ponder" || true
+
+          echo ">>> Dropping app schema..."
+          ssh cow-deploy "docker exec ${DB_CONTAINER} \
+            psql -U ${POSTGRES_USER:-postgres} -d ${POSTGRES_DB:-programmatic-orders} \
+            -c 'DROP SCHEMA IF EXISTS \"programmatic_orders\" CASCADE'" || true
+
+          echo ">>> Building new image (revision=${REVISION})..."
+          ssh cow-deploy "APP_REVISION=${REVISION} DATABASE_SCHEMA=programmatic_orders ${DC} build --no-cache"
+
+          echo ">>> Starting containers..."
+          ssh cow-deploy "APP_REVISION=${REVISION} DATABASE_SCHEMA=programmatic_orders ${DC} up -d --remove-orphans"
+
+          echo ">>> Pruning old images..."
+          ssh cow-deploy "docker image prune -f && docker container prune -f" || true
+
+          echo ">>> Deploy complete (revision=${REVISION})."

From cbc2142c9033987b97605504128b97b681ae3a8a Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Tue, 16 Jun 2026 01:10:47 -0300
Subject: [PATCH 79/84] fix(deploy): use docker compose rm -sf instead of stop
 to clear container

'stop' leaves the container in stopped state; the subsequent 'up' then
fails with a name conflict. 'rm -sf' stops and removes it so 'up' can
create a fresh container with the new image.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .github/workflows/deploy.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
index 5b434eb..7301bc7 100644
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -75,8 +75,8 @@ jobs:
           # docker compose reads PROJECT_PREFIX from --env-file; supply APP_REVISION + DATABASE_SCHEMA inline
           DC="docker compose -p ${PROJECT_PREFIX} -f ${REMOTE_DIR}/docker-compose.yml --env-file ${REMOTE_ENV} --profile deploy"
 
-          echo ">>> Stopping ponder container..."
-          ssh cow-deploy "${DC} stop ponder" || true
+          echo ">>> Stopping and removing ponder container..."
+          ssh cow-deploy "${DC} rm -sf ponder" || true
 
           echo ">>> Dropping app schema..."
           ssh cow-deploy "docker exec ${DB_CONTAINER} \

From 726bd202bc19c5d67d2ccf4de3462b3a559f4800 Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Tue, 16 Jun 2026 01:13:33 -0300
Subject: [PATCH 80/84] fix(deploy): forcefully remove all ponder containers by
 name pattern

The old container may have been started with docker run rather than
docker compose, making 'docker compose rm' a no-op. Grep running and
stopped containers by name prefix and force-remove them before rebuild.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .github/workflows/deploy.yml | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
index 7301bc7..9b952da 100644
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -75,8 +75,10 @@ jobs:
           # docker compose reads PROJECT_PREFIX from --env-file; supply APP_REVISION + DATABASE_SCHEMA inline
           DC="docker compose -p ${PROJECT_PREFIX} -f ${REMOTE_DIR}/docker-compose.yml --env-file ${REMOTE_ENV} --profile deploy"
 
-          echo ">>> Stopping and removing ponder container..."
-          ssh cow-deploy "${DC} rm -sf ponder" || true
+          echo ">>> Stopping and removing any existing ponder containers..."
+          # Remove any container whose name matches the ponder service pattern,
+          # regardless of how it was originally started (docker run vs docker compose).
+          ssh cow-deploy "docker ps -a --format '{{.Names}}' | grep -E '^${PROJECT_PREFIX}-ponder' | xargs -r docker rm -f" || true
 
           echo ">>> Dropping app schema..."
           ssh cow-deploy "docker exec ${DB_CONTAINER} \

From 3bdebfa3507c304fa20fa3228b463d96f0da69fc Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Tue, 16 Jun 2026 01:18:27 -0300
Subject: [PATCH 81/84] chore: add temporary server monitoring workflow

---
 .github/workflows/monitor.yml | 37 +++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 .github/workflows/monitor.yml

diff --git a/.github/workflows/monitor.yml b/.github/workflows/monitor.yml
new file mode 100644
index 0000000..484ef4a
--- /dev/null
+++ b/.github/workflows/monitor.yml
@@ -0,0 +1,37 @@
+name: Monitor Server (temporary)
+
+on:
+  workflow_dispatch:
+
+jobs:
+  monitor:
+    name: Check indexer status
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    steps:
+      - name: Set up SSH key
+        run: |
+          mkdir -p ~/.ssh
+          echo "${{ secrets.DEPLOY_SSH_PRIVATE_KEY }}" > ~/.ssh/id_ed25519
+          chmod 600 ~/.ssh/id_ed25519
+
+      - name: Set up SSH config
+        run: |
+          cat <<EOF > ~/.ssh/config
+          Host cow-deploy
+              HostName ${{ secrets.DEPLOY_SERVER_HOST }}
+              User ${{ secrets.DEPLOY_SERVER_USER }}
+              Port 22
+              IdentityFile ~/.ssh/id_ed25519
+              StrictHostKeyChecking no
+              ServerAliveInterval 30
+          EOF
+          chmod 600 ~/.ssh/config
+
+      - name: Check running containers
+        run: ssh cow-deploy "docker ps --format 'table {{.Names}}\t{{.Status}}\t{{.Image}}'"
+
+      - name: Check recent ponder logs
+        run: |
+          ssh cow-deploy "docker logs --since 3m --tail 80 cow-programmatic-ponder-1 2>&1" || \
+          ssh cow-deploy "docker ps -a --format '{{.Names}}' | grep ponder | head -1 | xargs -r docker logs --since 3m --tail 80 2>&1"

From 55712a03a968320e5d9e72b7bc8ed7dd265972dd Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Tue, 16 Jun 2026 01:45:41 -0300
Subject: [PATCH 82/84] chore: add monitor_only mode to deploy workflow for
 status checks

---
 .github/workflows/deploy.yml | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
index 9b952da..22334f0 100644
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -6,6 +6,12 @@ concurrency:
 
 on:
   workflow_dispatch:
+    inputs:
+      monitor_only:
+        description: 'Only check server status — do NOT deploy'
+        required: false
+        default: 'false'
+        type: boolean
   push:
     branches:
       - main
@@ -41,10 +47,12 @@ jobs:
           chmod 600 ~/.ssh/config
 
       - name: Create .env file
+        if: inputs.monitor_only != 'true'
         run: |
           echo "${{ secrets.DEPLOY_ENV_FILE_CONTENT }}" > ../.env
 
       - name: Rsync source files
+        if: inputs.monitor_only != 'true'
         run: |
           rsync -avz --delete --mkpath \
             --exclude=.git \
@@ -57,10 +65,12 @@ jobs:
             ./ cow-deploy:${{ secrets.DEPLOY_PATH }}/
 
       - name: Copy env file to server
+        if: inputs.monitor_only != 'true'
         run: |
           scp ../.env cow-deploy:${{ secrets.DEPLOY_PATH }}/deployment/.env
 
       - name: Deploy via docker on server
+        if: inputs.monitor_only != 'true'
         env:
           DEPLOY_PATH: ${{ secrets.DEPLOY_PATH }}
         run: |
@@ -95,3 +105,22 @@ jobs:
           ssh cow-deploy "docker image prune -f && docker container prune -f" || true
 
           echo ">>> Deploy complete (revision=${REVISION})."
+
+      - name: Check server status
+        if: inputs.monitor_only == 'true'
+        run: |
+          echo "=== Running containers ==="
+          ssh cow-deploy "docker ps --format 'table {{.Names}}\t{{.Status}}\t{{.Image}}'"
+
+          echo ""
+          echo "=== Last 100 ponder log lines ==="
+          ssh cow-deploy "
+            CONTAINER=\$(docker ps --format '{{.Names}}' | grep ponder | head -1)
+            if [ -z \"\$CONTAINER\" ]; then
+              echo 'WARNING: No running ponder container found'
+              docker ps -a --format 'table {{.Names}}\t{{.Status}}' | grep -i ponder || echo 'No ponder containers at all'
+            else
+              echo \"Container: \$CONTAINER\"
+              docker logs --tail 100 \"\$CONTAINER\" 2>&1
+            fi
+          "

From b92bfba43bc10f5149c9219393d258690c30c247 Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Tue, 16 Jun 2026 01:49:08 -0300
Subject: [PATCH 83/84] fix(deploy): use string type for monitor_only input to
 fix boolean comparison

---
 .github/workflows/deploy.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
index 22334f0..ac66f70 100644
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -8,10 +8,10 @@ on:
   workflow_dispatch:
     inputs:
       monitor_only:
-        description: 'Only check server status — do NOT deploy'
+        description: "Set to 'true' to only check server status without deploying"
         required: false
         default: 'false'
-        type: boolean
+        type: string
   push:
     branches:
       - main

From 89358c71407100ac506f20af06957e771c8b323b Mon Sep 17 00:00:00 2001
From: Luiz Gustavo Abou Hatem de Liz <luizgustavoahsc@gmail.com>
Date: Tue, 16 Jun 2026 04:00:16 -0300
Subject: [PATCH 84/84] fix(COW-1019): chunk bulk inserts to avoid
 node-postgres bind param overflow
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Large TWAPs (e.g. 3277 parts × 9 cols = 29,493 params) cause
node-postgres to silently drop bind parameters, generating:
  "bind message has 29493 parameter formats but 0 parameters"
This stalls the indexer indefinitely on the affected block.

Fix: chunk candidateRows and discreteRows at 500 rows per INSERT so
each query stays well under the practical ~29k parameter limit.

Also:
- Add PONDER_EXPERIMENTAL_DB=platform to docker-compose.yml so future
  deploys can resume from existing checkpoints without a schema drop
- Add skip_schema_drop input to deploy workflow for hot-fix deploys

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .github/workflows/deploy.yml             | 18 ++++++++++++++----
 docker-compose.yml                       |  5 +++++
 src/application/helpers/uidPrecompute.ts | 13 +++++++++----
 3 files changed, 28 insertions(+), 8 deletions(-)

diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
index 9b952da..7811ff7 100644
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -6,6 +6,12 @@ concurrency:
 
 on:
   workflow_dispatch:
+    inputs:
+      skip_schema_drop:
+        description: "Set to 'true' to deploy without dropping the schema (preserves re-index progress)"
+        required: false
+        default: 'false'
+        type: string
   push:
     branches:
       - main
@@ -80,10 +86,14 @@ jobs:
           # regardless of how it was originally started (docker run vs docker compose).
           ssh cow-deploy "docker ps -a --format '{{.Names}}' | grep -E '^${PROJECT_PREFIX}-ponder' | xargs -r docker rm -f" || true
 
-          echo ">>> Dropping app schema..."
-          ssh cow-deploy "docker exec ${DB_CONTAINER} \
-            psql -U ${POSTGRES_USER:-postgres} -d ${POSTGRES_DB:-programmatic-orders} \
-            -c 'DROP SCHEMA IF EXISTS \"programmatic_orders\" CASCADE'" || true
+          if [ "${{ inputs.skip_schema_drop }}" != "true" ]; then
+            echo ">>> Dropping app schema..."
+            ssh cow-deploy "docker exec ${DB_CONTAINER} \
+              psql -U ${POSTGRES_USER:-postgres} -d ${POSTGRES_DB:-programmatic-orders} \
+              -c 'DROP SCHEMA IF EXISTS \"programmatic_orders\" CASCADE'" || true
+          else
+            echo ">>> Skipping schema drop — will resume from existing checkpoint (PONDER_EXPERIMENTAL_DB=platform)."
+          fi
 
           echo ">>> Building new image (revision=${REVISION})..."
           ssh cow-deploy "APP_REVISION=${REVISION} DATABASE_SCHEMA=programmatic_orders ${DC} build --no-cache"
diff --git a/docker-compose.yml b/docker-compose.yml
index e721c4d..0155a9c 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -52,6 +52,11 @@ services:
       # Add a new chain's RPC URL env var here when enabling it in src/chains/index.ts
       DISABLE_POLL_RESULT_CHECK: ${DISABLE_POLL_RESULT_CHECK:-false}
       DISABLE_SETTLEMENT_FACTORY_CHECK: ${DISABLE_SETTLEMENT_FACTORY_CHECK:-false}
+      # Skip Ponder build_id ownership check so config/handler changes can deploy
+      # without forcing a full re-index. Safe to set permanently — on a fresh schema
+      # (after drop) it's a no-op; on an existing schema it allows resuming from the
+      # last checkpoint rather than wiping and starting over.
+      PONDER_EXPERIMENTAL_DB: "platform"
     ports:
       - "${PONDER_EXPOSED_PORT:-40000}:3000"
     depends_on:
diff --git a/src/application/helpers/uidPrecompute.ts b/src/application/helpers/uidPrecompute.ts
index a0aeeb9..e26a972 100644
--- a/src/application/helpers/uidPrecompute.ts
+++ b/src/application/helpers/uidPrecompute.ts
@@ -145,10 +145,15 @@ export async function precomputeAndDiscover(
     }
   }
 
-  if (discreteRows.length > 0) {
+  // node-postgres silently drops parameter bindings above ~29k params, causing a
+  // "bind message has N parameter formats but 0 parameters" error.  Chunk at 500
+  // rows to keep each insert well under that threshold (500×12=6k params max).
+  const CHUNK = 500;
+
+  for (let i = 0; i < discreteRows.length; i += CHUNK) {
     await context.db.sql
       .insert(discreteOrder)
-      .values(discreteRows)
+      .values(discreteRows.slice(i, i + CHUNK))
       .onConflictDoUpdate({
         target: [discreteOrder.chainId, discreteOrder.orderUid],
         set: {
@@ -158,10 +163,10 @@ export async function precomputeAndDiscover(
       });
   }
 
-  if (candidateRows.length > 0) {
+  for (let i = 0; i < candidateRows.length; i += CHUNK) {
     await context.db.sql
       .insert(candidateDiscreteOrder)
-      .values(candidateRows)
+      .values(candidateRows.slice(i, i + CHUNK))
       .onConflictDoNothing();
   }