csm-dashboard 0.3.6.1__py3-none-any.whl → 0.4.0__py3-none-any.whl

src/data/strikes.py

@@ -2,6 +2,7 @@
 
 import asyncio
 import json
+import logging
 import time
 from dataclasses import dataclass
 from pathlib import Path
@@ -12,6 +13,8 @@ from web3 import Web3
 from ..core.config import get_settings
 from .cache import cached
 
+logger = logging.getLogger(__name__)
+
 
 # Strike thresholds by operator type (curve_id)
 # Default (Permissionless): 3 strikes till key exit
@@ -26,6 +29,8 @@ DEFAULT_STRIKE_THRESHOLD = 3
 
 def get_strike_threshold(curve_id: int) -> int:
     """Get the strike threshold for ejection based on operator curve_id."""
+    if curve_id not in STRIKE_THRESHOLDS:
+        logger.warning(f"Unknown curve_id {curve_id}, defaulting to strike threshold {DEFAULT_STRIKE_THRESHOLD}")
     return STRIKE_THRESHOLDS.get(curve_id, DEFAULT_STRIKE_THRESHOLD)
 
 
@@ -43,13 +48,6 @@ class ValidatorStrikes:
 class StrikesProvider:
     """Fetches strikes data from CSStrikes contract via IPFS."""
 
-    # IPFS gateways to try in order (same as ipfs_logs.py)
-    GATEWAYS = [
-        "https://dweb.link/ipfs/",
-        "https://ipfs.io/ipfs/",
-        "https://cloudflare-ipfs.com/ipfs/",
-    ]
-
     # Rate limiting: minimum seconds between gateway requests
     MIN_REQUEST_INTERVAL = 1.0
 
@@ -66,6 +64,8 @@ class StrikesProvider:
 
     def __init__(self, rpc_url: str | None = None, cache_dir: Path | None = None):
         self.settings = get_settings()
+        # Use configurable gateways from settings (comma-separated)
+        self.gateways = [g.strip() for g in self.settings.ipfs_gateways.split(",") if g.strip()]
         self.w3 = Web3(Web3.HTTPProvider(rpc_url or self.settings.eth_rpc_url))
         self.cache_dir = cache_dir or Path.home() / ".cache" / "csm-dashboard" / "strikes"
         self.cache_dir.mkdir(parents=True, exist_ok=True)
@@ -114,7 +114,9 @@ class StrikesProvider:
     @cached(ttl=300)  # Cache CID for 5 minutes
     async def get_tree_cid(self) -> str:
         """Get the current strikes tree CID from the contract."""
-        return self.csstrikes.functions.treeCid().call()
+        return await asyncio.to_thread(
+            self.csstrikes.functions.treeCid().call
+        )
 
     async def _fetch_tree_from_ipfs(self, cid: str) -> dict | None:
         """Fetch tree data from IPFS gateways."""
@@ -128,18 +130,24 @@ class StrikesProvider:
 
         # Try each gateway
         async with httpx.AsyncClient(timeout=30.0, follow_redirects=True) as client:
-            for gateway in self.GATEWAYS:
+            for gateway in self.gateways:
                 try:
                     url = f"{gateway}{cid}"
                     response = await client.get(url)
                     if response.status_code == 200:
-                        data = response.json()
+                        try:
+                            data = response.json()
+                        except json.JSONDecodeError as e:
+                            logger.warning(f"Failed to parse strikes tree JSON from {gateway}: {e}")
+                            continue
                         # Cache the successful result
                         self._save_to_cache(cid, data)
                         return data
-                except Exception:
+                except Exception as e:
+                    logger.debug(f"IPFS gateway {gateway} failed for strikes CID {cid}: {e}")
                     continue
 
+        logger.warning(f"All IPFS gateways failed for strikes CID {cid}")
         return None
 
     @cached(ttl=300)  # Cache parsed tree for 5 minutes
@@ -192,11 +200,25 @@ class StrikesProvider:
             pubkey = value[1]
             strikes_array = value[2]
 
+            # Validate types - operator_id must be an int
+            if not isinstance(entry_operator_id, int):
+                try:
+                    entry_operator_id = int(entry_operator_id)
+                except (ValueError, TypeError):
+                    continue
+
             if entry_operator_id != operator_id:
                 continue
 
