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

src/services/operator_service.py

@@ -2,7 +2,15 @@
 
 from decimal import Decimal
 
-from ..core.types import APYMetrics, BondSummary, HealthStatus, OperatorRewards, StrikeSummary
+from ..core.types import (
+    APYMetrics,
+    BondSummary,
+    DistributionFrame,
+    HealthStatus,
+    OperatorRewards,
+    StrikeSummary,
+    WithdrawalEvent,
+)
 from ..data.beacon import (
     BeaconDataProvider,
     ValidatorInfo,
@@ -13,7 +21,7 @@ from ..data.beacon import (
     epoch_to_datetime,
     get_earliest_activation,
 )
-from ..data.ipfs_logs import IPFSLogProvider
+from ..data.ipfs_logs import BEACON_GENESIS, IPFSLogProvider, epoch_to_datetime as epoch_to_dt
 from ..data.lido_api import LidoAPIProvider
 from ..data.onchain import OnChainDataProvider
 from ..data.rewards_tree import RewardsTreeProvider
@@ -32,7 +40,7 @@ class OperatorService:
         self.strikes = StrikesProvider(rpc_url)
 
     async def get_operator_by_address(
-        self, address: str, include_validators: bool = False
+        self, address: str, include_validators: bool = False, include_history: bool = False, include_withdrawals: bool = False
     ) -> OperatorRewards | None:
         """
         Main entry point: get complete rewards data for an address.
@@ -43,10 +51,10 @@ class OperatorService:
         if operator_id is None:
             return None
 
-        return await self.get_operator_by_id(operator_id, include_validators)
+        return await self.get_operator_by_id(operator_id, include_validators, include_history, include_withdrawals)
 
     async def get_operator_by_id(
-        self, operator_id: int, include_validators: bool = False
+        self, operator_id: int, include_validators: bool = False, include_history: bool = False, include_withdrawals: bool = False
     ) -> OperatorRewards | None:
         """Get complete rewards data for an operator ID."""
         from web3.exceptions import ContractLogicError
@@ -58,36 +66,41 @@ class OperatorService:
             # Operator ID doesn't exist on-chain
             return None
 
-        # Step 2: Get bond summary
+        # Step 2: Get bond curve and operator type
+        curve_id = await self.onchain.get_bond_curve_id(operator_id)
+        operator_type = self.onchain.get_operator_type_name(curve_id)
+
+        # Step 3: Get bond summary
         bond = await self.onchain.get_bond_summary(operator_id)
 
-        # Step 3: Get rewards from merkle tree
+        # Step 4: Get rewards from merkle tree
         rewards_info = await self.rewards_tree.get_operator_rewards(operator_id)
 
-        # Step 4: Get already distributed (claimed) shares
+        # Step 5: Get already distributed (claimed) shares
         distributed = await self.onchain.get_distributed_shares(operator_id)
 
-        # Step 5: Calculate unclaimed
+        # Step 6: Calculate unclaimed
         cumulative_shares = (
             rewards_info.cumulative_fee_shares if rewards_info else 0
         )
         unclaimed_shares = max(0, cumulative_shares - distributed)
 
-        # Step 6: Convert shares to ETH
+        # Step 7: Convert shares to ETH
         unclaimed_eth = await self.onchain.shares_to_eth(unclaimed_shares)
         cumulative_eth = await self.onchain.shares_to_eth(cumulative_shares)
         distributed_eth = await self.onchain.shares_to_eth(distributed)
 
-        # Step 7: Calculate total claimable
+        # Step 8: Calculate total claimable
         total_claimable = bond.excess_bond_eth + unclaimed_eth
 
-        # Step 8: Get validator details if requested
+        # Step 9: Get validator details if requested
         validator_details: list[ValidatorInfo] = []
         validators_by_status: dict[str, int] | None = None
         avg_effectiveness: float | None = None
         apy_metrics: APYMetrics | None = None
         active_since = None
         health_status: HealthStatus | None = None
+        withdrawals: list[WithdrawalEvent] | None = None
 
         if include_validators and operator.total_deposited_keys > 0:
             # Get validator pubkeys
@@ -100,13 +113,15 @@ class OperatorService:
             avg_effectiveness = calculate_avg_effectiveness(validator_details)
             active_since = get_earliest_activation(validator_details)
 
-            # Step 9: Calculate APY metrics (using historical IPFS data)
+            # Step 10: Calculate APY metrics (using historical IPFS data)
             apy_metrics = await self.calculate_apy_metrics(
                 operator_id=operator_id,
                 bond_eth=bond.current_bond_eth,
+                curve_id=curve_id,
+                include_history=include_history,
             )
 
-            # Step 10: Calculate health status
+            # Step 11: Calculate health status
             health_status = await self.calculate_health_status(
                 operator_id=operator_id,
                 bond=bond,
@@ -114,10 +129,16 @@ class OperatorService:
                 validator_details=validator_details,
             )
 
+        # Step 12: Fetch withdrawal history if requested
+        if include_withdrawals:
+            withdrawals = await self.get_withdrawal_history(operator_id)
+
         return OperatorRewards(
             node_operator_id=operator_id,
             manager_address=operator.manager_address,
             reward_address=operator.reward_address,
+            curve_id=curve_id,
+            operator_type=operator_type,
             current_bond_eth=bond.current_bond_eth,
             required_bond_eth=bond.required_bond_eth,
             excess_bond_eth=bond.excess_bond_eth,
@@ -137,6 +158,7 @@ class OperatorService:
             apy=apy_metrics,
             active_since=active_since,
             health=health_status,
+            withdrawals=withdrawals,
         )
 
     async def get_all_operators_with_rewards(self) -> list[int]:
@@ -147,18 +169,43 @@ class OperatorService:
         self,
         operator_id: int,
         bond_eth: Decimal,
+        curve_id: int = 0,
+        include_history: bool = False,
     ) -> APYMetrics:
         """Calculate APY metrics for an operator using historical IPFS data.
 
         Note: Validator APY (consensus rewards) is NOT calculated because CSM operators
         don't receive those rewards directly - they go to Lido protocol and are
         redistributed via CSM reward distributions (captured in reward_apy).
+
+        Args:
+            operator_id: The operator ID
+            bond_eth: Current bond in ETH
+            curve_id: Bond curve (0=Permissionless, 1=ICS/Legacy EA)
+            include_history: If True, populate the frames list with all historical data
+                            and calculate accurate per-frame lifetime APY
         """
         historical_reward_apy_28d = None
         historical_reward_apy_ltd = None
+        previous_distribution_eth = None
+        previous_distribution_apy = None
+        previous_net_apy = None
+        current_distribution_eth = None
+        current_distribution_apy = None
+        next_distribution_date = None
+        next_distribution_est_eth = None
+        lifetime_distribution_eth = None
+        # Accurate lifetime APY (calculated with per-frame bond when include_history=True)
+        lifetime_reward_apy = None
+        lifetime_bond_apy = None
+        lifetime_net_apy = None
+        frame_list: list[DistributionFrame] | None = None
+        frames = []
 
         # 1. Try to get historical APY from IPFS distribution logs
-        if bond_eth > 0:
+        # Minimum bond threshold: 0.01 ETH (dust amounts produce nonsensical APY)
+        MIN_BOND_ETH = Decimal("0.01")
+        if bond_eth >= MIN_BOND_ETH:
             try:
                 # Query historical log CIDs from contract events
                 log_history = await self.onchain.get_distribution_log_history()
@@ -170,14 +217,59 @@ class OperatorService:
                     )
 
                     if frames:
-                        # Calculate APY for 28-day and lifetime periods
-                        apy_results = self.ipfs_logs.calculate_historical_apy(
-                            frames=frames,
-                            bond_eth=bond_eth,
-                            periods=[28, None],  # 28-day and lifetime
+                        # Convert all frame shares to ETH values
+                        # IPFS logs store distributed_rewards in stETH shares, not ETH
+                        # We need to convert shares to ETH for accurate display and APY calculation
+                        total_shares = sum(f.distributed_rewards for f in frames)
+                        lifetime_distribution_eth = float(
+                            await self.onchain.shares_to_eth(total_shares)
                         )
-                        historical_reward_apy_28d = apy_results.get("28d")
-                        historical_reward_apy_ltd = apy_results.get("ltd")
+
+                        # Extract current frame data (most recent)
+                        current_frame = frames[-1]
+                        current_eth = await self.onchain.shares_to_eth(
+                            current_frame.distributed_rewards
+                        )
+                        current_days = self.ipfs_logs.calculate_frame_duration_days(current_frame)
+                        current_distribution_eth = float(current_eth)
+                        if current_days > 0 and bond_eth >= MIN_BOND_ETH:
+                            current_distribution_apy = round(
+                                float(current_eth / bond_eth) * (365.0 / current_days) * 100, 2
+                            )
+
+                        # Extract previous frame data (second-to-last)
+                        if len(frames) >= 2:
+                            previous_frame = frames[-2]
+                            prev_eth = await self.onchain.shares_to_eth(
+                                previous_frame.distributed_rewards
+                            )
+                            prev_days = self.ipfs_logs.calculate_frame_duration_days(previous_frame)
+                            previous_distribution_eth = float(prev_eth)
+                            if prev_days > 0 and bond_eth >= MIN_BOND_ETH:
+                                previous_distribution_apy = round(
+                                    float(prev_eth / bond_eth) * (365.0 / prev_days) * 100, 2
+                                )
+
+                        # Calculate APY using ETH values (now that we have them)
+                        # Calculate 28-day APY (current frame)
+                        if current_distribution_apy is not None:
+                            historical_reward_apy_28d = current_distribution_apy
+                        # NOTE: Lifetime APY is intentionally NOT calculated because:
+                        # - It uses current bond as denominator for all historical rewards
+                        # - This produces misleading values for operators who grew over time
+                        # - We keep lifetime_distribution_eth (ETH totals are accurate)
+                        # historical_reward_apy_ltd remains None
+
+                        # Estimate next distribution date (~28 days after current frame ends)
+                        # Frame duration ≈ 28 days = ~6300 epochs
+                        next_epoch = current_frame.end_epoch + 6300
+                        next_distribution_date = epoch_to_dt(next_epoch).isoformat()
+
+                        # Estimate next distribution ETH based on current daily rate
+                        if current_days > 0:
+                            daily_rate = current_eth / Decimal(current_days)
+                            next_distribution_est_eth = float(daily_rate * Decimal(28))
+
             except Exception:
                 # If historical APY calculation fails, continue without it
                 pass
@@ -186,26 +278,223 @@ class OperatorService:
         steth_data = await self.lido_api.get_steth_apr()
         bond_apy = steth_data.get("apr")
 
-        # 3. Net APY (Historical Reward APY + Bond APY)
+        # 3. Net APY calculations
         net_apy_28d = None
         net_apy_ltd = None
 
+        # Current frame net APY (historical_reward_apy_28d is basically current frame APY)
         if historical_reward_apy_28d is not None and bond_apy is not None:
-            net_apy_28d = historical_reward_apy_28d + bond_apy
+            net_apy_28d = round(historical_reward_apy_28d + bond_apy, 2)
         elif bond_apy is not None:
-            net_apy_28d = bond_apy
+            net_apy_28d = round(bond_apy, 2)
+
+        # Lifetime net APY - intentionally NOT calculated
+        # (same reason as historical_reward_apy_ltd - can't accurately calculate without historical bond)
+        # net_apy_ltd remains None
+
+        # Previous frame net APY calculation is moved after we know previous_bond_apy
+        # (calculated in section 4 below)
+
+        # 4. Calculate bond stETH earnings (from stETH rebasing)
+        # Formula: bond_eth * (apr / 100) * (duration_days / 365)
+        # Uses historical APR from Lido subgraph when available
+        # When include_history=True and we have per-frame validator counts, use accurate bond
+        previous_bond_eth = None
+        current_bond_eth = None
+        lifetime_bond_eth = None
+        previous_net_total_eth = None
+        current_net_total_eth = None
+        lifetime_net_total_eth = None
+        previous_bond_apr = None  # Track which APR was used
+        current_bond_apr = None
+        previous_bond_apy = None  # Bond APY for previous frame (for accurate previous_net_apy)
+
+        # Fetch historical APR data (returns [] if no API key)
+        historical_apr_data = await self.lido_api.get_historical_apr_data()
+
+        if bond_eth >= MIN_BOND_ETH:
+            # Previous frame bond earnings
+            if frames and len(frames) >= 2:
+                prev_frame = frames[-2]
+                prev_days = self.ipfs_logs.calculate_frame_duration_days(prev_frame)
+                if prev_days > 0:
+                    # Use average historical APR for the frame period
+                    prev_start_ts = BEACON_GENESIS + (prev_frame.start_epoch * 384)
+                    prev_end_ts = BEACON_GENESIS + (prev_frame.end_epoch * 384)
+                    prev_apr = self.lido_api.get_average_apr_for_range(
+                        historical_apr_data, prev_start_ts, prev_end_ts
+                    )
+                    if prev_apr is None:
+                        prev_apr = bond_apy
+                    if prev_apr is not None:
+                        previous_bond_apr = round(prev_apr, 2)
+                        previous_bond_apy = previous_bond_apr  # Same value, used for net APY
+
+                        # When include_history=True and we have validator count, use per-frame bond
+                        if include_history and prev_frame.validator_count > 0:
+                            prev_bond = self.onchain.calculate_required_bond(
+                                prev_frame.validator_count, curve_id
+                            )
+                            previous_bond_eth = round(
+                                float(prev_bond) * (prev_apr / 100) * (prev_days / 365), 6
+                            )
+                        else:
+                            previous_bond_eth = round(
+                                float(bond_eth) * (prev_apr / 100) * (prev_days / 365), 6
+                            )
+
+            # Current frame bond earnings
+            if frames:
+                curr_frame = frames[-1]
+                curr_days = self.ipfs_logs.calculate_frame_duration_days(curr_frame)
+                if curr_days > 0:
+                    # Use average historical APR for the frame period
+                    curr_start_ts = BEACON_GENESIS + (curr_frame.start_epoch * 384)
+                    curr_end_ts = BEACON_GENESIS + (curr_frame.end_epoch * 384)
+                    curr_apr = self.lido_api.get_average_apr_for_range(
+                        historical_apr_data, curr_start_ts, curr_end_ts
+                    )
+                    if curr_apr is None:
+                        curr_apr = bond_apy
+                    if curr_apr is not None:
+                        current_bond_apr = round(curr_apr, 2)
+                        current_bond_eth = round(
+                            float(bond_eth) * (curr_apr / 100) * (curr_days / 365), 6
+                        )
 
-        if historical_reward_apy_ltd is not None and bond_apy is not None:
-            net_apy_ltd = historical_reward_apy_ltd + bond_apy
-        elif bond_apy is not None:
-            net_apy_ltd = bond_apy
+            # Lifetime bond earnings (sum of all frame durations with per-frame APR)
+            # When include_history=True, calculate accurate lifetime APY with per-frame bond
+            if frames:
+                lifetime_bond_sum = 0.0
+                # For accurate lifetime APY calculation (duration-weighted)
+                frame_reward_apys = []
+                frame_bond_apys = []
+                frame_durations = []
+
+                for f in frames:
+                    f_days = self.ipfs_logs.calculate_frame_duration_days(f)
+                    if f_days > 0:
+                        # Use average historical APR for each frame period
+                        f_start_ts = BEACON_GENESIS + (f.start_epoch * 384)
+                        f_end_ts = BEACON_GENESIS + (f.end_epoch * 384)
+                        f_apr = self.lido_api.get_average_apr_for_range(
+                            historical_apr_data, f_start_ts, f_end_ts
+                        )
+                        if f_apr is None:
+                            f_apr = bond_apy
+
+                        if f_apr is not None:
+                            # When include_history=True and we have validator count, use per-frame bond
+                            if include_history and f.validator_count > 0:
+                                f_bond = self.onchain.calculate_required_bond(
+                                    f.validator_count, curve_id
+                                )
+                                lifetime_bond_sum += float(f_bond) * (f_apr / 100) * (f_days / 365)
+
+                                # Calculate per-frame reward APY for weighted average
+                                f_eth = await self.onchain.shares_to_eth(f.distributed_rewards)
+                                if f_bond > 0:
+                                    f_reward_apy = float(f_eth / f_bond) * (365.0 / f_days) * 100
+                                    frame_reward_apys.append(f_reward_apy)
+                                    frame_bond_apys.append(f_apr)
+                                    frame_durations.append(f_days)
+                            else:
+                                lifetime_bond_sum += float(bond_eth) * (f_apr / 100) * (f_days / 365)
+
+                if lifetime_bond_sum > 0:
+                    lifetime_bond_eth = round(lifetime_bond_sum, 6)
+
+                # Calculate duration-weighted lifetime APYs when include_history=True
+                if include_history and frame_durations:
+                    total_duration = sum(frame_durations)
+                    if total_duration > 0:
+                        # Duration-weighted average reward APY
+                        lifetime_reward_apy = round(
+                            sum(apy * dur for apy, dur in zip(frame_reward_apys, frame_durations))
+                            / total_duration,
+                            2
+                        )
+                        # Duration-weighted average bond APY
+                        lifetime_bond_apy = round(
+                            sum(apy * dur for apy, dur in zip(frame_bond_apys, frame_durations))
+                            / total_duration,
+                            2
+                        )
+                        # Net = Reward + Bond
+                        lifetime_net_apy = round(lifetime_reward_apy + lifetime_bond_apy, 2)
+
+        # 4b. Previous frame net APY (now that we have previous_bond_apy)
+        # Uses the actual APR from the previous frame period instead of current bond_apy
+        if previous_distribution_apy is not None:
+            prev_bond_apy_to_use = previous_bond_apy if previous_bond_apy is not None else bond_apy
+            if prev_bond_apy_to_use is not None:
+                previous_net_apy = round(previous_distribution_apy + prev_bond_apy_to_use, 2)
+
+        # 5. Calculate net totals (Rewards + Bond)
+        if previous_distribution_eth is not None or previous_bond_eth is not None:
+            previous_net_total_eth = round(
+                (previous_distribution_eth or 0) + (previous_bond_eth or 0), 6
+            )
+        if current_distribution_eth is not None or current_bond_eth is not None:
+            current_net_total_eth = round(
+                (current_distribution_eth or 0) + (current_bond_eth or 0), 6
+            )
+        if lifetime_distribution_eth is not None or lifetime_bond_eth is not None:
+            lifetime_net_total_eth = round(
+                (lifetime_distribution_eth or 0) + (lifetime_bond_eth or 0), 6
+            )
+
+        # 6. Build frame history if requested
+        if include_history and frames:
+            frame_list = []
+            for i, f in enumerate(frames):
+                # Convert shares to ETH (not just dividing by 10^18)
+                f_eth = await self.onchain.shares_to_eth(f.distributed_rewards)
+                f_days = self.ipfs_logs.calculate_frame_duration_days(f)
+                f_apy = None
+                if f_days > 0 and bond_eth >= MIN_BOND_ETH:
+                    f_apy = round(float(f_eth / bond_eth) * (365.0 / f_days) * 100, 2)
+
+                frame_list.append(
+                    DistributionFrame(
+                        frame_number=i + 1,
+                        start_date=epoch_to_dt(f.start_epoch).isoformat(),
+                        end_date=epoch_to_dt(f.end_epoch).isoformat(),
+                        rewards_eth=float(f_eth),
+                        rewards_shares=f.distributed_rewards,
+                        duration_days=round(f_days, 1),
+                        validator_count=f.validator_count,
+                        apy=f_apy,
+                    )
+                )
 
         return APYMetrics(
+            previous_distribution_eth=previous_distribution_eth,
+            previous_distribution_apy=previous_distribution_apy,
+            previous_net_apy=previous_net_apy,
+            current_distribution_eth=current_distribution_eth,
+            current_distribution_apy=current_distribution_apy,
+            next_distribution_date=next_distribution_date,
+            next_distribution_est_eth=next_distribution_est_eth,
+            lifetime_distribution_eth=lifetime_distribution_eth,
+            lifetime_reward_apy=lifetime_reward_apy,
+            lifetime_bond_apy=lifetime_bond_apy,
+            lifetime_net_apy=lifetime_net_apy,
             historical_reward_apy_28d=historical_reward_apy_28d,
             historical_reward_apy_ltd=historical_reward_apy_ltd,
             bond_apy=bond_apy,
             net_apy_28d=net_apy_28d,
             net_apy_ltd=net_apy_ltd,
+            frames=frame_list,
+            previous_bond_eth=previous_bond_eth,
+            current_bond_eth=current_bond_eth,
+            lifetime_bond_eth=lifetime_bond_eth,
+            previous_bond_apr=previous_bond_apr,
+            current_bond_apr=current_bond_apr,
+            uses_historical_apr=bool(historical_apr_data),
+            previous_net_total_eth=previous_net_total_eth,
+            current_net_total_eth=current_net_total_eth,
+            lifetime_net_total_eth=lifetime_net_total_eth,
         )
 
     async def calculate_health_status(
@@ -318,3 +607,24 @@ class OperatorService:
             return get_earliest_activation(validators)
         except Exception:
             return None
+
+    async def get_withdrawal_history(self, operator_id: int) -> list[WithdrawalEvent]:
+        """Get withdrawal/claim history for an operator.
+
+        Returns list of WithdrawalEvent objects representing when rewards were claimed.
+        """
+        try:
+            operator = await self.onchain.get_node_operator(operator_id)
+            events = await self.onchain.get_withdrawal_history(operator.reward_address)
+            return [
+                WithdrawalEvent(
+                    block_number=e["block_number"],
+                    timestamp=e["timestamp"],
+                    shares=e["shares"],
+                    eth_value=e["eth_value"],
+                    tx_hash=e["tx_hash"],
+                )
+                for e in events
+            ]
+        except Exception:
+            return []

src/web/routes.py

@@ -11,6 +11,8 @@ router = APIRouter()
 async def get_operator(
     identifier: str,
     detailed: bool = Query(False, description="Include validator status from beacon chain"),
+    history: bool = Query(False, description="Include all historical distribution frames"),
+    withdrawals: bool = Query(False, description="Include withdrawal/claim history"),
 ):
     """
     Get operator data by address or ID.
@@ -18,6 +20,8 @@ async def get_operator(
     - If identifier is numeric, treat as operator ID
     - If identifier starts with 0x, treat as Ethereum address
     - Add ?detailed=true to include validator status breakdown
+    - Add ?history=true to include all historical distribution frames
+    - Add ?withdrawals=true to include withdrawal/claim history
     """
     service = OperatorService()
 
@@ -26,9 +30,9 @@ async def get_operator(
         operator_id = int(identifier)
         if operator_id < 0 or operator_id > 1_000_000:
             raise HTTPException(status_code=400, detail="Invalid operator ID")
-        rewards = await service.get_operator_by_id(operator_id, detailed)
+        rewards = await service.get_operator_by_id(operator_id, detailed or history, history, withdrawals)
     elif identifier.startswith("0x"):
-        rewards = await service.get_operator_by_address(identifier, detailed)
+        rewards = await service.get_operator_by_address(identifier, detailed or history, history, withdrawals)
     else:
         raise HTTPException(status_code=400, detail="Invalid identifier format")
 
@@ -39,6 +43,8 @@ async def get_operator(
         "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),
@@ -79,13 +85,65 @@ async def get_operator(
 
     # Add APY metrics if available
     if rewards.apy:
+        # Use actual excess bond for lifetime values (estimates for previous/current)
+        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=true)
+        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 withdrawal history if withdrawals=true (already fetched during data gathering)
+    if 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
+        ]
 
     # Add active_since if available
     if rewards.active_since: