diff --git a/.claude/commands/debug-ponder.md b/.claude/commands/debug-ponder.md
index bac77f3..5271188 100644
--- a/.claude/commands/debug-ponder.md
+++ b/.claude/commands/debug-ponder.md
@@ -6,6 +6,30 @@ Analyze `ponder.log` to diagnose indexer issues. Run after `pnpm dev --disable-u
 
 **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 are:
+
+| 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 |
+
 ---
 
 ## Investigation Steps
@@ -15,39 +39,42 @@ Run all steps before reporting. If a step returns nothing, note it explicitly 
 ### Step 1 — Fatal errors
 
 ```bash
-grep -n "ERROR" ponder.log | head -40
+# 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" ponder.log | head -1
+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\|console.warn\|\[ComposableCow\].*failed\|\[ComposableCow\].*Unknown" ponder.log | head -40
+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
+grep -n "composableCow:" ponder.log | tail -30
 ```
 
 Healthy output looks like:
-```
-[ComposableCow] ConditionalOrderCreated event=... orderType=TWAP block=...
-[ComposableCow] Decoded event=... orderType=TWAP decodedParams=ok
+```json
+{"level":"info","msg":"composableCow:created","event":"...","chainId":1,"orderType":"TWAP","block":"..."}
+{"level":"info","msg":"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`
+- `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
 
@@ -55,7 +82,7 @@ Red flags:
 grep -n "INFO\|WARN\|ERROR" ponder.log | head -20
 ```
 
-Healthy startup sequence:
+These are Ponder's own framework lines (bare-word format). Healthy startup sequence:
 ```
 INFO  Connected to database
 INFO  Connected to JSON-RPC
@@ -107,158 +134,130 @@ After running all steps, output:
 
 ## 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.
+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 "\[COW:PRECOMPUTE\] SKIP" ponder.log | head -20
+grep -n "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:
+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 |
 |--------|---------|-----|
 | `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 |
+| `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.
+**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 "\[COW:PRECOMPUTE\] SKIP" ponder.log
+grep -c "precompute:skip" ponder.log
 ```
 
-### Verify deterministic types are NOT in C1
+The counterpart success log is `precompute:allTerminal` (all UIDs for a generator precomputed up front):
+
+```bash
+grep -c "precompute:allTerminal" ponder.log
+```
 
-After precompute fixes, C1 should only poll non-deterministic types. Check if C1 success lines show TWAP/StopLoss (they shouldn't):
+### Verify deterministic types are NOT in OrderDiscoveryPoller
+
+After precompute fixes, OrderDiscoveryPoller should only poll non-deterministic types. Inspect recent OrderDiscoveryPoller DONE lines on gnosis:
 
 ```bash
-grep "\[COW:C1\] DONE" ponder.log | grep 'chain=100' | tail -5
+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.
+A healthy `due` count should be much smaller than total generators — only non-deterministic types should remain.
 
 ---
 
-## Orderbook Cache (M3)
+## 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:
+Look for the setup log emitted once at startup (`setup:cacheReady`):
 
 ```bash
-grep -n "\[COW:SETUP\]" ponder.log | head -5
+grep -n "setup:cacheReady" ponder.log | head -5
 ```
 
-Healthy output:
-```
-[COW:SETUP] orderbook_cache ready — 42 entries from previous run
+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 `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.
+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.
 
-### Cache hits — verify terminal owners are served from cache
+### Orderbook fetches — what is served from cache vs. the API
 
-```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
+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 "\[COW:OB:CACHE\] SAVED" ponder.log | tail -20
+grep -n "ob:fetchResult" ponder.log | tail -20
 ```
 
 Healthy output:
-```
-[COW:OB:CACHE] SAVED owner=0x1234... chain=1 orders=3 (all terminal, cached permanently)
+```json
+{"level":"info","msg":"ob:fetchResult","owner":"0x1234...","chainId":1,"apiTotal":12,"composable":5,"cached":3,"refreshed":2}
 ```
 
-Active owners (with any `open` order) are intentionally NOT saved — they must be re-fetched on every poll cycle.
+- `cached` = composable orders served from the cache (no per-UID status refresh needed).
+- `refreshed` = composable orders whose status was re-fetched this cycle.
 
-### Orderbook poll cycle metrics
+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.
 
-```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):**
+Fetch-side failures and timeouts are warn lines worth scanning when fetches look wrong:
 
 ```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)
