csm-dashboard 0.3.2__py3-none-any.whl → 0.3.6__py3-none-any.whl

{csm_dashboard-0.3.2.dist-info → csm_dashboard-0.3.6.dist-info}/METADATA

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

{csm_dashboard-0.3.2.dist-info → csm_dashboard-0.3.6.dist-info}/RECORD

@@ -3,30 +3,31 @@ src/main.py,sha256=tj7C09FVBGBVyjKYwmElpX5M92xfydDm8RJ6-MSFdMk,951
 src/abis/CSAccounting.json,sha256=-eBMqw3XqgMDzlVrG8mOrd7IYLf8nfsBIpjYqaKPYno,1281
 src/abis/CSFeeDistributor.json,sha256=unLBacJcCHq4xsmB4xOPlVXcOrxGWNf6KDmC3Ld5u-c,1517
 src/abis/CSModule.json,sha256=T6D6aInBoqVH3ZD6U6p3lrPa3t_ucA9V83IwE80kOuU,1687
+src/abis/WithdrawalQueueERC721.json,sha256=b25a5RQW5HGPH_KQcolecVToHTgYwqeikz0ZEZ9MGxU,1424
 src/abis/__init__.py,sha256=9HV2hKMGSoNAi8evsjzymTr4V4kowITNsX1-LPu6l98,20
 src/abis/stETH.json,sha256=ldxbIRrtt8ePVFewJ9Tnz4qUGFmuOXa41GN1t3tnWEg,1106
 src/cli/__init__.py,sha256=mgHAwomqzAhOHJnlWrWtCguhGzhDWlkCvkzKsfoFsds,35
-src/cli/commands.py,sha256=B8-TUAPyQPanTGMd_nom6eo-PhnshrEiJD0NwLkdsbw,34954
+src/cli/commands.py,sha256=JNbn74H3nbwk5IT515OB4Muw-edCG9m7imub16geEyA,37506
 src/core/__init__.py,sha256=ZDHZojANK1ZFpn5lQROERTo97MYQFAxqA9APvs7ruEQ,57
-src/core/config.py,sha256=NqkS2zsWyDMDz-q0eE9akHmTE9kZ-snGdTxLn-Dks4E,1532
-src/core/contracts.py,sha256=8Y72h5uUTaIMLWYdtu5O2Bjw1hTyIHOegaDs0W8r74g,525
-src/core/types.py,sha256=ymHofuF5kkZDQpi-RyO4ZRHGJqz-_fw21lNRY-bnefA,7311
+src/core/config.py,sha256=KYYlJv383RtHo_CpaCt2DM7yaTr3C267cY4T8_ZRiEc,1613
+src/core/contracts.py,sha256=u1KW0z-9V21Zpf7qxGBvRy2Ffdo4YfGusUdT4K_ggP4,582
+src/core/types.py,sha256=pirEDIR6csbGWWUH2s3RDCG2ce-oqgEvdsamAI-rurM,7807
 src/data/__init__.py,sha256=DItA8aEp8Lbr0uFlJVppMaTtVEEznoA1hkRpH-vfHhk,57
-src/data/beacon.py,sha256=9oaR7TO2WcP_D3jVTzcd9WE6NbF2WnqQDW_y5M8GsZ0,13511
+src/data/beacon.py,sha256=jICauXdee4efYj8mj1GIoGsY5_uWmgHB57XhqkXvwS4,15439
 src/data/cache.py,sha256=w1iv4rM-FVgFlaSNYdQA3CfqyhZo9-gqbZwKmzKY0Ps,2134
-src/data/etherscan.py,sha256=UeCucGPd4m39yl13uogY7hCBm46Ge7nZQ96V3eoOmu4,5064
+src/data/etherscan.py,sha256=JcO6H2dFFZFOV-qCaNhoJvyza2ymd2GhgmJo7vxvTPM,10938
 src/data/ipfs_logs.py,sha256=gXUTP9dmZ_e7gW6ouotJ1r_72ixq2q_32y2evYQf0DM,10709
 src/data/known_cids.py,sha256=onwTTNvAv4h0-3LZgLhqMlKzuNH2VhBqQGZ9fm8GyoE,1705
 src/data/lido_api.py,sha256=477-1vqlMAwLaisaa61T9AxJuSUV6W7NLg1cxvdmheY,4884
-src/data/onchain.py,sha256=3B2dL8PHQL2BkSySUYOq1jwPI3WkUTOFPbiVkECiiMU,16716
+src/data/onchain.py,sha256=2eLGAI0URz1JuNZi2JmLWN-h_UDfkDlbT30rXpoqbts,25252
 src/data/rewards_tree.py,sha256=a-MO14b4COjOvy59FPd0jaf1dkgidlqCQKAFDinwRJU,1894
 src/data/strikes.py,sha256=b68exKntZpzjiEBftiI3AcvEclHp7vg5lsOiG2a7Kzo,9046
 src/services/__init__.py,sha256=MC7blFLAMazErCWuyYXvS6sO3uZm1z_RUOtnlIK0kSo,38
-src/services/operator_service.py,sha256=Q_Sc65T06IMHUAP_zgROGkZSbEyFPSL4B4ssVsFEUSg,29562
+src/services/operator_service.py,sha256=xncq7Z3DDUcr8cohcehvL9nqaONRUPRuvjBliEGYNd8,29985
 src/web/__init__.py,sha256=iI2c5xxXmzsNxIetm0P2qE3uVsT-ClsMfzn620r5YTU,40
