csm-dashboard 0.3.6__tar.gz → 0.4.0__tar.gz

{csm_dashboard-0.3.6 → csm_dashboard-0.4.0}/PKG-INFO

@@ -1,8 +1,9 @@
 Metadata-Version: 2.4
 Name: csm-dashboard
-Version: 0.3.6
+Version: 0.4.0
 Summary: Lido CSM Operator Dashboard for tracking validator earnings
 Requires-Python: >=3.11
+Requires-Dist: aiosqlite>=0.19
 Requires-Dist: fastapi>=0.104
 Requires-Dist: httpx>=0.25
 Requires-Dist: pydantic-settings>=2.0

{csm_dashboard-0.3.6 → csm_dashboard-0.4.0}/docker-compose.yml

@@ -30,6 +30,8 @@ services:
     
     # Restart policy
     restart: unless-stopped
+    volumes:
+      - ./dashboard-data/:/root/.cache/csm-dashboard/
     
     # Logging configuration
     logging:

{csm_dashboard-0.3.6 → csm_dashboard-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "csm-dashboard"
-version = "0.3.6"
+version = "0.4.0"
 description = "Lido CSM Operator Dashboard for tracking validator earnings"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -14,6 +14,7 @@ dependencies = [
     "pydantic>=2.5",
     "pydantic-settings>=2.0",
     "python-dotenv>=1.0",
+    "aiosqlite>=0.19",
 ]
 
 [project.optional-dependencies]

{csm_dashboard-0.3.6 → csm_dashboard-0.4.0}/src/cli/commands.py

@@ -110,6 +110,8 @@ def format_as_api_json(rewards: OperatorRewards, include_validators: bool = Fals
                     "duration_days": f.duration_days,
                     "validator_count": f.validator_count,
                     "apy": f.apy,
+                    "bond_apy": f.bond_apy,
+                    "net_apy": f.net_apy,
                 }
                 for f in rewards.apy.frames
             ]