-            # Count total strikes (sum of the 6-frame array)
-            strike_count = sum(strikes_array) if isinstance(strikes_array, list) else 0
+            # Ensure pubkey is a string
+            if not isinstance(pubkey, str):
+                pubkey = str(pubkey) if pubkey else ""
+
+            # Count total strikes (sum of the 6-frame array), filtering non-numeric values
+            if isinstance(strikes_array, list):
+                strike_count = sum(s for s in strikes_array if isinstance(s, (int, float)))
+            else:
+                strike_count = 0
 
             operator_strikes.append(
                 ValidatorStrikes(

src/main.py

@@ -1,9 +1,17 @@
 """Main entry point for the CSM Dashboard application."""
 
+import logging
+
 import typer
 
 from .cli.commands import app as cli_app
 
+# Configure root logger
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+
 # Create main app that includes all CLI commands
 app = typer.Typer(
     name="csm-dashboard",
@@ -25,6 +33,9 @@ def serve(
 
     from .web.app import create_app
 
+    logger = logging.getLogger(__name__)
+    logger.info(f"Starting CSM Dashboard server on {host}:{port}")
+
     web_app = create_app()
     uvicorn.run(
         web_app if not reload else "src.web.app:create_app",
@@ -32,6 +43,7 @@ def serve(
         port=port,
         reload=reload,
         factory=reload,
+        log_level="info",
     )
 
 

src/services/operator_service.py

@@ -1,7 +1,11 @@
 """Main service for computing operator rewards."""
 
+from datetime import datetime, timezone
+import logging
 from decimal import Decimal
 
+logger = logging.getLogger(__name__)
+
 from ..core.types import (
     APYMetrics,
     BondSummary,
@@ -263,17 +267,23 @@ class OperatorService:
 
                         # Estimate next distribution date (~28 days after current frame ends)
                         # Frame duration ≈ 28 days = ~6300 epochs
+                        # If IPFS logs are behind, keep advancing until we get a future date
+                        now = datetime.now(timezone.utc)
                         next_epoch = current_frame.end_epoch + 6300
-                        next_distribution_date = epoch_to_dt(next_epoch).isoformat()
+                        next_dt = epoch_to_dt(next_epoch)
+                        while next_dt < now:
+                            next_epoch += 6300  # Add another ~28 days
+                            next_dt = epoch_to_dt(next_epoch)
+                        next_distribution_date = next_dt.isoformat()
 
                         # Estimate next distribution ETH based on current daily rate
                         if current_days > 0:
                             daily_rate = current_eth / Decimal(current_days)
                             next_distribution_est_eth = float(daily_rate * Decimal(28))
 
-            except Exception:
+            except Exception as e:
                 # If historical APY calculation fails, continue without it
-                pass
+                logger.warning(f"Historical APY calculation failed for operator {operator_id}: {e}")
 
         # 2. Bond APY (stETH protocol rebase rate)
         steth_data = await self.lido_api.get_steth_apr()
@@ -330,12 +340,13 @@ class OperatorService:
                             prev_bond = self.onchain.calculate_required_bond(
                                 prev_frame.validator_count, curve_id
                             )
+                            # Keep calculation in Decimal for precision
                             previous_bond_eth = round(
-                                float(prev_bond) * (prev_apr / 100) * (prev_days / 365), 6
+                                float(prev_bond * Decimal(prev_apr / 100) * Decimal(prev_days / 365)), 6
                             )
                         else:
                             previous_bond_eth = round(
-                                float(bond_eth) * (prev_apr / 100) * (prev_days / 365), 6
+                                float(bond_eth * Decimal(prev_apr / 100) * Decimal(prev_days / 365)), 6
                             )
 
             # Current frame bond earnings
@@ -353,21 +364,29 @@ class OperatorService:
                         curr_apr = bond_apy
                     if curr_apr is not None:
                         current_bond_apr = round(curr_apr, 2)
+                        # Keep calculation in Decimal for precision
                         current_bond_eth = round(
-                            float(bond_eth) * (curr_apr / 100) * (curr_days / 365), 6
+                            float(bond_eth * Decimal(curr_apr / 100) * Decimal(curr_days / 365)), 6
                         )
 
             # Lifetime bond earnings (sum of all frame durations with per-frame APR)
             # When include_history=True, calculate accurate lifetime APY with per-frame bond
+            # Also build frame_list here to avoid duplicate loop
             if frames:
                 lifetime_bond_sum = 0.0
                 # For accurate lifetime APY calculation (duration-weighted)
                 frame_reward_apys = []
                 frame_bond_apys = []
                 frame_durations = []
+                frame_list = []  # Build frame_list here instead of separate loop
 
-                for f in frames:
+                for i, f in enumerate(frames):
                     f_days = self.ipfs_logs.calculate_frame_duration_days(f)
+                    f_eth = await self.onchain.shares_to_eth(f.distributed_rewards)
+                    f_apy = None
+                    f_bond_apy = None
+                    f_net_apy = None
+
                     if f_days > 0:
                         # Use average historical APR for each frame period
                         f_start_ts = BEACON_GENESIS + (f.start_epoch * 384)
@@ -384,17 +403,40 @@ class OperatorService:
                                 f_bond = self.onchain.calculate_required_bond(
                                     f.validator_count, curve_id
                                 )
-                                lifetime_bond_sum += float(f_bond) * (f_apr / 100) * (f_days / 365)
+                                # Keep calculations in Decimal for precision
+                                lifetime_bond_sum += float(f_bond * Decimal(f_apr / 100) * Decimal(f_days / 365))
 
-                                # Calculate per-frame reward APY for weighted average
-                                f_eth = await self.onchain.shares_to_eth(f.distributed_rewards)
+                                # Calculate per-frame reward APY using accurate per-frame bond
                                 if f_bond > 0:
-                                    f_reward_apy = float(f_eth / f_bond) * (365.0 / f_days) * 100
-                                    frame_reward_apys.append(f_reward_apy)
+                                    f_apy = round(float((f_eth / f_bond) * Decimal(365.0 / f_days) * Decimal(100)), 2)
+                                    f_bond_apy = round(f_apr, 2)
+                                    f_net_apy = round(f_apy + f_bond_apy, 2)
+
+                                    frame_reward_apys.append(f_apy)
                                     frame_bond_apys.append(f_apr)
                                     frame_durations.append(f_days)
                             else:
-                                lifetime_bond_sum += float(bond_eth) * (f_apr / 100) * (f_days / 365)
+                                lifetime_bond_sum += float(bond_eth * Decimal(f_apr / 100) * Decimal(f_days / 365))
+                                # Fallback: use current bond for APY calc
+                                if bond_eth >= MIN_BOND_ETH:
+                                    f_apy = round(float(f_eth / bond_eth) * (365.0 / f_days) * 100, 2)
+
+                    # Build frame_list entry if history requested
+                    if include_history:
+                        frame_list.append(
+                            DistributionFrame(
+                                frame_number=i + 1,
+                                start_date=epoch_to_dt(f.start_epoch).isoformat(),
+                                end_date=epoch_to_dt(f.end_epoch).isoformat(),
+                                rewards_eth=float(f_eth),
+                                rewards_shares=f.distributed_rewards,
+                                duration_days=round(f_days, 1),
+                                validator_count=f.validator_count,
+                                apy=f_apy,
+                                bond_apy=f_bond_apy,
+                                net_apy=f_net_apy,
+                            )
+                        )
 
                 if lifetime_bond_sum > 0:
                     lifetime_bond_eth = round(lifetime_bond_sum, 6)
@@ -447,30 +489,6 @@ class OperatorService:
                 (lifetime_distribution_eth or 0) + (lifetime_bond_eth or 0), 6
             )
 
-        # 6. Build frame history if requested
-        if include_history and frames:
-            frame_list = []
-            for i, f in enumerate(frames):
-                # Convert shares to ETH (not just dividing by 10^18)
-                f_eth = await self.onchain.shares_to_eth(f.distributed_rewards)
-                f_days = self.ipfs_logs.calculate_frame_duration_days(f)
-                f_apy = None
-                if f_days > 0 and bond_eth >= MIN_BOND_ETH:
-                    f_apy = round(float(f_eth / bond_eth) * (365.0 / f_days) * 100, 2)
-
-                frame_list.append(
-                    DistributionFrame(
-                        frame_number=i + 1,
-                        start_date=epoch_to_dt(f.start_epoch).isoformat(),
-                        end_date=epoch_to_dt(f.end_epoch).isoformat(),
-                        rewards_eth=float(f_eth),
-                        rewards_shares=f.distributed_rewards,
-                        duration_days=round(f_days, 1),
-                        validator_count=f.validator_count,
-                        apy=f_apy,
-                    )
-                )
-
         return APYMetrics(
             previous_distribution_eth=previous_distribution_eth,
             previous_distribution_apy=previous_distribution_apy,
@@ -532,9 +550,9 @@ class OperatorService:
                 max_strikes=summary.get("max_strikes", 0),
                 strike_threshold=summary.get("strike_threshold", 3),
             )
-        except Exception:
+        except Exception as e:
             # If strikes fetch fails, continue with empty summary
-            pass
+            logger.warning(f"Failed to fetch strikes for operator {operator_id}: {e}")
 
         return HealthStatus(
             bond_healthy=bond_healthy,
@@ -562,7 +580,8 @@ class OperatorService:
         """
         try:
             log_history = await self.onchain.get_distribution_log_history()
-        except Exception:
+        except Exception as e:
+            logger.warning(f"Failed to fetch distribution log history: {e}")
             return []
 
         if not log_history:
@@ -583,8 +602,9 @@ class OperatorService:
                         "start": start_date.strftime("%b %d"),
                         "end": end_date.strftime("%b %d"),
                     })
-            except Exception:
+            except Exception as e:
                 # Skip frames we can't fetch
+                logger.debug(f"Failed to fetch frame data for CID {entry.get('logCid', 'unknown')}: {e}")
                 continue
 
         # Pad to ensure we always have `count` entries (for UI consistency)
@@ -615,7 +635,8 @@ class OperatorService:
 
             validators = await self.beacon.get_validators_by_pubkeys(pubkeys)
             return get_earliest_activation(validators)
-        except Exception:
+        except Exception as e:
+            logger.debug(f"Failed to get active_since for operator {operator_id}: {e}")
             return None
 
     async def get_withdrawal_history(self, operator_id: int) -> list[WithdrawalEvent]:
@@ -643,5 +664,6 @@ class OperatorService:
                 )
                 for e in events
             ]
-        except Exception:
+        except Exception as e:
+            logger.warning(f"Failed to fetch withdrawal history for operator {operator_id}: {e}")
             return []