-src/web/app.py,sha256=iLnkIi8GF5ybWwIQAmpNMxMoBaA0ob1xmfQaJrnpZ4E,32604
-src/web/routes.py,sha256=cswOYAsw9x4tEmGaHBDbkwUvML80M1onmDfRlhtQkGo,9895
-csm_dashboard-0.3.2.dist-info/METADATA,sha256=S7WVOP9xDCfAx32g1My2AuSAi-uUsaFm910gDk5lR7I,12552
-csm_dashboard-0.3.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-csm_dashboard-0.3.2.dist-info/entry_points.txt,sha256=P1Ul8ALIPBwDlVlXqTPuzJ64xxRpIJsYW8U73Tyjgtg,37
-csm_dashboard-0.3.2.dist-info/RECORD,,
+src/web/app.py,sha256=AvNKmY6mNRDQaHQLDaLmf9LJxtcB0Mc-YG83XyJ7K9g,47944
+src/web/routes.py,sha256=UydCD7DMWBYv_lbQQjeHI82l8gLZkZ2lEy4OayPxNiU,10716
+csm_dashboard-0.3.6.dist-info/METADATA,sha256=7rgyMM56MfOPeTBY4M8TitFJOPMT70SuxqHMQhxGIwA,12552
+csm_dashboard-0.3.6.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+csm_dashboard-0.3.6.dist-info/entry_points.txt,sha256=P1Ul8ALIPBwDlVlXqTPuzJ64xxRpIJsYW8U73Tyjgtg,37
+csm_dashboard-0.3.6.dist-info/RECORD,,

src/abis/WithdrawalQueueERC721.json

@@ -0,0 +1,47 @@
+[
+  {
+    "name": "WithdrawalRequested",
+    "type": "event",
+    "anonymous": false,
+    "inputs": [
+      {"indexed": true, "name": "requestId", "type": "uint256"},
+      {"indexed": true, "name": "requestor", "type": "address"},
+      {"indexed": true, "name": "owner", "type": "address"},
+      {"indexed": false, "name": "amountOfStETH", "type": "uint256"},
+      {"indexed": false, "name": "amountOfShares", "type": "uint256"}
+    ]
+  },
+  {
+    "name": "WithdrawalClaimed",
+    "type": "event",
+    "anonymous": false,
+    "inputs": [
+      {"indexed": true, "name": "requestId", "type": "uint256"},
+      {"indexed": true, "name": "owner", "type": "address"},
+      {"indexed": true, "name": "receiver", "type": "address"},
+      {"indexed": false, "name": "amountOfETH", "type": "uint256"}
+    ]
+  },
+  {
+    "name": "getWithdrawalStatus",
+    "type": "function",
+    "stateMutability": "view",
+    "inputs": [
+      {"name": "_requestIds", "type": "uint256[]"}
+    ],
+    "outputs": [
+      {
+        "name": "statuses",
+        "type": "tuple[]",
+        "components": [
+          {"name": "amountOfStETH", "type": "uint256"},
+          {"name": "amountOfShares", "type": "uint256"},
+          {"name": "owner", "type": "address"},
+          {"name": "timestamp", "type": "uint256"},
+          {"name": "isFinalized", "type": "bool"},
+          {"name": "isClaimed", "type": "bool"}
+        ]
+      }
+    ]
+  }
+]

src/cli/commands.py