+grep -nE "ob:(noApiUrl|accountError|accountFetchFailed|accountTimeout|batchFetchError|batchFetchFailed|batchFetchTimeout|statusByUidsTimeout)" ponder.log | tail -20
 ```
 
-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).
+### OwnerBackfill — one-shot (`endBlock: "latest"`)
 
-**Full C4 trace (bootstrap work or empty):**
+`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 -n "\[COW:C4\]" ponder.log
+grep -nE "OwnerBackfill:(START|bootstrap_start|no_bootstrap_needed|DONE)" 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
+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}
 ```
 
-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"`.
+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
+## 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.
 
 ### DONE log — backoff count per cycle
 
 ```bash
-grep -n "\[COW:C1\] DONE" ponder.log | tail -20
+grep -n '"OrderDiscoveryPoller: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
+```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:
-```
-[COW:C1] DONE block=45678901 chain=100 due=180 success=3 never=0 backedOff=150
+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.
+`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
 
@@ -279,49 +278,49 @@ 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).
+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
+### 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 DeterministicCancellationSweeper — singleOrders() mapping sweep
+## CancellationWatcher — 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.
+`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 -n "\[COW:C5\]" ponder.log | tail -40
+grep -nE "CancellationWatcher:(ENTER|DONE)" 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
+```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=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).
+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 "\[COW:C5\] CANCELLED" ponder.log
+grep -n "CancellationWatcher: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
+```json
+{"level":"info","msg":"CancellationWatcher:CANCELLED","block":"...","chainId":1,"generatorId":"...","orderType":"StopLoss"}
 ```
 
-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
+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}
 ```
 
-C3's 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>';
@@ -329,20 +328,20 @@ 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).
+`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)
 
-If operators see no `[COW:C5]` lines at all and expect them:
+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.
+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
@@ -364,3 +363,4 @@ ORDER BY 1,2,3,4;
 | `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 |
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
diff --git a/.env.example b/.env.example
index 91aed4a..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.
 
@@ -33,6 +27,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 OrderStatusTracker 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
+
 # eth_getLogs block range cap (optional; default: 1000)
 # Increase if your RPC provider supports a larger range to speed up backfill.
 # Override per chain with the numeric chain-id suffix:
diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
index 4e8bfc7..ac47247 100644
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -6,6 +6,17 @@ concurrency:
 
 on:
   workflow_dispatch:
+    inputs:
+      monitor_only:
+        description: "Set to 'true' to only check server status without deploying"
+        required: false
+        default: 'false'
+        type: string
+      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
@@ -19,18 +30,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
@@ -53,8 +52,84 @@ 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 \
+            --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
+        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: |
+          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 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
+
+          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"
+
+          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})."
+
+      - name: Check server status
+        if: inputs.monitor_only == 'true'
         run: |
-          echo "${{ secrets.DEPLOY_ENV_FILE_CONTENT }}" > .env
+          echo "=== Running containers ==="
+          ssh cow-deploy "docker ps --format 'table {{.Names}}\t{{.Status}}\t{{.Image}}'"
 
-      - name: Run deploy script
-        run: npx tsx deployment/deploy-remotely.ts cow-deploy:${{ secrets.DEPLOY_PATH }} ../.env
+          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
+          "
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"
diff --git a/AGENTS.md b/AGENTS.md
index 0140b55..8d99c28 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -36,20 +36,17 @@ 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
 
 | 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 8 order type ABI structs, handler addresses, decoded fields, edge cases — **read before any decoder or block-handler work** |
 
 ## Working Conventions
 
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 . .
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/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/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/orderbook-integration-flow.md
similarity index 77%
rename from agent_docs/m3-orderbook-integration-flow.md
rename to agent_docs/orderbook-integration-flow.md
index b67e4ec..c7e6b5e 100644
--- a/agent_docs/m3-orderbook-integration-flow.md
+++ b/agent_docs/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.
 
 ---
 
@@ -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/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
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(
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"];
diff --git a/docker-compose.yml b/docker-compose.yml
index 66bd37a..99a1038 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -50,13 +50,21 @@ 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}
+      # 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:
       postgres:
         condition: service_healthy
+    ulimits:
+      nofile:
+        soft: 65536
+        hard: 65536
     logging:
       driver: json-file
       options:
diff --git a/docs/api-reference.md b/docs/api-reference.md
index e605547..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).
 
@@ -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 3cd93bf..a095d05 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 handlers for three independent on-chain event streams: `ComposableCow` (conditional order creation), `CoWShedFactory` (proxy wallet deployment), and `GPv2Settlement` (Aave adapter detection via `Settlement` events — `Trade` logs in the receipt identify the adapter address). During live sync, additional block handlers in `blockHandler.ts` poll contract state and the CoW orderbook API. See `blockHandler.ts` for the current handler list and responsibilities. `settlement.ts` detects Aave flash loan adapters via a queue-based approach: the `GPv2Settlement:Settlement` event handler enqueues tx hashes, and `SettlementResolver:block` drains the queue and does all RPC work so errors never crash the event handler.
 
@@ -14,9 +14,10 @@ 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"`).
 
