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

brawny/_rpc/selector.py

@@ -1,156 +0,0 @@
-"""Endpoint selection with health-aware ordering.
-
-This module extracts endpoint health tracking and selection from RPCManager,
-following OE6's separation of concerns.
-
-INVARIANT: order_endpoints() always returns ALL endpoints, just ordered.
-Unhealthy endpoints are moved to the end, not removed. This ensures
-recovered endpoints eventually get tried again.
-"""
-
-from __future__ import annotations
-
-import time
-from dataclasses import dataclass, field
-
-
-@dataclass
-class EndpointHealth:
-    """Health tracking for a single RPC endpoint."""
-
-    url: str
-    consecutive_failures: int = 0
-    last_success_ts: float | None = None
-    last_failure_ts: float | None = None
-    latency_ewma_ms: float = 100.0  # Start with reasonable default
-
-    # EWMA smoothing factor (0.3 = 30% weight to new samples, more responsive than old 0.1)
-    EWMA_ALPHA: float = 0.3
-
-    @property
-    def is_healthy(self) -> bool:
-        """Check if endpoint is currently healthy (below failure threshold)."""
-        # Threshold is managed by EndpointSelector
-        return True  # Selector determines health based on threshold
-
-    def record_success(self, latency_ms: float) -> None:
-        """Record a successful RPC call.
-
-        Args:
-            latency_ms: Request latency in milliseconds
-        """
-        self.consecutive_failures = 0
-        self.last_success_ts = time.time()
-        # EWMA update
-        self.latency_ewma_ms = (
-            self.EWMA_ALPHA * latency_ms + (1 - self.EWMA_ALPHA) * self.latency_ewma_ms
-        )
-
-    def record_failure(self) -> None:
-        """Record a failed RPC call (transport-class failures only)."""
-        self.consecutive_failures += 1
-        self.last_failure_ts = time.time()
-
-
-class EndpointSelector:
-    """Health-aware endpoint selection.
-
-    CONSTRAINTS (to prevent scope creep):
-    - Only track consecutive failures + EWMA latency
-    - No background probing
-    - No partial circuit breaker logic
-    - No complex health scoring
-
-    INVARIANT: order_endpoints() always returns ALL endpoints, just ordered.
-    Unhealthy endpoints are moved to the end, not removed. This ensures
-    recovered endpoints eventually get tried again.
-    """
-
-    def __init__(
-        self,
-        endpoints: list[str],
-        failure_threshold: int = 3,
-    ) -> None:
-        """Initialize endpoint selector.
-
-        Args:
-            endpoints: List of endpoint URLs
-            failure_threshold: Consecutive failures before endpoint is unhealthy
-        """
-        if not endpoints:
-            raise ValueError("At least one endpoint is required")
-
-        self._endpoints = [EndpointHealth(url=url.strip()) for url in endpoints if url.strip()]
-        if not self._endpoints:
-            raise ValueError("At least one non-empty endpoint is required")
-
-        self._failure_threshold = failure_threshold
-        self._endpoint_map: dict[str, EndpointHealth] = {e.url: e for e in self._endpoints}
-
-    @property
-    def endpoints(self) -> list[EndpointHealth]:
-        """Get all endpoint health objects."""
-        return self._endpoints
-
-    def get_endpoint(self, url: str) -> EndpointHealth | None:
-        """Get endpoint health by URL."""
-        return self._endpoint_map.get(url)
-
-    def is_healthy(self, endpoint: EndpointHealth) -> bool:
-        """Check if an endpoint is healthy (below failure threshold)."""
-        return endpoint.consecutive_failures < self._failure_threshold
-
-    def has_healthy_endpoint(self) -> bool:
-        """Check if any endpoint is healthy."""
-        return any(self.is_healthy(e) for e in self._endpoints)
-
-    def order_endpoints(self) -> list[EndpointHealth]:
-        """Return ALL endpoints ordered by health, preserving position priority.
-
-        Ordering:
-        1. Healthy endpoints in original order (first = primary)
-        2. Unhealthy endpoints in original order
-
-        Position-based: First healthy endpoint in user config is always preferred.
-        """
-        healthy = [e for e in self._endpoints if self.is_healthy(e)]
-        unhealthy = [e for e in self._endpoints if not self.is_healthy(e)]
-        return healthy + unhealthy
-
-    def get_active_endpoint(self) -> EndpointHealth:
-        """Get the preferred endpoint (healthiest first).
-
-        Returns first healthy endpoint. If no healthy endpoints,
-        returns least recently failed.
-
-        Recovery: When an endpoint's consecutive_failures resets to 0 via
-        record_success(), it becomes healthy and can be returned again.
-        """
-        ordered = self.order_endpoints()
-        if ordered:
-            return ordered[0]
-        # Fallback (should not happen if endpoints exist)
-        return self._endpoints[0]
-
-    def record_success(self, url: str, latency_ms: float) -> None:
-        """Record successful call for an endpoint.
-
-        Args:
-            url: Endpoint URL
-            latency_ms: Request latency in milliseconds
-        """
-        endpoint = self._endpoint_map.get(url)
-        if endpoint:
-            endpoint.record_success(latency_ms)
-
-    def record_failure(self, url: str) -> None:
-        """Record failed call for an endpoint (transport-class failures only).
-
-        Only call this for RPCRetryableError, not for Fatal/Recoverable errors.
-
-        Args:
-            url: Endpoint URL
-        """
-        endpoint = self._endpoint_map.get(url)
-        if endpoint:
-            endpoint.record_failure()