@@ -553,6 +555,9 @@ def rewards(
             history_table.add_column("Rewards (ETH)", style="green", justify="right")
             history_table.add_column("Vals", style="dim", justify="right")
             history_table.add_column("ETH/Val", style="green", justify="right")
+            history_table.add_column("Reward APY", style="green", justify="right")
+            history_table.add_column("Bond APY", style="green", justify="right")
+            history_table.add_column("Net APY", style="bold yellow", justify="right")
 
             # Display oldest first (chronological order)
             for frame in rewards.apy.frames:
@@ -571,6 +576,9 @@ def rewards(
                     f"{frame.rewards_eth:.4f}",
                     str(frame.validator_count),
                     f"{eth_per_val:.6f}",
+                    fmt_apy(frame.apy),
+                    fmt_apy(frame.bond_apy),
+                    fmt_apy(frame.net_apy),
                 )
 
             console.print(history_table)

{csm_dashboard-0.3.6 → csm_dashboard-0.4.0}/src/core/config.py

@@ -1,6 +1,7 @@
 """Configuration management using pydantic-settings."""
 
 from functools import lru_cache
+from pathlib import Path
 
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
@@ -31,6 +32,12 @@ class Settings(BaseSettings):
     # Cache Settings
     cache_ttl_seconds: int = 300  # 5 minutes
 
+    # Database Settings
+    database_path: Path = Path.home() / ".cache" / "csm-dashboard" / "operators.db"
+    # IPFS Gateway Configuration (comma-separated list)
+    # Default: dweb.link (IPFS Foundation), ipfs.io, w3s.link (web3.storage)
+    ipfs_gateways: str = "https://dweb.link/ipfs/,https://ipfs.io/ipfs/,https://w3s.link/ipfs/"
+
     # Contract Addresses (Mainnet)
     csmodule_address: str = "0xdA7dE2ECdDfccC6c3AF10108Db212ACBBf9EA83F"
     csaccounting_address: str = "0x4d72BFF1BeaC69925F8Bd12526a39BAAb069e5Da"

{csm_dashboard-0.3.6 → csm_dashboard-0.4.0}/src/core/types.py

@@ -58,7 +58,9 @@ class DistributionFrame(BaseModel):
     rewards_shares: int
     duration_days: float
     validator_count: int = 0  # Number of validators in this frame
-    apy: float | None = None  # Annualized for this frame (kept for backwards compat)
+    apy: float | None = None  # Reward APY for this frame (kept for backwards compat)
+    bond_apy: float | None = None  # Bond APY for this frame
+    net_apy: float | None = None  # Net APY (reward + bond) for this frame
 
 
 class WithdrawalEvent(BaseModel):
@@ -144,11 +146,6 @@ class APYMetrics(BaseModel):
     current_net_total_eth: float | None = None
     lifetime_net_total_eth: float | None = None
 
-    # Legacy fields (deprecated, kept for backwards compatibility)
-    reward_apy_7d: float | None = None
-    reward_apy_28d: float | None = None
-    net_apy_7d: float | None = None
-
 
 class StrikeSummary(BaseModel):
     """Summary of strikes for an operator."""

{csm_dashboard-0.3.6 → csm_dashboard-0.4.0}/src/data/beacon.py

@@ -1,12 +1,15 @@
 """Beacon chain data fetching via beaconcha.in API."""
 
 import asyncio
+import logging
 from datetime import datetime, timedelta, timezone
 from decimal import Decimal
 from enum import Enum
 
 import httpx
 
+logger = logging.getLogger(__name__)
+
 from ..core.config import get_settings
 from .cache import cached
 
@@ -256,14 +259,23 @@ class BeaconDataProvider:
 
     def _parse_validator(self, data: dict) -> ValidatorInfo:
         """Parse beaconcha.in validator response."""
+        # Validate epoch values - far-future values (like 2^64-1) indicate "not set"
+        activation_epoch = data.get("activationepoch")
+        if activation_epoch is not None and (activation_epoch < 0 or activation_epoch > 2**32):
+            activation_epoch = None
+
+        exit_epoch = data.get("exitepoch")
+        if exit_epoch is not None and (exit_epoch < 0 or exit_epoch > 2**32):
+            exit_epoch = None
+
         return ValidatorInfo(
             pubkey=data.get("pubkey", ""),
             index=data.get("validatorindex"),
             status=ValidatorStatus.from_beaconcha(data.get("status", "unknown")),
             balance_gwei=data.get("balance", 0),
             effectiveness=data.get("effectiveness"),
-            activation_epoch=data.get("activationepoch"),
-            exit_epoch=data.get("exitepoch") if data.get("exitepoch") is not None and data.get("exitepoch") >= 0 else None,
+            activation_epoch=activation_epoch,
+            exit_epoch=exit_epoch,
         )
 
     @cached(ttl=300)
@@ -280,8 +292,8 @@ class BeaconDataProvider:
 
                 if response.status_code == 200:
                     return response.json().get("data")
-            except Exception:
-                pass
+            except Exception as e:
+                logger.debug(f"Failed to get validator performance for index {validator_index}: {e}")
 
         return None
 
@@ -332,13 +344,15 @@ class BeaconDataProvider:
                             # attestation_head_reward (not a "total" field)
                             income = entry.get("income", {})
                             if isinstance(income, dict):
-                                # Sum all reward types (values are in gwei)
-                                total_income_gwei += sum(income.values())
-                            elif isinstance(income, int):
+                                # Sum all reward types (values are in gwei), filtering out non-numeric
+                                total_income_gwei += sum(
+                                    v for v in income.values() if isinstance(v, (int, float))
+                                )
+                            elif isinstance(income, (int, float)):
                                 total_income_gwei += income
-                except Exception:
+                except Exception as e:
                     # On error, continue with partial data
-                    pass
+                    logger.warning(f"Failed to fetch income for validator batch: {e}")
 
         return {
             "total_income_eth": Decimal(total_income_gwei) / Decimal(10**9),

csm_dashboard-0.4.0/src/data/cache.py

@@ -0,0 +1,112 @@
+"""Simple in-memory cache with TTL support and LRU eviction."""
+
+import hashlib
+import logging
+from collections import OrderedDict
+from datetime import datetime, timedelta
+from functools import wraps
+from typing import Any, Callable
+
+from ..core.config import get_settings
+
+logger = logging.getLogger(__name__)
+
+# Default maximum cache entries to prevent unbounded memory growth
+DEFAULT_MAX_SIZE = 1000
+
+
+class SimpleCache:
+    """
+    Simple in-memory cache with TTL and LRU eviction.
+
+    Safe for single-threaded async but not thread-safe.
+    Uses OrderedDict for LRU eviction when max_size is reached.
+    """
+
+    def __init__(self, default_ttl: int | None = None, max_size: int = DEFAULT_MAX_SIZE):
+        self._cache: OrderedDict[str, tuple[Any, datetime]] = OrderedDict()
+        self._default_ttl = default_ttl or get_settings().cache_ttl_seconds
+        self._max_size = max_size
+
+    def get(self, key: str) -> Any | None:
+        """Get value from cache if not expired. Moves accessed key to end (LRU)."""
+        if key in self._cache:
+            value, expiry = self._cache[key]
+            if datetime.now() < expiry:
+                # Move to end to mark as recently used
+                self._cache.move_to_end(key)
+                return value
+            # Expired - remove it
+            del self._cache[key]
+        return None
+
+    def set(self, key: str, value: Any, ttl: int | None = None) -> None:
+        """Set value in cache with TTL. Evicts LRU entries if at max size."""
+        # If key exists, remove it first (will be re-added at end)
+        if key in self._cache:
+            del self._cache[key]
+
+        # Evict oldest entries if at max size
+        while len(self._cache) >= self._max_size:
+            oldest_key, _ = self._cache.popitem(last=False)
+            logger.debug(f"Cache eviction: removed {oldest_key[:16]}...")
+
+        expiry = datetime.now() + timedelta(seconds=ttl or self._default_ttl)
+        self._cache[key] = (value, expiry)
+
+    def clear(self) -> None:
+        """Clear all cached values."""
+        self._cache.clear()
+
+    def cleanup_expired(self) -> int:
+        """Remove all expired entries. Returns count of removed entries."""
+        now = datetime.now()
+        expired_keys = [
+            key for key, (_, expiry) in self._cache.items() if now >= expiry
+        ]
+        for key in expired_keys:
+            del self._cache[key]
+        return len(expired_keys)
+
+    @property
+    def size(self) -> int:
+        """Current number of entries in cache."""
+        return len(self._cache)
+
+
+# Global cache instance
+_cache = SimpleCache()
+
+
+def cached(ttl: int | None = None) -> Callable:
+    """Decorator for caching async function results."""
+
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        async def wrapper(*args: Any, **kwargs: Any) -> Any:
+            # Create cache key from function name and arguments
+            # Skip 'self' in args to allow cache sharing across instances (for methods)
+            # Detect 'self' by checking if first arg is an instance with the decorated method
+            cache_args = args
+            if args and hasattr(args[0], func.__name__):
+                # First arg is likely 'self' - skip it for cache key
+                cache_args = args[1:]
+            key_data = f"{func.__module__}.{func.__name__}:{repr(cache_args)}:{repr(sorted(kwargs.items()))}"
+            cache_key = hashlib.md5(key_data.encode()).hexdigest()
+
+            cached_result = _cache.get(cache_key)
+            if cached_result is not None:
+                return cached_result
+
+            result = await func(*args, **kwargs)
+            _cache.set(cache_key, result, ttl)
+            return result
+
+        return wrapper
+
+    return decorator
+
+
+def get_cache() -> SimpleCache:
+    """Get the global cache instance."""
+    return _cache

csm_dashboard-0.4.0/src/data/database.py

@@ -0,0 +1,189 @@
+"""SQLite database for persisting saved operators."""
+
+import json
+import logging
+from datetime import datetime
+from pathlib import Path
+
+import aiosqlite
+
+from ..core.config import get_settings
+
+logger = logging.getLogger(__name__)
+
+_db_initialized = False
+
+# Database connection timeout in seconds (prevents hanging on locks)
+DB_TIMEOUT = 5.0
+
+
+async def get_db_path() -> Path:
+    """Get the database file path, creating parent directories if needed."""
+    settings = get_settings()
+    db_path = settings.database_path
+    db_path.parent.mkdir(parents=True, exist_ok=True)
+    logger.debug(f"Database path: {db_path}")
+    return db_path
+
+
+async def init_db() -> None:
+    """Initialize the database schema."""
+    global _db_initialized
+    if _db_initialized:
+        logger.debug("Database already initialized")
+        return
+
+    logger.info("Initializing database schema")
+    db_path = await get_db_path()
+    async with aiosqlite.connect(db_path, timeout=DB_TIMEOUT) as db:
+        # Enable WAL mode for better concurrent access
+        await db.execute("PRAGMA journal_mode=WAL")
+        await db.execute("""
+            CREATE TABLE IF NOT EXISTS saved_operators (
+                operator_id INTEGER PRIMARY KEY,
+                manager_address TEXT NOT NULL,
+                reward_address TEXT NOT NULL,
+                data_json TEXT NOT NULL,
+                saved_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        """)
+        await db.commit()
+    _db_initialized = True
+    logger.info("Database initialized successfully")
+
+
+async def save_operator(operator_id: int, data: dict) -> None:
+    """Save or update an operator in the database.
+
+    Args:
+        operator_id: The operator ID
+        data: The full operator data dictionary (from API response)
+    """
+    await init_db()
+    db_path = await get_db_path()
+
+    manager_address = data.get("manager_address", "")
+    reward_address = data.get("reward_address", "")
+    data_json = json.dumps(data)
+    now = datetime.utcnow().isoformat()
+
+    async with aiosqlite.connect(db_path, timeout=DB_TIMEOUT) as db:
+        await db.execute("""
+            INSERT INTO saved_operators (operator_id, manager_address, reward_address, data_json, saved_at, updated_at)
+            VALUES (?, ?, ?, ?, ?, ?)
+            ON CONFLICT(operator_id) DO UPDATE SET
+                manager_address = excluded.manager_address,
+                reward_address = excluded.reward_address,
+                data_json = excluded.data_json,
+                updated_at = excluded.updated_at
+        """, (operator_id, manager_address, reward_address, data_json, now, now))
+        await db.commit()
+
+
+async def get_saved_operators() -> list[dict]:
+    """Get all saved operators with their cached data.
+
+    Returns:
+        List of operator data dictionaries with added metadata (saved_at, updated_at)
+    """
+    try:
+        logger.debug("Getting saved operators from database")
+        await init_db()
+        db_path = await get_db_path()
+
+        async with aiosqlite.connect(db_path, timeout=DB_TIMEOUT) as db:
+            db.row_factory = aiosqlite.Row
+            async with db.execute("""
+                SELECT operator_id, data_json, saved_at, updated_at
+                FROM saved_operators
+                ORDER BY saved_at DESC
+            """) as cursor:
+                rows = await cursor.fetchall()
+
+        result = []
+        for row in rows:
+            try:
+                data = json.loads(row["data_json"])
+                data["_saved_at"] = row["saved_at"]
+                data["_updated_at"] = row["updated_at"]
+                result.append(data)
+            except json.JSONDecodeError:
+                logger.warning(f"Corrupted JSON for operator {row['operator_id']}, skipping")
+                continue
+
+        logger.debug(f"Retrieved {len(result)} saved operators from database")
+        return result
+    except Exception as e:
+        logger.error(f"Database error in get_saved_operators: {e}", exc_info=True)
+        return []
+
+
+async def delete_operator(operator_id: int) -> bool:
+    """Remove an operator from the saved list.
+
+    Args:
+        operator_id: The operator ID to remove
+
+    Returns:
+        True if the operator was deleted, False if not found
+    """
+    await init_db()
+    db_path = await get_db_path()
+
+    async with aiosqlite.connect(db_path, timeout=DB_TIMEOUT) as db:
+        cursor = await db.execute(
+            "DELETE FROM saved_operators WHERE operator_id = ?",
+            (operator_id,)
+        )
+        await db.commit()
+        return cursor.rowcount > 0
+
+
+async def is_operator_saved(operator_id: int) -> bool:
+    """Check if an operator is saved.
+
+    Args:
+        operator_id: The operator ID to check
+
+    Returns:
+        True if the operator is saved, False otherwise
+    """
+    await init_db()
+    db_path = await get_db_path()
+
+    async with aiosqlite.connect(db_path, timeout=DB_TIMEOUT) as db:
+        async with db.execute(
+            "SELECT 1 FROM saved_operators WHERE operator_id = ?",
+            (operator_id,)
+        ) as cursor:
+            row = await cursor.fetchone()
+            return row is not None
+
+
+async def update_operator_data(operator_id: int, data: dict) -> bool:
+    """Update the cached data for a saved operator.
+
+    Args:
+        operator_id: The operator ID
+        data: The new operator data dictionary
+
+    Returns:
+        True if updated, False if operator not found
+    """
+    await init_db()
+    db_path = await get_db_path()
+
+    manager_address = data.get("manager_address", "")
+    reward_address = data.get("reward_address", "")
+    data_json = json.dumps(data)
+    now = datetime.utcnow().isoformat()
+
+    async with aiosqlite.connect(db_path, timeout=DB_TIMEOUT) as db:
+        cursor = await db.execute("""
+            UPDATE saved_operators
+            SET manager_address = ?, reward_address = ?, data_json = ?, updated_at = ?
+            WHERE operator_id = ?
+        """, (manager_address, reward_address, data_json, now, operator_id))
+        await db.commit()
+        return cursor.rowcount > 0

{csm_dashboard-0.3.6 → csm_dashboard-0.4.0}/src/data/etherscan.py

@@ -1,10 +1,16 @@
 """Etherscan API client for event queries."""
 
+import json
+import logging
+from decimal import Decimal
+
 import httpx
 from web3 import Web3
 
 from ..core.config import get_settings
 
+logger = logging.getLogger(__name__)
+
 
 class EtherscanProvider:
     """Query contract events via Etherscan API."""
@@ -47,7 +53,12 @@ class EtherscanProvider:
                 },
             )
 