-`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 live-only block handlers from `blockHandler.ts` — all run during live sync only (`startBlock: "latest"`).
 
 Three contracts are indexed:
 
@@ -37,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
@@ -53,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
@@ -99,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.
@@ -163,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.
 
@@ -175,17 +176,17 @@ 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.
 
-**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.
 
 **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
 
@@ -234,5 +235,5 @@ See [api-reference.md](./api-reference.md) for the full endpoint list.
 
 ## Known Limitations
 
-- Cancellation detection has a small lag. For non-deterministic generators, `OrderDiscoveryPoller` catches `SingleOrderNotAuthed` on the next poll (every block). For deterministic generators, `CancellationWatcher` reads `singleOrders(owner, hash)` every `DETERMINISTIC_CANCEL_SWEEP_INTERVAL` blocks (default 100) — so on-chain removal is reflected with worst-case latency of ~100 blocks (~20 min mainnet, ~8 min Gnosis). There is no on-chain event for `remove()`, so shorter detection latency would require a higher-cadence sweep. Once the generator is marked `Cancelled`, `CandidateConfirmer` and `OrderStatusTracker` cascade the state to children on the next block. The `CandidateConfirmer` cascade does a preflight `/by_uids` query so candidates already on the orderbook get their actual status rather than defaulting to `cancelled`; API-terminal statuses (`fulfilled` / `unfilled` / `expired`) still win for children already promoted to `discrete_order`.
+- Cancellation detection has a small lag. For non-deterministic generators, `OrderDiscoveryPoller` catches `SingleOrderNotAuthed` on the next poll (every block). For deterministic generators, `CancellationWatcher` reads `singleOrders(owner, hash)` every `DETERMINISTIC_CANCEL_SWEEP_INTERVAL` blocks (default 100) — so on-chain removal is reflected with worst-case latency of ~100 blocks (~20 min mainnet, ~8 min Gnosis). There is no on-chain event for `remove()`, so shorter detection latency would require a higher-cadence sweep. Once the generator is marked `Cancelled`, `CandidateConfirmer` and `OrderStatusTracker` cascade the state to children on the next block; the `CandidateConfirmer` cascade does a preflight `/by_uids` query so that candidates already on the orderbook get their actual status rather than defaulting to `cancelled`; API-terminal statuses (`fulfilled` / `unfilled` / `expired`) still win for children already promoted to `discrete_order`.
 - Aave adapter owner resolution is reactive — `owner_mapping` is written when the adapter appears in settlement, which may be after the conditional order is created. The generator row keeps `resolvedOwner` equal to the adapter address when no mapping existed at insert time; that column is not backfilled when the mapping is inserted later. `ownerAddressType` on the generator IS backfilled when the mapping is inserted — after which GraphQL and REST filters on `ownerAddressType = "flash_loan_helper"` reflect the correct value. `resolvedOwner` is still not backfilled (set once at insert, unchanged thereafter).
diff --git a/docs/deployment.md b/docs/deployment.md
index 27159f2..17108f1 100644
--- a/docs/deployment.md
+++ b/docs/deployment.md
@@ -30,9 +30,8 @@ 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. |
 | `PINO_LOG_LEVEL` | No | Log verbosity: `debug`, `info`, `warn`, `error`. Defaults to Ponder's built-in default. |
 
@@ -62,14 +61,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
 
@@ -95,6 +87,63 @@ docker compose --profile deploy up -d
 
 The `Dockerfile` in the project root builds the Ponder image: two-stage Node 22 Alpine, installs dependencies with `--frozen-lockfile`, exposes port 3000, runs `pnpm start`. The health check hits `/ready` with a 24-hour start period (initial sync takes hours).
 
+### Kubernetes Probes
+
+The indexer exposes two health endpoints with distinct semantics:
+
+| Endpoint | Semantic | Returns 200 when |
+|----------|----------|-----------------|
+| `/health` | **Liveness** — is the process alive? | Always, once the server starts |
+| `/ready` | **Readiness** — is the index fully synced? | Only when fully synced |
+
+Map these to different K8s probe types. The specific timing values (`periodSeconds`, `failureThreshold`, `initialDelaySeconds`) depend on your cluster's SLOs; what matters is which path and port to use:
+
+```yaml
+livenessProbe:
+  httpGet:
+    path: /health
+    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
+```
+
+**Do not** use `/ready` as the liveness probe. A pod that is still indexing (which takes hours on a cold start) returns 200 on `/health` but not on `/ready`. Using `/ready` for liveness would kill the pod before it ever finishes syncing.
+
+A pod in `NotReady` state is not killed — it is simply removed from load-balancer rotation. On a cold start (no existing database), the pod will be `NotReady` for the duration of the historical backfill (hours). That is expected: the old pod (if any) keeps serving traffic during this window, and once the new pod catches up, K8s starts routing to it.
+
+The Docker Compose health check uses `/ready` with a 24-hour start period as a pragmatic fallback for single-container deployments, not as a K8s-style probe.
+
+### Structured Logging
+
+`pnpm start` runs with `--log-format json`, which makes both Ponder's internal log lines and the handler log lines emit newline-delimited JSON. Each handler log line includes structured fields (e.g. `chainId`, `block`) enabling log aggregators (Datadog, CloudWatch, Loki) to filter and alert by chain.
+
+`pnpm dev` uses Ponder's default pretty format for readability during local development.
+
+**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";
+
+log("info", "CandidateConfirmer:confirmed", { chainId, orderUid, block: String(event.block.number) });
+log("warn", "CandidateConfirmer:timeout",   { chainId, block: String(event.block.number) });
+```
+
+`warn` and `error` level messages go to `stderr`; `info` goes to `stdout`. The `level` field in the JSON payload is what log aggregators use to route and alert.
+
+
+### PostgreSQL Memory Flags
+
+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
 
 ### How it works in practice