@@ -582,7 +582,9 @@ def rewards(
         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("Type", style="magenta")
+        withdrawal_table.add_column("Amount", style="green", justify="right")
+        withdrawal_table.add_column("Status", style="yellow")
         withdrawal_table.add_column("Tx Hash", style="dim")
 
         for i, w in enumerate(rewards.withdrawals, 1):
@@ -592,16 +594,73 @@ def rewards(
             except (ValueError, TypeError):
                 w_date = w.timestamp[:10] if w.timestamp else "--"
 
+            # Determine display values based on type
+            withdrawal_type = w.withdrawal_type if w.withdrawal_type else "stETH"
+
+            # For unstETH, show claimed ETH if available, otherwise requested stETH
+            if withdrawal_type == "unstETH" and w.claimed_eth is not None:
+                amount_str = f"{w.claimed_eth:.4f} ETH"
+            else:
+                amount_str = f"{w.eth_value:.4f} stETH"
+
+            # Status column for unstETH
+            if withdrawal_type == "unstETH" and w.status:
+                status_colors = {
+                    "pending": "[yellow]Pending[/yellow]",
+                    "finalized": "[blue]Ready[/blue]",
+                    "claimed": "[green]Claimed[/green]",
+                    "unknown": "[dim]Unknown[/dim]",
+                }
+                status_str = status_colors.get(w.status, w.status)
+            elif withdrawal_type != "unstETH":
+                status_str = "[green]Claimed[/green]"
+            else:
+                status_str = "--"
+
             withdrawal_table.add_row(
                 str(i),
                 w_date,
-                f"{w.eth_value:.4f}",
+                withdrawal_type,
+                amount_str,
+                status_str,
                 f"{w.tx_hash[:10]}..." if w.tx_hash else "--",
             )
 
         console.print(withdrawal_table)
+
+        # Show totals
+        steth_total = sum(
+            w.eth_value for w in rewards.withdrawals
+            if w.withdrawal_type != "unstETH"
+        )
+        unsteth_claimed_total = sum(
+            w.claimed_eth for w in rewards.withdrawals
+            if w.withdrawal_type == "unstETH" and w.claimed_eth is not None
+        )
+        if steth_total > 0 or unsteth_claimed_total > 0:
+            total_parts = []
+            if steth_total > 0:
+                total_parts.append(f"{steth_total:.4f} stETH")
+            if unsteth_claimed_total > 0:
+                total_parts.append(f"{unsteth_claimed_total:.4f} ETH")
+            console.print(f"[bold]Total claimed:[/bold] {' + '.join(total_parts)}")
         console.print()
 
+        # Show pending unstETH summary if any
+        pending_unsteth = [
+            w for w in rewards.withdrawals
+            if w.withdrawal_type == "unstETH"
+            and w.status in ("pending", "finalized")
+        ]
+        if pending_unsteth:
+            pending_total = sum(w.eth_value for w in pending_unsteth)
+            ready_count = sum(1 for w in pending_unsteth if w.status == "finalized")
+            console.print(
+                f"[yellow]Note: {len(pending_unsteth)} unstETH request(s) "
+                f"({ready_count} ready to claim) totaling ~{pending_total:.4f} stETH[/yellow]"
+            )
+            console.print()
+
 
 @app.command()
 def health(

src/core/config.py

@@ -37,6 +37,7 @@ class Settings(BaseSettings):
     csfeedistributor_address: str = "0xD99CC66fEC647E68294C6477B40fC7E0F6F618D0"
     csstrikes_address: str = "0xaa328816027F2D32B9F56d190BC9Fa4A5C07637f"
     steth_address: str = "0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84"
+    withdrawal_queue_address: str = "0x889edC2eDab5f40e902b864aD4d7AdE8E412F9B1"
 
 
 @lru_cache

src/core/contracts.py

@@ -16,3 +16,4 @@ CSMODULE_ABI = load_abi("CSModule")
 CSACCOUNTING_ABI = load_abi("CSAccounting")
 CSFEEDISTRIBUTOR_ABI = load_abi("CSFeeDistributor")
 STETH_ABI = load_abi("stETH")
+WITHDRAWAL_QUEUE_ABI = load_abi("WithdrawalQueueERC721")

src/core/types.py

@@ -70,6 +70,16 @@ class WithdrawalEvent(BaseModel):
     eth_value: float
     tx_hash: str
 
+    # Withdrawal type: "stETH" (direct transfer) or "unstETH" (withdrawal NFT)
+    withdrawal_type: str = "stETH"
+
+    # unstETH-specific fields (only populated for unstETH type)
+    request_id: int | None = None
+    status: str | None = None  # "pending", "finalized", or "claimed"
+    claimed_eth: float | None = None  # Actual ETH received when claimed
+    claim_tx_hash: str | None = None  # Transaction where claim occurred
+    claim_timestamp: str | None = None  # When the claim happened
+
 
 class APYMetrics(BaseModel):
     """APY calculations for an operator.

src/data/beacon.py

@@ -1,5 +1,6 @@
 """Beacon chain data fetching via beaconcha.in API."""
 
+import asyncio
 from datetime import datetime, timedelta, timezone
 from decimal import Decimal
 from enum import Enum
@@ -172,47 +173,84 @@ class BeaconDataProvider:
         Fetch validator info for multiple pubkeys.
 
         beaconcha.in supports comma-separated pubkeys (up to 100).
+        Includes retry logic for rate limiting and proper error handling.
         """
         if not pubkeys:
             return []
 
         validators = []
         batch_size = 100  # beaconcha.in limit
+        max_retries = 3
 
         async with httpx.AsyncClient(timeout=30.0) as client:
             for i in range(0, len(pubkeys), batch_size):
                 batch = pubkeys[i : i + batch_size]
                 pubkeys_param = ",".join(batch)
 
-                try:
-                    response = await client.get(
-                        f"{self.base_url}/validator/{pubkeys_param}",
-                        headers=self._get_headers(),
-                    )
+                # Add delay between batches to avoid rate limiting
+                if i > 0:
+                    await asyncio.sleep(0.5)
 
-                    if response.status_code == 200:
-                        data = response.json().get("data", [])
-                        # API returns single object if only one validator
-                        if isinstance(data, dict):
-                            data = [data]
+                for attempt in range(max_retries):
+                    try:
+                        response = await client.get(
+                            f"{self.base_url}/validator/{pubkeys_param}",
+                            headers=self._get_headers(),
+                        )
 
-                        for v in data:
-                            validators.append(self._parse_validator(v))
-                    elif response.status_code == 404:
-                        # Validators not found - create placeholder entries
+                        if response.status_code == 200:
+                            data = response.json().get("data", [])
+                            # API returns single object if only one validator
+                            if isinstance(data, dict):
+                                data = [data]
+
+                            for v in data:
+                                validators.append(self._parse_validator(v))
+                            break  # Success, exit retry loop
+                        elif response.status_code == 404:
+                            # Validators not found - create placeholder entries
+                            for pubkey in batch:
+                                validators.append(
+                                    ValidatorInfo(
+                                        pubkey=pubkey,
+                                        status=ValidatorStatus.PENDING_INITIALIZED,
+                                    )
+                                )
+                            break  # Success, exit retry loop
+                        elif response.status_code == 429:
+                            # Rate limited - wait and retry
+                            if attempt < max_retries - 1:
+                                await asyncio.sleep(2**attempt)  # 1s, 2s, 4s
+                                continue
+                            # Max retries reached, add as unknown
+                            for pubkey in batch:
+                                validators.append(
+                                    ValidatorInfo(
+                                        pubkey=pubkey, status=ValidatorStatus.UNKNOWN
+                                    )
+                                )
+                            break
+                        else:
+                            # Other error status - add as unknown
+                            for pubkey in batch:
+                                validators.append(
+                                    ValidatorInfo(
+                                        pubkey=pubkey, status=ValidatorStatus.UNKNOWN
+                                    )
+                                )
+                            break
+                    except Exception:
+                        if attempt < max_retries - 1:
+                            await asyncio.sleep(1)
+                            continue
+                        # On final failure, add unknown status for this batch
                         for pubkey in batch:
                             validators.append(
                                 ValidatorInfo(
-                                    pubkey=pubkey,
-                                    status=ValidatorStatus.PENDING_INITIALIZED,
+                                    pubkey=pubkey, status=ValidatorStatus.UNKNOWN
                                 )
                             )
-                except Exception:
-                    # On error, add unknown status for this batch
-                    for pubkey in batch:
-                        validators.append(
-                            ValidatorInfo(pubkey=pubkey, status=ValidatorStatus.UNKNOWN)
-                        )
+                        break
 
         return validators
 

src/data/etherscan.py

@@ -136,3 +136,162 @@ class EtherscanProvider:
                     continue
 
             return sorted(results, key=lambda x: x["block"])
+
+    async def get_withdrawal_requested_events(
+        self,
+        contract_address: str,
+        requestor: str,
+        owner: str,
+        from_block: int,
+        to_block: str | int = "latest",
+    ) -> list[dict]:
+        """Query WithdrawalRequested events from Etherscan.
+
+        Args:
+            contract_address: WithdrawalQueue contract address
+            requestor: Address that requested the withdrawal (CSAccounting)
+            owner: Address that owns the unstETH NFT (reward_address)
+            from_block: Starting block
+            to_block: Ending block
+
+        Returns:
+            List of withdrawal request events
+        """
+        if not self.api_key:
+            return []
+
+        # Event: WithdrawalRequested(uint256 indexed requestId, address indexed requestor,
+        #                            address indexed owner, uint256 amountOfStETH, uint256 amountOfShares)
+        topic0 = (
+            "0x"
+            + Web3.keccak(
+                text="WithdrawalRequested(uint256,address,address,uint256,uint256)"
+            ).hex()
+        )
+        # topic1 is indexed requestId - not filtering on this
+        # topic2 is indexed 'requestor' address (padded to 32 bytes)
+        topic2 = "0x" + requestor.lower().replace("0x", "").zfill(64)
+        # topic3 is indexed 'owner' address (padded to 32 bytes)
+        topic3 = "0x" + owner.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": contract_address,
+                    "topic0": topic0,
+                    "topic2": topic2,
+                    "topic3": topic3,
+                    "topic0_2_opr": "and",
+                    "topic2_3_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", []):
+                try:
+                    # requestId is topic1 (indexed)
+                    request_id = int(log["topics"][1], 16)
+                    # amountOfStETH and amountOfShares are in data field
+                    raw_data = log["data"]
+                    # Each uint256 is 64 hex chars (32 bytes)
+                    amount_steth = int(raw_data[2:66], 16)
+                    amount_shares = int(raw_data[66:130], 16)
+
+                    results.append(
+                        {
+                            "request_id": request_id,
+                            "block": int(log["blockNumber"], 16),
+                            "tx_hash": log["transactionHash"],
+                            "amount_steth": amount_steth,
+                            "amount_shares": amount_shares,
+                        }
+                    )
+                except (ValueError, TypeError, IndexError):
+                    continue
+
+            return sorted(results, key=lambda x: x["block"])
+
+    async def get_withdrawal_claimed_events(
+        self,
+        contract_address: str,
+        receiver: str,
+        from_block: int,
+        to_block: str | int = "latest",
+    ) -> list[dict]:
+        """Query WithdrawalClaimed events from Etherscan.
+
+        Args:
+            contract_address: WithdrawalQueue contract address
+            receiver: Address that received the ETH (reward_address)
+            from_block: Starting block
+            to_block: Ending block
+
+        Returns:
+            List of withdrawal claim events
+        """
+        if not self.api_key:
+            return []
+
+        # Event: WithdrawalClaimed(uint256 indexed requestId, address indexed owner,
+        #                          address indexed receiver, uint256 amountOfETH)
+        topic0 = (
+            "0x"
+            + Web3.keccak(
+                text="WithdrawalClaimed(uint256,address,address,uint256)"
+            ).hex()
+        )
+        # topic3 is indexed 'receiver' address (padded to 32 bytes)
+        topic3 = "0x" + receiver.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": contract_address,
+                    "topic0": topic0,
+                    "topic3": topic3,
+                    "topic0_3_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", []):
+                try:
+                    # requestId is topic1 (indexed)
+                    request_id = int(log["topics"][1], 16)
+                    # amountOfETH is in data field
+                    amount_eth = int(log["data"], 16) / 10**18
+
+                    results.append(
+                        {
+                            "request_id": request_id,
+                            "tx_hash": log["transactionHash"],
+                            "amount_eth": amount_eth,
+                            "block": int(log["blockNumber"], 16),
+                        }
+                    )
+                except (ValueError, TypeError, IndexError):
+                    continue
+
+            return sorted(results, key=lambda x: x["block"])

src/data/onchain.py

@@ -11,6 +11,7 @@ from ..core.contracts import (
     CSFEEDISTRIBUTOR_ABI,
     CSMODULE_ABI,
     STETH_ABI,
+    WITHDRAWAL_QUEUE_ABI,
 )
 from ..core.types import BondSummary, NodeOperator
 from .cache import cached
@@ -42,6 +43,10 @@ class OnChainDataProvider:
             address=Web3.to_checksum_address(self.settings.steth_address),
             abi=STETH_ABI,
         )