brawny/db/base_new.py

@@ -1,165 +0,0 @@
-"""Slim database interface for brawny.
-
-Provides 4 execution primitives + transaction + connect/close.
-All domain operations live in db/ops/ modules.
-"""
-
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from contextlib import contextmanager
-from dataclasses import dataclass
-from datetime import datetime
-from typing import Any, Iterator, Literal
-
-
-Dialect = Literal["postgres", "sqlite"]
-IsolationLevel = Literal["SERIALIZABLE", "READ COMMITTED", "REPEATABLE READ"]
-
-
-@dataclass
-class BlockState:
-    """Block processing state."""
-
-    chain_id: int
-    last_processed_block_number: int
-    last_processed_block_hash: str
-    created_at: datetime
-    updated_at: datetime
-
-
-@dataclass
-class BlockHashEntry:
-    """Block hash history entry for reorg detection."""
-
-    id: int
-    chain_id: int
-    block_number: int
-    block_hash: str
-    inserted_at: datetime
-
-
-@dataclass
-class ABICacheEntry:
-    """Cached ABI entry."""
-
-    chain_id: int
-    address: str
-    abi_json: str
-    source: str
-    resolved_at: datetime
-
-
-@dataclass
-class ProxyCacheEntry:
-    """Cached proxy resolution entry."""
-
-    chain_id: int
-    proxy_address: str
-    implementation_address: str
-    resolved_at: datetime
-
-
-class Database(ABC):
-    """Database interface with 4 execution primitives.
-
-    Implementations provide connection management and query execution.
-    SQL queries are in db/queries.py, row mapping in db/mappers.py.
-    """
-
-    @property
-    @abstractmethod
-    def dialect(self) -> Dialect:
-        """Return dialect name for query selection."""
-        ...
-
-    @abstractmethod
-    def connect(self) -> None:
-        """Establish database connection."""
-        ...
-
-    @abstractmethod
-    def close(self) -> None:
-        """Close database connection and cleanup resources."""
-        ...
-
-    @abstractmethod
-    def is_connected(self) -> bool:
-        """Check if database is connected."""
-        ...
-
-    @abstractmethod
-    @contextmanager
-    def transaction(
-        self, isolation_level: IsolationLevel | None = None
-    ) -> Iterator[None]:
-        """Context manager for database transactions.
-
-        Args:
-            isolation_level: Optional isolation level (Postgres only, ignored on SQLite)
-
-        Usage:
-            with db.transaction():
-                ops.intents.create_intent(db, ...)
-                ops.nonces.reserve_nonce(db, ...)
-
-            # For atomic nonce reservation on Postgres
-            with db.transaction(isolation_level="SERIALIZABLE"):
-                ...
-        """
-        ...
-
-    @abstractmethod
-    def execute(self, query: str, params: dict[str, Any] | None = None) -> None:
-        """Execute a query without returning results.
-
-        Args:
-            query: SQL with :name placeholders
-            params: Dict of parameter values
-        """
-        ...
-
-    @abstractmethod
-    def fetch_one(
-        self, query: str, params: dict[str, Any] | None = None
-    ) -> dict[str, Any] | None:
-        """Execute a query and return single result or None.
-
-        Args:
-            query: SQL with :name placeholders
-            params: Dict of parameter values
-
-        Returns:
-            Single row as dict, or None if no results
-        """
-        ...
-
-    @abstractmethod
-    def fetch_all(
-        self, query: str, params: dict[str, Any] | None = None
-    ) -> list[dict[str, Any]]:
-        """Execute a query and return all results.
-
-        Args:
-            query: SQL with :name placeholders
-            params: Dict of parameter values
-
-        Returns:
-            List of rows as dicts
-        """
-        ...
-
-    @abstractmethod
-    def execute_rowcount(
-        self, query: str, params: dict[str, Any] | None = None
-    ) -> int:
-        """Execute a query and return affected row count.
-
-        Args:
-            query: SQL with :name placeholders
-            params: Dict of parameter values
-
-        Returns:
-            Number of rows affected
-        """
-        ...

