csm-dashboard 0.2.2__py3-none-any.whl → 0.3.1__py3-none-any.whl

src/cli/commands.py

@@ -25,23 +25,25 @@ def run_async(coro):
     return asyncio.run(coro)
 
 
-def format_as_api_json(rewards: OperatorRewards, include_validators: bool = False) -> dict:
+def format_as_api_json(rewards: OperatorRewards, include_validators: bool = False, include_withdrawals: bool = False) -> dict:
     """Format rewards data in the same structure as the API endpoint."""
     result = {
         "operator_id": rewards.node_operator_id,
         "manager_address": rewards.manager_address,
         "reward_address": rewards.reward_address,
+        "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,
@@ -64,13 +66,53 @@ def format_as_api_json(rewards: OperatorRewards, include_validators: bool = Fals
 
     # Add APY metrics if available
     if rewards.apy:
+        # Use actual excess bond for lifetime values (matches Web API)
+        lifetime_bond = float(rewards.excess_bond_eth)
+        lifetime_net_total = (rewards.apy.lifetime_distribution_eth or 0) + lifetime_bond
+
         result["apy"] = {
+            "previous_distribution_eth": rewards.apy.previous_distribution_eth,
+            "previous_distribution_apy": rewards.apy.previous_distribution_apy,
+            "previous_net_apy": rewards.apy.previous_net_apy,
+            "previous_bond_eth": rewards.apy.previous_bond_eth,
+            "previous_bond_apr": rewards.apy.previous_bond_apr,
+            "previous_net_total_eth": rewards.apy.previous_net_total_eth,
+            "current_distribution_eth": rewards.apy.current_distribution_eth,
+            "current_distribution_apy": rewards.apy.current_distribution_apy,
+            "current_bond_eth": rewards.apy.current_bond_eth,
+            "current_bond_apr": rewards.apy.current_bond_apr,
+            "current_net_total_eth": rewards.apy.current_net_total_eth,
+            "lifetime_distribution_eth": rewards.apy.lifetime_distribution_eth,
+            "lifetime_bond_eth": lifetime_bond,  # Actual excess bond, not estimate
+            "lifetime_net_total_eth": lifetime_net_total,  # Matches Total Claimable
+            # Accurate lifetime APY (per-frame bond calculation when available)
+            "lifetime_reward_apy": rewards.apy.lifetime_reward_apy,
+            "lifetime_bond_apy": rewards.apy.lifetime_bond_apy,
+            "lifetime_net_apy": rewards.apy.lifetime_net_apy,
+            "next_distribution_date": rewards.apy.next_distribution_date,
+            "next_distribution_est_eth": rewards.apy.next_distribution_est_eth,
             "historical_reward_apy_28d": rewards.apy.historical_reward_apy_28d,
             "historical_reward_apy_ltd": rewards.apy.historical_reward_apy_ltd,
             "bond_apy": rewards.apy.bond_apy,
             "net_apy_28d": rewards.apy.net_apy_28d,
             "net_apy_ltd": rewards.apy.net_apy_ltd,
+            "uses_historical_apr": rewards.apy.uses_historical_apr,
         }
+        # Add frames if available (from --history flag)
+        if rewards.apy.frames:
+            result["apy"]["frames"] = [
+                {
+                    "frame_number": f.frame_number,
+                    "start_date": f.start_date,
+                    "end_date": f.end_date,
+                    "rewards_eth": f.rewards_eth,
+                    "rewards_shares": f.rewards_shares,
+                    "duration_days": f.duration_days,
+                    "validator_count": f.validator_count,
+                    "apy": f.apy,
+                }
+                for f in rewards.apy.frames
+            ]
 
     # Add active_since if available
     if rewards.active_since:
@@ -80,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,
@@ -94,6 +136,19 @@ def format_as_api_json(rewards: OperatorRewards, include_validators: bool = Fals
             "has_issues": rewards.health.has_issues,
         }
 
+    # Add withdrawal history if requested
+    if include_withdrawals and rewards.withdrawals:
+        result["withdrawals"] = [
+            {
+                "block_number": w.block_number,
+                "timestamp": w.timestamp,
+                "shares": w.shares,
+                "eth_value": w.eth_value,
+                "tx_hash": w.tx_hash,
+            }
+            for w in rewards.withdrawals
+        ]
+
     return result
 
 
@@ -115,6 +170,12 @@ def rewards(
     detailed: bool = typer.Option(
         False, "--detailed", "-d", help="Include validator status from beacon chain"
     ),
+    history: bool = typer.Option(
+        False, "--history", "-H", help="Show all historical distribution frames"
+    ),
+    withdrawals: bool = typer.Option(
+        False, "--withdrawals", "-w", help="Include withdrawal/claim history"
+    ),
 ):
     """
     Check CSM operator rewards and earnings.
@@ -124,6 +185,8 @@ def rewards(
         csm rewards 42
         csm rewards 0xYourAddress --json
         csm rewards 42 --detailed
+        csm rewards 42 --history
+        csm rewards 42 --withdrawals
     """
     if address is None and operator_id is None:
         console.print("[red]Error: Must provide either ADDRESS or --id[/red]")
@@ -139,20 +202,20 @@ def rewards(
     if not output_json:
         console.print()
         status_msg = "[bold blue]Fetching operator data..."
-        if detailed:
+        if detailed or history or withdrawals:
             status_msg = "[bold blue]Fetching operator data and validator status..."
         with console.status(status_msg):
             if operator_id is not None:
-                rewards = run_async(service.get_operator_by_id(operator_id, detailed))
+                rewards = run_async(service.get_operator_by_id(operator_id, detailed or history, history, withdrawals))
             else:
                 console.print(f"[dim]Looking up operator for address: {address}[/dim]")
-                rewards = run_async(service.get_operator_by_address(address, detailed))
+                rewards = run_async(service.get_operator_by_address(address, detailed or history, history, withdrawals))
     else:
         # JSON mode - no status output
         if operator_id is not None:
-            rewards = run_async(service.get_operator_by_id(operator_id, detailed))
+            rewards = run_async(service.get_operator_by_id(operator_id, detailed or history, history, withdrawals))
         else:
-            rewards = run_async(service.get_operator_by_address(address, detailed))
+            rewards = run_async(service.get_operator_by_address(address, detailed or history, history, withdrawals))
 
     if rewards is None:
         if output_json:
@@ -163,17 +226,18 @@ def rewards(
 
     # JSON output mode
     if output_json:
-        print(json.dumps(format_as_api_json(rewards, detailed), indent=2))
+        print(json.dumps(format_as_api_json(rewards, detailed, withdrawals), indent=2))
         return
 
     # Header panel
     active_since_str = ""
     if rewards.active_since:
         active_since_str = f"Active Since: {rewards.active_since.strftime('%b %d, %Y')}"
+    operator_type_str = f"Type: {rewards.operator_type}"
     console.print(
         Panel(
             f"[bold]CSM Operator #{rewards.node_operator_id}[/bold]\n"
-            f"{active_since_str}\n\n"
+            f"{active_since_str}  |  {operator_type_str}\n\n"
             f"Manager: {rewards.manager_address}\n"
             f"Rewards: {rewards.reward_address}",
             title="Operator Info",
@@ -352,35 +416,190 @@ def rewards(
     console.print(rewards_table)
     console.print()
 
-    # APY Metrics table (only shown with --detailed flag)
-    if detailed and rewards.apy:
-        apy_table = Table(title="APY Metrics (Historical)")
-        apy_table.add_column("Metric", style="cyan")
-        apy_table.add_column("28-Day", style="green", justify="right")
-        apy_table.add_column("Lifetime", style="green", justify="right")
-
+    # APY Metrics table (only shown with --detailed or --history flag)
+    if (detailed or history) and rewards.apy:
         def fmt_apy(val: float | None) -> str:
             return f"{val:.2f}%" if val is not None else "--"
 
-        apy_table.add_row(
-            "Reward APY",
-            fmt_apy(rewards.apy.historical_reward_apy_28d),
-            fmt_apy(rewards.apy.historical_reward_apy_ltd),
-        )
-        apy_table.add_row(
-            "Bond APY (stETH)*",
-            fmt_apy(rewards.apy.bond_apy),
-            fmt_apy(rewards.apy.bond_apy),
-        )
-        apy_table.add_row("", "", "")
-        apy_table.add_row(
-            "[bold]NET APY[/bold]",
-            f"[bold yellow]{fmt_apy(rewards.apy.net_apy_28d)}[/bold yellow]",
-            f"[bold yellow]{fmt_apy(rewards.apy.net_apy_ltd)}[/bold yellow]",
-        )
+        def fmt_eth(val: float | None) -> str:
+            return f"{val:.4f}" if val is not None else "--"
+
+        # Determine which columns to show
+        # --detailed only: Current column only
+        # --history: Previous, Current, and Lifetime columns
+        show_all_columns = history
+
+        if show_all_columns:
+            # Full table with 3 columns (Previous, Current, Lifetime)
+            apy_table = Table(title="APY Metrics")
+            apy_table.add_column("Metric", style="cyan")
+            apy_table.add_column("Previous", style="green", justify="right")
+            apy_table.add_column("Current", style="green", justify="right")
+            apy_table.add_column("Lifetime", style="green", justify="right")
+
+            # Use accurate lifetime APY when available (per-frame bond calculation)
+            lifetime_reward_apy = rewards.apy.lifetime_reward_apy or rewards.apy.historical_reward_apy_ltd
+            lifetime_bond_apy = rewards.apy.lifetime_bond_apy or rewards.apy.bond_apy
+            lifetime_net_apy = rewards.apy.lifetime_net_apy or rewards.apy.net_apy_ltd
+
+            apy_table.add_row(
+                "Reward APY",
+                fmt_apy(rewards.apy.previous_distribution_apy),
+                fmt_apy(rewards.apy.current_distribution_apy),
+                fmt_apy(lifetime_reward_apy),
+            )
+            # Show historical APR for Previous/Current if available, otherwise current APR
+            prev_bond_apr = rewards.apy.previous_bond_apr or rewards.apy.bond_apy
+            curr_bond_apr = rewards.apy.current_bond_apr or rewards.apy.bond_apy
+            bond_label = "Bond APY (stETH)"
+            apy_table.add_row(
+                bond_label,
+                fmt_apy(prev_bond_apr),
+                fmt_apy(curr_bond_apr),
+                fmt_apy(lifetime_bond_apy),
+            )
+            apy_table.add_row(
+                "[bold]NET APY[/bold]",
+                f"[bold yellow]{fmt_apy(rewards.apy.previous_net_apy)}[/bold yellow]",
+                f"[bold yellow]{fmt_apy(rewards.apy.net_apy_28d)}[/bold yellow]",
+                f"[bold yellow]{fmt_apy(lifetime_net_apy)}[/bold yellow]",
+            )
+            apy_table.add_row("─" * 15, "─" * 10, "─" * 10, "─" * 10)
+            apy_table.add_row(
+                "Rewards (stETH)",
+                fmt_eth(rewards.apy.previous_distribution_eth),
+                fmt_eth(rewards.apy.current_distribution_eth),
+                fmt_eth(rewards.apy.lifetime_distribution_eth),
+            )
+            # All columns show estimated bond stETH rebasing earnings (consistent metric)
+            apy_table.add_row(
+                "Bond (stETH)*",
+                fmt_eth(rewards.apy.previous_bond_eth),
+                fmt_eth(rewards.apy.current_bond_eth),
+                fmt_eth(rewards.apy.lifetime_bond_eth),
+            )
+            # All columns show sum of Rewards + Bond (consistent metric)
+            apy_table.add_row(
+                "[bold]Net Total (stETH)[/bold]",
+                f"[bold]{fmt_eth(rewards.apy.previous_net_total_eth)}[/bold]",
+                f"[bold]{fmt_eth(rewards.apy.current_net_total_eth)}[/bold]",
+                f"[bold]{fmt_eth(rewards.apy.lifetime_net_total_eth)}[/bold]",
+            )
+
+            console.print(apy_table)
+            # Show footnote about per-frame bond calculation
+            console.print("[dim]*Previous/Current use per-frame validator count for bond calculations[/dim]")
+        else:
+            # Single column (Current only) for --detailed without --history
+            apy_table = Table(title="APY Metrics (Current Frame)")
+            apy_table.add_column("Metric", style="cyan")
+            apy_table.add_column("Current", style="green", justify="right")
+
+            apy_table.add_row(
+                "Reward APY",
+                fmt_apy(rewards.apy.current_distribution_apy),
+            )
+            curr_bond_apr = rewards.apy.current_bond_apr or rewards.apy.bond_apy
+            apy_table.add_row(
+                "Bond APY (stETH)",
+                fmt_apy(curr_bond_apr),
+            )
+            apy_table.add_row(
+                "[bold]NET APY[/bold]",
+                f"[bold yellow]{fmt_apy(rewards.apy.net_apy_28d)}[/bold yellow]",
+            )
+            apy_table.add_row("─" * 15, "─" * 10)
+            apy_table.add_row(
+                "Rewards (stETH)",
+                fmt_eth(rewards.apy.current_distribution_eth),
+            )
+            apy_table.add_row(
+                "Bond (stETH)*",
+                fmt_eth(rewards.apy.current_bond_eth),
+            )
+            apy_table.add_row(
+                "[bold]Net Total (stETH)[/bold]",
+                f"[bold]{fmt_eth(rewards.apy.current_net_total_eth)}[/bold]",
+            )
+
+            console.print(apy_table)
+            # Show appropriate footer based on whether historical APR was used
+            if rewards.apy.uses_historical_apr:
+                console.print("[dim]*Bond (stETH) is estimated from current bond and historical APR[/dim]")
+            else:
+                console.print("[dim]*Bond (stETH) is estimated from current bond and APR[/dim]")
+
+        # Show next distribution estimate
+        if rewards.apy.next_distribution_date:
+            from datetime import datetime
+            try:
+                next_dt = datetime.fromisoformat(rewards.apy.next_distribution_date)
+                next_date_str = next_dt.strftime("%b %d, %Y")
+                est_eth = rewards.apy.next_distribution_est_eth
+                if est_eth:
+                    console.print(f"\n[cyan]Next Distribution:[/cyan] ~{next_date_str} (est. {est_eth:.4f} ETH)")
+                else:
+                    console.print(f"\n[cyan]Next Distribution:[/cyan] ~{next_date_str}")
+            except (ValueError, TypeError):
+                pass
+        console.print()
+
+        # Show full distribution history if --history flag is used
+        if history and rewards.apy.frames:
+            from datetime import datetime
+            history_table = Table(title="Distribution History")
+            history_table.add_column("#", style="cyan", justify="right")
+            history_table.add_column("Distribution Date", style="white")
+            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")
+
+            # Display oldest first (chronological order)
+            for frame in rewards.apy.frames:
+                try:
+                    end_dt = datetime.fromisoformat(frame.end_date)
+                    dist_date = end_dt.strftime("%b %d, %Y")
+                except (ValueError, TypeError):
+                    dist_date = frame.end_date
+
+                # Calculate ETH per validator
+                eth_per_val = frame.rewards_eth / frame.validator_count if frame.validator_count > 0 else 0
+
+                history_table.add_row(
+                    str(frame.frame_number),
+                    dist_date,
+                    f"{frame.rewards_eth:.4f}",
+                    str(frame.validator_count),
+                    f"{eth_per_val:.6f}",
+                )
+
+            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")
+
+        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 "--",
+            )
 
-        console.print(apy_table)
-        console.print("[dim]*Bond APY uses current stETH rate[/dim]")
+        console.print(withdrawal_table)
         console.print()
 
 
@@ -446,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
@@ -458,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,
@@ -468,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,
@@ -564,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:

src/core/config.py

@@ -20,6 +20,9 @@ class Settings(BaseSettings):
     # Etherscan API (optional, for historical event queries)
     etherscan_api_key: str | None = None
 
+    # The Graph API (optional, for historical stETH APR data)
+    thegraph_api_key: str | None = None
+
     # Data Sources
     rewards_proofs_url: str = (
         "https://raw.githubusercontent.com/lidofinance/csm-rewards/mainnet/proofs.json"

src/core/types.py

@@ -48,6 +48,29 @@ class RewardsInfo(BaseModel):
     proof: list[str]
 
 
+class DistributionFrame(BaseModel):
+    """Single distribution frame data."""
+
+    frame_number: int
+    start_date: str  # ISO format
+    end_date: str
+    rewards_eth: float
+    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)
+
+
+class WithdrawalEvent(BaseModel):
+    """A single reward claim/withdrawal event."""
+
+    block_number: int
+    timestamp: str  # ISO format
+    shares: int
+    eth_value: float
+    tx_hash: str
+
+
 class APYMetrics(BaseModel):
     """APY calculations for an operator.
 
@@ -59,17 +82,58 @@ class APYMetrics(BaseModel):
     which is more accurate than calculating from unclaimed amounts.
     """
 
+    # Previous distribution frame metrics
+    previous_distribution_eth: float | None = None
+    previous_distribution_apy: float | None = None
+    previous_net_apy: float | None = None  # previous_reward_apy + previous_bond_apy
+
+    # Current distribution frame metrics
+    current_distribution_eth: float | None = None
+    current_distribution_apy: float | None = None
+
+    # Next distribution estimates
+    next_distribution_date: str | None = None  # ISO format
+    next_distribution_est_eth: float | None = None
+
+    # Lifetime totals
+    lifetime_distribution_eth: float | None = None  # Sum of all frame rewards
+
+    # Accurate lifetime APY (calculated with per-frame bond when history available)
+    lifetime_reward_apy: float | None = None  # Duration-weighted avg from all frames
+    lifetime_bond_apy: float | None = None  # Duration-weighted avg bond APY
+    lifetime_net_apy: float | None = None  # lifetime_reward_apy + lifetime_bond_apy
+
     # Historical Reward APY (from IPFS distribution logs) - most accurate
-    historical_reward_apy_28d: float | None = None  # Last ~28 days (1 frame)
-    historical_reward_apy_ltd: float | None = None  # Lifetime
+    historical_reward_apy_28d: float | None = None  # Kept for backwards compat
+    historical_reward_apy_ltd: float | None = None  # Lifetime (legacy)
 
     # Bond APY (stETH rebase appreciation)
     bond_apy: float | None = None
 
     # Net APY (Historical Reward APY + Bond APY)
-    net_apy_28d: float | None = None
+    net_apy_28d: float | None = None  # Kept for backwards compat
     net_apy_ltd: float | None = None
 
+    # Full frame history (only populated with --history flag)
+    frames: list[DistributionFrame] | None = None
+
+    # Bond stETH earnings (estimated from stETH rebasing)
+    previous_bond_eth: float | None = None
+    current_bond_eth: float | None = None
+    lifetime_bond_eth: float | None = None
+
+    # Historical APR values used for each frame (from Lido subgraph)
+    previous_bond_apr: float | None = None  # APR used for previous frame
+    current_bond_apr: float | None = None  # APR used for current frame
+
+    # Track whether historical APR was used (vs fallback to current)
+    uses_historical_apr: bool = False
+
+    # Net total stETH (Rewards + Bond)
+    previous_net_total_eth: float | None = None
+    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
@@ -80,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):
@@ -117,6 +182,10 @@ class OperatorRewards(BaseModel):
     manager_address: str
     reward_address: str
 
+    # Operator type (from bond curve)
+    curve_id: int = 0  # 0=Permissionless, 1=ICS/Legacy EA
+    operator_type: str = "Permissionless"  # Human-readable type
+
     # Bond information
     current_bond_eth: Decimal
     required_bond_eth: Decimal
@@ -151,3 +220,6 @@ class OperatorRewards(BaseModel):
 
     # Health status (optional, requires detailed lookup)
     health: HealthStatus | None = None
+
+    # Withdrawal history (optional, populated with --history flag)
+    withdrawals: list[WithdrawalEvent] | None = None

src/data/etherscan.py

@@ -76,3 +76,63 @@ class EtherscanProvider:
                         continue
 
             return sorted(results, key=lambda x: x["block"])
+
+    async def get_transfer_events(
+        self,
+        token_address: str,
+        from_address: str,
+        to_address: str,
+        from_block: int,
+        to_block: str | int = "latest",
+    ) -> list[dict]:
+        """Query Transfer events from Etherscan for a specific from/to pair."""
+        if not self.api_key:
+            return []
+
+        # Event topic: keccak256("Transfer(address,address,uint256)")
+        topic0 = "0x" + Web3.keccak(text="Transfer(address,address,uint256)").hex()
+        # topic1 is indexed 'from' address (padded to 32 bytes)
+        topic1 = "0x" + from_address.lower().replace("0x", "").zfill(64)
+        # topic2 is indexed 'to' address (padded to 32 bytes)
+        topic2 = "0x" + to_address.lower().replace("0x", "").zfill(64)
+
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            response = await client.get(
+                self.BASE_URL,
+                params={
+                    "chainid": 1,
+                    "module": "logs",
+                    "action": "getLogs",
+                    "address": token_address,
+                    "topic0": topic0,
+                    "topic1": topic1,
+                    "topic2": topic2,
+                    "topic0_1_opr": "and",
+                    "topic1_2_opr": "and",
+                    "fromBlock": from_block,
+                    "toBlock": to_block,
+                    "apikey": self.api_key,
+                },
+            )
+
+            data = response.json()
+            if data.get("status") != "1":
+                return []
+
+            results = []
+            for log in data.get("result", []):
+                # The data field contains the non-indexed value (amount)
+                raw_data = log["data"]
+                try:
+                    value = int(raw_data, 16)
+                    results.append(
+                        {
+                            "block": int(log["blockNumber"], 16),
+                            "tx_hash": log["transactionHash"],
+                            "value": value,
+                        }
+                    )
+                except (ValueError, TypeError):
+                    continue
+
+            return sorted(results, key=lambda x: x["block"])