+        self.withdrawal_queue = self.w3.eth.contract(
+            address=Web3.to_checksum_address(self.settings.withdrawal_queue_address),
+            abi=WITHDRAWAL_QUEUE_ABI,
+        )
 
     @cached(ttl=60)
     async def get_node_operators_count(self) -> int:
@@ -337,23 +342,38 @@ class OnChainDataProvider:
         self, reward_address: str, start_block: int | None = None
     ) -> list[dict]:
         """
-        Get withdrawal history for an operator's reward address.
+        Get complete withdrawal history for an operator's 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)
+        Combines multiple withdrawal types:
+        1. stETH Transfer events from CSAccounting (claimRewardsStETH)
+        2. unstETH withdrawal requests/claims (claimRewardsUnstETH)
 
         Args:
             reward_address: The operator's reward address
             start_block: Starting block number (default: CSM deployment ~20873000)
 
         Returns:
-            List of withdrawal events with block, tx_hash, shares, and timestamp
+            List of withdrawal events with block, tx_hash, shares, timestamp, and type
         """
         if start_block is None:
             start_block = 20873000  # CSM deployment block
 
         reward_address = Web3.to_checksum_address(reward_address)
+
+        # Fetch both stETH and unstETH withdrawals
+        steth_events = await self._get_steth_withdrawals(reward_address, start_block)
+        unsteth_events = await self._get_unsteth_withdrawals(reward_address, start_block)
+
+        # Combine and sort by block number
+        all_events = steth_events + unsteth_events
+        all_events.sort(key=lambda x: x["block_number"])
+
+        return all_events
+
+    async def _get_steth_withdrawals(
+        self, reward_address: str, start_block: int
+    ) -> list[dict]:
+        """Get stETH direct transfer withdrawals (claimRewardsStETH)."""
         csaccounting_address = self.settings.csaccounting_address
 
         # 1. Try Etherscan API first (most reliable)
@@ -366,18 +386,218 @@ class OnChainDataProvider:
                 from_block=start_block,
             )
             if events:
-                # Enrich with block timestamps
-                return await self._enrich_withdrawal_events(events)
+                enriched = await self._enrich_withdrawal_events(events)
+                # Mark as stETH type
+                for e in enriched:
+                    e["withdrawal_type"] = "stETH"
+                return enriched
 
         # 2. Try chunked RPC queries
         events = await self._query_transfer_events_chunked(
             csaccounting_address, reward_address, start_block
         )
         if events:
