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

src/cli/commands.py

@@ -25,12 +25,14 @@ 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),
@@ -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:
@@ -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,37 +416,192 @@ 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)
-        console.print("[dim]*Bond APY uses current stETH rate[/dim]")
+            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(withdrawal_table)
+            console.print()
+
 
 @app.command()
 def health(

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
@@ -117,6 +181,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 +219,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"])

src/data/ipfs_logs.py

@@ -3,6 +3,7 @@
 import json
 import time
 from dataclasses import dataclass
+from datetime import datetime, timezone
 from decimal import Decimal
 from pathlib import Path
 
@@ -11,6 +12,19 @@ import httpx
 from ..core.config import get_settings
 
 
+# Ethereum Beacon Chain genesis timestamp (Dec 1, 2020 12:00:23 UTC)
+BEACON_GENESIS = 1606824023
+
+
+def epoch_to_datetime(epoch: int) -> datetime:
+    """Convert beacon chain epoch to datetime.
+
+    Each epoch is 32 slots * 12 seconds = 384 seconds.
+    """
+    timestamp = BEACON_GENESIS + (epoch * 384)
+    return datetime.fromtimestamp(timestamp, tz=timezone.utc)
+
+
 @dataclass
 class FrameData:
     """Data from a single distribution frame."""
@@ -20,6 +34,7 @@ class FrameData:
     log_cid: str
     block_number: int
     distributed_rewards: int  # For specific operator, in wei
+    validator_count: int  # Number of validators for operator in this frame
 
 
 class IPFSLogProvider:
@@ -27,7 +42,6 @@ class IPFSLogProvider:
 
     # IPFS gateways to try in order
     GATEWAYS = [
-        "https://dweb.link/ipfs/",
         "https://ipfs.io/ipfs/",
         "https://cloudflare-ipfs.com/ipfs/",
     ]
@@ -113,6 +127,9 @@ class IPFSLogProvider:
         Extract operator's distributed_rewards for a frame.
 
         Returns rewards in wei (shares), or None if operator not in frame.
+
+        Note: The IPFS log field name changed from "distributed" to "distributed_rewards"
+        around Dec 2025. We check both for backwards compatibility.
         """
         operators = log_data.get("operators", {})
         op_key = str(operator_id)
@@ -120,7 +137,12 @@ class IPFSLogProvider:
         if op_key not in operators:
             return None
 
-        return operators[op_key].get("distributed_rewards", 0)
+        op_data = operators[op_key]
+        # Handle both new and old field names for backwards compatibility
+        rewards = op_data.get("distributed_rewards")
+        if rewards is None:
+            rewards = op_data.get("distributed")  # Fallback to old field name
+        return rewards if rewards is not None else 0
 
     def get_frame_info(self, log_data: dict) -> tuple[int, int]:
         """
@@ -133,6 +155,22 @@ class IPFSLogProvider:
             return (0, 0)
         return (frame[0], frame[1])
 
+    def get_operator_validator_count(self, log_data: dict, operator_id: int) -> int:
+        """
+        Get the number of validators for an operator in a frame.
+
+        Returns the count of validators, or 0 if operator not in frame.
+        """
+        operators = log_data.get("operators", {})
+        op_key = str(operator_id)
+
+        if op_key not in operators:
+            return 0
+
+        op_data = operators[op_key]
+        validators = op_data.get("validators", {})
+        return len(validators)
+
     async def get_operator_history(
         self,
         operator_id: int,
@@ -164,6 +202,7 @@ class IPFSLogProvider:
                 continue
 
             start_epoch, end_epoch = self.get_frame_info(log_data)
+            validator_count = self.get_operator_validator_count(log_data, operator_id)
 
             frames.append(
                 FrameData(
@@ -172,6 +211,7 @@ class IPFSLogProvider:
                     log_cid=cid,
                     block_number=block,
                     distributed_rewards=rewards,
+                    validator_count=validator_count,
                 )
             )