@@ -118,3 +167,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 (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.
+
+### `/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, 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 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 c04aa03..3b5fc38 100644
--- a/docs/supported-order-types.md
+++ b/docs/supported-order-types.md
@@ -1,8 +1,8 @@
 # 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`.
 
-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 OrderDiscoveryPoller discovery path (`allCandidatesKnown=false`). This is logged as `precompute:skip`. Such pathological orders are valid on-chain but are impractical in practice.
 
 ---
 
@@ -101,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 |
@@ -145,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 |
 
@@ -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.
 
 ---
 
@@ -239,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 |
 
@@ -257,13 +259,101 @@ 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.
 
 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`:
 
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/patches/ponder@0.16.6.patch b/patches/ponder@0.16.6.patch
new file mode 100644
index 0000000..cec1267
--- /dev/null
+++ b/patches/ponder@0.16.6.patch
@@ -0,0 +1,151 @@
+diff --git a/dist/esm/indexing-store/cache.js b/dist/esm/indexing-store/cache.js
+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) => {
+ 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,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" }),
+             };
+             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") {
+-                    await qb.wrap((db) => db.execute("SAVEPOINT flush"), 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 currentQb.wrap((db) => db.execute(`RELEASE ${sp}`), context);
+                 }
+                 else {
+                     // Note: pglite must run sequentially
+@@ -405,13 +408,20 @@ 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);
++                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) {
+@@ -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();
+-                        await qb.wrap((db) => db.execute("SAVEPOINT flush"), 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 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 currentQb.wrap((db) => db.execute(`SAVEPOINT ${sp}`), context);
+                         });
+                         if (result.status === "error") {
+                             error = new DelayedInsertError(result.error.message);
+@@ -471,15 +481,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("SAVEPOINT flush"), 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 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 currentQb.wrap((db) => db.execute(`SAVEPOINT ${sp}`), 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/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 b4eb45f..5bb5c42 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -4,6 +4,11 @@ settings:
   autoInstallPeers: true
   excludeLinksFromLockfile: false
 
+patchedDependencies:
+  ponder@0.16.6:
+    hash: f0612e7102efb92911aeae79416c3c5c52fcaf41c4a22e7903ba90ef8aa952d5
+    path: patches/ponder@0.16.6.patch
+
 importers:
 
   .:
@@ -24,8 +29,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(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)
@@ -797,8 +802,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 +2231,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 +3441,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 +4849,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(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)
@@ -4853,7 +4858,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
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
diff --git a/ponder.config.ts b/ponder.config.ts
index a1d18b5..faae337 100644
--- a/ponder.config.ts
+++ b/ponder.config.ts
@@ -72,19 +72,21 @@ export default createConfig({
     },
   },
   blocks: {
+    // Block handler intervals are tuned per chain to keep total handler time
+    // well within the available window while reducing unnecessary invocations.
+    //
+    // 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
+    //
+    // 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.
-    // 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) } : {}),
-          },
+          { startBlock: "latest" as const, interval: c.blockTime < 8 ? 10 : 4 },
         ]),
       ),
       interval: 1,
@@ -92,14 +94,20 @@ 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, interval: c.blockTime < 8 ? 10 : 4 },
+        ]),
       ),
       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, interval: c.blockTime < 8 ? 10 : 4 },
+        ]),
       ),
       interval: 1,
     },
@@ -113,20 +121,18 @@ export default createConfig({
       ),
       interval: 1,
     },
-    // 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.
+    // 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.
     CancellationWatcher: {
       chain: Object.fromEntries(
-        ACTIVE_CHAINS.map((c) => [c.name, { startBlock: "latest" as const }]),
-      ),
-      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 }]),
+        ACTIVE_CHAINS.map((c) => [
+          c.name,
+          {
+            startBlock: "latest" as const,
+            interval: c.blockTime < 8 ? 10 : 4,
+          },
+        ]),
       ),
       interval: 1,
     },
diff --git a/schema/tables.ts b/schema/tables.ts
index ae58d1d..73b5e7d 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",
 ]);
 
@@ -70,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(),
@@ -86,8 +89,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),
+    // OrderDiscoveryPoller + CancellationWatcher: per-block SELECT with
+    // chainId + status + allCandidatesKnown equality filters, ORDER BY lastCheckBlock.
+    // 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),
   })
 );
 
@@ -105,13 +111,15 @@ 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),
-    statusIdx: index("discrete_order_status_idx").on(table.status),
+    // 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 +140,9 @@ export const candidateDiscreteOrder = onchainTable(
     pk: primaryKey({ columns: [table.chainId, table.orderUid] }),
     generatorIdx: index("candidate_discrete_order_generator_idx")
       .on(table.chainId, table.conditionalOrderGeneratorId),
+    // CandidateConfirmer stale sweep: SELECT WHERE chainId + validTo <= timestamp LIMIT 500.
+    staleIdx: index("candidate_discrete_order_stale_idx")
+      .on(table.chainId, table.validTo),
   })
 );
 
@@ -149,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/api/endpoints/sync-progress.ts b/src/api/endpoints/sync-progress.ts
index 4caf985..a856b12 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
+        // (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/api/router.ts b/src/api/router.ts
index 8c83ded..954de00 100644
--- a/src/api/router.ts
+++ b/src/api/router.ts
@@ -7,15 +7,16 @@ 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",
-      message: err instanceof Error ? err.message : "Unknown error",
+      message: "An unexpected error occurred",
     },
     500,
   );
diff --git a/src/application/handlers/blockHandler.ts b/src/application/handlers/blockHandler.ts
index dc5c822..04c6692 100644
--- a/src/application/handlers/blockHandler.ts
+++ b/src/application/handlers/blockHandler.ts
@@ -1,22 +1,22 @@
 /**
  * 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";
 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, ne, or, sql } from "ponder";
 import type { Hex } from "viem";
 import {
   COMPOSABLE_COW_ADDRESS_BY_CHAIN_ID,
@@ -24,7 +24,9 @@ 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,
   DETERMINISTIC_CANCEL_SWEEP_INTERVAL,
   ORDERBOOK_HTTP_TIMEOUT_MS,
@@ -46,12 +48,12 @@ 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"]);
 
-// 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 = [
   {
@@ -67,13 +69,12 @@ 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.
 
 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];
@@ -82,9 +83,9 @@ ponder.on("OrderDiscoveryPoller: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({
@@ -192,7 +193,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(),
       );
@@ -294,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.
 
@@ -348,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.
@@ -365,43 +366,48 @@ 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.
-      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 });
@@ -410,6 +416,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 +438,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;
@@ -530,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));
@@ -565,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) });
         }
       }
     }
@@ -608,16 +622,27 @@ 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 }) => {
   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.isFinite(rawOrderCap) && rawOrderCap > 0 ? rawOrderCap : 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(
@@ -625,38 +650,61 @@ ponder.on("OrderStatusTracker:block", async ({ event, context }) => {
         eq(discreteOrder.chainId, chainId),
         eq(discreteOrder.status, "open"),
       ),
-    ) as { orderUid: string }[];
+    )
+    .orderBy(asc(discreteOrder.promotedAt))
+    .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) {
-      log("info", "OrderStatusTracker:DONE", { block: String(event.block.number), chainId, open: openOrders.length, updated });
+    // 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)
+        // promotedAt is intentionally omitted — preserve the original promotion timestamp across status updates.
+        .onConflictDoUpdate({
+          target: [discreteOrder.chainId, discreteOrder.orderUid],
+          set: {
+            status: sql`excluded.status`,
+            executedSellAmount: sql`excluded.executed_sell_amount`,
+            executedBuyAmount: sql`excluded.executed_buy_amount`,
+          },
+        });
+
+      log("info", "OrderStatusTracker:DONE", { block: String(event.block.number), chainId, open: openOrders.length, updated: rowsToUpdate.length });
     }
   }
 
@@ -706,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".
 
@@ -722,11 +770,62 @@ 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>();
 
   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),
@@ -738,6 +837,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 });
@@ -751,34 +853,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)));
 
@@ -800,6 +874,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 });
@@ -816,17 +893,16 @@ 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 (COW-918) reconcile
+// 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.
 
 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];
@@ -834,9 +910,9 @@ ponder.on("CancellationWatcher: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({
@@ -950,6 +1026,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,
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,
     );
diff --git a/src/application/handlers/settlement.ts b/src/application/handlers/settlement.ts
index 3aad857..62e6bdc 100644
--- a/src/application/handlers/settlement.ts
+++ b/src/application/handlers/settlement.ts
@@ -1,12 +1,9 @@
 import { ponder } from "ponder:registry";
 import {
   AddressType,
-  conditionalOrderGenerator,
   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";
@@ -15,7 +12,7 @@ import {
   GPV2_SETTLEMENT_DEPLOYMENTS,
 } from "../../data";
 import { BLOCK_HANDLER_RPC_TIMEOUT_MS, SETTLEMENT_INNER_RPC_TIMEOUT_MS } from "../../constants";
-import { TimeoutError as _TimeoutError, withTimeout } from "../helpers/withTimeout";
+import { withTimeout } from "../helpers/withTimeout";
 
 // Trade(address,address,address,uint256,uint256,uint256,bytes) — topic0 hash
 const TRADE_TOPIC = keccak256(
@@ -56,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;
 
@@ -94,159 +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.sql
-        .delete(settlementQueue)
-        .where(and(eq(settlementQueue.chainId, chainId), eq(settlementQueue.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();
-
-      await context.db.sql
-        .update(conditionalOrderGenerator)
-        .set({ ownerAddressType: AddressType.FlashLoanHelper })
-        .where(
-          and(
-            eq(conditionalOrderGenerator.chainId, chainId),
-            eq(conditionalOrderGenerator.owner, ownerAddress),
-          ),
-        );
-
-      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.sql
-      .delete(settlementQueue)
-      .where(and(eq(settlementQueue.chainId, chainId), eq(settlementQueue.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();
 });
diff --git a/src/application/helpers/orderUid.ts b/src/application/helpers/orderUid.ts
index 97b1f15..61213f0 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";
@@ -46,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/orderbookClient.ts b/src/application/helpers/orderbookClient.ts
index 0b99df5..a599282 100644
--- a/src/application/helpers/orderbookClient.ts
+++ b/src/application/helpers/orderbookClient.ts
@@ -18,12 +18,12 @@ 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";
 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";
@@ -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. */
@@ -93,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) {
@@ -146,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
@@ -174,35 +156,33 @@ export async function upsertDiscreteOrders(
   chainId: number,
   orders: ComposableOrder[],
 ): Promise<number> {
-  let count = 0;
-  for (const order of orders) {
-    await context.db.sql
-      .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: BigInt(order.creationDate),
-        executedSellAmount: order.executedSellAmount,
-        executedBuyAmount: order.executedBuyAmount,
-      })
-      .onConflictDoUpdate({
-        target: [discreteOrder.chainId, discreteOrder.orderUid],
-        set: {
-          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;
 }
 
 /**
@@ -278,7 +258,7 @@ export async function fetchOrderStatusByUids(
           buyAmount: order.buyAmount,
           feeAmount: order.feeAmount,
           validTo: order.validTo,
-          creationDate: 0,
+          creationDate: 0n,
           executedSellAmount: order.executedSellAmount,
           executedBuyAmount: order.executedBuyAmount,
         });
@@ -320,11 +300,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;
@@ -332,7 +317,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,
@@ -347,7 +334,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) {
@@ -363,45 +350,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.map((item) => 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 ──────────────────────────────────────────────────────────────
@@ -441,23 +435,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;
 
@@ -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,
     });
@@ -552,30 +551,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/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/application/helpers/uidPrecompute.ts b/src/application/helpers/uidPrecompute.ts
index 16a3644..d1d9972 100644
--- a/src/application/helpers/uidPrecompute.ts
+++ b/src/application/helpers/uidPrecompute.ts
@@ -16,17 +16,13 @@
  */
 
 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 { 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";
-
-// GPv2Order.sol constant hashes
-const KIND_SELL = "0xf3b277728b3fee749481eb3e0b3b48980dbbab78658fc419025cb16eee346775" as Hex;
-const KIND_BUY = "0x6ed88e868af0a1983e3886d5f3e95a2fafbd6c3450bc229e27342283dc429ccc" as Hex;
-const BALANCE_ERC20 = "0x5a28e9363bb942b639270062aa6bb295f434bcdfc42c97267bf003f272060dc9" as Hex;
+import { MAX_TWAP_PRECOMPUTE_PARTS } from "../../constants";
 
 // ─── Types ───────────────────────────────────────────────────────────────────
 
@@ -104,51 +100,72 @@ 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,
+      });
     }
   }
 
+  // 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.slice(i, i + CHUNK))
+      .onConflictDoUpdate({
+        target: [discreteOrder.chainId, discreteOrder.orderUid],
+        set: {
+          status: sql`excluded.status`,
+          validTo: sql`excluded.valid_to`,
+        },
+      });
+  }
+
+  for (let i = 0; i < candidateRows.length; i += CHUNK) {
+    await context.db.sql
+      .insert(candidateDiscreteOrder)
+      .values(candidateRows.slice(i, i + CHUNK))
+      .onConflictDoNothing();
+  }
+
   const allTerminal = precomputed.every((o) => {
     const s = statuses.get(o.orderUid)?.status;
     return s === "fulfilled" || s === "expired" || s === "cancelled";
@@ -173,7 +190,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 })
@@ -234,7 +251,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/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") {
diff --git a/src/chains/types.ts b/src/chains/types.ts
index 5d0b480..cc0eeb8 100644
--- a/src/chains/types.ts
+++ b/src/chains/types.ts
@@ -3,9 +3,9 @@ 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.
+ * 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 51c17d8..ef27867 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;
@@ -82,3 +82,44 @@ export const SETTLEMENT_INNER_RPC_TIMEOUT_MS = 5_000;
  * the normal OrderDiscoveryPoller / CandidateConfirmer path picks them up on subsequent blocks.
  */
 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
+ * OrderDiscoveryPoller discovery path (allCandidatesKnown=false). Logged as
+ * `precompute:skip` with reason=too_many_parts when triggered.
+ */
+export const MAX_TWAP_PRECOMPUTE_PARTS = 100_000;
+
+/**
+ * Hard per-block ceiling on how many open discrete orders OrderStatusTracker
+ * 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;
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.
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..c92ebe7 100644
--- a/src/decoders/good-after-time.ts
+++ b/src/decoders/good-after-time.ts
@@ -9,11 +9,11 @@ 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;
 }
 
-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/src/utils/order-types.ts b/src/utils/order-types.ts
index 93cd1b3..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
@@ -21,14 +21,17 @@ export type OrderType =
   | "CirclesBackingOrder"
   | "SwapOrderHandler"
   | "ERC4626CowSwapFeeBurner"
+  | "CurveCowSwapBurner"
+  | "BalancerCowSwapFeeBurner"
+  | "CowAmmConstantProduct"
   | "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",
@@ -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/api/orders-by-owner.test.ts b/tests/api/orders-by-owner.test.ts
index 3113295..707ec71 100644
--- a/tests/api/orders-by-owner.test.ts
+++ b/tests/api/orders-by-owner.test.ts
@@ -11,7 +11,7 @@ vi.mock("ponder:schema", () => {
   const conditionalOrderGenerator = {
     eventId: "eventId", chainId: "chainId", orderType: "orderType",
     owner: "owner", resolvedOwner: "resolvedOwner", status: "status",
-    ownerAddressType: "ownerAddressType",
+    ownerAddressType: "ownerAddressType", hash: "hash",
   };
   const discreteOrder = {
     conditionalOrderGeneratorId: "conditionalOrderGeneratorId",
@@ -173,6 +173,8 @@ describe("ordersByOwnerHandler", () => {
   });
 });
 
+// ─── Schema tests ──────────────────────────────────────────────────
+
 // A minimal valid GeneratorSummary payload that satisfies all required fields.
 const validGenerator = {
   eventId: "0xabc123",
@@ -186,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", () => {
@@ -199,9 +201,24 @@ describe("GeneratorSummary schema", () => {
     }
   });
 
-  // Regression guard: ownerAddressType is nullable — null is the common case
-  // for generators that don't go through a proxy.
-  it("ownerAddressType accepts null", () => {
+  it("fails parse when hash is not a string (number supplied)", () => {
+    const result = GeneratorSummary.safeParse({ ...validGenerator, hash: 12345 });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      const paths = result.error.issues.map((i) => i.path.join("."));
+      expect(paths).toContain("hash");
+    }
+  });
+
+  it("hash field carries the correct describe() text", () => {
+    const shape = GeneratorSummary.shape;
+    const description = shape.hash.description;
+    expect(description).toBe(
+      "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).",
+    );
+  });
+
+  it("ownerAddressType accepts null (regression guard for unchanged field)", () => {
     const result = GeneratorSummary.safeParse({ ...validGenerator, ownerAddressType: null });
     expect(result.success).toBe(true);
     if (result.success) {
@@ -243,3 +260,4 @@ describe("OrdersByOwnerResponse schema", () => {
     }
   });
 });
+
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);
   });
 
diff --git a/tests/constants.test.ts b/tests/constants.test.ts
new file mode 100644
index 0000000..4799405
--- /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", () => {
+  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/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 }],
     );
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
new file mode 100644
index 0000000..473c18e
--- /dev/null
+++ b/tests/helpers/statusFilter.test.ts
@@ -0,0 +1,197 @@
+/**
+ * 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"]);
+ *
+ * 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 OrderStatusTracker.
+ * 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("OrderStatusTracker 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);
+  });
+});
diff --git a/tests/utils/order-types.test.ts b/tests/utils/order-types.test.ts
index 46e39d0..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);
   });
 
@@ -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);
   });
 });