brawny/db/mappers.py

@@ -1,182 +0,0 @@
-"""Row to model mappers for database results.
-
-Centralized conversion from database rows (dicts) to domain models.
-"""
-
-from __future__ import annotations
-
-import json
-from typing import Any
-from uuid import UUID
-
-from brawny.db.base_new import BlockState, BlockHashEntry, ABICacheEntry, ProxyCacheEntry
-from brawny.model.types import (
-    JobConfig,
-    TxIntent,
-    TxAttempt,
-    SignerState,
-    NonceReservation,
-    GasParams,
-)
-from brawny.model.enums import IntentStatus, AttemptStatus, NonceStatus
-
-
-def row_to_block_state(row: dict[str, Any]) -> BlockState:
-    """Convert database row to BlockState."""
-    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 row_to_block_hash_entry(row: dict[str, Any]) -> BlockHashEntry:
-    """Convert database row to BlockHashEntry."""
-    return BlockHashEntry(
-        id=row["id"],
-        chain_id=row["chain_id"],
-        block_number=row["block_number"],
-        block_hash=row["block_hash"],
-        inserted_at=row["inserted_at"],
-    )
-
-
-def row_to_job_config(row: dict[str, Any]) -> JobConfig:
-    """Convert database row to 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 row_to_signer_state(row: dict[str, Any]) -> SignerState:
-    """Convert database row to 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 row_to_nonce_reservation(row: dict[str, Any]) -> NonceReservation:
-    """Convert database row to NonceReservation."""
-    intent_id = row["intent_id"]
-    # Handle string UUIDs (SQLite stores as string)
-    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 row_to_intent(row: dict[str, Any]) -> TxIntent:
-    """Convert database row to TxIntent."""
-    intent_id = row["intent_id"]
-    # Handle string UUIDs (SQLite stores as string)
-    if isinstance(intent_id, str):
-        intent_id = UUID(intent_id)
-
-    # Parse metadata_json once at DB boundary
-    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.get("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_group=row.get("broadcast_group"),
-        broadcast_endpoints_json=row.get("broadcast_endpoints_json"),
-        metadata=metadata,
-    )
-
-
-def row_to_attempt(row: dict[str, Any]) -> TxAttempt:
-    """Convert database row to TxAttempt."""
-    attempt_id = row["attempt_id"]
-    intent_id = row["intent_id"]
-    replaces_attempt_id = row.get("replaces_attempt_id")
-
-    # Handle string UUIDs (SQLite stores as string)
-    if isinstance(attempt_id, str):
-        attempt_id = UUID(attempt_id)
-    if isinstance(intent_id, str):
-        intent_id = UUID(intent_id)
-    if replaces_attempt_id and isinstance(replaces_attempt_id, str):
-        replaces_attempt_id = UUID(replaces_attempt_id)
-
-    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.get("error_code"),
-        error_detail=row.get("error_detail"),
-        replaces_attempt_id=replaces_attempt_id,
-        broadcast_block=row.get("broadcast_block"),
-        broadcast_at=row.get("broadcast_at"),
-        included_block=row.get("included_block"),
-        created_at=row["created_at"],
-        updated_at=row["updated_at"],
-        broadcast_group=row.get("broadcast_group"),
-        endpoint_url=row.get("endpoint_url"),
-    )
-
-
-def row_to_abi_cache(row: dict[str, Any]) -> ABICacheEntry:
-    """Convert database row to ABICacheEntry."""
-    return ABICacheEntry(
-        chain_id=row["chain_id"],
-        address=row["address"],
-        abi_json=row["abi_json"],
-        source=row["source"],
-        resolved_at=row["resolved_at"],
-    )
-
-
-def row_to_proxy_cache(row: dict[str, Any]) -> ProxyCacheEntry:
-    """Convert database row to ProxyCacheEntry."""
-    return ProxyCacheEntry(
-        chain_id=row["chain_id"],
-        proxy_address=row["proxy_address"],
-        implementation_address=row["implementation_address"],
-        resolved_at=row["resolved_at"],
-    )

