brawny 0.1.13__py3-none-any.whl → 0.1.22__py3-none-any.whl

brawny/scheduler/reorg.py

@@ -9,6 +9,7 @@ Implements reorg detection from SPEC 5.2:
 
 from __future__ import annotations
 
+import asyncio
 from dataclasses import dataclass, replace
 from typing import TYPE_CHECKING, Callable
 
@@ -16,12 +17,14 @@ from brawny.alerts.health import health_alert
 from brawny.logging import LogEvents, get_logger
 from brawny.metrics import REORGS_DETECTED, get_metrics
 from brawny.model.enums import AttemptStatus, IntentStatus, NonceStatus
+from brawny.model.errors import DatabaseError
 from brawny.tx.intent import transition_intent
+from brawny._rpc.errors import RPCError
 
 if TYPE_CHECKING:
     from brawny.db.base import Database
     from brawny.lifecycle import LifecycleDispatcher
-    from brawny._rpc.manager import RPCManager
+    from brawny._rpc.clients import ReadClient
 
 logger = get_logger(__name__)
 
@@ -59,7 +62,7 @@ class ReorgDetector:
     def __init__(
         self,
         db: Database,
-        rpc: RPCManager,
+        rpc: ReadClient,
         chain_id: int,
         reorg_depth: int = 32,
         block_hash_history_size: int = 256,
@@ -91,14 +94,14 @@ class ReorgDetector:
         self._health_chat_id = health_chat_id
         self._health_cooldown = health_cooldown
 
-    def check(self, current_block: int) -> ReorgResult:
+    def check(self, current_block: int) -> ReorgResult | None:
         """Check for reorg at the current block height.
 
         Args:
             current_block: Current block being processed
 
         Returns:
-            ReorgResult with detection status
+            ReorgResult with detection status, or None if probing fails
         """
         # Get block state
         block_state = self._db.get_block_state(self._chain_id)
@@ -126,6 +129,15 @@ class ReorgDetector:
                     return ReorgResult(reorg_detected=False)
                 anchor_missing = True
             elif anchor_height >= history_min:
+                if history_max is not None and history_max - history_min < self._reorg_depth:
+                    logger.warning(
+                        "reorg.history_insufficient",
+                        anchor_height=anchor_height,
+                        history_min=history_min,
+                        history_max=history_max,
+                        reorg_depth=self._reorg_depth,
+                    )
+                    return ReorgResult(reorg_detected=False)
                 # Expected history missing -> possible corruption
                 logger.error(
                     "reorg.history_missing",
@@ -170,10 +182,13 @@ class ReorgDetector:
                 chain_hash = chain_hash.hex()
             if not chain_hash.startswith("0x"):
                 chain_hash = f"0x{chain_hash}"
-        except Exception as e:
+        except asyncio.CancelledError:
+            raise
+        except RPCError as e:
             logger.warning(
                 "reorg.check_failed",
                 anchor_height=anchor_height,
+                chain_id=self._chain_id,
                 error=str(e),
             )
             return ReorgResult(reorg_detected=False)
@@ -188,6 +203,11 @@ class ReorgDetector:
 
         # Reorg detected!
         rewind_reason = "missing_history" if anchor_missing else "anchor_mismatch"
+        # Find last good height via binary search
+        last_good_height = self._find_last_good_height(anchor_height, last_processed)
+        if last_good_height is None:
+            return None
+
         logger.warning(
             LogEvents.BLOCK_REORG_DETECTED,
             anchor_height=anchor_height,
@@ -198,9 +218,6 @@ class ReorgDetector:
         metrics.counter(REORGS_DETECTED).inc(
             chain_id=self._chain_id,
         )
-
-        # Find last good height via binary search
-        last_good_height = self._find_last_good_height(anchor_height, last_processed)
         oldest = history_min
         if oldest is not None and last_good_height < oldest:
             finality_floor = max(0, last_processed - self._finality_confirmations)
@@ -271,7 +288,7 @@ class ReorgDetector:
             last_processed=last_processed,
         )
 
-    def _find_last_good_height(self, low: int, high: int) -> int:
+    def _find_last_good_height(self, low: int, high: int) -> int | None:
         """Binary search to find last matching block height.
 
         Args:
@@ -279,29 +296,33 @@ class ReorgDetector:
             high: Upper bound (known bad)
 
         Returns:
-            Last good block height
+            Last good block height, or None if probing fails
         """
-        oldest = self._db.get_oldest_block_in_history(self._chain_id)
-        if oldest is None:
-            return low
+        mid = None
+        left = None
+        right = None
 
-        # Start from the known bad anchor and search forward
-        # We need to find where the chain diverged
-        left = max(oldest, low)
-        right = high
+        try:
+            oldest = self._db.get_oldest_block_in_history(self._chain_id)
+            if oldest is None:
+                return low
 
-        last_good = left - 1  # Assume nothing matches if search fails
+            # Start from the known bad anchor and search forward
+            # We need to find where the chain diverged
+            left = max(oldest, low)
+            right = high
 
-        while left <= right:
-            mid = (left + right) // 2
+            last_good = left - 1  # Assume nothing matches if search fails
 
-            stored = self._db.get_block_hash_at_height(self._chain_id, mid)
-            if stored is None:
-                # No history here, move right
-                left = mid + 1
-                continue
+            while left <= right:
+                mid = (left + right) // 2
+
+                stored = self._db.get_block_hash_at_height(self._chain_id, mid)
+                if stored is None:
+                    # No history here, move right
+                    left = mid + 1
+                    continue
 
-            try:
                 block = self._rpc.get_block(mid)
                 if block is None:
                     left = mid + 1
@@ -312,19 +333,41 @@ class ReorgDetector:
                     chain_hash = chain_hash.hex()
                 if not chain_hash.startswith("0x"):
                     chain_hash = f"0x{chain_hash}"
-            except Exception:
-                left = mid + 1
-                continue
 
-            if stored.lower() == chain_hash.lower():
-                # Match - reorg is after this point
-                last_good = mid
-                left = mid + 1
+                if stored.lower() == chain_hash.lower():
+                    # Match - reorg is after this point
+                    last_good = mid
+                    left = mid + 1
+                else:
+                    # Mismatch - reorg is at or before this point
+                    right = mid - 1
+
+            return last_good
+        except asyncio.CancelledError:
+            raise
+        except (DatabaseError, RPCError):
+            endpoint = getattr(self._rpc, "endpoint", None)
+            if endpoint is None:
+                endpoint = getattr(self._rpc, "url", None)
+
+            log_fields = {
+                "chain_id": self._chain_id,
+                "low": low,
+                "high": high,
+                "endpoint": endpoint,
+            }
+            if mid is None:
+                log_fields["left"] = left
+                log_fields["right"] = right
             else:
-                # Mismatch - reorg is at or before this point
-                right = mid - 1
+                log_fields["mid"] = mid
 
-        return last_good
+            logger.warning(
+                "reorg.probe_failed",
+                exc_info=True,
+                **log_fields,
+            )
+            return None
     def rewind(self, reorg_result: ReorgResult) -> ReorgResult:
         """Rewind state using the centralized recovery contract."""
         recovery = ReorgRecovery(
@@ -392,7 +435,7 @@ class ReorgRecovery:
     def __init__(
         self,
         db: Database,
-        rpc: RPCManager,
+        rpc: ReadClient,
         chain_id: int,
         lifecycle: "LifecycleDispatcher | None" = None,
         finality_confirmations: int = 0,
@@ -453,7 +496,15 @@ class ReorgRecovery:
                             rewind_hash = block["hash"]
                             if isinstance(rewind_hash, bytes):
                                 rewind_hash = rewind_hash.hex()
-                    except Exception:
+                    except asyncio.CancelledError:
+                        raise
+                    except RPCError as e:
+                        logger.warning(
+                            "reorg.rewind_hash_fetch_failed",
+                            chain_id=self._chain_id,
+                            to_height=to_height,
+                            error=str(e),
+                        )
                         rewind_hash = None
 
                 if rewind_hash is None:
@@ -467,11 +518,15 @@ class ReorgRecovery:
 
                 intents_reverted, attempts_reverted = self._revert_reorged_intents(to_height)
                 self._assert_no_confirmed_above(to_height)
+        except asyncio.CancelledError:
+            raise
         except Exception as e:
             logger.error(
                 "reorg.rewind_failed",
+                chain_id=self._chain_id,
                 to_height=to_height,
                 error=str(e)[:200],
+                exc_info=True,
             )
             health_alert(
                 component="brawny.scheduler.reorg",
@@ -564,10 +619,11 @@ class ReorgRecovery:
                             NonceStatus.IN_FLIGHT.value,
                             intent_id=intent.intent_id,
                         )
-                except Exception as e:
+                except DatabaseError as e:
                     logger.warning(
                         "reorg.nonce_reconcile_failed",
                         intent_id=str(intent.intent_id),
+                        chain_id=self._chain_id,
                         nonce=attempt.nonce,
                         error=str(e)[:200],
                     )