csm-dashboard 0.3.0__tar.gz → 0.3.1__tar.gz

{csm_dashboard-0.3.0 → csm_dashboard-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: csm-dashboard
-Version: 0.3.0
+Version: 0.3.1
 Summary: Lido CSM Operator Dashboard for tracking validator earnings
 Requires-Python: >=3.11
 Requires-Dist: fastapi>=0.104

{csm_dashboard-0.3.0 → csm_dashboard-0.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "csm-dashboard"
-version = "0.3.0"
+version = "0.3.1"
 description = "Lido CSM Operator Dashboard for tracking validator earnings"
 readme = "README.md"
 requires-python = ">=3.11"

{csm_dashboard-0.3.0 → csm_dashboard-0.3.1}/src/cli/commands.py

@@ -34,16 +34,16 @@ def format_as_api_json(rewards: OperatorRewards, include_validators: bool = Fals
         "curve_id": rewards.curve_id,
         "operator_type": rewards.operator_type,
         "rewards": {
-            "current_bond_eth": float(rewards.current_bond_eth),
-            "required_bond_eth": float(rewards.required_bond_eth),
-            "excess_bond_eth": float(rewards.excess_bond_eth),
+            "current_bond_eth": str(rewards.current_bond_eth),
+            "required_bond_eth": str(rewards.required_bond_eth),
+            "excess_bond_eth": str(rewards.excess_bond_eth),
             "cumulative_rewards_shares": rewards.cumulative_rewards_shares,
-            "cumulative_rewards_eth": float(rewards.cumulative_rewards_eth),
+            "cumulative_rewards_eth": str(rewards.cumulative_rewards_eth),
             "distributed_shares": rewards.distributed_shares,
-            "distributed_eth": float(rewards.distributed_eth),
+            "distributed_eth": str(rewards.distributed_eth),
             "unclaimed_shares": rewards.unclaimed_shares,
-            "unclaimed_eth": float(rewards.unclaimed_eth),
-            "total_claimable_eth": float(rewards.total_claimable_eth),
+            "unclaimed_eth": str(rewards.unclaimed_eth),
+            "total_claimable_eth": str(rewards.total_claimable_eth),
         },
         "validators": {
             "total": rewards.total_validators,
@@ -122,7 +122,7 @@ def format_as_api_json(rewards: OperatorRewards, include_validators: bool = Fals
     if rewards.health:
         result["health"] = {
             "bond_healthy": rewards.health.bond_healthy,
-            "bond_deficit_eth": float(rewards.health.bond_deficit_eth),
+            "bond_deficit_eth": str(rewards.health.bond_deficit_eth),
             "stuck_validators_count": rewards.health.stuck_validators_count,
             "slashed_validators_count": rewards.health.slashed_validators_count,
             "validators_at_risk_count": rewards.health.validators_at_risk_count,
@@ -576,31 +576,31 @@ def rewards(
             console.print(history_table)
             console.print()
 
-        # Show withdrawal history if --withdrawals flag is used
-        if withdrawals and rewards.withdrawals:
-            from datetime import datetime
-            withdrawal_table = Table(title="Withdrawal History")
-            withdrawal_table.add_column("#", style="cyan", justify="right")
-            withdrawal_table.add_column("Date", style="white")
-            withdrawal_table.add_column("Amount (stETH)", style="green", justify="right")
-            withdrawal_table.add_column("Tx Hash", style="dim")
+    # Show withdrawal history if --withdrawals flag is used
+    if withdrawals and rewards.withdrawals:
+        from datetime import datetime
+        withdrawal_table = Table(title="Withdrawal History")
+        withdrawal_table.add_column("#", style="cyan", justify="right")
+        withdrawal_table.add_column("Date", style="white")
+        withdrawal_table.add_column("Amount (stETH)", style="green", justify="right")
+        withdrawal_table.add_column("Tx Hash", style="dim")
 
-            for i, w in enumerate(rewards.withdrawals, 1):
-                try:
-                    w_dt = datetime.fromisoformat(w.timestamp)
-                    w_date = w_dt.strftime("%b %d, %Y")
-                except (ValueError, TypeError):
-                    w_date = w.timestamp[:10] if w.timestamp else "--"
+        for i, w in enumerate(rewards.withdrawals, 1):
+            try:
+                w_dt = datetime.fromisoformat(w.timestamp)
+                w_date = w_dt.strftime("%b %d, %Y")
+            except (ValueError, TypeError):
+                w_date = w.timestamp[:10] if w.timestamp else "--"
 
-                withdrawal_table.add_row(
-                    str(i),
-                    w_date,
-                    f"{w.eth_value:.4f}",
-                    f"{w.tx_hash[:10]}..." if w.tx_hash else "--",
-                )
+            withdrawal_table.add_row(
+                str(i),
+                w_date,
+                f"{w.eth_value:.4f}",
+                f"{w.tx_hash[:10]}..." if w.tx_hash else "--",
+            )
 
-            console.print(withdrawal_table)
-            console.print()
+        console.print(withdrawal_table)
+        console.print()
 
 
 @app.command()
@@ -665,11 +665,12 @@ def health(
             # Fetch validator strikes details
             validator_strikes = []
             if rewards.health.strikes.total_validators_with_strikes > 0:
-                strikes_data = run_async(service.get_operator_strikes(rewards.node_operator_id))
+                strikes_data = run_async(service.get_operator_strikes(rewards.node_operator_id, rewards.curve_id))
                 validator_strikes = [
                     {
                         "pubkey": vs.pubkey,
                         "strike_count": vs.strike_count,
+                        "strike_threshold": vs.strike_threshold,
                         "at_ejection_risk": vs.at_ejection_risk,
                     }
                     for vs in strikes_data
@@ -677,7 +678,7 @@ def health(
 
             result["health"] = {
                 "bond_healthy": rewards.health.bond_healthy,
-                "bond_deficit_eth": float(rewards.health.bond_deficit_eth),
+                "bond_deficit_eth": str(rewards.health.bond_deficit_eth),
                 "stuck_validators_count": rewards.health.stuck_validators_count,
                 "slashed_validators_count": rewards.health.slashed_validators_count,
                 "validators_at_risk_count": rewards.health.validators_at_risk_count,
@@ -687,6 +688,7 @@ def health(
                     "validators_near_ejection": rewards.health.strikes.validators_near_ejection,
                     "total_strikes": rewards.health.strikes.total_strikes,
                     "max_strikes": rewards.health.strikes.max_strikes,
+                    "strike_threshold": rewards.health.strikes.strike_threshold,
                     "validators": validator_strikes,
                 },
                 "has_issues": rewards.health.has_issues,
@@ -783,9 +785,9 @@ def health(
     if strikes.total_validators_with_strikes > 0:
         console.print()
         console.print("[bold]Validator Strikes Detail:[/bold]")
-        validator_strikes = run_async(service.get_operator_strikes(rewards.node_operator_id))
+        validator_strikes = run_async(service.get_operator_strikes(rewards.node_operator_id, rewards.curve_id))
         for vs in validator_strikes:
-            strike_display = f"{vs.strike_count}/3"
+            strike_display = f"{vs.strike_count}/{vs.strike_threshold}"
             if vs.at_ejection_risk:
                 console.print(f"  {vs.pubkey}: [red bold]{strike_display}[/red bold] (EJECTION RISK!)")
             elif vs.strike_count > 0:

{csm_dashboard-0.3.0 → csm_dashboard-0.3.1}/src/core/types.py

@@ -144,10 +144,11 @@ class StrikeSummary(BaseModel):
     """Summary of strikes for an operator."""
 
     total_validators_with_strikes: int = 0
-    validators_at_risk: int = 0  # Validators with 3+ strikes (ejection eligible)
-    validators_near_ejection: int = 0  # Validators with 2 strikes (one away from ejection)
+    validators_at_risk: int = 0  # Validators at or above strike threshold (ejection eligible)
+    validators_near_ejection: int = 0  # Validators one strike away from ejection
     total_strikes: int = 0
     max_strikes: int = 0  # Highest strike count on any single validator
+    strike_threshold: int = 3  # Strikes required for ejection (3 for Permissionless, 4 for ICS)
 
 
 class HealthStatus(BaseModel):

{csm_dashboard-0.3.0 → csm_dashboard-0.3.1}/src/data/onchain.py

@@ -339,8 +339,9 @@ class OnChainDataProvider:
         """
         Get withdrawal history for an operator's reward address.
 
-        Queries stETH Transfer events from CSFeeDistributor to the reward address.
+        Queries stETH Transfer events from CSAccounting to the reward address.
         These represent when the operator claimed their rewards.
+        (Note: Claims flow CSFeeDistributor -> CSAccounting -> reward_address)
 
         Args:
             reward_address: The operator's reward address
@@ -353,14 +354,14 @@ class OnChainDataProvider:
             start_block = 20873000  # CSM deployment block
 
         reward_address = Web3.to_checksum_address(reward_address)
-        csfeedistributor_address = self.settings.csfeedistributor_address
+        csaccounting_address = self.settings.csaccounting_address
 
         # 1. Try Etherscan API first (most reliable)
         etherscan = EtherscanProvider()
         if etherscan.is_available():
             events = await etherscan.get_transfer_events(
                 token_address=self.settings.steth_address,
-                from_address=csfeedistributor_address,
+                from_address=csaccounting_address,
                 to_address=reward_address,
                 from_block=start_block,
             )
@@ -370,7 +371,7 @@ class OnChainDataProvider:
 
         # 2. Try chunked RPC queries
         events = await self._query_transfer_events_chunked(
-            csfeedistributor_address, reward_address, start_block
+            csaccounting_address, reward_address, start_block
         )
         if events:
             return await self._enrich_withdrawal_events(events)

{csm_dashboard-0.3.0 → csm_dashboard-0.3.1}/src/data/strikes.py

@@ -13,6 +13,22 @@ from ..core.config import get_settings
 from .cache import cached
 
 
+# Strike thresholds by operator type (curve_id)
+# Default (Permissionless): 3 strikes till key exit
+# ICS (Identified Community Staker): 4 strikes till key exit
+STRIKE_THRESHOLDS = {
+    0: 3,  # Permissionless (Legacy)
+    1: 4,  # ICS/Legacy EA
+    2: 3,  # Permissionless (current)
+}
+DEFAULT_STRIKE_THRESHOLD = 3
+
+
+def get_strike_threshold(curve_id: int) -> int:
+    """Get the strike threshold for ejection based on operator curve_id."""
+    return STRIKE_THRESHOLDS.get(curve_id, DEFAULT_STRIKE_THRESHOLD)
+
+
 @dataclass
 class ValidatorStrikes:
     """Strike information for a single validator."""
@@ -20,7 +36,8 @@ class ValidatorStrikes:
     pubkey: str
     strikes: list[int]  # Array of 6 values (0 or 1) representing strikes per frame
     strike_count: int  # Total strikes in the 6-frame window
-    at_ejection_risk: bool  # True if 3+ strikes (eligible for ejection)
+    strike_threshold: int  # Number of strikes required for ejection (3 or 4)
+    at_ejection_risk: bool  # True if strike_count >= strike_threshold
 
 
 class StrikesProvider:
@@ -141,12 +158,16 @@ class StrikesProvider:
             return None
         return await self._fetch_tree_from_ipfs(cid)
 
-    async def get_operator_strikes(self, operator_id: int) -> list[ValidatorStrikes]:
+    async def get_operator_strikes(
+        self, operator_id: int, curve_id: int | None = None
+    ) -> list[ValidatorStrikes]:
         """
         Get strikes for all validators belonging to an operator.
 
         Args:
             operator_id: The CSM operator ID
+            curve_id: The operator's bond curve ID (determines strike threshold)
+                     If None, defaults to 3 strikes (permissionless threshold)
 
         Returns:
             List of ValidatorStrikes for validators with any strikes.
@@ -159,6 +180,9 @@ class StrikesProvider:
         values = tree_data.get("values", [])
         operator_strikes = []
 
+        # Determine strike threshold based on operator type
+        strike_threshold = get_strike_threshold(curve_id) if curve_id is not None else DEFAULT_STRIKE_THRESHOLD
+
         for entry in values:
             value = entry.get("value", [])
             if len(value) < 3:
@@ -179,33 +203,42 @@ class StrikesProvider:
                     pubkey=pubkey,
                     strikes=strikes_array if isinstance(strikes_array, list) else [],
                     strike_count=strike_count,
-                    at_ejection_risk=strike_count >= 3,
+                    strike_threshold=strike_threshold,
+                    at_ejection_risk=strike_count >= strike_threshold,
                 )
             )
 
         return operator_strikes
 
     async def get_operator_strike_summary(
-        self, operator_id: int
+        self, operator_id: int, curve_id: int | None = None
     ) -> dict[str, int]:
         """
         Get a summary of strikes for an operator.
 
+        Args:
+            operator_id: The CSM operator ID
+            curve_id: The operator's bond curve ID (determines strike threshold)
+
         Returns:
             Dict with:
             - total_validators_with_strikes: Count of validators with any strikes
-            - validators_at_risk: Count of validators with 3+ strikes
+            - validators_at_risk: Count of validators at ejection risk (>= threshold)
+            - validators_near_ejection: Count one strike away from ejection
             - total_strikes: Sum of all strikes across all validators
             - max_strikes: Highest strike count on any single validator
+            - strike_threshold: The ejection threshold for this operator type
         """
-        strikes = await self.get_operator_strikes(operator_id)
+        strikes = await self.get_operator_strikes(operator_id, curve_id)
+        strike_threshold = get_strike_threshold(curve_id) if curve_id is not None else DEFAULT_STRIKE_THRESHOLD
 
         return {
             "total_validators_with_strikes": len(strikes),
             "validators_at_risk": sum(1 for s in strikes if s.at_ejection_risk),
-            "validators_near_ejection": sum(1 for s in strikes if s.strike_count == 2),
+            "validators_near_ejection": sum(1 for s in strikes if s.strike_count == strike_threshold - 1),
             "total_strikes": sum(s.strike_count for s in strikes),
             "max_strikes": max((s.strike_count for s in strikes), default=0),
+            "strike_threshold": strike_threshold,
         }
 
     def clear_cache(self) -> None:

{csm_dashboard-0.3.0 → csm_dashboard-0.3.1}/src/services/operator_service.py

@@ -127,6 +127,7 @@ class OperatorService:
                 bond=bond,
                 stuck_validators_count=operator.stuck_validators_count,
                 validator_details=validator_details,
+                curve_id=curve_id,
             )
 
         # Step 12: Fetch withdrawal history if requested
@@ -503,6 +504,7 @@ class OperatorService:
         bond: BondSummary,
         stuck_validators_count: int,
         validator_details: list[ValidatorInfo],
+        curve_id: int | None = None,
     ) -> HealthStatus:
         """Calculate health status for an operator.
 
@@ -516,16 +518,17 @@ class OperatorService:
         slashed_count = count_slashed_validators(validator_details)
         at_risk_count = count_at_risk_validators(validator_details)
 
-        # Get strikes data
+        # Get strikes data (pass curve_id for operator-specific thresholds)
         strike_summary = StrikeSummary()
         try:
-            summary = await self.strikes.get_operator_strike_summary(operator_id)
+            summary = await self.strikes.get_operator_strike_summary(operator_id, curve_id)
             strike_summary = StrikeSummary(
                 total_validators_with_strikes=summary.get("total_validators_with_strikes", 0),
                 validators_at_risk=summary.get("validators_at_risk", 0),
                 validators_near_ejection=summary.get("validators_near_ejection", 0),
                 total_strikes=summary.get("total_strikes", 0),
                 max_strikes=summary.get("max_strikes", 0),
+                strike_threshold=summary.get("strike_threshold", 3),
             )
         except Exception:
             # If strikes fetch fails, continue with empty summary
@@ -540,9 +543,14 @@ class OperatorService:
             strikes=strike_summary,
         )
 
-    async def get_operator_strikes(self, operator_id: int):
-        """Get detailed strikes for an operator's validators."""
-        return await self.strikes.get_operator_strikes(operator_id)
+    async def get_operator_strikes(self, operator_id: int, curve_id: int | None = None):
+        """Get detailed strikes for an operator's validators.
+
+        Args:
+            operator_id: The CSM operator ID
+            curve_id: The operator's bond curve ID (determines strike threshold)
+        """
+        return await self.strikes.get_operator_strikes(operator_id, curve_id)
 
     async def get_recent_frame_dates(self, count: int = 6) -> list[dict]:
         """Get date ranges for the most recent N distribution frames.

{csm_dashboard-0.3.0 → csm_dashboard-0.3.1}/src/web/app.py

@@ -473,9 +473,11 @@ def create_app() -> FastAPI:
                                 const opId = document.getElementById('operator-id').textContent;
                                 const strikesResp = await fetch(`/api/operator/${opId}/strikes`);
                                 const strikesData = await strikesResp.json();
+                                const threshold = strikesData.strike_threshold || 3;
                                 strikesList.innerHTML = strikesData.validators.map(v => {
+                                    const vThreshold = v.strike_threshold || threshold;
                                     const colorClass = v.at_ejection_risk ? 'text-red-400' :
-                                        (v.strike_count === 2 ? 'text-orange-400' : 'text-yellow-400');
+                                        (v.strike_count === vThreshold - 1 ? 'text-orange-400' : 'text-yellow-400');
 
                                     // Generate 6 dots with date tooltips
                                     const dots = v.strikes.map((strike, i) => {
@@ -497,7 +499,7 @@ def create_app() -> FastAPI:
                                         <a href="${beaconUrl}" target="_blank" rel="noopener"
                                            class="text-blue-400 hover:text-blue-300 text-sm" title="View on beaconcha.in">↗</a>
                                         <span class="flex gap-0.5 text-base ml-1">${dots}</span>
-                                        <span class="text-gray-400 text-xs">(${v.strike_count}/3)</span>
+                                        <span class="text-gray-400 text-xs">(${v.strike_count}/${vThreshold})</span>
                                     </div>`;
                                 }).join('');
                                 strikesLoaded = true;
@@ -533,6 +535,7 @@ def create_app() -> FastAPI:
                     }
 
                     // Overall - color-coded by severity
+                    const strikeThreshold = h.strikes.strike_threshold || 3;
                     if (!h.has_issues) {
                         document.getElementById('health-overall').innerHTML = '<span class="text-green-400">No issues detected</span>';
                     } else if (
@@ -540,18 +543,18 @@ def create_app() -> FastAPI:
                         h.stuck_validators_count > 0 ||
                         h.slashed_validators_count > 0 ||
                         h.validators_at_risk_count > 0 ||
-                        h.strikes.max_strikes >= 3
+                        h.strikes.max_strikes >= strikeThreshold
                     ) {
                         // Critical issues (red)
                         let message = 'Issues detected - action required!';
-                        if (h.strikes.max_strikes >= 3) {
-                            message = `Validator ejectable (${h.strikes.validators_at_risk} at 3/3 strikes)`;
+                        if (h.strikes.max_strikes >= strikeThreshold) {
+                            message = `Validator ejectable (${h.strikes.validators_at_risk} at ${strikeThreshold}/${strikeThreshold} strikes)`;
                         }
                         document.getElementById('health-overall').innerHTML = `<span class="text-red-400">${message}</span>`;
-                    } else if (h.strikes.max_strikes === 2) {
+                    } else if (h.strikes.max_strikes === strikeThreshold - 1) {
                         // Warning level 2 (orange) - one more strike = ejectable
                         document.getElementById('health-overall').innerHTML =
-                            `<span class="text-orange-400">Warning - ${h.strikes.validators_near_ejection} validator(s) at 2/3 strikes</span>`;
+                            `<span class="text-orange-400">Warning - ${h.strikes.validators_near_ejection} validator(s) at ${strikeThreshold - 1}/${strikeThreshold} strikes</span>`;
                     } else {
                         // Warning level 1 (yellow) - has strikes but not critical
                         document.getElementById('health-overall').innerHTML =

{csm_dashboard-0.3.0 → csm_dashboard-0.3.1}/src/web/routes.py

@@ -46,16 +46,16 @@ async def get_operator(
         "curve_id": rewards.curve_id,
         "operator_type": rewards.operator_type,
         "rewards": {
-            "current_bond_eth": float(rewards.current_bond_eth),
-            "required_bond_eth": float(rewards.required_bond_eth),
-            "excess_bond_eth": float(rewards.excess_bond_eth),
+            "current_bond_eth": str(rewards.current_bond_eth),
+            "required_bond_eth": str(rewards.required_bond_eth),
+            "excess_bond_eth": str(rewards.excess_bond_eth),
             "cumulative_rewards_shares": rewards.cumulative_rewards_shares,
-            "cumulative_rewards_eth": float(rewards.cumulative_rewards_eth),
+            "cumulative_rewards_eth": str(rewards.cumulative_rewards_eth),
             "distributed_shares": rewards.distributed_shares,
-            "distributed_eth": float(rewards.distributed_eth),
+            "distributed_eth": str(rewards.distributed_eth),
             "unclaimed_shares": rewards.unclaimed_shares,
-            "unclaimed_eth": float(rewards.unclaimed_eth),
-            "total_claimable_eth": float(rewards.total_claimable_eth),
+            "unclaimed_eth": str(rewards.unclaimed_eth),
+            "total_claimable_eth": str(rewards.total_claimable_eth),
         },
         "validators": {
             "total": rewards.total_validators,
@@ -153,7 +153,7 @@ async def get_operator(
     if rewards.health:
         result["health"] = {
             "bond_healthy": rewards.health.bond_healthy,
-            "bond_deficit_eth": float(rewards.health.bond_deficit_eth),
+            "bond_deficit_eth": str(rewards.health.bond_deficit_eth),
             "stuck_validators_count": rewards.health.stuck_validators_count,
             "slashed_validators_count": rewards.health.slashed_validators_count,
             "validators_at_risk_count": rewards.health.validators_at_risk_count,
@@ -163,6 +163,7 @@ async def get_operator(
                 "validators_near_ejection": rewards.health.strikes.validators_near_ejection,
                 "total_strikes": rewards.health.strikes.total_strikes,
                 "max_strikes": rewards.health.strikes.max_strikes,
+                "strike_threshold": rewards.health.strikes.strike_threshold,
             },
             "has_issues": rewards.health.has_issues,
         }
@@ -193,18 +194,25 @@ async def get_operator_strikes(identifier: str):
     else:
         raise HTTPException(status_code=400, detail="Invalid identifier format")
 
-    strikes = await service.get_operator_strikes(operator_id)
+    # Get curve_id to determine strike threshold
+    curve_id = await service.onchain.get_bond_curve_id(operator_id)
+    strikes = await service.get_operator_strikes(operator_id, curve_id)
 
     # Fetch frame dates for tooltip display
     frame_dates = await service.get_recent_frame_dates(6)
 
+    # Get the threshold for this operator type
+    strike_threshold = strikes[0].strike_threshold if strikes else 3
+
     return {
         "operator_id": operator_id,
+        "strike_threshold": strike_threshold,
         "frame_dates": frame_dates,
         "validators": [
             {
                 "pubkey": s.pubkey,
                 "strike_count": s.strike_count,
+                "strike_threshold": s.strike_threshold,
                 "strikes": s.strikes,
                 "at_ejection_risk": s.at_ejection_risk,
             }

csm_dashboard-0.3.1/tests/conftest.py

@@ -0,0 +1,108 @@
+"""Shared pytest fixtures for CSM Dashboard tests."""
+
+import pytest
+from decimal import Decimal
+from datetime import datetime, timedelta
+
+from src.core.types import (
+    APYMetrics,
+    BondSummary,
+    DistributionFrame,
+    HealthStatus,
+    OperatorRewards,
+    StrikeSummary,
+    WithdrawalEvent,
+)
+
+
+@pytest.fixture
+def sample_bond_summary():
+    """Sample bond summary data."""
+    return BondSummary(
+        current_bond_wei=26269317414398397106,
+        required_bond_wei=26200000000000000000,
+        current_bond_eth=Decimal("26.269317414398397106"),
+        required_bond_eth=Decimal("26.2"),
+        excess_bond_eth=Decimal("0.069317414398397106"),
+    )
+
+
+@pytest.fixture
+def sample_strike_summary():
+    """Sample strike summary data."""
+    return StrikeSummary(
+        total_validators_with_strikes=2,
+        validators_at_risk=1,
+        validators_near_ejection=1,
+        total_strikes=5,
+        max_strikes=3,
+        strike_threshold=3,
+    )
+
+
+@pytest.fixture
+def sample_health_status(sample_strike_summary):
+    """Sample health status data."""
+    return HealthStatus(
+        bond_healthy=True,
+        bond_deficit_eth=Decimal("0"),
+        stuck_validators_count=0,
+        slashed_validators_count=0,
+        validators_at_risk_count=0,
+        strikes=sample_strike_summary,
+    )
+
+
+@pytest.fixture
+def sample_apy_metrics():
+    """Sample APY metrics data."""
+    return APYMetrics(
+        current_distribution_eth=0.5,
+        current_distribution_apy=2.77,
+        current_bond_eth=0.3,
+        current_bond_apr=2.56,
+        previous_distribution_eth=0.45,
+        previous_distribution_apy=2.65,
+        lifetime_reward_apy=2.80,
+        lifetime_bond_apy=2.60,
+        lifetime_net_apy=5.40,
+    )
+
+
+@pytest.fixture
+def sample_operator_rewards(sample_bond_summary, sample_health_status, sample_apy_metrics):
+    """Sample operator rewards data."""
+    return OperatorRewards(
+        node_operator_id=333,
+        manager_address="0x6ac683C503CF210CCF88193ec7ebDe2c993f63a4",
+        reward_address="0x55915Cf2115c4D6e9085e94c8dAD710cabefef31",
+        curve_id=2,
+        operator_type="Permissionless",
+        current_bond_eth=sample_bond_summary.current_bond_eth,
+        required_bond_eth=sample_bond_summary.required_bond_eth,
+        excess_bond_eth=sample_bond_summary.excess_bond_eth,
+        cumulative_rewards_shares=1234567890,
+        cumulative_rewards_eth=Decimal("10.96"),
+        distributed_shares=1000000000,
+        distributed_eth=Decimal("9.61"),
+        unclaimed_shares=234567890,
+        unclaimed_eth=Decimal("1.35"),
+        total_claimable_eth=Decimal("1.419317414398397106"),
+        total_validators=500,
+        active_validators=500,
+        exited_validators=0,
+        health=sample_health_status,
+        apy=sample_apy_metrics,
+    )
+
+
+@pytest.fixture
+def sample_withdrawal_event():
+    """Sample withdrawal event data."""
+    return WithdrawalEvent(
+        block_number=21278373,
+        timestamp="2024-12-15T10:30:00",
+        shares=126100000000000000,
+        eth_value=0.1261,
+        tx_hash="0x59efb01ebbc20103d4a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3",
+    )

csm_dashboard-0.3.1/tests/unit/test_cache.py

@@ -0,0 +1,162 @@
+"""Tests for the cache module."""
+
+import pytest
+from datetime import datetime, timedelta
+from unittest.mock import patch
+
+from src.data.cache import SimpleCache, cached, get_cache
+
+
+class TestSimpleCache:
+    """Tests for the SimpleCache class."""
+
+    def test_cache_set_and_get(self):
+        """Test basic set and get operations."""
+        cache = SimpleCache(default_ttl=300)
+        cache.set("key1", "value1")
+        assert cache.get("key1") == "value1"
+
+    def test_cache_returns_none_for_missing_key(self):
+        """Test that missing keys return None."""
+        cache = SimpleCache(default_ttl=300)
+        assert cache.get("nonexistent") is None
+
+    def test_cache_expiry(self):
+        """Test that expired entries are not returned."""
+        cache = SimpleCache(default_ttl=300)
+        cache.set("key1", "value1", ttl=1)
+
+        # Immediately should work
+        assert cache.get("key1") == "value1"
+
+        # Mock time to be past expiry
+        with patch("src.data.cache.datetime") as mock_datetime:
+            mock_datetime.now.return_value = datetime.now() + timedelta(seconds=2)
+            assert cache.get("key1") is None
+
+    def test_cache_custom_ttl(self):
+        """Test setting custom TTL per entry."""
+        cache = SimpleCache(default_ttl=300)
+        cache.set("key1", "value1", ttl=600)
+
+        # Mock time to be 400 seconds later (past default TTL but within custom TTL)
+        with patch("src.data.cache.datetime") as mock_datetime:
+            mock_datetime.now.return_value = datetime.now() + timedelta(seconds=400)
+            mock_datetime.side_effect = lambda *args, **kw: datetime(*args, **kw)
+            # Note: This test is tricky due to how timedelta works with mocked datetime
+            # The cache stores expiry at set time, so checking is against stored expiry
+
+    def test_cache_clear(self):
+        """Test clearing all cached entries."""
+        cache = SimpleCache(default_ttl=300)
+        cache.set("key1", "value1")
+        cache.set("key2", "value2")
+
+        assert cache.get("key1") == "value1"
+        assert cache.get("key2") == "value2"
+
+        cache.clear()
+
+        assert cache.get("key1") is None
+        assert cache.get("key2") is None
+
+    def test_cache_overwrite(self):
+        """Test that setting the same key overwrites the value."""
+        cache = SimpleCache(default_ttl=300)
+        cache.set("key1", "value1")
+        cache.set("key1", "value2")
+        assert cache.get("key1") == "value2"
+
+    def test_cache_stores_different_types(self):
+        """Test that cache can store various Python types."""
+        cache = SimpleCache(default_ttl=300)
+
+        cache.set("str", "string value")
+        cache.set("int", 42)
+        cache.set("float", 3.14)
+        cache.set("list", [1, 2, 3])
+        cache.set("dict", {"a": 1, "b": 2})
+        cache.set("none", None)
+
+        assert cache.get("str") == "string value"
+        assert cache.get("int") == 42
+        assert cache.get("float") == 3.14
+        assert cache.get("list") == [1, 2, 3]
+        assert cache.get("dict") == {"a": 1, "b": 2}
+        # Note: None is a valid cached value, but get() returns None for missing keys too
+
+
+class TestCachedDecorator:
+    """Tests for the @cached decorator."""
+
+    @pytest.fixture(autouse=True)
+    def clear_cache(self):
+        """Clear the global cache before each test."""
+        get_cache().clear()
+
+    @pytest.mark.asyncio
+    async def test_cached_decorator_caches_result(self):
+        """Test that the decorator caches function results."""
+        call_count = 0
+
+        @cached(ttl=300)
+        async def my_function(x):
+            nonlocal call_count
+            call_count += 1
+            return x * 2
+
+        # First call should execute the function
+        result1 = await my_function(5)
+        assert result1 == 10
+        assert call_count == 1
+
+        # Second call should return cached result
+        result2 = await my_function(5)
+        assert result2 == 10
+        assert call_count == 1  # Function not called again
+
+    @pytest.mark.asyncio
+    async def test_cached_decorator_different_args(self):
+        """Test that different arguments result in different cache keys."""
+        call_count = 0
+
+        @cached(ttl=300)
+        async def my_function(x):
+            nonlocal call_count
+            call_count += 1
+            return x * 2
+
+        result1 = await my_function(5)
+        result2 = await my_function(10)
+
+        assert result1 == 10
+        assert result2 == 20
+        assert call_count == 2  # Both should call the function
+
+    @pytest.mark.asyncio
+    async def test_cached_decorator_with_kwargs(self):
+        """Test that kwargs are included in cache key."""
+        call_count = 0
+
+        @cached(ttl=300)
+        async def my_function(x, multiplier=2):
+            nonlocal call_count
+            call_count += 1
+            return x * multiplier
+
+        result1 = await my_function(5, multiplier=2)
+        result2 = await my_function(5, multiplier=3)
+
+        assert result1 == 10
+        assert result2 == 15
+        assert call_count == 2  # Different kwargs = different cache key
+
+
+class TestGetCache:
+    """Tests for the get_cache function."""
+
+    def test_get_cache_returns_singleton(self):
+        """Test that get_cache returns the same instance."""
+        cache1 = get_cache()
+        cache2 = get_cache()
+        assert cache1 is cache2

csm_dashboard-0.3.1/tests/unit/test_config.py

@@ -0,0 +1,91 @@
+"""Tests for the config module."""
+
+import os
+import pytest
+from unittest.mock import patch
+
+from src.core.config import Settings, get_settings
+
+
+class TestSettings:
+    """Tests for the Settings class."""
+
+    def test_default_values(self):
+        """Test that settings have expected structure and types.
+
+        Note: Actual values may differ if a .env file is present.
+        """
+        settings = Settings()
+
+        # Test that settings exist and have correct types
+        assert isinstance(settings.eth_rpc_url, str)
+        assert settings.eth_rpc_url.startswith("https://")
+        assert isinstance(settings.beacon_api_url, str)
+        assert settings.beacon_api_key is None or isinstance(settings.beacon_api_key, str)
+        assert settings.etherscan_api_key is None or isinstance(settings.etherscan_api_key, str)
+        assert settings.thegraph_api_key is None or isinstance(settings.thegraph_api_key, str)
+        assert isinstance(settings.cache_ttl_seconds, int)
+        assert settings.cache_ttl_seconds > 0
+
+    def test_contract_addresses(self):
+        """Test that contract addresses are set correctly."""
+        settings = Settings()
+
+        assert settings.csmodule_address == "0xdA7dE2ECdDfccC6c3AF10108Db212ACBBf9EA83F"
+        assert settings.csaccounting_address == "0x4d72BFF1BeaC69925F8Bd12526a39BAAb069e5Da"
+        assert settings.csfeedistributor_address == "0xD99CC66fEC647E68294C6477B40fC7E0F6F618D0"
+        assert settings.csstrikes_address == "0xaa328816027F2D32B9F56d190BC9Fa4A5C07637f"
+        assert settings.steth_address == "0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84"
+
+    def test_environment_variable_override(self):
+        """Test that environment variables override defaults."""
+        custom_rpc = "https://custom.rpc.example.com"
+        custom_ttl = "600"
+
+        with patch.dict(
+            os.environ,
+            {
+                "ETH_RPC_URL": custom_rpc,
+                "CACHE_TTL_SECONDS": custom_ttl,
+            },
+        ):
+            settings = Settings()
+
+        assert settings.eth_rpc_url == custom_rpc
+        assert settings.cache_ttl_seconds == 600
+
+    def test_optional_api_keys(self):
+        """Test that optional API keys can be set."""
+        with patch.dict(
+            os.environ,
+            {
+                "BEACON_API_KEY": "beacon_key_123",
+                "ETHERSCAN_API_KEY": "etherscan_key_456",
+                "THEGRAPH_API_KEY": "graph_key_789",
+            },
+        ):
+            settings = Settings()
+
+        assert settings.beacon_api_key == "beacon_key_123"
+        assert settings.etherscan_api_key == "etherscan_key_456"
+        assert settings.thegraph_api_key == "graph_key_789"
+
+
+class TestGetSettings:
+    """Tests for the get_settings function."""
+
+    def test_get_settings_returns_settings_instance(self):
+        """Test that get_settings returns a Settings instance."""
+        settings = get_settings()
+        assert isinstance(settings, Settings)
+
+    def test_get_settings_is_cached(self):
+        """Test that get_settings returns the same cached instance."""
+        # Clear the cache first
+        get_settings.cache_clear()
+
+        settings1 = get_settings()
+        settings2 = get_settings()
+
+        # Should be the same instance (cached)
+        assert settings1 is settings2

csm_dashboard-0.3.1/tests/unit/test_strikes.py

@@ -0,0 +1,115 @@
+"""Tests for the strikes module."""
+
+import pytest
+
+from src.data.strikes import (
+    DEFAULT_STRIKE_THRESHOLD,
+    STRIKE_THRESHOLDS,
+    ValidatorStrikes,
+    get_strike_threshold,
+)
+
+
+class TestStrikeThresholds:
+    """Tests for strike threshold logic."""
+
+    def test_strike_thresholds_mapping(self):
+        """Test the STRIKE_THRESHOLDS mapping is correct."""
+        assert STRIKE_THRESHOLDS[0] == 3  # Permissionless (Legacy)
+        assert STRIKE_THRESHOLDS[1] == 4  # ICS/Legacy EA
+        assert STRIKE_THRESHOLDS[2] == 3  # Permissionless (current)
+
+    def test_default_strike_threshold(self):
+        """Test the default strike threshold is 3."""
+        assert DEFAULT_STRIKE_THRESHOLD == 3
+
+    def test_get_strike_threshold_permissionless_legacy(self):
+        """Test threshold for curve 0 (Permissionless Legacy)."""
+        assert get_strike_threshold(0) == 3
+
+    def test_get_strike_threshold_ics(self):
+        """Test threshold for curve 1 (ICS/Legacy EA)."""
+        assert get_strike_threshold(1) == 4
+
+    def test_get_strike_threshold_permissionless(self):
+        """Test threshold for curve 2 (Permissionless)."""
+        assert get_strike_threshold(2) == 3
+
+    def test_get_strike_threshold_unknown_curve(self):
+        """Test threshold for unknown curve_id defaults to 3."""
+        assert get_strike_threshold(99) == 3
+        assert get_strike_threshold(100) == 3
+        assert get_strike_threshold(-1) == 3
+
+
+class TestValidatorStrikes:
+    """Tests for ValidatorStrikes dataclass."""
+
+    def test_validator_strikes_creation(self):
+        """Test creating a ValidatorStrikes instance."""
+        vs = ValidatorStrikes(
+            pubkey="0x12345...",
+            strikes=[1, 0, 1, 0, 0, 1],
+            strike_count=3,
+            strike_threshold=3,
+            at_ejection_risk=True,
+        )
+
+        assert vs.pubkey == "0x12345..."
+        assert vs.strike_count == 3
+        assert vs.strike_threshold == 3
+        assert vs.at_ejection_risk is True
+
+    def test_validator_strikes_not_at_risk(self):
+        """Test validator with 2 strikes (not at risk for permissionless)."""
+        vs = ValidatorStrikes(
+            pubkey="0xabc...",
+            strikes=[1, 0, 1, 0, 0, 0],
+            strike_count=2,
+            strike_threshold=3,
+            at_ejection_risk=False,
+        )
+
+        assert vs.strike_count == 2
+        assert vs.at_ejection_risk is False
+
+    def test_validator_strikes_ics_not_at_risk(self):
+        """Test ICS validator with 3 strikes (not at risk since threshold is 4)."""
+        vs = ValidatorStrikes(
+            pubkey="0xdef...",
+            strikes=[1, 1, 1, 0, 0, 0],
+            strike_count=3,
+            strike_threshold=4,  # ICS threshold
+            at_ejection_risk=False,
+        )
+
+        assert vs.strike_count == 3
+        assert vs.strike_threshold == 4
+        assert vs.at_ejection_risk is False  # Not at risk because threshold is 4
+
+    def test_validator_strikes_ics_at_risk(self):
+        """Test ICS validator with 4 strikes (at risk)."""
+        vs = ValidatorStrikes(
+            pubkey="0xghi...",
+            strikes=[1, 1, 1, 1, 0, 0],
+            strike_count=4,
+            strike_threshold=4,  # ICS threshold
+            at_ejection_risk=True,
+        )
+
+        assert vs.strike_count == 4
+        assert vs.at_ejection_risk is True
+
+    def test_validator_strikes_empty_array(self):
+        """Test validator with no strikes."""
+        vs = ValidatorStrikes(
+            pubkey="0xjkl...",
+            strikes=[0, 0, 0, 0, 0, 0],
+            strike_count=0,
+            strike_threshold=3,
+            at_ejection_risk=False,
+        )
+
+        assert vs.strike_count == 0
+        assert vs.at_ejection_risk is False
+        assert sum(vs.strikes) == 0

csm_dashboard-0.3.1/tests/unit/test_types.py

@@ -0,0 +1,207 @@
+"""Tests for the core types module."""
+
+import pytest
+from decimal import Decimal
+from pydantic import ValidationError
+
+from src.core.types import (
+    APYMetrics,
+    BondSummary,
+    DistributionFrame,
+    HealthStatus,
+    OperatorRewards,
+    StrikeSummary,
+    WithdrawalEvent,
+)
+
+
+class TestBondSummary:
+    """Tests for the BondSummary model."""
+
+    def test_bond_summary_creation(self, sample_bond_summary):
+        """Test creating a BondSummary instance."""
+        assert sample_bond_summary.current_bond_wei == 26269317414398397106
+        assert sample_bond_summary.current_bond_eth == Decimal("26.269317414398397106")
+        assert sample_bond_summary.excess_bond_eth == Decimal("0.069317414398397106")
+
+    def test_bond_summary_decimal_precision(self):
+        """Test that Decimal values maintain full precision."""
+        bond = BondSummary(
+            current_bond_wei=26269317414398397106,
+            required_bond_wei=26200000000000000000,
+            current_bond_eth=Decimal("26.269317414398397106"),
+            required_bond_eth=Decimal("26.200000000000000000"),
+            excess_bond_eth=Decimal("0.069317414398397106"),
+        )
+
+        # Verify full precision is maintained
+        assert str(bond.current_bond_eth) == "26.269317414398397106"
+        assert str(bond.excess_bond_eth) == "0.069317414398397106"
+
+
+class TestStrikeSummary:
+    """Tests for the StrikeSummary model."""
+
+    def test_strike_summary_defaults(self):
+        """Test that StrikeSummary has sensible defaults."""
+        summary = StrikeSummary()
+
+        assert summary.total_validators_with_strikes == 0
+        assert summary.validators_at_risk == 0
+        assert summary.validators_near_ejection == 0
+        assert summary.total_strikes == 0
+        assert summary.max_strikes == 0
+        assert summary.strike_threshold == 3  # Default threshold
+
+    def test_strike_summary_with_ics_threshold(self):
+        """Test StrikeSummary with ICS threshold (4 strikes)."""
+        summary = StrikeSummary(
+            total_validators_with_strikes=5,
+            validators_at_risk=2,
+            validators_near_ejection=2,
+            total_strikes=15,
+            max_strikes=4,
+            strike_threshold=4,  # ICS threshold
+        )
+
+        assert summary.strike_threshold == 4
+        assert summary.validators_at_risk == 2
+
+    def test_strike_summary_with_permissionless_threshold(self):
+        """Test StrikeSummary with Permissionless threshold (3 strikes)."""
+        summary = StrikeSummary(
+            total_validators_with_strikes=5,
+            validators_at_risk=3,
+            validators_near_ejection=1,
+            total_strikes=12,
+            max_strikes=3,
+            strike_threshold=3,  # Permissionless threshold
+        )
+
+        assert summary.strike_threshold == 3
+        assert summary.validators_at_risk == 3
+
+
+class TestHealthStatus:
+    """Tests for the HealthStatus model."""
+
+    def test_health_status_defaults(self):
+        """Test that HealthStatus has sensible defaults."""
+        health = HealthStatus()
+
+        assert health.bond_healthy is True
+        assert health.bond_deficit_eth == Decimal(0)
+        assert health.stuck_validators_count == 0
+        assert health.slashed_validators_count == 0
+        assert health.validators_at_risk_count == 0
+        assert health.strikes.strike_threshold == 3
+
+    def test_has_issues_property_no_issues(self):
+        """Test has_issues returns False when no issues."""
+        health = HealthStatus()
+        assert health.has_issues is False
+
+    def test_has_issues_property_with_bond_deficit(self):
+        """Test has_issues returns True when bond is unhealthy."""
+        health = HealthStatus(
+            bond_healthy=False,
+            bond_deficit_eth=Decimal("1.5"),
+        )
+        assert health.has_issues is True
+
+    def test_has_issues_property_with_slashed(self):
+        """Test has_issues returns True when validators are slashed."""
+        health = HealthStatus(slashed_validators_count=1)
+        assert health.has_issues is True
+
+    def test_has_issues_property_with_strikes(self):
+        """Test has_issues returns True when validators have strikes."""
+        health = HealthStatus(
+            strikes=StrikeSummary(total_validators_with_strikes=1, total_strikes=2)
+        )
+        assert health.has_issues is True
+
+
+class TestAPYMetrics:
+    """Tests for the APYMetrics model."""
+
+    def test_apy_metrics_defaults(self):
+        """Test that APYMetrics fields are optional with None defaults."""
+        apy = APYMetrics()
+
+        assert apy.current_distribution_eth is None
+        assert apy.current_distribution_apy is None
+        assert apy.lifetime_reward_apy is None
+        assert apy.frames is None
+
+    def test_apy_metrics_with_values(self, sample_apy_metrics):
+        """Test APYMetrics with actual values."""
+        assert sample_apy_metrics.current_distribution_apy == 2.77
+        assert sample_apy_metrics.lifetime_net_apy == 5.40
+
+
+class TestDistributionFrame:
+    """Tests for the DistributionFrame model."""
+
+    def test_distribution_frame_creation(self):
+        """Test creating a DistributionFrame instance."""
+        frame = DistributionFrame(
+            frame_number=1,
+            start_date="2025-03-14T00:00:00",
+            end_date="2025-04-11T00:00:00",
+            rewards_eth=1.2345,
+            rewards_shares=1234500000000000000,
+            duration_days=28.0,
+            validator_count=500,
+            apy=2.85,
+        )
+
+        assert frame.frame_number == 1
+        assert frame.rewards_eth == 1.2345
+        assert frame.validator_count == 500
+        assert frame.apy == 2.85
+
+
+class TestWithdrawalEvent:
+    """Tests for the WithdrawalEvent model."""
+
+    def test_withdrawal_event_creation(self, sample_withdrawal_event):
+        """Test creating a WithdrawalEvent instance."""
+        assert sample_withdrawal_event.block_number == 21278373
+        assert sample_withdrawal_event.eth_value == 0.1261
+        assert sample_withdrawal_event.tx_hash.startswith("0x")
+
+    def test_withdrawal_event_required_fields(self):
+        """Test that all fields are required for WithdrawalEvent."""
+        with pytest.raises(ValidationError):
+            WithdrawalEvent()  # Missing all required fields
+
+
+class TestOperatorRewards:
+    """Tests for the OperatorRewards model."""
+
+    def test_operator_rewards_creation(self, sample_operator_rewards):
+        """Test creating an OperatorRewards instance."""
+        assert sample_operator_rewards.node_operator_id == 333
+        assert sample_operator_rewards.operator_type == "Permissionless"
+        assert sample_operator_rewards.curve_id == 2
+        assert sample_operator_rewards.total_validators == 500
+
+    def test_operator_rewards_decimal_precision(self, sample_operator_rewards):
+        """Test that Decimal fields maintain full precision."""
+        # Convert to string to verify full precision
+        assert "269317414398397106" in str(sample_operator_rewards.current_bond_eth)
+        assert str(sample_operator_rewards.unclaimed_eth) == "1.35"
+
+    def test_operator_rewards_with_withdrawals(self, sample_operator_rewards, sample_withdrawal_event):
+        """Test OperatorRewards with withdrawal history."""
+        sample_operator_rewards.withdrawals = [sample_withdrawal_event]
+
+        assert len(sample_operator_rewards.withdrawals) == 1
+        assert sample_operator_rewards.withdrawals[0].eth_value == 0.1261
+
+    def test_operator_rewards_health_status(self, sample_operator_rewards):
+        """Test that health status is properly linked."""
+        assert sample_operator_rewards.health is not None
+        assert sample_operator_rewards.health.bond_healthy is True
+        assert sample_operator_rewards.health.strikes.strike_threshold == 3