brawny/db/migrations/008_add_transactions.sql

@@ -1,72 +0,0 @@
--- brawny transactions table migration
--- Version: 008
--- Description: Add single Transaction model replacing TxIntent + TxAttempt
---
--- This is Phase 1 of the ATTEMPT_MODEL.md simplification:
--- - Single transactions table (no joins)
--- - 4-state TxStatus (created, broadcast, confirmed, failed)
--- - JSON blobs for rarely-queried fields
--- - Append-only tx_hash_history for debugging
-
--- ============================================================================
--- Transactions - single model for job transaction lifecycle
--- ============================================================================
-CREATE TABLE IF NOT EXISTS transactions (
-    -- Identity (queryable, indexed)
-    tx_id UUID PRIMARY KEY,
-    job_id VARCHAR(200) NOT NULL,
-    chain_id INTEGER NOT NULL,
-    idempotency_key VARCHAR(200) NOT NULL,
-
-    -- Payload (immutable after creation)
-    signer_address VARCHAR(42) NOT NULL,
-    to_address VARCHAR(42) NOT NULL,
-    data TEXT,
-    value_wei VARCHAR(78) NOT NULL DEFAULT '0',
-    min_confirmations INTEGER NOT NULL DEFAULT 1,
-    deadline_ts TIMESTAMP,
-
-    -- Status (queryable)
-    status VARCHAR(20) NOT NULL DEFAULT 'created'
-        CHECK (status IN ('created', 'broadcast', 'confirmed', 'failed')),
-    failure_type VARCHAR(50),
-
-    -- Broadcast state (queryable)
-    current_tx_hash VARCHAR(66),
-    current_nonce BIGINT,
-    replacement_count INTEGER NOT NULL DEFAULT 0,
-
-    -- Worker coordination (queryable)
-    claim_token VARCHAR(100),
-    claimed_at TIMESTAMP,
-
-    -- Confirmation (queryable)
-    included_block BIGINT,
-    confirmed_at TIMESTAMP,
-
-    -- Audit (queryable)
-    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-
-    -- JSON BLOBS (rarely queried - no indexes)
-    gas_params_json TEXT,           -- {"gas_limit": N, "max_fee": N, "priority_fee": N}
-    broadcast_info_json TEXT,       -- {"group": str, "endpoints": [...]}
-    error_info_json TEXT,           -- ErrorInfo as JSON
-    tx_hash_history TEXT            -- Append-only JSON array of TxHashRecord
-);
-
--- Indexes (only on queryable columns)
-CREATE INDEX IF NOT EXISTS idx_transactions_status ON transactions(status);
-CREATE INDEX IF NOT EXISTS idx_transactions_job_status ON transactions(job_id, status);
-CREATE INDEX IF NOT EXISTS idx_transactions_signer ON transactions(chain_id, signer_address);
-CREATE INDEX IF NOT EXISTS idx_transactions_tx_hash ON transactions(current_tx_hash) WHERE current_tx_hash IS NOT NULL;
-CREATE INDEX IF NOT EXISTS idx_transactions_created ON transactions(created_at);
-
--- Idempotency is scoped to (chain_id, signer_address)
-CREATE UNIQUE INDEX IF NOT EXISTS uq_transactions_idempotency_scoped
-    ON transactions(chain_id, signer_address, idempotency_key);
-
--- ============================================================================
--- Record this migration
--- ============================================================================
-INSERT INTO schema_migrations (version) VALUES ('008');