-            return await self._enrich_withdrawal_events(events)
+            enriched = await self._enrich_withdrawal_events(events)
+            for e in enriched:
+                e["withdrawal_type"] = "stETH"
+            return enriched
 
         return []
 
+    async def _get_unsteth_withdrawals(
+        self, reward_address: str, start_block: int
+    ) -> list[dict]:
+        """Get unstETH withdrawal requests (claimRewardsUnstETH).
+
+        Queries WithdrawalRequested events where CSAccounting is the requestor
+        and the reward_address is the owner of the withdrawal NFT.
+        """
+        csaccounting_address = self.settings.csaccounting_address
+
+        # Try Etherscan API first
+        etherscan = EtherscanProvider()
+        if etherscan.is_available():
+            events = await etherscan.get_withdrawal_requested_events(
+                contract_address=self.settings.withdrawal_queue_address,
+                requestor=csaccounting_address,
+                owner=reward_address,
+                from_block=start_block,
+            )
+            if events:
+                return await self._enrich_unsteth_events(events, reward_address)
+
+        # Fallback to chunked RPC queries
+        events = await self._query_withdrawal_requested_chunked(
+            csaccounting_address, reward_address, start_block
+        )
+        if events:
+            return await self._enrich_unsteth_events(events, reward_address)
+
+        return []
+
+    async def _query_withdrawal_requested_chunked(
+        self,
+        requestor: str,
+        owner: str,
+        start_block: int,
+        chunk_size: int = 10000,
+    ) -> list[dict]:
+        """Query WithdrawalRequested events in chunks via RPC."""
+        current_block = self.w3.eth.block_number
+        all_events = []
+
+        requestor = Web3.to_checksum_address(requestor)
+        owner = Web3.to_checksum_address(owner)
+
+        for from_blk in range(start_block, current_block, chunk_size):
+            to_blk = min(from_blk + chunk_size - 1, current_block)
+            try:
+                events = self.withdrawal_queue.events.WithdrawalRequested.get_logs(
+                    from_block=from_blk,
+                    to_block=to_blk,
+                    argument_filters={
+                        "requestor": requestor,
+                        "owner": owner,
+                    },
+                )
+                for e in events:
+                    all_events.append(
+                        {
+                            "request_id": e["args"]["requestId"],
+                            "block": e["blockNumber"],
+                            "tx_hash": e["transactionHash"].hex(),
+                            "amount_steth": e["args"]["amountOfStETH"],
+                            "amount_shares": e["args"]["amountOfShares"],
+                        }
+                    )
+            except Exception:
+                # If chunked queries fail, give up on this method
+                return []
+
+        return sorted(all_events, key=lambda x: x["block"])
+
+    async def _enrich_unsteth_events(
+        self, events: list[dict], reward_address: str
+    ) -> list[dict]:
+        """Add timestamps, status, and claim info to unstETH events."""
+        from datetime import datetime, timezone
+
+        if not events:
+            return []
+
+        # Get status for all request IDs
+        request_ids = [e["request_id"] for e in events]
+        try:
+            statuses = self.withdrawal_queue.functions.getWithdrawalStatus(
+                request_ids
+            ).call()
+        except Exception:
+            # If status query fails, set all as unknown
+            statuses = [None] * len(events)
+
+        # Get claim events for this address
+        claim_events = await self._get_withdrawal_claimed_events(reward_address)
+        claims_by_request = {c["request_id"]: c for c in claim_events}
+
+        enriched = []
+        for i, event in enumerate(events):
+            try:
+                # Get block timestamp
+                block = self.w3.eth.get_block(event["block"])
+                timestamp = datetime.fromtimestamp(
+                    block["timestamp"], tz=timezone.utc
+                ).isoformat()
+
+                # Determine status from contract query
+                status = statuses[i] if i < len(statuses) and statuses[i] else None
+                if status:
+                    if status[5]:  # isClaimed
+                        withdrawal_status = "claimed"
+                    elif status[4]:  # isFinalized
+                        withdrawal_status = "finalized"
+                    else:
+                        withdrawal_status = "pending"
+                else:
+                    withdrawal_status = "unknown"
+
+                # Convert shares to ETH for display
+                shares = event.get("amount_shares", event.get("value", 0))
+                eth_value = await self.shares_to_eth(shares)
+
+                enriched_event = {
+                    "block_number": event["block"],
+                    "timestamp": timestamp,
+                    "shares": shares,
+                    "eth_value": float(eth_value),
+                    "tx_hash": event["tx_hash"],
+                    "withdrawal_type": "unstETH",
+                    "request_id": event["request_id"],
+                    "status": withdrawal_status,
+                }
+
+                # Add claim info if claimed
+                claim = claims_by_request.get(event["request_id"])
+                if claim:
+                    enriched_event["claimed_eth"] = claim["amount_eth"]
+                    enriched_event["claim_tx_hash"] = claim["tx_hash"]
+                    # Get claim timestamp
+                    try:
+                        claim_block = self.w3.eth.get_block(claim["block"])
+                        enriched_event["claim_timestamp"] = datetime.fromtimestamp(
+                            claim_block["timestamp"], tz=timezone.utc
+                        ).isoformat()
+                    except Exception:
+                        pass
+
+                enriched.append(enriched_event)
+            except Exception:
+                continue
+
+        return enriched
+
+    async def _get_withdrawal_claimed_events(
+        self, receiver: str, start_block: int = 20873000
+    ) -> list[dict]:
+        """Get WithdrawalClaimed events for a receiver address."""
+        receiver = Web3.to_checksum_address(receiver)
+
+        # Try Etherscan first
+        etherscan = EtherscanProvider()
+        if etherscan.is_available():
+            events = await etherscan.get_withdrawal_claimed_events(
+                contract_address=self.settings.withdrawal_queue_address,
+                receiver=receiver,
+                from_block=start_block,
+            )
+            if events:
+                return events
+
+        # RPC fallback - query in chunks
+        current_block = self.w3.eth.block_number
+        all_events = []
+
+        for from_blk in range(start_block, current_block, 10000):
+            to_blk = min(from_blk + 9999, current_block)
+            try:
+                logs = self.withdrawal_queue.events.WithdrawalClaimed.get_logs(
+                    from_block=from_blk,
+                    to_block=to_blk,
+                    argument_filters={"receiver": receiver},
+                )
+                for e in logs:
+                    all_events.append(
+                        {
+                            "request_id": e["args"]["requestId"],
+                            "tx_hash": e["transactionHash"].hex(),
+                            "amount_eth": e["args"]["amountOfETH"] / 10**18,
+                            "block": e["blockNumber"],
+                        }
+                    )
+            except Exception:
+                continue
+
+        return all_events
+
     async def _query_transfer_events_chunked(
         self,
         from_address: str,

src/services/operator_service.py

@@ -620,6 +620,7 @@ class OperatorService:
         """Get withdrawal/claim history for an operator.
 
         Returns list of WithdrawalEvent objects representing when rewards were claimed.
+        Includes both stETH direct transfers and unstETH (withdrawal NFT) claims.
         """
         try:
             operator = await self.onchain.get_node_operator(operator_id)
@@ -631,6 +632,12 @@ class OperatorService:
                     shares=e["shares"],
                     eth_value=e["eth_value"],
                     tx_hash=e["tx_hash"],
+                    withdrawal_type=e.get("withdrawal_type", "stETH"),
+                    request_id=e.get("request_id"),
+                    status=e.get("status"),
+                    claimed_eth=e.get("claimed_eth"),
+                    claim_tx_hash=e.get("claim_tx_hash"),
+                    claim_timestamp=e.get("claim_timestamp"),
                 )
                 for e in events
             ]

