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

brawny/db/sqlite.py

@@ -1,2733 +0,0 @@
-"""SQLite database implementation for brawny.
-
-SQLite is for development only. Production deployments must use PostgreSQL.
-
-Key differences from PostgreSQL:
-- Uses IMMEDIATE transaction mode for nonce reservation (app-level locking)
-- Uses deterministic ordering with secondary sort for intent claiming
-- No connection pooling (single connection)
-- SERIAL becomes INTEGER PRIMARY KEY AUTOINCREMENT
-"""
-
-from __future__ import annotations
-
-import json
-import re
-import sqlite3
-import threading
-from contextlib import contextmanager
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any, Iterator
-from uuid import UUID
-
-from brawny.db.base import (
-    ABICacheEntry,
-    BlockHashEntry,
-    BlockState,
-    Database,
-    IsolationLevel,
-    ProxyCacheEntry,
-)
-from brawny.db.circuit_breaker import DatabaseCircuitBreaker
-from brawny.model.enums import AttemptStatus, IntentStatus, NonceStatus, TxStatus
-from brawny.model.errors import DatabaseError, ErrorInfo, FailureType
-from brawny.model.types import (
-    BroadcastInfo,
-    GasParams,
-    JobConfig,
-    NonceReservation,
-    SignerState,
-    Transaction,
-    TxAttempt,
-    TxHashRecord,
-    TxIntent,
-)
-
-
-def adapt_datetime(dt: datetime) -> str:
-    """Adapt datetime to ISO format string for SQLite."""
-    if dt.tzinfo is None:
-        dt = dt.replace(tzinfo=timezone.utc)
-    return dt.isoformat()
-
-
-def convert_datetime(val: bytes) -> datetime:
-    """Convert ISO format string from SQLite to datetime."""
-    s = val.decode("utf-8")
-    # Handle various formats
-    try:
-        return datetime.fromisoformat(s)
-    except ValueError:
-        # Try parsing without timezone
-        return datetime.strptime(s, "%Y-%m-%d %H:%M:%S").replace(tzinfo=timezone.utc)
-
-
-# Register adapters
-sqlite3.register_adapter(datetime, adapt_datetime)
-sqlite3.register_converter("TIMESTAMP", convert_datetime)
-
-
-class SQLiteDatabase(Database):
-    """SQLite implementation of the Database interface.
-
-    Thread-safety: Uses a per-thread connection model with a shared lock
-    for transaction isolation.
-    """
-
-    def __init__(
-        self,
-        database_path: str,
-        circuit_breaker_failures: int = 5,
-        circuit_breaker_seconds: int = 30,
-    ) -> None:
-        """Initialize SQLite database.
-
-        Args:
-            database_path: Path to SQLite database file (or :memory:)
-            circuit_breaker_failures: Failures before opening breaker
-            circuit_breaker_seconds: Seconds to keep breaker open
-        """
-        # Remove sqlite:/// prefix if present
-        if database_path.startswith("sqlite:///"):
-            database_path = database_path[10:]
-
-        self._database_path = database_path
-        self._conn: sqlite3.Connection | None = None
-        self._lock = threading.RLock()
-        self._in_transaction = False
-        self._circuit_breaker = DatabaseCircuitBreaker(
-            failure_threshold=circuit_breaker_failures,
-            open_seconds=circuit_breaker_seconds,
-            backend="sqlite",
-        )
-
-    @property
-    def dialect(self) -> str:
-        """Return dialect name for query selection."""
-        return "sqlite"
-
-    def connect(self) -> None:
-        """Establish database connection."""
-        if self._conn is not None:
-            return
-
-        # Create directory if needed
-        if self._database_path != ":memory:":
-            path = Path(self._database_path)
-            path.parent.mkdir(parents=True, exist_ok=True)
-
-        self._conn = sqlite3.connect(
-            self._database_path,
-            detect_types=sqlite3.PARSE_DECLTYPES | sqlite3.PARSE_COLNAMES,
-            check_same_thread=False,
-            timeout=30.0,
-        )
-        self._conn.row_factory = sqlite3.Row
-        # Enable foreign keys
-        self._conn.execute("PRAGMA foreign_keys = ON")
-        # Use WAL mode for better concurrency
-        self._conn.execute("PRAGMA journal_mode = WAL")
-
-    def close(self) -> None:
-        """Close database connection."""
-        if self._conn:
-            self._conn.close()
-            self._conn = None
-
-    def is_connected(self) -> bool:
-        """Check if database is connected."""
-        return self._conn is not None
-
-    def _ensure_connected(self) -> sqlite3.Connection:
-        """Ensure connection exists and return it."""
-        if self._conn is None:
-            raise DatabaseError("Database not connected. Call connect() first.")
-        return self._conn
-
-    @contextmanager
-    def transaction(
-        self, isolation_level: IsolationLevel | None = None
-    ) -> Iterator[None]:
-        """Context manager for database transactions.
-
-        SQLite supports: DEFERRED, IMMEDIATE, EXCLUSIVE
-        We map:
-        - SERIALIZABLE -> EXCLUSIVE
-        - READ COMMITTED -> IMMEDIATE
-        - Others -> DEFERRED
-        """
-        conn = self._ensure_connected()
-
-        # Map isolation levels to SQLite modes
-        if isolation_level == "SERIALIZABLE":
-            begin_cmd = "BEGIN EXCLUSIVE"
-        elif isolation_level in ("READ COMMITTED", "REPEATABLE READ"):
-            begin_cmd = "BEGIN IMMEDIATE"
-        else:
-            begin_cmd = "BEGIN DEFERRED"
-
-        with self._lock:
-            try:
-                conn.execute(begin_cmd)
-                self._in_transaction = True
-                yield
-                conn.commit()
-            except Exception:
-                conn.rollback()
-                raise
-            finally:
-                self._in_transaction = False
-
-    def _adapt_sql(self, query: str) -> str:
-        """Adapt PostgreSQL-style SQL to SQLite.
-
-        Handles:
-        - $1, $2 -> ? (parameter placeholders)
-        - SERIAL -> INTEGER (type mapping)
-        - NOW() -> CURRENT_TIMESTAMP
-        """
-        # Replace $N parameters with ?
-        query = re.sub(r"\$\d+", "?", query)
-        # Replace SERIAL with appropriate SQLite type
-        query = query.replace("SERIAL", "INTEGER")
-        # Replace NOW() with CURRENT_TIMESTAMP
-        query = query.replace("NOW()", "CURRENT_TIMESTAMP")
-        return query
-
-    def execute(
-        self,
-        query: str,
-        params: tuple[Any, ...] | dict[str, Any] | None = None,
-    ) -> None:
-        """Execute a query without returning results."""
-        conn = self._ensure_connected()
-        query = self._adapt_sql(query)
-        self._circuit_breaker.before_call()
-
-        with self._lock:
-            cursor = conn.cursor()
-            try:
-                if params is None:
-                    cursor.execute(query)
-                elif isinstance(params, dict):
-                    cursor.execute(query, params)
-                else:
-                    cursor.execute(query, params)
-                if not self._in_transaction:
-                    conn.commit()
-                self._circuit_breaker.record_success()
-            except sqlite3.Error as e:
-                self._circuit_breaker.record_failure(e)
-                raise DatabaseError(f"SQLite query failed: {e}") from e
-            finally:
-                cursor.close()
-
-    def execute_returning(
-        self,
-        query: str,
-        params: tuple[Any, ...] | dict[str, Any] | None = None,
-    ) -> list[dict[str, Any]]:
-        """Execute a query and return all results as dicts."""
-        conn = self._ensure_connected()
-        query = self._adapt_sql(query)
-        self._circuit_breaker.before_call()
-
-        with self._lock:
-            cursor = conn.cursor()
-            try:
-                if params is None:
-                    cursor.execute(query)
-                elif isinstance(params, dict):
-                    cursor.execute(query, params)
-                else:
-                    cursor.execute(query, params)
-
-                rows = cursor.fetchall()
-                if not rows:
-                    self._circuit_breaker.record_success()
-                    return []
-
-                # Convert Row objects to dicts
-                self._circuit_breaker.record_success()
-                return [dict(row) for row in rows]
-            except sqlite3.Error as e:
-                self._circuit_breaker.record_failure(e)
-                raise DatabaseError(f"SQLite query failed: {e}") from e
-            finally:
-                cursor.close()
-
-    def execute_one(
-        self,
-        query: str,
-        params: tuple[Any, ...] | dict[str, Any] | None = None,
-    ) -> dict[str, Any] | None:
-        """Execute a query and return a single result or None."""
-        results = self.execute_returning(query, params)
-        return results[0] if results else None
-
-    def execute_returning_rowcount(
-        self,
-        query: str,
-        params: tuple[Any, ...] | dict[str, Any] | None = None,
-    ) -> int:
-        """Execute SQL and return rowcount.
-
-        IMPORTANT: Both sqlite3 and psycopg2 expose cursor.rowcount after execute.
-        This method ensures we capture it reliably.
-        """
-        conn = self._ensure_connected()
-        query = self._adapt_sql(query)
-        self._circuit_breaker.before_call()
-
-        with self._lock:
-            cursor = conn.cursor()
-            try:
-                if params is None:
-                    cursor.execute(query)
-                else:
-                    cursor.execute(query, params)
-                rowcount = cursor.rowcount
-                if not self._in_transaction:
-                    conn.commit()
-                self._circuit_breaker.record_success()
-                return rowcount
-            except sqlite3.Error as e:
-                self._circuit_breaker.record_failure(e)
-                raise DatabaseError(f"SQLite query failed: {e}") from e
-            finally:
-                cursor.close()
-
-    # =========================================================================
-    # Block State Operations
-    # =========================================================================
-
-    def get_block_state(self, chain_id: int) -> BlockState | None:
-        row = self.execute_one(
-            "SELECT * FROM block_state WHERE chain_id = ?",
-            (chain_id,),
-        )
-        if not row:
-            return None
-        return BlockState(
-            chain_id=row["chain_id"],
-            last_processed_block_number=row["last_processed_block_number"],
-            last_processed_block_hash=row["last_processed_block_hash"],
-            created_at=row["created_at"],
-            updated_at=row["updated_at"],
-        )
-
-    def upsert_block_state(
-        self,
-        chain_id: int,
-        block_number: int,
-        block_hash: str,
-    ) -> None:
-        self.execute(
-            """
-            INSERT INTO block_state (chain_id, last_processed_block_number, last_processed_block_hash)
-            VALUES (?, ?, ?)
-            ON CONFLICT(chain_id) DO UPDATE SET
-                last_processed_block_number = excluded.last_processed_block_number,
-                last_processed_block_hash = excluded.last_processed_block_hash,
-                updated_at = CURRENT_TIMESTAMP
-            """,
-            (chain_id, block_number, block_hash),
-        )
-
-    def get_block_hash_at_height(
-        self, chain_id: int, block_number: int
-    ) -> str | None:
-        row = self.execute_one(
-            "SELECT block_hash FROM block_hash_history WHERE chain_id = ? AND block_number = ?",
-            (chain_id, block_number),
-        )
-        return row["block_hash"] if row else None
-
-    def insert_block_hash(
-        self, chain_id: int, block_number: int, block_hash: str
-    ) -> None:
-        self.execute(
-            """
-            INSERT INTO block_hash_history (chain_id, block_number, block_hash)
-            VALUES (?, ?, ?)
-            ON CONFLICT(chain_id, block_number) DO UPDATE SET
-                block_hash = excluded.block_hash,
-                inserted_at = CURRENT_TIMESTAMP
-            """,
-            (chain_id, block_number, block_hash),
-        )
-
-    def delete_block_hashes_above(self, chain_id: int, block_number: int) -> int:
-        conn = self._ensure_connected()
-        with self._lock:
-            cursor = conn.cursor()
-            cursor.execute(
-                "DELETE FROM block_hash_history WHERE chain_id = ? AND block_number > ?",
-                (chain_id, block_number),
-            )
-            count = cursor.rowcount
-            if not self._in_transaction:
-                conn.commit()
-            cursor.close()
-            return count
-
-    def delete_block_hash_at_height(self, chain_id: int, block_number: int) -> bool:
-        conn = self._ensure_connected()
-        with self._lock:
-            cursor = conn.cursor()
-            cursor.execute(
-                "DELETE FROM block_hash_history WHERE chain_id = ? AND block_number = ?",
-                (chain_id, block_number),
-            )
-            deleted = cursor.rowcount > 0
-            if not self._in_transaction:
-                conn.commit()
-            cursor.close()
-            return deleted
-
-    def cleanup_old_block_hashes(self, chain_id: int, keep_count: int) -> int:
-        # Get max block number
-        row = self.execute_one(
-            "SELECT MAX(block_number) as max_block FROM block_hash_history WHERE chain_id = ?",
-            (chain_id,),
-        )
-        if not row or row["max_block"] is None:
-            return 0
-
-        cutoff = row["max_block"] - keep_count + 1
-        conn = self._ensure_connected()
-        with self._lock:
-            cursor = conn.cursor()
-            cursor.execute(
-                "DELETE FROM block_hash_history WHERE chain_id = ? AND block_number < ?",
-                (chain_id, cutoff),
-            )
-            count = cursor.rowcount
-            if not self._in_transaction:
-                conn.commit()
-            cursor.close()
-            return count
-
-    def get_oldest_block_in_history(self, chain_id: int) -> int | None:
-        row = self.execute_one(
-            "SELECT MIN(block_number) as min_block FROM block_hash_history WHERE chain_id = ?",
-            (chain_id,),
-        )
-        return row["min_block"] if row else None
-
-    def get_latest_block_in_history(self, chain_id: int) -> int | None:
-        row = self.execute_one(
-            "SELECT MAX(block_number) as max_block FROM block_hash_history WHERE chain_id = ?",
-            (chain_id,),
-        )
-        return row["max_block"] if row else None
-
-    def get_inflight_intent_count(
-        self, chain_id: int, job_id: str, signer_address: str
-    ) -> int:
-        row = self.execute_one(
-            """
-            SELECT COUNT(*) as count
-            FROM tx_intents
-            WHERE chain_id = ?
-              AND job_id = ?
-              AND signer_address = ?
-              AND status IN ('created', 'claimed', 'sending', 'pending')
-            """,
-            (chain_id, job_id, signer_address.lower()),
-        )
-        return int(row["count"]) if row else 0
-
-    def get_inflight_intents_for_scope(
-        self,
-        chain_id: int,
-        job_id: str,
-        signer_address: str,
-        to_address: str,
-    ) -> list[dict[str, Any]]:
-        rows = self.execute_returning(
-            """
-            SELECT intent_id, status, claimed_at, created_at
-            FROM tx_intents
-            WHERE chain_id = ?
-              AND job_id = ?
-              AND signer_address = ?
-              AND to_address = ?
-              AND status IN ('created', 'claimed', 'sending', 'pending')
-            ORDER BY created_at ASC
-            """,
-            (chain_id, job_id, signer_address.lower(), to_address),
-        )
-        return [dict(row) for row in rows]
-
-    # =========================================================================
-    # Job Operations
-    # =========================================================================
-
-    def get_job(self, job_id: str) -> JobConfig | None:
-        row = self.execute_one("SELECT * FROM jobs WHERE job_id = ?", (job_id,))
-        if not row:
-            return None
-        return self._row_to_job_config(row)
-
-    def get_enabled_jobs(self) -> list[JobConfig]:
-        rows = self.execute_returning(
-            "SELECT * FROM jobs WHERE enabled = 1 ORDER BY job_id"
-        )
-        return [self._row_to_job_config(row) for row in rows]
-
-    def list_all_jobs(self) -> list[JobConfig]:
-        rows = self.execute_returning("SELECT * FROM jobs ORDER BY job_id")
-        return [self._row_to_job_config(row) for row in rows]
-
-    def _row_to_job_config(self, row: dict[str, Any]) -> JobConfig:
-        return JobConfig(
-            job_id=row["job_id"],
-            job_name=row["job_name"],
-            enabled=bool(row["enabled"]),
-            check_interval_blocks=row["check_interval_blocks"],
-            last_checked_block_number=row["last_checked_block_number"],
-            last_triggered_block_number=row["last_triggered_block_number"],
-            created_at=row["created_at"],
-            updated_at=row["updated_at"],
-        )
-
-    def upsert_job(
-        self,
-        job_id: str,
-        job_name: str,
-        check_interval_blocks: int,
-        enabled: bool = True,
-    ) -> None:
-        self.execute(
-            """
-            INSERT INTO jobs (job_id, job_name, check_interval_blocks, enabled)
-            VALUES (?, ?, ?, ?)
-            ON CONFLICT(job_id) DO UPDATE SET
-                job_name = excluded.job_name,
-                check_interval_blocks = excluded.check_interval_blocks,
-                updated_at = CURRENT_TIMESTAMP
-            """,
-            (job_id, job_name, check_interval_blocks, enabled),
-        )
-
-    def update_job_checked(
-        self, job_id: str, block_number: int, triggered: bool = False
-    ) -> None:
-        if triggered:
-            self.execute(
-                """
-                UPDATE jobs SET
-                    last_checked_block_number = ?,
-                    last_triggered_block_number = ?,
-                    updated_at = CURRENT_TIMESTAMP
-                WHERE job_id = ?
-                """,
-                (block_number, block_number, job_id),
-            )
-        else:
-            self.execute(
-                """
-                UPDATE jobs SET
-                    last_checked_block_number = ?,
-                    updated_at = CURRENT_TIMESTAMP
-                WHERE job_id = ?
-                """,
-                (block_number, job_id),
-            )
-
-    def set_job_enabled(self, job_id: str, enabled: bool) -> bool:
-        conn = self._ensure_connected()
-        with self._lock:
-            cursor = conn.cursor()
-            cursor.execute(
-                "UPDATE jobs SET enabled = ?, updated_at = CURRENT_TIMESTAMP WHERE job_id = ?",
-                (enabled, job_id),
-            )
-            updated = cursor.rowcount > 0
-            if not self._in_transaction:
-                conn.commit()
-            cursor.close()
-            return updated
-
-    def delete_job(self, job_id: str) -> bool:
-        conn = self._ensure_connected()
-        with self._lock:
-            cursor = conn.cursor()
-            # Delete job_kv entries first (foreign key)
-            cursor.execute("DELETE FROM job_kv WHERE job_id = ?", (job_id,))
-            cursor.execute("DELETE FROM jobs WHERE job_id = ?", (job_id,))
-            deleted = cursor.rowcount > 0
-            if not self._in_transaction:
-                conn.commit()
-            cursor.close()
-            return deleted
-
-    def get_job_kv(self, job_id: str, key: str) -> Any | None:
-        row = self.execute_one(
-            "SELECT value_json FROM job_kv WHERE job_id = ? AND key = ?",
-            (job_id, key),
-        )
-        if not row:
-            return None
-        return json.loads(row["value_json"])
-
-    def set_job_kv(self, job_id: str, key: str, value: Any) -> None:
-        value_json = json.dumps(value)
-        self.execute(
-            """
-            INSERT INTO job_kv (job_id, key, value_json)
-            VALUES (?, ?, ?)
-            ON CONFLICT(job_id, key) DO UPDATE SET
-                value_json = excluded.value_json,
-                updated_at = CURRENT_TIMESTAMP
-            """,
-            (job_id, key, value_json),
-        )
-
-    def delete_job_kv(self, job_id: str, key: str) -> bool:
-        conn = self._ensure_connected()
-        with self._lock:
-            cursor = conn.cursor()
-            cursor.execute(
-                "DELETE FROM job_kv WHERE job_id = ? AND key = ?",
-                (job_id, key),
-            )
-            deleted = cursor.rowcount > 0
-            if not self._in_transaction:
-                conn.commit()
-            cursor.close()
-            return deleted
-
-    # =========================================================================
-    # Signer & Nonce Operations
-    # =========================================================================
-
-    def get_signer_state(self, chain_id: int, address: str) -> SignerState | None:
-        row = self.execute_one(
-            "SELECT * FROM signers WHERE chain_id = ? AND signer_address = ?",
-            (chain_id, address),
-        )
-        if not row:
-            return None
-        return self._row_to_signer_state(row)
-
-    def get_all_signers(self, chain_id: int) -> list[SignerState]:
-        rows = self.execute_returning(
-            "SELECT * FROM signers WHERE chain_id = ?", (chain_id,)
-        )
-        return [self._row_to_signer_state(row) for row in rows]
-
-    def _row_to_signer_state(self, row: dict[str, Any]) -> SignerState:
-        return SignerState(
-            chain_id=row["chain_id"],
-            signer_address=row["signer_address"],
-            next_nonce=row["next_nonce"],
-            last_synced_chain_nonce=row["last_synced_chain_nonce"],
-            created_at=row["created_at"],
-            updated_at=row["updated_at"],
-            gap_started_at=row.get("gap_started_at"),
-            alias=row.get("alias"),
-        )
-
-    def upsert_signer(
-        self,
-        chain_id: int,
-        address: str,
-        next_nonce: int,
-        last_synced_chain_nonce: int | None = None,
-    ) -> None:
-        self.execute(
-            """
-            INSERT INTO signers (chain_id, signer_address, next_nonce, last_synced_chain_nonce)
-            VALUES (?, ?, ?, ?)
-            ON CONFLICT(chain_id, signer_address) DO UPDATE SET
-                next_nonce = excluded.next_nonce,
-                last_synced_chain_nonce = excluded.last_synced_chain_nonce,
-                updated_at = CURRENT_TIMESTAMP
-            """,
-            (chain_id, address, next_nonce, last_synced_chain_nonce),
-        )
-
-    def update_signer_next_nonce(
-        self, chain_id: int, address: str, next_nonce: int
-    ) -> None:
-        self.execute(
-            """
-            UPDATE signers SET next_nonce = ?, updated_at = CURRENT_TIMESTAMP
-            WHERE chain_id = ? AND signer_address = ?
-            """,
-            (next_nonce, chain_id, address),
-        )
-
-    def update_signer_chain_nonce(
-        self, chain_id: int, address: str, chain_nonce: int
-    ) -> None:
-        self.execute(
-            """
-            UPDATE signers SET last_synced_chain_nonce = ?, updated_at = CURRENT_TIMESTAMP
-            WHERE chain_id = ? AND signer_address = ?
-            """,
-            (chain_nonce, chain_id, address),
-        )
-
-    def set_gap_started_at(
-        self, chain_id: int, address: str, started_at: datetime
-    ) -> None:
-        """Record when gap blocking started for a signer."""
-        self.execute(
-            """
-            UPDATE signers SET gap_started_at = ?, updated_at = CURRENT_TIMESTAMP
-            WHERE chain_id = ? AND signer_address = ?
-            """,
-            (started_at.isoformat() if started_at else None, chain_id, address),
-        )
-
-    def clear_gap_started_at(self, chain_id: int, address: str) -> None:
-        """Clear gap tracking (gap resolved or force reset)."""
-        self.execute(
-            """
-            UPDATE signers SET gap_started_at = NULL, updated_at = CURRENT_TIMESTAMP
-            WHERE chain_id = ? AND signer_address = ?
-            """,
-            (chain_id, address),
-        )
-
-    def get_signer_by_alias(self, chain_id: int, alias: str) -> SignerState | None:
-        """Get signer by alias. Returns None if not found."""
-        row = self.execute_one(
-            """
-            SELECT * FROM signers
-            WHERE chain_id = ? AND alias = ?
-            """,
-            (chain_id, alias),
-        )
-        if not row:
-            return None
-        return self._row_to_signer_state(row)
-
-    def reserve_nonce_atomic(
-        self,
-        chain_id: int,
-        address: str,
-        chain_nonce: int | None,
-        intent_id: UUID | None = None,
-    ) -> int:
-        conn = self._ensure_connected()
-        intent_id_str = str(intent_id) if intent_id else None
-        with self._lock:
-            try:
-                conn.execute("BEGIN IMMEDIATE")
-                self._in_transaction = True
-
-                conn.execute(
-                    """
-                    INSERT INTO signers (chain_id, signer_address, next_nonce, last_synced_chain_nonce)
-                    VALUES (?, ?, 0, NULL)
-                    ON CONFLICT(chain_id, signer_address) DO NOTHING
-                    """,
-                    (chain_id, address),
-                )
-
-                cursor = conn.cursor()
-                cursor.execute(
-                    """
-                    SELECT next_nonce FROM signers
-                    WHERE chain_id = ? AND signer_address = ?
-                    """,
-                    (chain_id, address),
-                )
-                row = cursor.fetchone()
-                cursor.close()
-                if row is None:
-                    raise DatabaseError("Failed to lock signer row")
-
-                db_next_nonce = row["next_nonce"]
-                base_nonce = chain_nonce if chain_nonce is not None else db_next_nonce
-
-                cursor = conn.cursor()
-                cursor.execute(
-                    """
-                    SELECT nonce FROM nonce_reservations
-                    WHERE chain_id = ? AND signer_address = ?
-                    AND status != ?
-                    AND nonce >= ?
-                    ORDER BY nonce
-                    """,
-                    (chain_id, address, NonceStatus.RELEASED.value, base_nonce),
-                )
-                rows = cursor.fetchall()
-                cursor.close()
-
-                candidate = base_nonce
-                for res in rows:
-                    if res["nonce"] == candidate:
-                        candidate += 1
-                    elif res["nonce"] > candidate:
-                        break
-
-                if candidate - base_nonce > 100:
-                    raise DatabaseError(
-                        f"Could not find available nonce within 100 slots for signer {address}"
-                    )
-
-                conn.execute(
-                    """
-                    INSERT INTO nonce_reservations (chain_id, signer_address, nonce, status, intent_id)
-                    VALUES (?, ?, ?, ?, ?)
-                    ON CONFLICT(chain_id, signer_address, nonce) DO UPDATE SET
-                        status = excluded.status,
-                        intent_id = excluded.intent_id,
-                        updated_at = CURRENT_TIMESTAMP
-                    """,
-                    (chain_id, address, candidate, NonceStatus.RESERVED.value, intent_id_str),
-                )
-
-                new_next_nonce = max(db_next_nonce, candidate + 1)
-                conn.execute(
-                    """
-                    UPDATE signers SET next_nonce = ?, updated_at = CURRENT_TIMESTAMP
-                    WHERE chain_id = ? AND signer_address = ?
-                    """,
-                    (new_next_nonce, chain_id, address),
-                )
-
-                conn.commit()
-                return candidate
-            except Exception:
-                conn.rollback()
-                raise
-            finally:
-                self._in_transaction = False
-
-    def get_nonce_reservation(
-        self, chain_id: int, address: str, nonce: int
-    ) -> NonceReservation | None:
-        row = self.execute_one(
-            """
-            SELECT * FROM nonce_reservations
-            WHERE chain_id = ? AND signer_address = ? AND nonce = ?
-            """,
-            (chain_id, address, nonce),
-        )
-        if not row:
-            return None
-        return self._row_to_nonce_reservation(row)
-
-    def get_reservations_for_signer(
-        self, chain_id: int, address: str, status: str | None = None
-    ) -> list[NonceReservation]:
-        if status:
-            rows = self.execute_returning(
-                """
-                SELECT * FROM nonce_reservations
-                WHERE chain_id = ? AND signer_address = ? AND status = ?
-                ORDER BY nonce
-                """,
-                (chain_id, address, status),
-            )
-        else:
-            rows = self.execute_returning(
-                """
-                SELECT * FROM nonce_reservations
-                WHERE chain_id = ? AND signer_address = ?
-                ORDER BY nonce
-                """,
-                (chain_id, address),
-            )
-        return [self._row_to_nonce_reservation(row) for row in rows]
-
-    def get_reservations_below_nonce(
-        self, chain_id: int, address: str, nonce: int
-    ) -> list[NonceReservation]:
-        rows = self.execute_returning(
-            """
-            SELECT * FROM nonce_reservations
-            WHERE chain_id = ? AND signer_address = ? AND nonce < ?
-            ORDER BY nonce
-            """,
-            (chain_id, address, nonce),
-        )
-        return [self._row_to_nonce_reservation(row) for row in rows]
-
-    def _row_to_nonce_reservation(self, row: dict[str, Any]) -> NonceReservation:
-        intent_id = row["intent_id"]
-        if intent_id and isinstance(intent_id, str):
-            intent_id = UUID(intent_id)
-        return NonceReservation(
-            id=row["id"],
-            chain_id=row["chain_id"],
-            signer_address=row["signer_address"],
-            nonce=row["nonce"],
-            status=NonceStatus(row["status"]),
-            intent_id=intent_id,
-            created_at=row["created_at"],
-            updated_at=row["updated_at"],
-        )
-
-    def create_nonce_reservation(
-        self,
-        chain_id: int,
-        address: str,
-        nonce: int,
-        status: str = "reserved",
-        intent_id: UUID | None = None,
-    ) -> NonceReservation:
-        intent_id_str = str(intent_id) if intent_id else None
-        self.execute(
-            """
-            INSERT INTO nonce_reservations (chain_id, signer_address, nonce, status, intent_id)
-            VALUES (?, ?, ?, ?, ?)
-            ON CONFLICT(chain_id, signer_address, nonce) DO UPDATE SET
-                status = excluded.status,
-                intent_id = excluded.intent_id,
-                updated_at = CURRENT_TIMESTAMP
-            """,
-            (chain_id, address, nonce, status, intent_id_str),
-        )
-        # Fetch and return the reservation
-        reservation = self.get_nonce_reservation(chain_id, address, nonce)
-        if not reservation:
-            raise DatabaseError("Failed to create nonce reservation")
-        return reservation
-
-    def update_nonce_reservation_status(
-        self,
-        chain_id: int,
-        address: str,
-        nonce: int,
-        status: str,
-        intent_id: UUID | None = None,
-    ) -> bool:
-        conn = self._ensure_connected()
-        intent_id_str = str(intent_id) if intent_id else None
-        with self._lock:
-            cursor = conn.cursor()
-            if intent_id_str:
-                cursor.execute(
-                    """
-                    UPDATE nonce_reservations SET status = ?, intent_id = ?, updated_at = CURRENT_TIMESTAMP
-                    WHERE chain_id = ? AND signer_address = ? AND nonce = ?
-                    """,
-                    (status, intent_id_str, chain_id, address, nonce),
-                )
-            else:
-                cursor.execute(
-                    """
-                    UPDATE nonce_reservations SET status = ?, updated_at = CURRENT_TIMESTAMP
-                    WHERE chain_id = ? AND signer_address = ? AND nonce = ?
-                    """,
-                    (status, chain_id, address, nonce),
-                )
-            updated = cursor.rowcount > 0
-            if not self._in_transaction:
-                conn.commit()
-            cursor.close()
-            return updated
-
-    def release_nonce_reservation(
-        self, chain_id: int, address: str, nonce: int
-    ) -> bool:
-        return self.update_nonce_reservation_status(
-            chain_id, address, nonce, "released"
-        )
-
-    def cleanup_orphaned_nonces(
-        self, chain_id: int, older_than_hours: int = 24
-    ) -> int:
-        conn = self._ensure_connected()
-        with self._lock:
-            cursor = conn.cursor()
-            try:
-                cursor.execute(
-                    """
-                    DELETE FROM nonce_reservations
-                    WHERE chain_id = ?
-                      AND status = 'orphaned'
-                      AND updated_at < datetime('now', ? || ' hours')
-                    """,
-                    (chain_id, f"-{older_than_hours}"),
-                )
-                deleted = cursor.rowcount
-                if not self._in_transaction:
-                    conn.commit()
-                return deleted
-            finally:
-                cursor.close()
-
-    # =========================================================================
-    # Intent Operations
-    # =========================================================================
-
-    def create_intent(
-        self,
-        intent_id: UUID,
-        job_id: str,
-        chain_id: int,
-        signer_address: str,
-        idempotency_key: str,
-        to_address: str,
-        data: str | None,
-        value_wei: str,
-        gas_limit: int | None,
-        max_fee_per_gas: str | None,
-        max_priority_fee_per_gas: str | None,
-        min_confirmations: int,
-        deadline_ts: datetime | None,
-        broadcast_group: str | None = None,
-        broadcast_endpoints: list[str] | None = None,
-        metadata: dict | None = None,
-    ) -> TxIntent | None:
-        signer_address = signer_address.lower()
-        try:
-            self.execute(
-                """
-                INSERT INTO tx_intents (
-                    intent_id, job_id, chain_id, signer_address, idempotency_key,
-                    to_address, data, value_wei, gas_limit, max_fee_per_gas,
-                    max_priority_fee_per_gas, min_confirmations, deadline_ts,
-                    broadcast_group, broadcast_endpoints_json, retry_after, status,
-                    metadata_json
-                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, 'created', ?)
-                """,
-                (
-                    str(intent_id),
-                    job_id,
-                    chain_id,
-                    signer_address,
-                    idempotency_key,
-                    to_address,
-                    data,
-                    value_wei,
-                    gas_limit,
-                    max_fee_per_gas,
-                    max_priority_fee_per_gas,
-                    min_confirmations,
-                    deadline_ts,
-                    broadcast_group,
-                    json.dumps(broadcast_endpoints) if broadcast_endpoints else None,
-                    json.dumps(metadata) if metadata else None,
-                ),
-            )
-            return self.get_intent(intent_id)
-        except sqlite3.IntegrityError:
-            # Idempotency key already exists
-            return None
-        except DatabaseError as e:
-            if "UNIQUE constraint failed" in str(e):
-                return None
-            raise
-
-    def get_intent(self, intent_id: UUID) -> TxIntent | None:
-        row = self.execute_one(
-            "SELECT * FROM tx_intents WHERE intent_id = ?",
-            (str(intent_id),),
-        )
-        if not row:
-            return None
-        return self._row_to_intent(row)
-
-    def get_intent_by_idempotency_key(
-        self,
-        chain_id: int,
-        signer_address: str,
-        idempotency_key: str,
-    ) -> TxIntent | None:
-        row = self.execute_one(
-            "SELECT * FROM tx_intents WHERE chain_id = ? AND signer_address = ? AND idempotency_key = ?",
-            (chain_id, signer_address.lower(), idempotency_key),
-        )
-        if not row:
-            return None
-        return self._row_to_intent(row)
-
-    def _row_to_intent(self, row: dict[str, Any]) -> TxIntent:
-        intent_id = row["intent_id"]
-        if isinstance(intent_id, str):
-            intent_id = UUID(intent_id)
-        # Parse metadata_json
-        metadata_json = row.get("metadata_json")
-        metadata = json.loads(metadata_json) if metadata_json else {}
-        return TxIntent(
-            intent_id=intent_id,
-            job_id=row["job_id"],
-            chain_id=row["chain_id"],
-            signer_address=row["signer_address"],
-            idempotency_key=row["idempotency_key"],
-            to_address=row["to_address"],
-            data=row["data"],
-            value_wei=row["value_wei"],
-            gas_limit=row["gas_limit"],
-            max_fee_per_gas=row["max_fee_per_gas"],
-            max_priority_fee_per_gas=row["max_priority_fee_per_gas"],
-            min_confirmations=row["min_confirmations"],
-            deadline_ts=row["deadline_ts"],
-            retry_after=row["retry_after"],
-            retry_count=row.get("retry_count", 0),
-            status=IntentStatus(row["status"]),
-            claim_token=row["claim_token"],
-            claimed_at=row["claimed_at"],
-            created_at=row["created_at"],
-            updated_at=row["updated_at"],
-            # Broadcast binding (may be None if not yet broadcast)
-            broadcast_group=row.get("broadcast_group"),
-            broadcast_endpoints_json=row.get("broadcast_endpoints_json"),
-            metadata=metadata,
-        )
-
-    def get_intents_by_status(
-        self,
-        status: str | list[str],
-        chain_id: int | None = None,
-        job_id: str | None = None,
-        limit: int = 100,
-    ) -> list[TxIntent]:
-        if isinstance(status, str):
-            status = [status]
-
-        placeholders = ",".join("?" * len(status))
-        query = f"SELECT * FROM tx_intents WHERE status IN ({placeholders})"
-        params: list[Any] = list(status)
-
-        if chain_id is not None:
-            query += " AND chain_id = ?"
-            params.append(chain_id)
-        if job_id is not None:
-            query += " AND job_id = ?"
-            params.append(job_id)
-
-        query += " ORDER BY created_at ASC LIMIT ?"
-        params.append(limit)
-
-        rows = self.execute_returning(query, tuple(params))
-        return [self._row_to_intent(row) for row in rows]
-
-    def list_intents_filtered(
-        self,
-        status: str | None = None,
-        job_id: str | None = None,
-        limit: int = 50,
-    ) -> list[dict[str, Any]]:
-        query = "SELECT * FROM tx_intents WHERE 1=1"
-        params: list[Any] = []
-
-        if status is not None:
-            query += " AND status = ?"
-            params.append(status)
-        if job_id is not None:
-            query += " AND job_id = ?"
-            params.append(job_id)
-
-        query += " ORDER BY created_at DESC LIMIT ?"
-        params.append(limit)
-
-        return self.execute_returning(query, tuple(params))
-
-    def get_active_intent_count(self, job_id: str, chain_id: int | None = None) -> int:
-        statuses = [
-            IntentStatus.CREATED.value,
-            IntentStatus.CLAIMED.value,
-            IntentStatus.SENDING.value,
-            IntentStatus.PENDING.value,
-        ]
-        placeholders = ",".join("?" * len(statuses))
-        query = f"SELECT COUNT(*) AS count FROM tx_intents WHERE status IN ({placeholders}) AND job_id = ?"
-        params: list[Any] = list(statuses)
-        params.append(job_id)
-        if chain_id is not None:
-            query += " AND chain_id = ?"
-            params.append(chain_id)
-        row = self.execute_one(query, tuple(params))
-        return int(row["count"]) if row else 0
-
-    def get_pending_intent_count(self, chain_id: int | None = None) -> int:
-        statuses = [
-            IntentStatus.CREATED.value,
-            IntentStatus.CLAIMED.value,
-            IntentStatus.SENDING.value,
-            IntentStatus.PENDING.value,
-        ]
-        placeholders = ",".join("?" * len(statuses))
-        query = f"SELECT COUNT(*) AS count FROM tx_intents WHERE status IN ({placeholders})"
-        params: list[Any] = list(statuses)
-        if chain_id is not None:
-            query += " AND chain_id = ?"
-            params.append(chain_id)
-        row = self.execute_one(query, tuple(params))
-        return int(row["count"]) if row else 0
-
-    def get_backing_off_intent_count(self, chain_id: int | None = None) -> int:
-        query = "SELECT COUNT(*) AS count FROM tx_intents WHERE retry_after > CURRENT_TIMESTAMP"
-        params: list[Any] = []
-        if chain_id is not None:
-            query += " AND chain_id = ?"
-            params.append(chain_id)
-        row = self.execute_one(query, tuple(params))
-        return int(row["count"]) if row else 0
-
-    def get_oldest_pending_intent_age(self, chain_id: int) -> float | None:
-        query = """
-            SELECT (julianday('now') - julianday(MIN(created_at))) * 86400 AS age_seconds
-            FROM tx_intents
-            WHERE chain_id = ?
-              AND status IN ('created', 'pending', 'claimed', 'sending')
-        """
-        result = self.execute_one(query, (chain_id,))
-        if result and result.get("age_seconds") is not None:
-            return result["age_seconds"]
-        return None
-
-    def list_intent_inconsistencies(
-        self,
-        max_age_seconds: int,
-        limit: int = 100,
-        chain_id: int | None = None,
-    ) -> list[dict[str, Any]]:
-        chain_clause = ""
-        chain_params: list[Any] = []
-        if chain_id is not None:
-            chain_clause = " AND chain_id = ?"
-            chain_params = [chain_id] * 5
-
-        query = f"""
-        SELECT intent_id, status, 'pending_no_attempt' AS reason
-        FROM tx_intents
-        WHERE status = 'pending'
-        {chain_clause}
-        AND NOT EXISTS (
-            SELECT 1 FROM tx_attempts
-            WHERE tx_attempts.intent_id = tx_intents.intent_id
-              AND tx_attempts.tx_hash IS NOT NULL
-        )
-
-        UNION ALL
-        SELECT intent_id, status, 'confirmed_no_confirmed_attempt' AS reason
-        FROM tx_intents
-        WHERE status = 'confirmed'
-        {chain_clause}
-        AND NOT EXISTS (
-            SELECT 1 FROM tx_attempts
-            WHERE tx_attempts.intent_id = tx_intents.intent_id
-              AND tx_attempts.status = 'confirmed'
-        )
-
-        UNION ALL
-        SELECT intent_id, status, 'claimed_missing_claim' AS reason
-        FROM tx_intents
-        WHERE status = 'claimed'
-        {chain_clause}
-        AND (claim_token IS NULL OR claimed_at IS NULL)
-
-        UNION ALL
-        SELECT intent_id, status, 'nonclaimed_with_claim' AS reason
-        FROM tx_intents
-        WHERE status != 'claimed'
-        {chain_clause}
-        AND (claim_token IS NOT NULL OR claimed_at IS NOT NULL)
-
-        UNION ALL
-        SELECT intent_id, status, 'sending_stuck' AS reason
-        FROM tx_intents
-        WHERE status = 'sending'
-        {chain_clause}
-        AND updated_at < datetime('now', ? || ' seconds')
-
-        LIMIT ?
-        """
-        params_with_age = chain_params + [f"-{max_age_seconds}", limit]
-        rows = self.execute_returning(query, tuple(params_with_age))
-        return [dict(row) for row in rows]
-
-    def list_sending_intents_older_than(
-        self,
-        max_age_seconds: int,
-        limit: int = 100,
-        chain_id: int | None = None,
-    ) -> list[TxIntent]:
-        query = """
-        SELECT * FROM tx_intents
-        WHERE status = 'sending'
-        AND updated_at < datetime('now', ? || ' seconds')
-        """
-        params: list[Any] = [f"-{max_age_seconds}"]
-        if chain_id is not None:
-            query += " AND chain_id = ?"
-            params.append(chain_id)
-        query += " ORDER BY updated_at ASC LIMIT ?"
-        params.append(limit)
-        rows = self.execute_returning(query, tuple(params))
-        return [self._row_to_intent(row) for row in rows]
-
-    def claim_next_intent(
-        self,
-        claim_token: str,
-        claimed_by: str | None = None,
-    ) -> TxIntent | None:
-        """Claim the next available intent for processing.
-
-        SQLite version uses deterministic ordering with immediate lock.
-        """
-        conn = self._ensure_connected()
-        with self._lock:
-            # Use IMMEDIATE transaction for claiming
-            conn.execute("BEGIN IMMEDIATE")
-            try:
-                cursor = conn.cursor()
-                # Find and claim in one atomic operation
-                cursor.execute(
-                    """
-                    UPDATE tx_intents
-                    SET status = 'claimed', claim_token = ?, claimed_at = CURRENT_TIMESTAMP,
-                        claimed_by = ?,
-                        retry_after = NULL,
-                        updated_at = CURRENT_TIMESTAMP
-                    WHERE intent_id = (
-                        SELECT intent_id FROM tx_intents
-                        WHERE status = 'created'
-                        AND (deadline_ts IS NULL OR deadline_ts > CURRENT_TIMESTAMP)
-                        AND (retry_after IS NULL OR retry_after <= CURRENT_TIMESTAMP)
-                        ORDER BY created_at ASC, intent_id ASC
-                        LIMIT 1
-                    )
-                    AND status = 'created'
-                    """,
-                    (claim_token, claimed_by),
-                )
-
-                if cursor.rowcount == 0:
-                    conn.rollback()
-                    cursor.close()
-                    return None
-
-                # Get the claimed intent
-                cursor.execute(
-                    "SELECT * FROM tx_intents WHERE claim_token = ? AND status = 'claimed'",
-                    (claim_token,),
-                )
-                row = cursor.fetchone()
-                conn.commit()
-                cursor.close()
-
-                if row:
-                    return self._row_to_intent(dict(row))
-                return None
-            except Exception:
-                conn.rollback()
-                raise
-
-    def update_intent_status(
-        self,
-        intent_id: UUID,
-        status: str,
-        claim_token: str | None = None,
-    ) -> bool:
-        conn = self._ensure_connected()
-        with self._lock:
-            cursor = conn.cursor()
-            if claim_token:
-                cursor.execute(
-                    """
-                    UPDATE tx_intents SET status = ?, claim_token = ?,
-                        claimed_at = CURRENT_TIMESTAMP, updated_at = CURRENT_TIMESTAMP
-                    WHERE intent_id = ?
-                    """,
-                    (status, claim_token, str(intent_id)),
-                )
-            else:
-                cursor.execute(
-                    """
-                    UPDATE tx_intents SET status = ?, updated_at = CURRENT_TIMESTAMP
-                    WHERE intent_id = ?
-                    """,
-                    (status, str(intent_id)),
-                )
-            updated = cursor.rowcount > 0
-            if not self._in_transaction:
-                conn.commit()
-            cursor.close()
-            return updated
-
-    def update_intent_status_if(
-        self,
-        intent_id: UUID,
-        status: str,
-        expected_status: str | list[str],
-    ) -> bool:
-        if isinstance(expected_status, str):
-            expected_status = [expected_status]
-        placeholders = ",".join("?" * len(expected_status))
-        conn = self._ensure_connected()
-        with self._lock:
-            cursor = conn.cursor()
-            cursor.execute(
-                f"""
-                UPDATE tx_intents SET status = ?, updated_at = CURRENT_TIMESTAMP
-                WHERE intent_id = ? AND status IN ({placeholders})
-                """,
-                (status, str(intent_id), *expected_status),
-            )
-            updated = cursor.rowcount > 0
-            if not self._in_transaction:
-                conn.commit()
-            cursor.close()
-            return updated
-
-    def transition_intent_status(
-        self,
-        intent_id: UUID,
-        from_statuses: list[str],
-        to_status: str,
-    ) -> tuple[bool, str | None]:
-        """Atomic status transition with conditional claim clearing.
-
-        SQLite version: uses BEGIN IMMEDIATE for fewer lock surprises,
-        then SELECT + UPDATE with WHERE status guard.
-        """
-        conn = self._ensure_connected()
-        placeholders = ",".join("?" * len(from_statuses))
-
-        with self._lock:
-            cursor = conn.cursor()
-            started_tx = False
-            if not self._in_transaction:
-                # BEGIN IMMEDIATE to acquire write lock early
-                cursor.execute("BEGIN IMMEDIATE")
-                started_tx = True
-
-            try:
-                # Get current status (within transaction)
-                cursor.execute(
-                    "SELECT status FROM tx_intents WHERE intent_id = ?",
-                    (str(intent_id),)
-                )
-                row = cursor.fetchone()
-                if not row:
-                    if started_tx:
-                        conn.rollback()
-                    cursor.close()
-                    return (False, None)
-
-                old_status = row[0]
-
-                # Check if transition is allowed
-                if old_status not in from_statuses:
-                    if started_tx:
-                        conn.rollback()
-                    cursor.close()
-                    return (False, None)
-
-                # Clear claim only if leaving 'claimed' (not claimed->claimed)
-                should_clear_claim = old_status == "claimed" and to_status != "claimed"
-
-                if should_clear_claim:
-                    cursor.execute(
-                        f"""
-                        UPDATE tx_intents
-                        SET status = ?,
-                            updated_at = CURRENT_TIMESTAMP,
-                            claim_token = NULL,
-                            claimed_at = NULL,
-                            claimed_by = NULL
-                        WHERE intent_id = ? AND status IN ({placeholders})
-                        """,
-                        (to_status, str(intent_id), *from_statuses),
-                    )
-                else:
-                    cursor.execute(
-                        f"""
-                        UPDATE tx_intents
-                        SET status = ?, updated_at = CURRENT_TIMESTAMP
-                        WHERE intent_id = ? AND status IN ({placeholders})
-                        """,
-                        (to_status, str(intent_id), *from_statuses),
-                    )
-
-                if cursor.rowcount == 0:
-                    # Lost race - status changed between SELECT and UPDATE
-                    if started_tx:
-                        conn.rollback()
-                    cursor.close()
-                    return (False, None)
-
-                if started_tx:
-                    conn.commit()
-                cursor.close()
-                return (True, old_status)
-
-            except Exception:
-                if started_tx:
-                    conn.rollback()
-                cursor.close()
-                raise
-
-    def update_intent_signer(self, intent_id: UUID, signer_address: str) -> bool:
-        conn = self._ensure_connected()
-        with self._lock:
-            cursor = conn.cursor()
-            cursor.execute(
-                """
-                UPDATE tx_intents SET signer_address = ?, updated_at = CURRENT_TIMESTAMP
-                WHERE intent_id = ?
-                """,
-                (signer_address.lower(), str(intent_id)),
-            )
-            updated = cursor.rowcount > 0
-            if not self._in_transaction:
-                conn.commit()
-            cursor.close()
-            return updated
-
-    def release_intent_claim(self, intent_id: UUID) -> bool:
-        conn = self._ensure_connected()
-        with self._lock:
-            cursor = conn.cursor()
-            cursor.execute(
-                """
-                UPDATE tx_intents SET status = 'created', claim_token = NULL,
-                    claimed_at = NULL, updated_at = CURRENT_TIMESTAMP
-                WHERE intent_id = ? AND status = 'claimed'
-                """,
-                (str(intent_id),),
-            )
-            updated = cursor.rowcount > 0
-            if not self._in_transaction:
-                conn.commit()
-            cursor.close()
-            return updated
-
-    def release_intent_claim_if_token(self, intent_id: UUID, claim_token: str) -> bool:
-        rowcount = self.execute_returning_rowcount(
-            """
-            UPDATE tx_intents
-            SET status = 'created',
-                claim_token = NULL,
-                claimed_at = NULL,
-                claimed_by = NULL,
-                updated_at = CURRENT_TIMESTAMP
-            WHERE intent_id = ? AND claim_token = ? AND status = 'claimed'
-            """,
-            (str(intent_id), claim_token),
-        )
-        return rowcount == 1
-
-    def clear_intent_claim(self, intent_id: UUID) -> bool:
-        conn = self._ensure_connected()
-        with self._lock:
-            cursor = conn.cursor()
-            cursor.execute(
-                """
-                UPDATE tx_intents
-                SET claim_token = NULL, claimed_at = NULL, updated_at = CURRENT_TIMESTAMP
-                WHERE intent_id = ?
-                """,
-                (str(intent_id),),
-            )
-            updated = cursor.rowcount > 0
-            if not self._in_transaction:
-                conn.commit()
-            cursor.close()
-            return updated
-
-    def set_intent_retry_after(self, intent_id: UUID, retry_after: datetime | None) -> bool:
-        conn = self._ensure_connected()
-        with self._lock:
-            cursor = conn.cursor()
-            cursor.execute(
-                """
-                UPDATE tx_intents
-                SET retry_after = ?, updated_at = CURRENT_TIMESTAMP
-                WHERE intent_id = ?
-                """,
-                (retry_after, str(intent_id)),
-            )
-            updated = cursor.rowcount > 0
-            if not self._in_transaction:
-                conn.commit()
-            cursor.close()
-            return updated
-
-    def increment_intent_retry_count(self, intent_id: UUID) -> int:
-        conn = self._ensure_connected()
-        with self._lock:
-            cursor = conn.cursor()
-            cursor.execute(
-                """
-                UPDATE tx_intents
-                SET retry_count = retry_count + 1, updated_at = CURRENT_TIMESTAMP
-                WHERE intent_id = ?
-                """,
-                (str(intent_id),),
-            )
-            if cursor.rowcount == 0:
-                cursor.close()
-                return 0
-            cursor.execute(
-                "SELECT retry_count FROM tx_intents WHERE intent_id = ?",
-                (str(intent_id),),
-            )
-            row = cursor.fetchone()
-            if not self._in_transaction:
-                conn.commit()
-            cursor.close()
-            return row[0] if row else 0
-
-    def release_stale_intent_claims(self, max_age_seconds: int) -> int:
-        conn = self._ensure_connected()
-        with self._lock:
-            cursor = conn.cursor()
-            cursor.execute(
-                """
-                UPDATE tx_intents
-                SET status = 'created', claim_token = NULL, claimed_at = NULL,
-                    updated_at = CURRENT_TIMESTAMP
-                WHERE status = 'claimed'
-                AND claimed_at < datetime('now', ? || ' seconds')
-                AND NOT EXISTS (
-                    SELECT 1 FROM tx_attempts WHERE tx_attempts.intent_id = tx_intents.intent_id
-                )
-                """,
-                (f"-{max_age_seconds}",),
-            )
-            count = cursor.rowcount
-            if not self._in_transaction:
-                conn.commit()
-            cursor.close()
-            return count
-
-    def abandon_intent(self, intent_id: UUID) -> bool:
-        return self.update_intent_status(intent_id, "abandoned")
-
-    def get_pending_intents_for_signer(
-        self, chain_id: int, address: str
-    ) -> list[TxIntent]:
-        rows = self.execute_returning(
-            """
-            SELECT * FROM tx_intents
-            WHERE chain_id = ? AND signer_address = ?
-            AND status IN ('sending', 'pending')
-            ORDER BY created_at
-            """,
-            (chain_id, address),
-        )
-        return [self._row_to_intent(row) for row in rows]
-
-    # =========================================================================
-    # Broadcast Binding Operations
-    # =========================================================================
-
-    def get_broadcast_binding(self, intent_id: UUID) -> tuple[str | None, list[str]] | None:
-        """Get binding if exists, None for first broadcast.
-
-        Returns:
-            Tuple of (group_name or None, endpoints) or None if not bound yet
-
-        Raises:
-            ValueError: If binding is corrupt (wrong type, empty)
-        """
-        row = self.execute_one(
-            """
-            SELECT broadcast_group, broadcast_endpoints_json
-            FROM tx_intents
-            WHERE intent_id = ?
-            """,
-            (str(intent_id),),
-        )
-
-        if not row:
-            return None
-
-        has_endpoints = row["broadcast_endpoints_json"] is not None
-
-        # No endpoints → not bound yet
-        if not has_endpoints:
-            return None
-
-        # Parse and validate endpoints
-        endpoints = json.loads(row["broadcast_endpoints_json"])
-        if not isinstance(endpoints, list):
-            raise ValueError(
-                f"Corrupt binding for intent {intent_id}: "
-                f"endpoints_json is {type(endpoints).__name__}, expected list"
-            )
-        if not endpoints:
-            raise ValueError(
-                f"Corrupt binding for intent {intent_id}: endpoints list is empty"
-            )
-        if not all(isinstance(ep, str) for ep in endpoints):
-            raise ValueError(
-                f"Corrupt binding for intent {intent_id}: endpoints contains non-string"
-            )
-
-        return row["broadcast_group"], endpoints
-
-    # =========================================================================
-    # Attempt Operations
-    # =========================================================================
-
-    def create_attempt(
-        self,
-        attempt_id: UUID,
-        intent_id: UUID,
-        nonce: int,
-        gas_params_json: str,
-        status: str = "signed",
-        tx_hash: str | None = None,
-        replaces_attempt_id: UUID | None = None,
-        broadcast_group: str | None = None,
-        endpoint_url: str | None = None,
-        binding: tuple[str | None, list[str]] | None = None,
-    ) -> TxAttempt:
-        """Create attempt, optionally setting binding atomically.
-
-        Args:
-            binding: If provided (first broadcast), persist binding atomically.
-                     Tuple of (group_name or None, endpoints)
-
-        CRITICAL: Uses WHERE broadcast_endpoints_json IS NULL to prevent overwrites.
-        """
-        replaces_str = str(replaces_attempt_id) if replaces_attempt_id else None
-        conn = self._ensure_connected()
-
-        with self._lock:
-            try:
-                conn.execute("BEGIN IMMEDIATE")
-                self._in_transaction = True
-
-                if binding is not None:
-                    # First broadcast: check existence + binding state for clear error messages
-                    # (The UPDATE's WHERE clause is the true guard; this is for diagnostics)
-                    cursor = conn.cursor()
-                    cursor.execute(
-                        "SELECT broadcast_endpoints_json FROM tx_intents WHERE intent_id = ?",
-                        (str(intent_id),),
-                    )
-                    row = cursor.fetchone()
-                    cursor.close()
-
-                    if not row:
-                        raise ValueError(f"Intent {intent_id} not found")
-                    if row["broadcast_endpoints_json"] is not None:
-                        raise ValueError(
-                            f"Intent {intent_id} already bound. "
-                            f"Cannot rebind — may indicate race condition."
-                        )
-
-                    group_name, endpoints = binding
-                    # Defensive copy — don't persist a list that might be mutated elsewhere
-                    endpoints_snapshot = list(endpoints)
-
-                    rowcount = self.execute_returning_rowcount(
-                        """
-                        UPDATE tx_intents
-                        SET broadcast_group = ?,
-                            broadcast_endpoints_json = ?,
-                            updated_at = CURRENT_TIMESTAMP
-                        WHERE intent_id = ?
-                          AND broadcast_endpoints_json IS NULL
-                        """,
-                        (
-                            group_name,
-                            json.dumps(endpoints_snapshot),
-                            str(intent_id),
-                        ),
-                    )
-
-                    # Rowcount check guards against TOCTOU race (SELECT passed but UPDATE lost)
-                    if rowcount != 1:
-                        raise ValueError(
-                            f"Binding race condition for intent {intent_id}: "
-                            f"another process bound it between SELECT and UPDATE"
-                        )
-
-                # Create attempt with broadcast audit fields
-                conn.execute(
-                    """
-                    INSERT INTO tx_attempts (
-                        attempt_id, intent_id, nonce, gas_params_json, status,
-                        tx_hash, replaces_attempt_id, broadcast_group, endpoint_url
-                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-                    """,
-                    (
-                        str(attempt_id),
-                        str(intent_id),
-                        nonce,
-                        gas_params_json,
-                        status,
-                        tx_hash,
-                        replaces_str,
-                        broadcast_group,
-                        endpoint_url,
-                    ),
-                )
-
-                conn.commit()
-            except Exception:
-                conn.rollback()
-                raise
-            finally:
-                self._in_transaction = False
-
-        attempt = self.get_attempt(attempt_id)
-        if not attempt:
-            raise DatabaseError("Failed to create attempt")
-        return attempt
-
-    def get_attempt(self, attempt_id: UUID) -> TxAttempt | None:
-        row = self.execute_one(
-            "SELECT * FROM tx_attempts WHERE attempt_id = ?",
-            (str(attempt_id),),
-        )
-        if not row:
-            return None
-        return self._row_to_attempt(row)
-
-    def get_attempts_for_intent(self, intent_id: UUID) -> list[TxAttempt]:
-        rows = self.execute_returning(
-            "SELECT * FROM tx_attempts WHERE intent_id = ? ORDER BY created_at",
-            (str(intent_id),),
-        )
-        return [self._row_to_attempt(row) for row in rows]
-
-    def get_latest_attempt_for_intent(self, intent_id: UUID) -> TxAttempt | None:
-        row = self.execute_one(
-            """
-            SELECT * FROM tx_attempts WHERE intent_id = ?
-            ORDER BY created_at DESC LIMIT 1
-            """,
-            (str(intent_id),),
-        )
-        if not row:
-            return None
-        return self._row_to_attempt(row)
-
-    def get_attempt_by_tx_hash(self, tx_hash: str) -> TxAttempt | None:
-        row = self.execute_one(
-            "SELECT * FROM tx_attempts WHERE tx_hash = ?",
-            (tx_hash,),
-        )
-        if not row:
-            return None
-        return self._row_to_attempt(row)
-
-    def _row_to_attempt(self, row: dict[str, Any]) -> TxAttempt:
-        attempt_id = row["attempt_id"]
-        if isinstance(attempt_id, str):
-            attempt_id = UUID(attempt_id)
-        intent_id = row["intent_id"]
-        if isinstance(intent_id, str):
-            intent_id = UUID(intent_id)
-        replaces = row["replaces_attempt_id"]
-        if replaces and isinstance(replaces, str):
-            replaces = UUID(replaces)
-        return TxAttempt(
-            attempt_id=attempt_id,
-            intent_id=intent_id,
-            nonce=row["nonce"],
-            tx_hash=row["tx_hash"],
-            gas_params=GasParams.from_json(row["gas_params_json"]),
-            status=AttemptStatus(row["status"]),
-            error_code=row["error_code"],
-            error_detail=row["error_detail"],
-            replaces_attempt_id=replaces,
-            broadcast_block=row["broadcast_block"],
-            broadcast_at=row.get("broadcast_at"),
-            included_block=row.get("included_block"),
-            created_at=row["created_at"],
-            updated_at=row["updated_at"],
-            # Audit trail (may be None for older attempts)
-            broadcast_group=row.get("broadcast_group"),
-            endpoint_url=row.get("endpoint_url"),
-        )
-
-    def update_attempt_status(
-        self,
-        attempt_id: UUID,
-        status: str,
-        tx_hash: str | None = None,
-        broadcast_block: int | None = None,
-        broadcast_at: datetime | None = None,
-        included_block: int | None = None,
-        error_code: str | None = None,
-        error_detail: str | None = None,
-    ) -> bool:
-        conn = self._ensure_connected()
-        with self._lock:
-            cursor = conn.cursor()
-            # Build dynamic update
-            updates = ["status = ?", "updated_at = CURRENT_TIMESTAMP"]
-            params: list[Any] = [status]
-
-            if tx_hash is not None:
-                updates.append("tx_hash = ?")
-                params.append(tx_hash)
-            if broadcast_block is not None:
-                updates.append("broadcast_block = ?")
-                params.append(broadcast_block)
-            if broadcast_at is not None:
-                updates.append("broadcast_at = ?")
-                params.append(broadcast_at)
-            if included_block is not None:
-                updates.append("included_block = ?")
-                params.append(included_block)
-            if error_code is not None:
-                updates.append("error_code = ?")
-                params.append(error_code)
-            if error_detail is not None:
-                updates.append("error_detail = ?")
-                params.append(error_detail)
-
-            params.append(str(attempt_id))
-            query = f"UPDATE tx_attempts SET {', '.join(updates)} WHERE attempt_id = ?"
-            cursor.execute(query, params)
-            updated = cursor.rowcount > 0
-            if not self._in_transaction:
-                conn.commit()
-            cursor.close()
-            return updated
-
-    # =========================================================================
-    # Transaction Operations (NEW - replaces Intent/Attempt in Phase 2+)
-    #
-    # IMPORTANT: Transaction is the only durable execution model.
-    # Do not add attempt-related methods here.
-    # =========================================================================
-
-    def create_tx(
-        self,
-        tx_id: UUID,
-        job_id: str,
-        chain_id: int,
-        idempotency_key: str,
-        signer_address: str,
-        to_address: str,
-        data: str | None,
-        value_wei: str,
-        min_confirmations: int,
-        deadline_ts: datetime | None,
-        gas_params: GasParams | None = None,
-    ) -> Transaction | None:
-        """Create a new transaction.
-
-        Returns None if idempotency_key already exists (idempotency).
-        """
-        gas_params_json = gas_params.to_json() if gas_params else None
-        conn = self._ensure_connected()
-
-        with self._lock:
-            cursor = conn.cursor()
-            try:
-                cursor.execute(
-                    """
-                    INSERT INTO transactions (
-                        tx_id, job_id, chain_id, idempotency_key,
-                        signer_address, to_address, data, value_wei,
-                        min_confirmations, deadline_ts, status,
-                        replacement_count, gas_params_json
-                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'created', 0, ?)
-                    """,
-                    (
-                        str(tx_id),
-                        job_id,
-                        chain_id,
-                        idempotency_key,
-                        signer_address,
-                        to_address,
-                        data,
-                        value_wei,
-                        min_confirmations,
-                        deadline_ts,
-                        gas_params_json,
-                    ),
-                )
-                if not self._in_transaction:
-                    conn.commit()
-                cursor.close()
-                return self.get_tx(tx_id)
-            except sqlite3.IntegrityError:
-                # Idempotency key already exists
-                cursor.close()
-                return None
-
-    def get_tx(self, tx_id: UUID) -> Transaction | None:
-        """Get a transaction by ID."""
-        row = self.execute_one(
-            "SELECT * FROM transactions WHERE tx_id = ?",
-            (str(tx_id),),
-        )
-        if not row:
-            return None
-        return self._row_to_transaction(row)
-
-    def get_tx_by_idempotency_key(
-        self,
-        chain_id: int,
-        signer_address: str,
-        idempotency_key: str,
-    ) -> Transaction | None:
-        """Get a transaction by idempotency key (scoped to chain and signer)."""
-        row = self.execute_one(
-            "SELECT * FROM transactions WHERE chain_id = ? AND signer_address = ? AND idempotency_key = ?",
-            (chain_id, signer_address.lower(), idempotency_key),
-        )
-        if not row:
-            return None
-        return self._row_to_transaction(row)
-
-    def get_tx_by_hash(self, tx_hash: str) -> Transaction | None:
-        """Get a transaction by current tx hash.
-
-        NOTE: Does NOT search tx_hash_history. Only matches current_tx_hash.
-        """
-        row = self.execute_one(
-            "SELECT * FROM transactions WHERE current_tx_hash = ?",
-            (tx_hash,),
-        )
-        if not row:
-            return None
-        return self._row_to_transaction(row)
-
-    def list_pending_txs(
-        self,
-        chain_id: int | None = None,
-        job_id: str | None = None,
-    ) -> list[Transaction]:
-        """List transactions in CREATED or BROADCAST status."""
-        query = "SELECT * FROM transactions WHERE status IN ('created', 'broadcast')"
-        params: list[Any] = []
-
-        if chain_id is not None:
-            query += " AND chain_id = ?"
-            params.append(chain_id)
-        if job_id is not None:
-            query += " AND job_id = ?"
-            params.append(job_id)
-
-        query += " ORDER BY created_at ASC"
-        rows = self.execute_returning(query, tuple(params))
-        return [self._row_to_transaction(row) for row in rows]
-
-    def claim_tx(self, claim_token: str) -> Transaction | None:
-        """Claim the next CREATED transaction for processing.
-
-        Status remains CREATED while claimed - no "claimed" status.
-        """
-        conn = self._ensure_connected()
-        with self._lock:
-            conn.execute("BEGIN IMMEDIATE")
-            try:
-                cursor = conn.cursor()
-                # Find and claim atomically
-                cursor.execute(
-                    """
-                    UPDATE transactions
-                    SET claim_token = ?, claimed_at = CURRENT_TIMESTAMP,
-                        updated_at = CURRENT_TIMESTAMP
-                    WHERE tx_id = (
-                        SELECT tx_id FROM transactions
-                        WHERE status = 'created'
-                        AND claim_token IS NULL
-                        AND (deadline_ts IS NULL OR deadline_ts > CURRENT_TIMESTAMP)
-                        ORDER BY created_at ASC, tx_id ASC
-                        LIMIT 1
-                    )
-                    AND status = 'created'
-                    AND claim_token IS NULL
-                    """,
-                    (claim_token,),
-                )
-
-                if cursor.rowcount == 0:
-                    conn.rollback()
-                    cursor.close()
-                    return None
-
-                # Get the claimed transaction
-                cursor.execute(
-                    "SELECT * FROM transactions WHERE claim_token = ? AND status = 'created'",
-                    (claim_token,),
-                )
-                row = cursor.fetchone()
-                conn.commit()
-                cursor.close()
-
-                if row:
-                    return self._row_to_transaction(dict(row))
-                return None
-            except Exception:
-                conn.rollback()
-                raise
-
-    def set_tx_broadcast(
-        self,
-        tx_id: UUID,
-        tx_hash: str,
-        nonce: int,
-        gas_params: GasParams,
-        broadcast_block: int,
-        broadcast_info: BroadcastInfo | None = None,
-    ) -> bool:
-        """Record initial broadcast.
-
-        Sets status=BROADCAST, creates first tx_hash_history record.
-        """
-        conn = self._ensure_connected()
-        now = datetime.now(timezone.utc)
-
-        # Create first history record
-        history_record = TxHashRecord(
-            tx_hash=tx_hash,
-            nonce=nonce,
-            broadcast_at=now.isoformat(),
-            broadcast_block=broadcast_block,
-            gas_limit=gas_params.gas_limit,
-            max_fee_per_gas=gas_params.max_fee_per_gas,
-            max_priority_fee_per_gas=gas_params.max_priority_fee_per_gas,
-            reason="initial",
-            outcome=None,
-        )
-        tx_hash_history = json.dumps([history_record.to_dict()])
-
-        with self._lock:
-            cursor = conn.cursor()
-            cursor.execute(
-                """
-                UPDATE transactions
-                SET status = 'broadcast',
-                    current_tx_hash = ?,
-                    current_nonce = ?,
-                    gas_params_json = ?,
-                    broadcast_info_json = ?,
-                    tx_hash_history = ?,
-                    updated_at = CURRENT_TIMESTAMP
-                WHERE tx_id = ?
-                AND status = 'created'
-                """,
-                (
-                    tx_hash,
-                    nonce,
-                    gas_params.to_json(),
-                    broadcast_info.to_json() if broadcast_info else None,
-                    tx_hash_history,
-                    str(tx_id),
-                ),
-            )
-            updated = cursor.rowcount > 0
-            if not self._in_transaction:
-                conn.commit()
-            cursor.close()
-            return updated
-
-    def set_tx_replaced(
-        self,
-        tx_id: UUID,
-        new_tx_hash: str,
-        gas_params: GasParams,
-        broadcast_block: int,
-        reason: str = "fee_bump",
-    ) -> bool:
-        """Record replacement broadcast.
-
-        Appends to tx_hash_history, updates current_tx_hash, increments
-        replacement_count. Status remains BROADCAST.
-        """
-        conn = self._ensure_connected()
-        now = datetime.now(timezone.utc)
-
-        with self._lock:
-            # First, get current state to update history
-            cursor = conn.cursor()
-            cursor.execute(
-                "SELECT current_nonce, tx_hash_history FROM transactions WHERE tx_id = ? AND status = 'broadcast'",
-                (str(tx_id),),
-            )
-            row = cursor.fetchone()
-            if not row:
-                cursor.close()
-                return False
-
-            nonce = row["current_nonce"]
-            existing_history = json.loads(row["tx_hash_history"]) if row["tx_hash_history"] else []
-
-            # Mark previous entry as replaced
-            if existing_history:
-                existing_history[-1]["outcome"] = "replaced"
-
-            # Add new history record
-            new_record = TxHashRecord(
-                tx_hash=new_tx_hash,
-                nonce=nonce,
-                broadcast_at=now.isoformat(),
-                broadcast_block=broadcast_block,
-                gas_limit=gas_params.gas_limit,
-                max_fee_per_gas=gas_params.max_fee_per_gas,
-                max_priority_fee_per_gas=gas_params.max_priority_fee_per_gas,
-                reason=reason,
-                outcome=None,
-            )
-            existing_history.append(new_record.to_dict())
-
-            cursor.execute(
-                """
-                UPDATE transactions
-                SET current_tx_hash = ?,
-                    gas_params_json = ?,
-                    tx_hash_history = ?,
-                    replacement_count = replacement_count + 1,
-                    updated_at = CURRENT_TIMESTAMP
-                WHERE tx_id = ?
-                AND status = 'broadcast'
-                """,
-                (
-                    new_tx_hash,
-                    gas_params.to_json(),
-                    json.dumps(existing_history),
-                    str(tx_id),
-                ),
-            )
-            updated = cursor.rowcount > 0
-            if not self._in_transaction:
-                conn.commit()
-            cursor.close()
-            return updated
-
-    def set_tx_confirmed(
-        self,
-        tx_id: UUID,
-        included_block: int,
-    ) -> bool:
-        """Mark transaction confirmed.
-
-        Sets status=CONFIRMED, included_block, confirmed_at.
-        Updates tx_hash_history with outcome.
-        """
-        conn = self._ensure_connected()
-        now = datetime.now(timezone.utc)
-
-        with self._lock:
-            # Update history outcome
-            cursor = conn.cursor()
-            cursor.execute(
-                "SELECT tx_hash_history FROM transactions WHERE tx_id = ? AND status = 'broadcast'",
-                (str(tx_id),),
-            )
-            row = cursor.fetchone()
-            if not row:
-                cursor.close()
-                return False
-
-            existing_history = json.loads(row["tx_hash_history"]) if row["tx_hash_history"] else []
-            if existing_history:
-                existing_history[-1]["outcome"] = "confirmed"
-
-            cursor.execute(
-                """
-                UPDATE transactions
-                SET status = 'confirmed',
-                    included_block = ?,
-                    confirmed_at = ?,
-                    tx_hash_history = ?,
-                    updated_at = CURRENT_TIMESTAMP
-                WHERE tx_id = ?
-                AND status = 'broadcast'
-                """,
-                (
-                    included_block,
-                    now,
-                    json.dumps(existing_history),
-                    str(tx_id),
-                ),
-            )
-            updated = cursor.rowcount > 0
-            if not self._in_transaction:
-                conn.commit()
-            cursor.close()
-            return updated
-
-    def set_tx_failed(
-        self,
-        tx_id: UUID,
-        failure_type: FailureType,
-        error_info: ErrorInfo | None = None,
-    ) -> bool:
-        """Mark transaction failed.
-
-        Sets status=FAILED, failure_type, error_info_json.
-        Updates tx_hash_history with outcome if applicable.
-        """
-        conn = self._ensure_connected()
-
-        # Serialize error_info
-        error_info_json = None
-        if error_info:
-            error_info_json = json.dumps({
-                "error_type": error_info.error_type,
-                "message": error_info.message,
-                "code": error_info.code,
-            })
-
-        with self._lock:
-            # Get and update history if broadcast
-            cursor = conn.cursor()
-            cursor.execute(
-                "SELECT status, tx_hash_history FROM transactions WHERE tx_id = ? AND status IN ('created', 'broadcast')",
-                (str(tx_id),),
-            )
-            row = cursor.fetchone()
-            if not row:
-                cursor.close()
-                return False
-
-            existing_history = json.loads(row["tx_hash_history"]) if row["tx_hash_history"] else []
-            if existing_history and row["status"] == "broadcast":
-                existing_history[-1]["outcome"] = "failed"
-
-            cursor.execute(
-                """
-                UPDATE transactions
-                SET status = 'failed',
-                    failure_type = ?,
-                    error_info_json = ?,
-                    tx_hash_history = ?,
-                    updated_at = CURRENT_TIMESTAMP
-                WHERE tx_id = ?
-                AND status IN ('created', 'broadcast')
-                """,
-                (
-                    failure_type.value,
-                    error_info_json,
-                    json.dumps(existing_history) if existing_history else None,
-                    str(tx_id),
-                ),
-            )
-            updated = cursor.rowcount > 0
-            if not self._in_transaction:
-                conn.commit()
-            cursor.close()
-            return updated
-
-    def release_stale_tx_claims(self, max_age_seconds: int) -> int:
-        """Release claims older than threshold. 0 = release all claims."""
-        conn = self._ensure_connected()
-        with self._lock:
-            cursor = conn.cursor()
-            if max_age_seconds == 0:
-                # Release ALL claims
-                cursor.execute(
-                    """
-                    UPDATE transactions
-                    SET claim_token = NULL, claimed_at = NULL,
-                        updated_at = CURRENT_TIMESTAMP
-                    WHERE status = 'created'
-                    AND claim_token IS NOT NULL
-                    """
-                )
-            else:
-                cursor.execute(
-                    """
-                    UPDATE transactions
-                    SET claim_token = NULL, claimed_at = NULL,
-                        updated_at = CURRENT_TIMESTAMP
-                    WHERE status = 'created'
-                    AND claim_token IS NOT NULL
-                    AND claimed_at < datetime('now', ? || ' seconds')
-                    """,
-                    (f"-{max_age_seconds}",),
-                )
-            count = cursor.rowcount
-            if not self._in_transaction:
-                conn.commit()
-            cursor.close()
-            return count
-
-    def _row_to_transaction(self, row: dict[str, Any]) -> Transaction:
-        """Convert database row to Transaction object."""
-        tx_id = row["tx_id"]
-        if isinstance(tx_id, str):
-            tx_id = UUID(tx_id)
-
-        # Parse failure_type if present
-        failure_type = None
-        if row.get("failure_type"):
-            failure_type = FailureType(row["failure_type"])
-
-        return Transaction(
-            tx_id=tx_id,
-            job_id=row["job_id"],
-            chain_id=row["chain_id"],
-            idempotency_key=row["idempotency_key"],
-            signer_address=row["signer_address"],
-            to_address=row["to_address"],
-            data=row["data"],
-            value_wei=row["value_wei"],
-            min_confirmations=row["min_confirmations"],
-            deadline_ts=row["deadline_ts"],
-            status=TxStatus(row["status"]),
-            failure_type=failure_type,
-            current_tx_hash=row["current_tx_hash"],
-            current_nonce=row["current_nonce"],
-            replacement_count=row["replacement_count"],
-            claim_token=row["claim_token"],
-            claimed_at=row["claimed_at"],
-            included_block=row["included_block"],
-            confirmed_at=row["confirmed_at"],
-            created_at=row["created_at"],
-            updated_at=row["updated_at"],
-            gas_params_json=row["gas_params_json"],
-            broadcast_info_json=row["broadcast_info_json"],
-            error_info_json=row["error_info_json"],
-            tx_hash_history=row["tx_hash_history"],
-        )
-
-    # =========================================================================
-    # ABI Cache Operations
-    # =========================================================================
-
-    def get_cached_abi(self, chain_id: int, address: str) -> ABICacheEntry | None:
-        row = self.execute_one(
-            "SELECT * FROM abi_cache WHERE chain_id = ? AND address = ?",
-            (chain_id, address),
-        )
-        if not row:
-            return None
-        return ABICacheEntry(
-            chain_id=row["chain_id"],
-            address=row["address"],
-            abi_json=row["abi_json"],
-            source=row["source"],
-            resolved_at=row["resolved_at"],
-        )
-
-    def set_cached_abi(
-        self,
-        chain_id: int,
-        address: str,
-        abi_json: str,
-        source: str,
-    ) -> None:
-        self.execute(
-            """
-            INSERT INTO abi_cache (chain_id, address, abi_json, source)
-            VALUES (?, ?, ?, ?)
-            ON CONFLICT(chain_id, address) DO UPDATE SET
-                abi_json = excluded.abi_json,
-                source = excluded.source,
-                resolved_at = CURRENT_TIMESTAMP
-            """,
-            (chain_id, address, abi_json, source),
-        )
-
-    def clear_cached_abi(self, chain_id: int, address: str) -> bool:
-        conn = self._ensure_connected()
-        with self._lock:
-            cursor = conn.cursor()
-            cursor.execute(
-                "DELETE FROM abi_cache WHERE chain_id = ? AND address = ?",
-                (chain_id, address),
-            )
-            deleted = cursor.rowcount > 0
-            if not self._in_transaction:
-                conn.commit()
-            cursor.close()
-            return deleted
-
-    def cleanup_expired_abis(self, max_age_seconds: int) -> int:
-        conn = self._ensure_connected()
-        with self._lock:
-            cursor = conn.cursor()
-            cursor.execute(
-                """
-                DELETE FROM abi_cache
-                WHERE resolved_at < datetime('now', ? || ' seconds')
-                """,
-                (f"-{max_age_seconds}",),
-            )
-            count = cursor.rowcount
-            if not self._in_transaction:
-                conn.commit()
-            cursor.close()
-            return count
-
-    # =========================================================================
-    # Proxy Cache Operations
-    # =========================================================================
-
-    def get_cached_proxy(
-        self, chain_id: int, proxy_address: str
-    ) -> ProxyCacheEntry | None:
-        row = self.execute_one(
-            "SELECT * FROM proxy_cache WHERE chain_id = ? AND proxy_address = ?",
-            (chain_id, proxy_address),
-        )
-        if not row:
-            return None
-        return ProxyCacheEntry(
-            chain_id=row["chain_id"],
-            proxy_address=row["proxy_address"],
-            implementation_address=row["implementation_address"],
-            resolved_at=row["resolved_at"],
-        )
-
-    def set_cached_proxy(
-        self,
-        chain_id: int,
-        proxy_address: str,
-        implementation_address: str,
-    ) -> None:
-        self.execute(
-            """
-            INSERT INTO proxy_cache (chain_id, proxy_address, implementation_address)
-            VALUES (?, ?, ?)
-            ON CONFLICT(chain_id, proxy_address) DO UPDATE SET
-                implementation_address = excluded.implementation_address,
-                resolved_at = CURRENT_TIMESTAMP
-            """,
-            (chain_id, proxy_address, implementation_address),
-        )
-
-    def clear_cached_proxy(self, chain_id: int, proxy_address: str) -> bool:
-        conn = self._ensure_connected()
-        with self._lock:
-            cursor = conn.cursor()
-            cursor.execute(
-                "DELETE FROM proxy_cache WHERE chain_id = ? AND proxy_address = ?",
-                (chain_id, proxy_address),
-            )
-            deleted = cursor.rowcount > 0
-            if not self._in_transaction:
-                conn.commit()
-            cursor.close()
-            return deleted
-
-    # =========================================================================
-    # Cleanup & Maintenance
-    # =========================================================================
-
-    def cleanup_old_intents(
-        self,
-        older_than_days: int,
-        statuses: list[str] | None = None,
-    ) -> int:
-        if statuses is None:
-            statuses = ["confirmed", "failed", "abandoned"]
-
-        conn = self._ensure_connected()
-        placeholders = ",".join("?" * len(statuses))
-
-        with self._lock:
-            cursor = conn.cursor()
-            cursor.execute(
-                f"""
-                DELETE FROM tx_intents
-                WHERE status IN ({placeholders})
-                AND created_at < datetime('now', ? || ' days')
-                """,
-                (*statuses, f"-{older_than_days}"),
-            )
-            count = cursor.rowcount
-            if not self._in_transaction:
-                conn.commit()
-            cursor.close()
-            return count
-
-    def get_database_stats(self) -> dict[str, Any]:
-        """Get database statistics for health checks."""
-        stats: dict[str, Any] = {"type": "sqlite", "path": self._database_path}
-
-        # Count intents by status
-        rows = self.execute_returning(
-            "SELECT status, COUNT(*) as count FROM tx_intents GROUP BY status"
-        )
-        stats["intents_by_status"] = {row["status"]: row["count"] for row in rows}
-
-        # Count total jobs
-        row = self.execute_one("SELECT COUNT(*) as count FROM jobs")
-        stats["total_jobs"] = row["count"] if row else 0
-
-        # Count enabled jobs
-        row = self.execute_one("SELECT COUNT(*) as count FROM jobs WHERE enabled = 1")
-        stats["enabled_jobs"] = row["count"] if row else 0
-
-        # Get block state
-        rows = self.execute_returning("SELECT * FROM block_state")
-        stats["block_states"] = [
-            {
-                "chain_id": row["chain_id"],
-                "last_block": row["last_processed_block_number"],
-            }
-            for row in rows
-        ]
-
-        return stats
-
-    # =========================================================================
-    # Reconciliation Operations
-    # =========================================================================
-
-    def clear_orphaned_claims(self, chain_id: int, older_than_minutes: int = 2) -> int:
-        """Clear claim fields where status != 'claimed' and claim is stale."""
-        conn = self._ensure_connected()
-        with self._lock:
-            cursor = conn.cursor()
-            cursor.execute(
-                """
-                UPDATE tx_intents
-                SET claim_token = NULL,
-                    claimed_at = NULL,
-                    claimed_by = NULL,
-                    updated_at = CURRENT_TIMESTAMP
-                WHERE chain_id = ?
-                  AND status != 'claimed'
-                  AND claim_token IS NOT NULL
-                  AND claimed_at IS NOT NULL
-                  AND claimed_at < datetime('now', ? || ' minutes')
-                """,
-                (chain_id, f"-{older_than_minutes}"),
-            )
-            count = cursor.rowcount
-            if not self._in_transaction:
-                conn.commit()
-            cursor.close()
-            return count
-
-    def release_orphaned_nonces(self, chain_id: int, older_than_minutes: int = 5) -> int:
-        """Release nonces for terminal intents that are stale."""
-        # SQLite doesn't support UPDATE...FROM, use subquery
-        conn = self._ensure_connected()
-        with self._lock:
-            cursor = conn.cursor()
-            cursor.execute(
-                """
-                UPDATE nonce_reservations
-                SET status = 'released',
-                    updated_at = CURRENT_TIMESTAMP
-                WHERE chain_id = ?
-                  AND status = 'reserved'
-                  AND updated_at < datetime('now', ? || ' minutes')
-                  AND intent_id IN (
-                      SELECT intent_id FROM tx_intents
-                      WHERE status IN ('failed', 'abandoned', 'reverted')
-                      AND updated_at < datetime('now', ? || ' minutes')
-                  )
-                """,
-                (chain_id, f"-{older_than_minutes}", f"-{older_than_minutes}"),
-            )
-            count = cursor.rowcount
-            if not self._in_transaction:
-                conn.commit()
-            cursor.close()
-            return count
-
-    def count_pending_without_attempts(self, chain_id: int) -> int:
-        """Count pending intents with no attempt records (integrity issue)."""
-        result = self.execute_one(
-            """
-            SELECT COUNT(*) as count
-            FROM tx_intents ti
-            LEFT JOIN tx_attempts ta ON ti.intent_id = ta.intent_id
-            WHERE ti.chain_id = ?
-              AND ti.status = 'pending'
-              AND ta.attempt_id IS NULL
-            """,
-            (chain_id,),
-        )
-        return result["count"] if result else 0
-
-    def count_stale_claims(self, chain_id: int, older_than_minutes: int = 10) -> int:
-        """Count intents stuck in CLAIMED for too long."""
-        result = self.execute_one(
-            """
-            SELECT COUNT(*) as count
-            FROM tx_intents
-            WHERE chain_id = ?
-              AND status = 'claimed'
-              AND claimed_at IS NOT NULL
-              AND claimed_at < datetime('now', ? || ' minutes')
-            """,
-            (chain_id, f"-{older_than_minutes}"),
-        )
-        return result["count"] if result else 0
-
-    # =========================================================================
-    # Invariant Queries (Phase 2)
-    # =========================================================================
-
-    def count_stuck_claimed(self, chain_id: int, older_than_minutes: int = 10) -> int:
-        """Count intents stuck in CLAIMED status for too long."""
-        conn = self._ensure_connected()
-        cursor = conn.cursor()
-        cursor.execute(
-            """
-            SELECT COUNT(*) as count
-            FROM tx_intents
-            WHERE chain_id = ?
-              AND status = 'claimed'
-              AND datetime(claimed_at) < datetime('now', ? || ' minutes')
-            """,
-            (chain_id, -older_than_minutes),
-        )
-        row = cursor.fetchone()
-        return row[0] if row else 0
-
-    def count_orphaned_claims(self, chain_id: int) -> int:
-        """Count intents with claim_token set but status != claimed."""
-        conn = self._ensure_connected()
-        cursor = conn.cursor()
-        cursor.execute(
-            """
-            SELECT COUNT(*) as count
-            FROM tx_intents
-            WHERE chain_id = ?
-              AND status != 'claimed'
-              AND claim_token IS NOT NULL
-            """,
-            (chain_id,),
-        )
-        row = cursor.fetchone()
-        return row[0] if row else 0
-
-    def count_orphaned_nonces(self, chain_id: int) -> int:
-        """Count reserved/in_flight nonces for failed/abandoned intents."""
-        conn = self._ensure_connected()
-        cursor = conn.cursor()
-        cursor.execute(
-            """
-            SELECT COUNT(*) as count
-            FROM nonce_reservations nr
-            JOIN tx_intents ti ON nr.intent_id = ti.intent_id
-            WHERE nr.chain_id = ?
-              AND nr.status IN ('reserved', 'in_flight')
-              AND ti.status IN ('failed', 'abandoned', 'reverted')
-            """,
-            (chain_id,),
-        )
-        row = cursor.fetchone()
-        return row[0] if row else 0
-
-    def get_oldest_nonce_gap_age_seconds(self, chain_id: int) -> float:
-        """Get age in seconds of the oldest nonce gap.
-
-        Anchors from signers (small table) for efficiency.
-        Returns 0 if no gaps or if chain nonce not synced.
-        """
-        conn = self._ensure_connected()
-        cursor = conn.cursor()
-        cursor.execute(
-            """
-            SELECT COALESCE(
-                (julianday('now') - julianday(datetime(MIN(nr.created_at)))) * 86400,
-                0
-            ) AS oldest_gap_seconds
-            FROM signers s
-            JOIN nonce_reservations nr
-              ON nr.chain_id = s.chain_id
-             AND nr.signer_address = s.signer_address
-            WHERE s.chain_id = ?
-              AND s.last_synced_chain_nonce IS NOT NULL
-              AND nr.status IN ('reserved', 'in_flight')
-              AND nr.nonce < s.last_synced_chain_nonce
-            """,
-            (chain_id,),
-        )
-        row = cursor.fetchone()
-        return float(row[0]) if row else 0.0