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

src/data/lido_api.py

@@ -2,9 +2,11 @@
 
 import httpx
 
+from ..core.config import get_settings
 from .cache import cached
 
 LIDO_API_BASE = "https://eth-api.lido.fi/v1"
+LIDO_SUBGRAPH_ID = "Sxx812XgeKyzQPaBpR5YZWmGV5fZuBaPdh7DFhzSwiQ"
 
 
 class LidoAPIProvider:
@@ -33,3 +35,106 @@ class LidoAPIProvider:
                 pass
 
         return {"apr": None, "timestamp": None}
+
+    @cached(ttl=3600)  # Cache for 1 hour
+    async def get_historical_apr_data(self) -> list[dict]:
+        """Fetch historical APR data from Lido subgraph.
+
+        Returns list of {block, apr, blockTime} sorted by block ascending.
+        Returns empty list if API key not configured or query fails.
+        """
+        settings = get_settings()
+        if not settings.thegraph_api_key:
+            return []
+
+        # Query in descending order to get most recent 1000 entries
+        # (CSM frames are at blocks 21M+, we need recent data)
+        query = """
+        {
+          totalRewards(first: 1000, orderBy: block, orderDirection: desc) {
+            apr
+            block
+            blockTime
+          }
+        }
+        """
+
+        endpoint = f"https://gateway-arbitrum.network.thegraph.com/api/{settings.thegraph_api_key}/subgraphs/id/{LIDO_SUBGRAPH_ID}"
+
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            try:
+                response = await client.post(
+                    endpoint,
+                    json={"query": query},
+                    headers={"Content-Type": "application/json"},
+                )
+                if response.status_code == 200:
+                    data = response.json()
+                    results = data.get("data", {}).get("totalRewards", [])
+                    # Reverse to get ascending order (oldest to newest) for binary search
+                    return list(reversed(results))
+            except Exception:
+                pass
+
+        return []
+
+    def get_apr_for_block(self, apr_data: list[dict], target_block: int) -> float | None:
+        """Find the APR for a specific block number.
+
+        Returns the APR from the oracle report closest to (but not after) target_block.
+        """
+        if not apr_data:
+            return None
+
+        # Find the closest report at or before target_block
+        closest = None
+        for entry in apr_data:
+            block = int(entry["block"])
+            if block <= target_block:
+                closest = entry
+            else:
+                break  # apr_data is sorted ascending
+
+        return float(closest["apr"]) if closest else None
+
+    def get_average_apr_for_range(
+        self, apr_data: list[dict], start_timestamp: int, end_timestamp: int
+    ) -> float | None:
+        """Calculate average APR for a time range.
+
+        Averages all APR values from oracle reports within the given timestamp range.
+        Falls back to the closest APR before the range if no reports fall within.
+
+        Args:
+            apr_data: List of {block, apr, blockTime} sorted by block ascending
+            start_timestamp: Unix timestamp for range start
+            end_timestamp: Unix timestamp for range end
+
+        Returns:
+            Average APR as a percentage, or None if no data available
+        """
+        if not apr_data:
+            return None
+
+        # Find all APR reports within the time range
+        reports_in_range = []
+        closest_before = None
+
+        for entry in apr_data:
+            block_time = int(entry["blockTime"])
+            if block_time < start_timestamp:
+                closest_before = entry  # Keep track of most recent before range
+            elif block_time <= end_timestamp:
+                reports_in_range.append(entry)
+            else:
+                break  # Past the range, stop searching
+
+        if reports_in_range:
+            # Average all reports within the range
+            total_apr = sum(float(r["apr"]) for r in reports_in_range)
+            return total_apr / len(reports_in_range)
+        elif closest_before:
+            # No reports in range, use the closest one before
+            return float(closest_before["apr"])
+
+        return None

src/data/onchain.py

@@ -122,6 +122,81 @@ class OnChainDataProvider:
 
         return None
 