src/web/app.py

@@ -1,7 +1,10 @@
 """FastAPI application factory."""
 
+from pathlib import Path
+
 from fastapi import FastAPI
 from fastapi.responses import HTMLResponse
+from fastapi.staticfiles import StaticFiles
 
 from .routes import router
 
@@ -11,11 +14,16 @@ def create_app() -> FastAPI:
     app = FastAPI(
         title="CSM Operator Dashboard",
         description="Track your Lido CSM validator earnings",
-        version="0.1.0",
+        version="0.3.6",
     )
 
     app.include_router(router, prefix="/api")
 
+    # Mount static files for favicon and images
+    img_dir = Path(__file__).parent.parent.parent / "img"
+    if img_dir.exists():
+        app.mount("/img", StaticFiles(directory=str(img_dir)), name="img")
+
     @app.get("/", response_class=HTMLResponse)
     async def index():
         return """
@@ -23,6 +31,7 @@ def create_app() -> FastAPI:
 <html>
 <head>
     <title>CSM Operator Dashboard</title>
+    <link rel="icon" type="image/x-icon" href="/img/favicon.ico">
     <script src="https://cdn.tailwindcss.com"></script>
 </head>
 <body class="bg-gray-900 text-white min-h-screen p-8">
@@ -247,6 +256,83 @@ def create_app() -> FastAPI:
                     </table>
                 </div>
                 <p class="mt-3 text-xs text-gray-500">*Bond APY uses current stETH rate</p>
+
+                <!-- Next Distribution -->
+                <div id="next-distribution" class="hidden mt-4 pt-4 border-t border-gray-700">
+                    <h4 class="text-md font-semibold mb-2 text-blue-400">Next Distribution</h4>
+                    <div class="flex justify-between text-sm">
+                        <span class="text-gray-400">Estimated Date</span>
+                        <span id="next-dist-date">--</span>
+                    </div>
+                    <div class="flex justify-between text-sm mt-1">
+                        <span class="text-gray-400">Est. Rewards</span>
+                        <span class="text-green-400">~<span id="next-dist-eth">--</span> stETH</span>
+                    </div>
+                </div>
+            </div>
+
+            <!-- Distribution History Section -->
+            <div id="history-section" class="hidden mt-6 bg-gray-800 rounded-lg p-6">
+                <div class="flex justify-between items-center mb-4">
+                    <h3 class="text-lg font-bold">Distribution History</h3>
+                    <button id="load-history-btn" class="px-4 py-2 bg-blue-600 rounded hover:bg-blue-700 text-sm font-medium">
+                        Load History
+                    </button>
+                </div>
+                <div id="history-loading" class="hidden">
+                    <div class="flex items-center justify-center p-4">
+                        <div class="animate-spin rounded-full h-5 w-5 border-b-2 border-blue-500"></div>
+                        <span class="ml-2 text-gray-400 text-sm">Loading history...</span>
+                    </div>
+                </div>
+                <div id="history-table" class="hidden overflow-x-auto">
+                    <table class="w-full text-sm">
+                        <thead>
+                            <tr class="text-gray-400">
+                                <th class="text-left py-2">#</th>
+                                <th class="text-left py-2">Date Range</th>
+                                <th class="text-right py-2">Rewards</th>
+                                <th class="text-right py-2">Validators</th>
+                                <th class="text-right py-2">Per Val</th>
+                            </tr>
+                        </thead>
+                        <tbody id="history-tbody">
+                            <!-- Populated by JavaScript -->
+                        </tbody>
+                    </table>
+                </div>
+            </div>
+
+            <!-- Withdrawal History Section -->
+            <div id="withdrawal-section" class="hidden mt-6 bg-gray-800 rounded-lg p-6">
+                <div class="flex justify-between items-center mb-4">
+                    <h3 class="text-lg font-bold">Withdrawal History</h3>
+                    <button id="load-withdrawals-btn" class="px-4 py-2 bg-blue-600 rounded hover:bg-blue-700 text-sm font-medium">
+                        Load Withdrawals
+                    </button>
+                </div>
+                <div id="withdrawal-loading" class="hidden">
+                    <div class="flex items-center justify-center p-4">
+                        <div class="animate-spin rounded-full h-5 w-5 border-b-2 border-blue-500"></div>
+                        <span class="ml-2 text-gray-400 text-sm">Loading withdrawals...</span>
+                    </div>
+                </div>
+                <div id="withdrawal-table" class="hidden overflow-x-auto">
+                    <table class="w-full text-sm">
+                        <thead>
+                            <tr class="text-gray-400">
+                                <th class="text-left py-2">#</th>
+                                <th class="text-left py-2">Date</th>
+                                <th class="text-left py-2">Type</th>
+                                <th class="text-right py-2">Amount</th>
+                                <th class="text-left py-2">Status</th>
+                            </tr>
+                        </thead>
+                        <tbody id="withdrawal-tbody">
+                            <!-- Populated by JavaScript -->
+                        </tbody>
+                    </table>
+                </div>
             </div>
         </div>
     </div>
@@ -262,6 +348,17 @@ def create_app() -> FastAPI:
         const validatorStatus = document.getElementById('validator-status');
         const apySection = document.getElementById('apy-section');
         const healthSection = document.getElementById('health-section');
+        const historySection = document.getElementById('history-section');
+        const loadHistoryBtn = document.getElementById('load-history-btn');
+        const historyLoading = document.getElementById('history-loading');
+        const historyTable = document.getElementById('history-table');
+        const historyTbody = document.getElementById('history-tbody');
+        const nextDistribution = document.getElementById('next-distribution');
+        const withdrawalSection = document.getElementById('withdrawal-section');
+        const loadWithdrawalsBtn = document.getElementById('load-withdrawals-btn');
+        const withdrawalLoading = document.getElementById('withdrawal-loading');
+        const withdrawalTable = document.getElementById('withdrawal-table');
+        const withdrawalTbody = document.getElementById('withdrawal-tbody');
 
         function formatApy(val) {
             return val !== null && val !== undefined ? val.toFixed(2) + '%' : '--%';
@@ -280,6 +377,17 @@ def create_app() -> FastAPI:
             validatorStatus.classList.add('hidden');
             apySection.classList.add('hidden');
             healthSection.classList.add('hidden');
+            historySection.classList.add('hidden');
+            nextDistribution.classList.add('hidden');
+            historyTable.classList.add('hidden');
+            historyTbody.innerHTML = '';
+            historyLoaded = false;
+            loadHistoryBtn.textContent = 'Load History';
+            withdrawalSection.classList.add('hidden');
+            withdrawalTable.classList.add('hidden');
+            withdrawalTbody.innerHTML = '';
+            withdrawalsLoaded = false;
+            loadWithdrawalsBtn.textContent = 'Load Withdrawals';
             document.getElementById('active-since-row').classList.add('hidden');
             loadDetailsBtn.classList.remove('hidden');
             loadDetailsBtn.disabled = false;
@@ -394,7 +502,23 @@ def create_app() -> FastAPI:
                     document.getElementById('net-apy-28d').textContent = formatApy(data.apy.net_apy_28d);
                     document.getElementById('net-apy-ltd').textContent = formatApy(data.apy.net_apy_ltd);
 
+                    // Show next distribution info if available
+                    if (data.apy.next_distribution_date || data.apy.next_distribution_est_eth) {
+                        if (data.apy.next_distribution_date) {
+                            const nextDate = new Date(data.apy.next_distribution_date);
+                            const options = { year: 'numeric', month: 'short', day: 'numeric' };
+                            document.getElementById('next-dist-date').textContent = nextDate.toLocaleDateString('en-US', options);
+                        }
+                        if (data.apy.next_distribution_est_eth) {
+                            document.getElementById('next-dist-eth').textContent = data.apy.next_distribution_est_eth.toFixed(4);
+                        }
+                        nextDistribution.classList.remove('hidden');
+                    }
+
                     apySection.classList.remove('hidden');
+                    // Show history and withdrawal sections with toggles
+                    historySection.classList.remove('hidden');
+                    withdrawalSection.classList.remove('hidden');
                 }
 
                 // Display Active Since date if available
@@ -571,6 +695,163 @@ def create_app() -> FastAPI:
                 isLoadingDetails = false;
             }
         });
+
+        // History button handler
+        let historyLoaded = false;
+        loadHistoryBtn.addEventListener('click', async () => {
+            if (historyLoaded) {
+                // Toggle visibility
+                historyTable.classList.toggle('hidden');
+                loadHistoryBtn.textContent = historyTable.classList.contains('hidden')
+                    ? 'Load History' : 'Hide History';
+                return;
+            }
+
+            const operatorId = document.getElementById('operator-id').textContent;
+            historyLoading.classList.remove('hidden');
+            historyTable.classList.add('hidden');
+
+            try {
+                const response = await fetch(`/api/operator/${operatorId}?detailed=true&history=true`);
+                const data = await response.json();
+
+                historyLoading.classList.add('hidden');
+
+                if (!response.ok || !data.apy || !data.apy.frames) {
+                    historyTbody.innerHTML = '<tr><td colspan="5" class="py-4 text-center text-gray-400">No history available</td></tr>';
+                    historyTable.classList.remove('hidden');
+                    return;
+                }
+
+                // Populate history table
+                historyTbody.innerHTML = data.apy.frames.map(frame => {
+                    const startDate = new Date(frame.start_date).toLocaleDateString('en-US', { month: 'short', day: 'numeric' });
+                    const endDate = new Date(frame.end_date).toLocaleDateString('en-US', { month: 'short', day: 'numeric', year: 'numeric' });
+                    const perVal = frame.validator_count > 0 ? (frame.rewards_eth / frame.validator_count).toFixed(6) : '--';
+                    return `<tr class="border-t border-gray-700">
+                        <td class="py-2">${frame.frame_number}</td>
+                        <td class="py-2">${startDate} - ${endDate}</td>
+                        <td class="py-2 text-right text-green-400">${frame.rewards_eth.toFixed(4)}</td>
+                        <td class="py-2 text-right">${frame.validator_count}</td>
+                        <td class="py-2 text-right text-gray-400">${perVal}</td>
+                    </tr>`;
+                }).join('');
+
+                // Add total row
+                const totalEth = data.apy.frames.reduce((sum, f) => sum + f.rewards_eth, 0);
+                historyTbody.innerHTML += `<tr class="border-t-2 border-gray-600 font-bold">
+                    <td class="py-2" colspan="2">Total</td>
+                    <td class="py-2 text-right text-yellow-400">${totalEth.toFixed(4)}</td>
+                    <td class="py-2 text-right">--</td>
+                    <td class="py-2 text-right">--</td>
+                </tr>`;
+
+                historyTable.classList.remove('hidden');
+                historyLoaded = true;
+                loadHistoryBtn.textContent = 'Hide History';
+            } catch (err) {
+                historyLoading.classList.add('hidden');
+                historyTbody.innerHTML = '<tr><td colspan="5" class="py-4 text-center text-red-400">Failed to load history</td></tr>';
+                historyTable.classList.remove('hidden');
+            }
+        });
+
+        // Withdrawal button handler
+        let withdrawalsLoaded = false;
+        loadWithdrawalsBtn.addEventListener('click', async () => {
+            if (withdrawalsLoaded) {
+                // Toggle visibility
+                withdrawalTable.classList.toggle('hidden');
+                loadWithdrawalsBtn.textContent = withdrawalTable.classList.contains('hidden')
+                    ? 'Load Withdrawals' : 'Hide Withdrawals';
+                return;
+            }
+
+            const operatorId = document.getElementById('operator-id').textContent;
+            withdrawalLoading.classList.remove('hidden');
+            withdrawalTable.classList.add('hidden');
+
+            try {
+                const response = await fetch(`/api/operator/${operatorId}?withdrawals=true`);
+                const data = await response.json();
+
+                withdrawalLoading.classList.add('hidden');
+
+                if (!response.ok || !data.withdrawals || data.withdrawals.length === 0) {
+                    withdrawalTbody.innerHTML = '<tr><td colspan="5" class="py-4 text-center text-gray-400">No withdrawals found</td></tr>';
+                    withdrawalTable.classList.remove('hidden');
+                    withdrawalsLoaded = true;
+                    loadWithdrawalsBtn.textContent = 'Hide Withdrawals';
+                    return;
+                }
+
+                // Populate withdrawal table
+                withdrawalTbody.innerHTML = data.withdrawals.map((w, i) => {
+                    const date = new Date(w.timestamp).toLocaleDateString('en-US', { month: 'short', day: 'numeric', year: 'numeric' });
+                    const wType = w.withdrawal_type || 'stETH';
+                    // For unstETH, show claimed ETH if available, otherwise show stETH value
+                    let amount, amountClass;
+                    if (wType === 'unstETH' && w.claimed_eth !== null) {
+                        amount = w.claimed_eth.toFixed(4) + ' ETH';
+                        amountClass = 'text-green-400';
+                    } else {
+                        amount = w.eth_value.toFixed(4) + ' stETH';
+                        amountClass = 'text-green-400';
+                    }
+                    // Status for unstETH
+                    let status;
+                    if (wType === 'unstETH' && w.status) {
+                        const statusColors = {
+                            'pending': 'text-yellow-400',
+                            'finalized': 'text-blue-400',
+                            'claimed': 'text-green-400',
+                        };
+                        const statusLabels = {
+                            'pending': 'Pending',
+                            'finalized': 'Ready',
+                            'claimed': 'Claimed',
+                        };
+                        status = `<span class="${statusColors[w.status] || 'text-gray-400'}">${statusLabels[w.status] || w.status}</span>`;
+                    } else if (wType !== 'unstETH') {
+                        status = '<span class="text-green-400">Claimed</span>';
+                    } else {
+                        status = '--';
+                    }
+                    return `<tr class="border-t border-gray-700">
+                        <td class="py-2">${i + 1}</td>
+                        <td class="py-2">${date}</td>
+                        <td class="py-2"><span class="${wType === 'unstETH' ? 'text-purple-400' : 'text-blue-400'}">${wType}</span></td>
+                        <td class="py-2 text-right ${amountClass}">${amount}</td>
+                        <td class="py-2">${status}</td>
+                    </tr>`;
+                }).join('');
+
+                // Add total row
+                const stethTotal = data.withdrawals
+                    .filter(w => w.withdrawal_type !== 'unstETH')
+                    .reduce((sum, w) => sum + w.eth_value, 0);
+                const ethTotal = data.withdrawals
+                    .filter(w => w.withdrawal_type === 'unstETH' && w.claimed_eth !== null)
+                    .reduce((sum, w) => sum + w.claimed_eth, 0);
+                let totalStr = '';
+                if (stethTotal > 0) totalStr += stethTotal.toFixed(4) + ' stETH';
+                if (ethTotal > 0) totalStr += (totalStr ? ' + ' : '') + ethTotal.toFixed(4) + ' ETH';
+                if (!totalStr) totalStr = '0';
+
+                withdrawalTbody.innerHTML += `<tr class="border-t-2 border-gray-600 font-bold">
+                    <td class="py-2" colspan="3">Total Claimed</td>
+                    <td class="py-2 text-right text-yellow-400" colspan="2">${totalStr}</td>
+                </tr>`;
+
+                withdrawalTable.classList.remove('hidden');
+                withdrawalsLoaded = true;
+                loadWithdrawalsBtn.textContent = 'Hide Withdrawals';
+            } catch (err) {
+                withdrawalLoading.classList.add('hidden');
+                withdrawalTbody.innerHTML = '<tr><td colspan="5" class="py-4 text-center text-red-400">Failed to load withdrawals</td></tr>';
+                withdrawalTable.classList.remove('hidden');
+            }
+        });
     </script>
 </body>
 </html>

src/web/routes.py

@@ -141,10 +141,29 @@ async def get_operator(
                 "shares": w.shares,
                 "eth_value": w.eth_value,
                 "tx_hash": w.tx_hash,
+                "withdrawal_type": w.withdrawal_type,
+                "request_id": w.request_id,
+                "status": w.status,
+                "claimed_eth": w.claimed_eth,
+                "claim_tx_hash": w.claim_tx_hash,
+                "claim_timestamp": w.claim_timestamp,
             }
             for w in rewards.withdrawals
         ]
 
+        # Add summary for pending unstETH requests
+        pending_unsteth = [
+            w for w in rewards.withdrawals
+            if w.withdrawal_type == "unstETH"
+            and w.status in ("pending", "finalized")
+        ]
+        if pending_unsteth:
+            result["pending_unsteth"] = {
+                "count": len(pending_unsteth),
+                "ready_to_claim": sum(1 for w in pending_unsteth if w.status == "finalized"),
+                "total_steth_value": sum(w.eth_value for w in pending_unsteth),
+            }
+
     # Add active_since if available
     if rewards.active_since:
         result["active_since"] = rewards.active_since.isoformat()