-            data = response.json()
+            try:
+                data = response.json()
+            except json.JSONDecodeError as e:
+                logger.warning(f"Failed to parse Etherscan response: {e}")
+                return []
+
             if data.get("status") != "1":
                 return []
 
@@ -115,7 +126,12 @@ class EtherscanProvider:
                 },
             )
 
-            data = response.json()
+            try:
+                data = response.json()
+            except json.JSONDecodeError as e:
+                logger.warning(f"Failed to parse Etherscan transfer events response: {e}")
+                return []
+
             if data.get("status") != "1":
                 return []
 
@@ -193,7 +209,12 @@ class EtherscanProvider:
                 },
             )
 
-            data = response.json()
+            try:
+                data = response.json()
+            except json.JSONDecodeError as e:
+                logger.warning(f"Failed to parse Etherscan withdrawal requested events: {e}")
+                return []
+
             if data.get("status") != "1":
                 return []
 
@@ -271,7 +292,12 @@ class EtherscanProvider:
                 },
             )
 
-            data = response.json()
+            try:
+                data = response.json()
+            except json.JSONDecodeError as e:
+                logger.warning(f"Failed to parse Etherscan withdrawal claimed events: {e}")
+                return []
+
             if data.get("status") != "1":
                 return []
 
@@ -280,14 +306,14 @@ class EtherscanProvider:
                 try:
                     # requestId is topic1 (indexed)
                     request_id = int(log["topics"][1], 16)
-                    # amountOfETH is in data field
-                    amount_eth = int(log["data"], 16) / 10**18
+                    # amountOfETH is in data field - use Decimal for precision
+                    amount_eth = Decimal(int(log["data"], 16)) / Decimal(10**18)
 
                     results.append(
                         {
                             "request_id": request_id,
                             "tx_hash": log["transactionHash"],
-                            "amount_eth": amount_eth,
+                            "amount_eth": float(amount_eth),  # Convert to float for JSON serialization
                             "block": int(log["blockNumber"], 16),
                         }
                     )