+    @cached(ttl=300)
+    async def get_bond_curve_id(self, operator_id: int) -> int:
+        """Get the bond curve ID for an operator.
+
+        Returns:
+            0 = Permissionless (2.4 ETH first validator, 1.3 ETH subsequent)
+            1 = ICS/Legacy EA (1.5 ETH first validator, 1.3 ETH subsequent)
+        """
+        try:
+            return self.csaccounting.functions.getBondCurveId(operator_id).call()
+        except Exception:
+            # Fall back to 0 (Permissionless) if call fails
+            return 0
+
+    @staticmethod
+    def calculate_required_bond(validator_count: int, curve_id: int = 0) -> Decimal:
+        """Calculate required bond for a given validator count and curve type.
+
+        Args:
+            validator_count: Number of validators
+            curve_id: Bond curve ID from CSAccounting contract
+
+        Returns:
+            Required bond in ETH
+
+        Note:
+            Curve IDs on mainnet CSM:
+            - Curve 0: Original permissionless (2 ETH first, 1.3 ETH subsequent) - deprecated
+            - Curve 1: Original ICS/EA (1.5 ETH first, 1.3 ETH subsequent) - deprecated
+            - Curve 2: Current permissionless default (1.5 ETH first, 1.3 ETH subsequent)
+            The contract returns curve points directly, but for estimation we use
+            standard formulas.
+        """
+        if validator_count <= 0:
+            return Decimal(0)
+
+        # Curve 2 is the current mainnet default (1.5 ETH first, 1.3 ETH subsequent)
+        # Curve 0/1 were the original curves, now deprecated
+        if curve_id == 0:  # Original Permissionless (deprecated)
+            first_bond = Decimal("2.0")
+        else:  # Curve 1, 2, etc - current default curves
+            first_bond = Decimal("1.5")
+
+        subsequent_bond = Decimal("1.3")
+
+        if validator_count == 1:
+            return first_bond
+        else:
+            return first_bond + (subsequent_bond * (validator_count - 1))
+
+    @staticmethod
+    def get_operator_type_name(curve_id: int) -> str:
+        """Get human-readable operator type from curve ID.
+
+        Args:
+            curve_id: Bond curve ID from CSAccounting contract
+
+        Returns:
+            Operator type name
+
+        Note:
+            Curve IDs on mainnet CSM:
+            - Curve 0: Original permissionless (deprecated)
+            - Curve 1: Original ICS/EA (deprecated)
+            - Curve 2: Current permissionless default
+        """
+        if curve_id == 0:
+            return "Permissionless (Legacy)"
+        elif curve_id == 1:
+            return "ICS/Legacy EA"
+        elif curve_id == 2:
+            return "Permissionless"
+        else:
+            return f"Custom (Curve {curve_id})"
+
     @cached(ttl=60)
     async def get_bond_summary(self, operator_id: int) -> BondSummary:
         """Get bond summary for an operator."""
@@ -256,3 +331,118 @@ class OnChainDataProvider:
                 return []
 
         return sorted(all_events, key=lambda x: x["block"])
+
+    @cached(ttl=3600)  # Cache for 1 hour
+    async def get_withdrawal_history(
+        self, reward_address: str, start_block: int | None = None
+    ) -> list[dict]:
+        """
+        Get withdrawal history for an operator's reward address.
+
+        Queries stETH Transfer events from CSFeeDistributor to the reward address.
+        These represent when the operator claimed their rewards.
+
+        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
+        """
+        if start_block is None:
+            start_block = 20873000  # CSM deployment block
+
+        reward_address = Web3.to_checksum_address(reward_address)
+        csfeedistributor_address = self.settings.csfeedistributor_address
+
+        # 1. Try Etherscan API first (most reliable)
+        etherscan = EtherscanProvider()
+        if etherscan.is_available():
+            events = await etherscan.get_transfer_events(
+                token_address=self.settings.steth_address,
+                from_address=csfeedistributor_address,
+                to_address=reward_address,
+                from_block=start_block,
+            )
+            if events:
+                # Enrich with block timestamps
+                return await self._enrich_withdrawal_events(events)
+
+        # 2. Try chunked RPC queries
+        events = await self._query_transfer_events_chunked(
+            csfeedistributor_address, reward_address, start_block
+        )
+        if events:
+            return await self._enrich_withdrawal_events(events)
+
+        return []
+
+    async def _query_transfer_events_chunked(
+        self,
+        from_address: str,
+        to_address: str,
+        start_block: int,
+        chunk_size: int = 10000,
+    ) -> list[dict]:
+        """Query Transfer events in smaller chunks."""
+        current_block = self.w3.eth.block_number
+        all_events = []
+
+        from_address = Web3.to_checksum_address(from_address)
+        to_address = Web3.to_checksum_address(to_address)
+
+        for from_blk in range(start_block, current_block, chunk_size):
+            to_blk = min(from_blk + chunk_size - 1, current_block)
+            try:
+                events = self.steth.events.Transfer.get_logs(
+                    from_block=from_blk,
+                    to_block=to_blk,
+                    argument_filters={
+                        "from": from_address,
+                        "to": to_address,
+                    },
+                )
+                for e in events:
+                    all_events.append(
+                        {
+                            "block": e["blockNumber"],
+                            "tx_hash": e["transactionHash"].hex(),
+                            "value": e["args"]["value"],
+                        }
+                    )
+            except Exception:
+                # If chunked queries fail, give up on this method
+                return []
+
+        return sorted(all_events, key=lambda x: x["block"])
+
+    async def _enrich_withdrawal_events(self, events: list[dict]) -> list[dict]:
+        """Add timestamps and ETH values to withdrawal events."""
+        from datetime import datetime, timezone
+
+        enriched = []
+        for event in events:
+            try:
+                # Get block timestamp
+                block = self.w3.eth.get_block(event["block"])
+                timestamp = datetime.fromtimestamp(
+                    block["timestamp"], tz=timezone.utc
+                ).isoformat()
+
+                # Convert shares to ETH (using current rate as approximation)
+                eth_value = await self.shares_to_eth(event["value"])
+
+                enriched.append(
+                    {
+                        "block_number": event["block"],
+                        "timestamp": timestamp,
+                        "shares": event["value"],
+                        "eth_value": float(eth_value),
+                        "tx_hash": event["tx_hash"],
+                    }
+                )
+            except Exception:
+                # Skip events we can't enrich
+                continue
+
+        return enriched