brawny/db/ops/attempts.py

@@ -1,108 +0,0 @@
-"""Transaction attempt operations."""
-
-from __future__ import annotations
-
-from datetime import datetime
-from uuid import UUID
-
-from brawny.db.base_new import Database
-from brawny.db import queries as Q
-from brawny.db import mappers as M
-from brawny.model.types import TxAttempt, GasParams
-
-
-def create_attempt(
-    db: Database,
-    attempt_id: UUID,
-    intent_id: UUID,
-    nonce: int,
-    tx_hash: str | None,
-    gas_params: GasParams,
-    status: str,
-    broadcast_block: int | None = None,
-    broadcast_at: datetime | None = None,
-    broadcast_group: str | None = None,
-    endpoint_url: str | None = None,
-) -> TxAttempt | None:
-    """Create a new transaction attempt."""
-    row = db.fetch_one(Q.CREATE_ATTEMPT, {
-        "attempt_id": str(attempt_id),
-        "intent_id": str(intent_id),
-        "nonce": nonce,
-        "tx_hash": tx_hash,
-        "gas_params_json": gas_params.to_json(),
-        "status": status,
-        "broadcast_block": broadcast_block,
-        "broadcast_at": broadcast_at,
-        "broadcast_group": broadcast_group,
-        "endpoint_url": endpoint_url,
-    })
-    return M.row_to_attempt(row) if row else None
-
-
-def get_attempt(db: Database, attempt_id: UUID) -> TxAttempt | None:
-    """Get attempt by ID."""
-    row = db.fetch_one(Q.GET_ATTEMPT, {"attempt_id": str(attempt_id)})
-    return M.row_to_attempt(row) if row else None
-
-
-def get_attempt_by_tx_hash(db: Database, tx_hash: str) -> TxAttempt | None:
-    """Get attempt by transaction hash."""
-    row = db.fetch_one(Q.GET_ATTEMPT_BY_TX_HASH, {"tx_hash": tx_hash})
-    return M.row_to_attempt(row) if row else None
-
-
-def get_attempts_for_intent(db: Database, intent_id: UUID) -> list[TxAttempt]:
-    """Get all attempts for an intent, ordered by created_at DESC."""
-    rows = db.fetch_all(Q.GET_ATTEMPTS_FOR_INTENT, {"intent_id": str(intent_id)})
-    return [M.row_to_attempt(row) for row in rows]
-
-
-def get_latest_attempt_for_intent(db: Database, intent_id: UUID) -> TxAttempt | None:
-    """Get the most recent attempt for an intent."""
-    row = db.fetch_one(Q.GET_LATEST_ATTEMPT_FOR_INTENT, {"intent_id": str(intent_id)})
-    return M.row_to_attempt(row) if row else None
-
-
-def update_attempt_status(db: Database, attempt_id: UUID, status: str) -> bool:
-    """Update attempt status."""
-    count = db.execute_rowcount(Q.UPDATE_ATTEMPT_STATUS, {
-        "attempt_id": str(attempt_id),
-        "status": status,
-    })
-    return count > 0
-
-
-def update_attempt_included(
-    db: Database, attempt_id: UUID, status: str, included_block: int
-) -> bool:
-    """Update attempt with inclusion info."""
-    count = db.execute_rowcount(Q.UPDATE_ATTEMPT_INCLUDED, {
-        "attempt_id": str(attempt_id),
-        "status": status,
-        "included_block": included_block,
-    })
-    return count > 0
-
-
-def update_attempt_error(
-    db: Database,
-    attempt_id: UUID,
-    status: str,
-    error_code: str | None,
-    error_detail: str | None,
-) -> bool:
-    """Update attempt with error info."""
-    count = db.execute_rowcount(Q.UPDATE_ATTEMPT_ERROR, {
-        "attempt_id": str(attempt_id),
-        "status": status,
-        "error_code": error_code,
-        "error_detail": error_detail,
-    })
-    return count > 0
-
-
-def get_pending_attempts(db: Database, chain_id: int) -> list[TxAttempt]:
-    """Get pending attempts for a chain."""
-    rows = db.fetch_all(Q.GET_PENDING_ATTEMPTS, {"chain_id": chain_id})
-    return [M.row_to_attempt(row) for row in rows]