Replay collateral per block so capacity reflects window state (#409)

[anderdc]

Summary

Closes #409. Capacity weighting used to multiply already-replayed crown by the miner's current collateral, read once at scoring time via contract_client.get_miner_collateral. The replayed crown intervals are historical; the collateral read is live. A miner can hold crown through the window with low collateral, then top up before the next scoring pass and receive the higher capacity multiplier retroactively.

This PR treats collateral the same way active, busy, rate, and reservation_pin are already treated: a per-block event series replayed inside replay_crown_time_window, with the capacity multiplier evaluated at the block being credited.

Approach

• New CollateralEvent in event_watcher.py, with its own in-memory list + _by_hotkey index, schema (collateral_events), CRUD, and prune helpers — same shape as ActiveEvent/BusyEvent.
• apply_event handles CollateralPosted and CollateralWithdrawn (writing total / remaining respectively, which the contract emits as post-event balances).
• SwapCompleted and SwapTimedOut also tap the series. The contract's apply_collateral_penalty silently deducts the fee/slash without emitting CollateralWithdrawn, so the watcher mirrors the deduction from SwapCompleted.fee_amount / SwapTimedOut.slash_amount. CollateralSlashed is deliberately skipped to avoid double-counting with SwapTimedOut.
• Cold bootstrap anchors current collateral at cursor for every active miner. Same trade-off active_events already makes — a fresh validator can only read current state and treats it as constant across the first window.
• replay_crown_time_window reconstructs collateral at window_start and applies a new EventKind.COLLATERAL. Inside credit_interval, each holder's split is multiplied by capacity_factor(collateral_at_block, max_swap_rao) and accumulated into a parallel cap_weighted_blocks dict that the trace exposes.
• calculate_miner_rewards divides cap_weighted_blocks[hk] / crown_blocks[hk] to get the time-weighted effective capacity multiplier, then drops the contract read entirely.

Notes

• Cold-start anchor uses current collateral; the first scoring window after a fresh boot treats current as constant. Documented in code.
• Withdrawal is gated by MinerStillActive on chain, so during any crown-earning interval the series is monotone non-decreasing (post-only). The retroactive boost path is closed.
• WeightingTrace.collateral dropped; the log line now shows only cap= since the effective multiplier is time-averaged and no single collateral value is the right thing to print.

Merged with test

Rebased onto latest test and resolved conflicts in scoring.py and tests/test_scoring_v1.py:

• reconstruct_window_start_state keeps the collateral-aware 5-tuple signature and folds in test's batched-rate-read docstring.
• Both added test classes (TestHistoricalCollateralReplay + TestScoringCadenceAndWindow) are retained.
• test lowered SCORING_WINDOW_BLOCKS 600 → 300, so the window is now (9_700, 10_000]. test_mid_window_topup_blends_capacity's top-up moved 9_700 → 9_850 (new midpoint) to keep the 150/150 split; stale window-math comments updated. No behavior change to the fix itself.

Test plan

• uv run pytest tests/test_scoring_v1.py — 131 pass
• uv run pytest — 624 pass
• uv run ruff check — clean
• New regression: test_409_retroactive_topup_does_not_boost_window mirrors the proof in the issue
• test_mid_window_topup_blends_capacity covers the time-weighted average path
• test_swap_completed_deducts_fee_from_collateral_series / test_swap_timed_out_deducts_slash_from_collateral_series cover the silent deductions
• test_prune_keeps_latest_collateral_event_per_hotkey covers the reconstruction anchor invariant
• test_collateral_events_persist_across_hydrate covers warm restart round-trip