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

brawny/db/sqlite/repos/attempts.py

@@ -0,0 +1,372 @@
+from __future__ import annotations
+
+import json
+import sqlite3
+from datetime import datetime
+from typing import Any
+from uuid import UUID
+
+from brawny.db.sqlite import mappers, tx
+from brawny.model.errors import DatabaseError, InvariantViolation
+from brawny.model.types import TxAttempt
+
+
+def create_attempt(
+    db: Any,
+    attempt_id: UUID,
+    intent_id: UUID,
+    nonce: int,
+    gas_params_json: str,
+    status: str = "pending_send",
+    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,
+    actor: str | None = None,
+    reason: str | None = None,
+    source: 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
+    with tx.transaction_conn(db, tx.SQLiteBeginMode.IMMEDIATE) as conn:
+        binding_id: str | None = None
+
+        if binding is not None:
+            group_name, endpoints = binding
+            db.bind_broadcast_endpoints(intent_id, group_name, endpoints)
+
+        cursor = conn.cursor()
+        try:
+            cursor.execute(
+                "SELECT broadcast_binding_id FROM tx_intents WHERE intent_id = ?",
+                (str(intent_id),),
+            )
+            row = cursor.fetchone()
+            if row is not None:
+                binding_id = row["broadcast_binding_id"]
+        finally:
+            cursor.close()
+
+        conn.execute(
+            """
+            INSERT INTO tx_attempts (
+                attempt_id, intent_id, nonce, gas_params_json, status,
+                tx_hash, replaces_attempt_id, broadcast_group, endpoint_url,
+                endpoint_binding_id
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                str(attempt_id),
+                str(intent_id),
+                nonce,
+                gas_params_json,
+                status,
+                tx_hash,
+                replaces_str,
+                broadcast_group,
+                endpoint_url,
+                binding_id,
+            ),
+        )
+
+    attempt = db.get_attempt(attempt_id)
+    if not attempt:
+        raise DatabaseError("Failed to create attempt")
+    db.record_mutation_audit(
+        entity_type="attempt",
+        entity_id=str(attempt_id),
+        action="create_attempt",
+        actor=actor,
+        reason=reason,
+        source=source,
+        metadata={"intent_id": str(intent_id), "nonce": nonce, "status": status},
+    )
+    return attempt
+
+
+def create_attempt_once(
+    db: Any,
+    attempt_id: UUID,
+    intent_id: UUID,
+    nonce: int,
+    gas_params_json: str,
+    status: str = "pending_send",
+    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,
+    actor: str | None = None,
+    reason: str | None = None,
+    source: str | None = None,
+) -> TxAttempt:
+    if replaces_attempt_id is not None:
+        return create_attempt(
+            db,
+            attempt_id=attempt_id,
+            intent_id=intent_id,
+            nonce=nonce,
+            gas_params_json=gas_params_json,
+            status=status,
+            tx_hash=tx_hash,
+            replaces_attempt_id=replaces_attempt_id,
+            broadcast_group=broadcast_group,
+            endpoint_url=endpoint_url,
+            binding=binding,
+            actor=actor,
+            reason=reason,
+            source=source,
+        )
+
+    try:
+        with tx.transaction_conn(db, tx.SQLiteBeginMode.IMMEDIATE) as conn:
+            cursor = conn.cursor()
+            try:
+                if binding is not None:
+                    group_name, endpoints = binding
+                    try:
+                        db.bind_broadcast_endpoints(intent_id, group_name, endpoints)
+                    except (DatabaseError, InvariantViolation) as exc:
+                        raise InvariantViolation(
+                            f"Intent {intent_id} binding failed: {exc}"
+                        ) from exc
+
+                cursor.execute(
+                    """
+                    SELECT * FROM tx_attempts
+                    WHERE intent_id = ? AND nonce = ? AND replaces_attempt_id IS NULL
+                    ORDER BY created_at ASC LIMIT 1
+                    """,
+                    (str(intent_id), nonce),
+                )
+                row = cursor.fetchone()
+                if row:
+                    attempt = mappers._row_to_attempt(dict(row))
+                    if tx_hash and attempt.tx_hash and attempt.tx_hash.lower() != tx_hash.lower():
+                        raise InvariantViolation(
+                            f"Attempt already exists for intent {intent_id} nonce {nonce}"
+                        )
+                    return attempt
+
+                cursor.execute(
+                    "SELECT broadcast_binding_id FROM tx_intents WHERE intent_id = ?",
+                    (str(intent_id),),
+                )
+                binding_row = cursor.fetchone()
+                binding_id = binding_row["broadcast_binding_id"] if binding_row else None
+
+                conn.execute(
+                    """
+                    INSERT INTO tx_attempts (
+                        attempt_id, intent_id, nonce, gas_params_json, status,
+                        tx_hash, replaces_attempt_id, broadcast_group, endpoint_url,
+                        endpoint_binding_id
+                    ) VALUES (?, ?, ?, ?, ?, ?, NULL, ?, ?, ?)
+                    """,
+                    (
+                        str(attempt_id),
+                        str(intent_id),
+                        nonce,
+                        gas_params_json,
+                        status,
+                        tx_hash,
+                        broadcast_group,
+                        endpoint_url,
+                        binding_id,
+                    ),
+                )
+            finally:
+                cursor.close()
+    except sqlite3.IntegrityError:
+        row = db.execute_one(
+            """
+            SELECT * FROM tx_attempts
+            WHERE intent_id = ? AND nonce = ? AND replaces_attempt_id IS NULL
+            ORDER BY created_at ASC LIMIT 1
+            """,
+            (str(intent_id), nonce),
+        )
+        if row:
+            attempt = mappers._row_to_attempt(row)
+            if tx_hash and attempt.tx_hash and attempt.tx_hash.lower() != tx_hash.lower():
+                raise InvariantViolation(
+                    f"Attempt already exists for intent {intent_id} nonce {nonce}"
+                )
+            return attempt
+        raise
+
+    attempt = db.get_attempt(attempt_id)
+    if not attempt:
+        raise DatabaseError("Failed to create attempt")
+    db.record_mutation_audit(
+        entity_type="attempt",
+        entity_id=str(attempt_id),
+        action="create_attempt",
+        actor=actor,
+        reason=reason,
+        source=source,
+        metadata={"intent_id": str(intent_id), "nonce": nonce, "status": status},
+    )
+    return attempt
+
+
+def require_bound_and_attempt(
+    db: Any,
+    intent_id: UUID,
+    nonce: int,
+    endpoints: list[str],
+) -> None:
+    canonical = db._canonicalize_endpoints(endpoints)
+    row = db.execute_one(
+        """
+        SELECT broadcast_binding_id, broadcast_endpoints_json
+        FROM tx_intents WHERE intent_id = ?
+        """,
+        (str(intent_id),),
+    )
+    if not row or row["broadcast_endpoints_json"] is None:
+        raise InvariantViolation(f"Intent {intent_id} has no broadcast binding")
+
+    stored = json.loads(row["broadcast_endpoints_json"])
+    stored_canonical = db._canonicalize_endpoints(stored)
+    if stored_canonical != canonical:
+        raise InvariantViolation(
+            f"Intent {intent_id} binding does not match endpoints"
+        )
+
+    binding_id = row["broadcast_binding_id"]
+    attempt_row = db.execute_one(
+        """
+        SELECT attempt_id, endpoint_binding_id
+        FROM tx_attempts
+        WHERE intent_id = ? AND nonce = ?
+        ORDER BY created_at ASC LIMIT 1
+        """,
+        (str(intent_id), nonce),
+    )
+    if not attempt_row:
+        raise InvariantViolation(f"Intent {intent_id} missing attempt for nonce {nonce}")
+
+    if binding_id is not None:
+        attempt_binding = attempt_row.get("endpoint_binding_id")
+        if attempt_binding is None or str(attempt_binding) != str(binding_id):
+            raise InvariantViolation(
+                f"Intent {intent_id} attempt binding mismatch for nonce {nonce}"
+            )
+
+
+def get_attempt(db: Any, attempt_id: UUID) -> TxAttempt | None:
+    row = db.execute_one(
+        "SELECT * FROM tx_attempts WHERE attempt_id = ?",
+        (str(attempt_id),),
+    )
+    if not row:
+        return None
+    return mappers._row_to_attempt(row)
+
+
+def get_attempts_for_intent(db: Any, intent_id: UUID) -> list[TxAttempt]:
+    rows = db.execute_returning(
+        "SELECT * FROM tx_attempts WHERE intent_id = ? ORDER BY created_at",
+        (str(intent_id),),
+    )
+    return [mappers._row_to_attempt(row) for row in rows]
+
+
+def get_latest_attempt_for_intent(db: Any, intent_id: UUID) -> TxAttempt | None:
+    row = db.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 mappers._row_to_attempt(row)
+
+
+def get_attempt_by_tx_hash(db: Any, tx_hash: str) -> TxAttempt | None:
+    row = db.execute_one(
+        "SELECT * FROM tx_attempts WHERE tx_hash = ?",
+        (tx_hash,),
+    )
+    if not row:
+        return None
+    return mappers._row_to_attempt(row)
+
+
+def update_attempt_status(
+    db: Any,
+    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,
+    endpoint_url: str | None = None,
+    error_code: str | None = None,
+    error_detail: str | None = None,
+    actor: str | None = None,
+    reason: str | None = None,
+    source: str | None = None,
+) -> bool:
+    with tx.transaction_conn(db) as conn:
+        cursor = conn.cursor()
+        try:
+            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 endpoint_url is not None:
+                updates.append("endpoint_url = ?")
+                params.append(endpoint_url)
+            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
+        finally:
+            cursor.close()
+
+    if updated:
+        db.record_mutation_audit(
+            entity_type="attempt",
+            entity_id=str(attempt_id),
+            action=f"status:{status}",
+            actor=actor,
+            reason=reason,
+            source=source,
+            metadata={
+                "tx_hash": tx_hash,
+                "broadcast_block": broadcast_block,
+                "included_block": included_block,
+                "error_code": error_code,
+            },
+        )
+    return updated

brawny/db/sqlite/repos/block_state.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from typing import Any
+
+from brawny.db.base import BlockState
+
+
+def get_block_state(db: Any, chain_id: int) -> BlockState | None:
+    row = db.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(db: Any, chain_id: int, block_number: int, block_hash: str) -> None:
+    db.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(db: Any, chain_id: int, block_number: int) -> str | None:
+    row = db.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(db: Any, chain_id: int, block_number: int, block_hash: str) -> None:
+    db.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(db: Any, chain_id: int, block_number: int) -> int:
+    return db.execute_returning_rowcount(
+        "DELETE FROM block_hash_history WHERE chain_id = ? AND block_number > ?",
+        (chain_id, block_number),
+    )
+
+
+def delete_block_hash_at_height(db: Any, chain_id: int, block_number: int) -> bool:
+    rowcount = db.execute_returning_rowcount(
+        "DELETE FROM block_hash_history WHERE chain_id = ? AND block_number = ?",
+        (chain_id, block_number),
+    )
+    return rowcount > 0
+
+
+def cleanup_old_block_hashes(db: Any, chain_id: int, keep_count: int) -> int:
+    row = db.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
+    return db.execute_returning_rowcount(
+        "DELETE FROM block_hash_history WHERE chain_id = ? AND block_number < ?",
+        (chain_id, cutoff),
+    )
+
+
+def get_oldest_block_in_history(db: Any, chain_id: int) -> int | None:
+    row = db.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(db: Any, chain_id: int) -> int | None:
+    row = db.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

brawny/db/sqlite/repos/cache.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+from typing import Any
+
+from brawny.db.base import ABICacheEntry, ProxyCacheEntry
+
+
+def get_cached_abi(db: Any, chain_id: int, address: str) -> ABICacheEntry | None:
+    address = db._normalize_address(address)
+    row = db.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(
+    db: Any,
+    chain_id: int,
+    address: str,
+    abi_json: str,
+    source: str,
+) -> None:
+    address = db._normalize_address(address)
+    db.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(db: Any, chain_id: int, address: str) -> bool:
+    address = db._normalize_address(address)
+    rowcount = db.execute_returning_rowcount(
+        "DELETE FROM abi_cache WHERE chain_id = ? AND address = ?",
+        (chain_id, address),
+    )
+    return rowcount > 0
+
+
+def cleanup_expired_abis(db: Any, max_age_seconds: int) -> int:
+    return db.execute_returning_rowcount(
+        "DELETE FROM abi_cache WHERE resolved_at < datetime('now', ? || ' seconds')",
+        (f"-{max_age_seconds}",),
+    )
+
+
+def get_cached_proxy(db: Any, chain_id: int, proxy_address: str) -> ProxyCacheEntry | None:
+    proxy_address = db._normalize_address(proxy_address)
+    row = db.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(
+    db: Any,
+    chain_id: int,
+    proxy_address: str,
+    implementation_address: str,
+) -> None:
+    proxy_address = db._normalize_address(proxy_address)
+    implementation_address = db._normalize_address(implementation_address)
+    db.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(db: Any, chain_id: int, proxy_address: str) -> bool:
+    proxy_address = db._normalize_address(proxy_address)
+    rowcount = db.execute_returning_rowcount(
+        "DELETE FROM proxy_cache WHERE chain_id = ? AND proxy_address = ?",
+        (chain_id, proxy_address),
+    )
+    return rowcount > 0