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

src/data/ipfs_logs.py

@@ -1,6 +1,8 @@
 """IPFS distribution log fetching with persistent caching."""
 
+import asyncio
 import json
+import logging
 import time
 from dataclasses import dataclass
 from datetime import datetime, timezone
@@ -11,6 +13,8 @@ import httpx
 
 from ..core.config import get_settings
 
+logger = logging.getLogger(__name__)
+
 
 # Ethereum Beacon Chain genesis timestamp (Dec 1, 2020 12:00:23 UTC)
 BEACON_GENESIS = 1606824023
@@ -40,20 +44,17 @@ class FrameData:
 class IPFSLogProvider:
     """Fetches and caches historical distribution logs from IPFS."""
 
-    # IPFS gateways to try in order
-    GATEWAYS = [
-        "https://ipfs.io/ipfs/",
-        "https://cloudflare-ipfs.com/ipfs/",
-    ]
-
     # Rate limiting: minimum seconds between gateway requests
     MIN_REQUEST_INTERVAL = 1.0
 
     def __init__(self, cache_dir: Path | None = None):
         self.settings = get_settings()
+        # Use configurable gateways from settings (comma-separated)
+        self.gateways = [g.strip() for g in self.settings.ipfs_gateways.split(",") if g.strip()]
         self.cache_dir = cache_dir or Path.home() / ".cache" / "csm-dashboard" / "ipfs"
         self.cache_dir.mkdir(parents=True, exist_ok=True)
         self._last_request_time = 0.0
+        self._rate_limit_lock = asyncio.Lock()
 
     def _get_cache_path(self, cid: str) -> Path:
         """Get the cache file path for a CID."""
@@ -80,13 +81,14 @@ class IPFSLogProvider:
         except OSError:
             pass  # Cache write failure is non-fatal
 
-    def _rate_limit(self) -> None:
-        """Ensure minimum interval between IPFS gateway requests."""
-        now = time.time()
-        elapsed = now - self._last_request_time
-        if elapsed < self.MIN_REQUEST_INTERVAL:
-            time.sleep(self.MIN_REQUEST_INTERVAL - elapsed)
-        self._last_request_time = time.time()
+    async def _rate_limit(self) -> None:
+        """Ensure minimum interval between IPFS gateway requests (async-safe)."""
+        async with self._rate_limit_lock:
+            now = time.time()
+            elapsed = now - self._last_request_time
+            if elapsed < self.MIN_REQUEST_INTERVAL:
+                await asyncio.sleep(self.MIN_REQUEST_INTERVAL - elapsed)
+            self._last_request_time = time.time()
 
     async def fetch_log(self, cid: str) -> dict | None:
         """
@@ -100,26 +102,32 @@ class IPFSLogProvider:
         if cached is not None:
             return cached
 
-        # Rate limit gateway requests
-        self._rate_limit()
+        # Rate limit gateway requests (async-safe)
+        await self._rate_limit()
 
         # Try each gateway
         async with httpx.AsyncClient(timeout=30.0, follow_redirects=True) as client:
-            for gateway in self.GATEWAYS:
+            for gateway in self.gateways:
                 try:
                     url = f"{gateway}{cid}"
                     response = await client.get(url)
                     if response.status_code == 200:
-                        data = response.json()
+                        try:
+                            data = response.json()
+                        except json.JSONDecodeError as e:
+                            logger.warning(f"Failed to parse IPFS JSON from {gateway}: {e}")
+                            continue
                         # The IPFS log is wrapped in a list, unwrap it
                         if isinstance(data, list) and len(data) == 1:
                             data = data[0]
                         # Cache the successful result
                         self._save_to_cache(cid, data)
                         return data
-                except Exception:
+                except Exception as e:
+                    logger.debug(f"IPFS gateway {gateway} failed for CID {cid}: {e}")
                     continue  # Try next gateway
 
+        logger.warning(f"All IPFS gateways failed for CID {cid}")
         return None
 
     def get_operator_frame_rewards(self, log_data: dict, operator_id: int) -> int | None:
@@ -289,9 +297,10 @@ class IPFSLogProvider:
             total_rewards_eth = Decimal(total_rewards_wei) / Decimal(10**18)
 
             # Annualize: (rewards / bond) * (365 / days) * 100
-            apy = float(total_rewards_eth / bond_eth) * (365.0 / total_days) * 100
+            # Keep calculation in Decimal for precision, convert to float only at the end
+            apy = (total_rewards_eth / bond_eth) * Decimal(365) / Decimal(total_days) * Decimal(100)
 
-            results[self._period_name(period)] = round(apy, 2)
+            results[self._period_name(period)] = round(float(apy), 2)
 
         return results
 

src/data/lido_api.py

@@ -1,10 +1,14 @@
 """Lido protocol API for stETH APR and other metrics."""
 
+import logging
+
 import httpx
 
 from ..core.config import get_settings
 from .cache import cached
 
+logger = logging.getLogger(__name__)
+
 LIDO_API_BASE = "https://eth-api.lido.fi/v1"
 LIDO_SUBGRAPH_ID = "Sxx812XgeKyzQPaBpR5YZWmGV5fZuBaPdh7DFhzSwiQ"
 
@@ -27,12 +31,14 @@ class LidoAPIProvider:
 
                 if response.status_code == 200:
                     data = response.json()
+                    # Handle case where data["data"] could be explicitly None
+                    data_obj = data.get("data") or {}
                     return {
-                        "apr": float(data.get("data", {}).get("smaApr", 0)),
-                        "timestamp": data.get("data", {}).get("timeUnix"),
+                        "apr": float(data_obj.get("smaApr", 0) or 0),
+                        "timestamp": data_obj.get("timeUnix"),
                     }
-            except Exception:
-                pass
+            except Exception as e:
+                logger.warning(f"Failed to fetch stETH APR from Lido API: {e}")
 
         return {"apr": None, "timestamp": None}
 
@@ -73,8 +79,8 @@ class LidoAPIProvider:
                     results = data.get("data", {}).get("totalRewards", [])
                     # Reverse to get ascending order (oldest to newest) for binary search
                     return list(reversed(results))
-            except Exception:
-                pass
+            except Exception as e:
+                logger.warning(f"Failed to fetch historical APR from TheGraph: {e}")
 
         return []
 
@@ -89,13 +95,21 @@ class LidoAPIProvider:
         # Find the closest report at or before target_block
         closest = None
         for entry in apr_data:
-            block = int(entry["block"])
+            try:
+                block = int(entry.get("block", 0))
+            except (ValueError, TypeError):
+                continue
             if block <= target_block:
                 closest = entry
             else:
                 break  # apr_data is sorted ascending
 
-        return float(closest["apr"]) if closest else None
+        if closest:
+            try:
+                return float(closest.get("apr", 0))
+            except (ValueError, TypeError):
+                return None
+        return None
 
     def get_average_apr_for_range(
         self, apr_data: list[dict], start_timestamp: int, end_timestamp: int
@@ -121,7 +135,10 @@ class LidoAPIProvider:
         closest_before = None
 
         for entry in apr_data:
-            block_time = int(entry["blockTime"])
+            try:
+                block_time = int(entry.get("blockTime", 0))
+            except (ValueError, TypeError):
+                continue
             if block_time < start_timestamp:
                 closest_before = entry  # Keep track of most recent before range
             elif block_time <= end_timestamp:
@@ -131,10 +148,19 @@ class LidoAPIProvider:
 
         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)
+            valid_aprs = []
+            for r in reports_in_range:
+                try:
+                    valid_aprs.append(float(r.get("apr", 0)))
+                except (ValueError, TypeError):
+                    continue
+            if valid_aprs:
+                return sum(valid_aprs) / len(valid_aprs)
         elif closest_before:
             # No reports in range, use the closest one before
-            return float(closest_before["apr"])
+            try:
+                return float(closest_before.get("apr", 0))
+            except (ValueError, TypeError):
+                pass
 
         return None

src/data/onchain.py

@@ -1,10 +1,14 @@
 """On-chain data fetching via Web3."""
 
 import asyncio
+import logging
 from decimal import Decimal
+from functools import partial
 
 from web3 import Web3
 
+logger = logging.getLogger(__name__)
+
 from ..core.config import get_settings
 from ..core.contracts import (
     CSACCOUNTING_ABI,
@@ -24,7 +28,12 @@ class OnChainDataProvider:
 
     def __init__(self, rpc_url: str | None = None):
         self.settings = get_settings()
-        self.w3 = Web3(Web3.HTTPProvider(rpc_url or self.settings.eth_rpc_url))
+        self.w3 = Web3(
+            Web3.HTTPProvider(
+                rpc_url or self.settings.eth_rpc_url,
+                request_kwargs={"timeout": 30},
+            )
+        )
 
         # Initialize contracts
         self.csmodule = self.w3.eth.contract(
@@ -51,12 +60,16 @@ class OnChainDataProvider:
     @cached(ttl=60)
     async def get_node_operators_count(self) -> int:
         """Get total number of node operators."""
-        return self.csmodule.functions.getNodeOperatorsCount().call()
+        return await asyncio.to_thread(
+            self.csmodule.functions.getNodeOperatorsCount().call
+        )
 
     @cached(ttl=300)
     async def get_node_operator(self, operator_id: int) -> NodeOperator:
         """Get node operator data by ID."""
-        data = self.csmodule.functions.getNodeOperator(operator_id).call()
+        data = await asyncio.to_thread(
+            self.csmodule.functions.getNodeOperator(operator_id).call
+        )
         return NodeOperator(
             node_operator_id=operator_id,
             total_added_keys=data[0],
@@ -95,10 +108,13 @@ class OnChainDataProvider:
 
             if batch_supported:
                 try:
-                    with self.w3.batch_requests() as batch:
-                        for op_id in range(start, end):
-                            batch.add(self.csmodule.functions.getNodeOperator(op_id))
-                        results = batch.execute()
+                    def run_batch():
+                        with self.w3.batch_requests() as batch:
+                            for op_id in range(start, end):
+                                batch.add(self.csmodule.functions.getNodeOperator(op_id))
+                            return batch.execute()
+
+                    results = await asyncio.to_thread(run_batch)
 
                     for i, data in enumerate(results):
                         op_id = start + i
@@ -114,7 +130,9 @@ class OnChainDataProvider:
             # Sequential fallback with rate limiting
             for op_id in range(start, end):
                 try:
-                    data = self.csmodule.functions.getNodeOperator(op_id).call()
+                    data = await asyncio.to_thread(
+                        self.csmodule.functions.getNodeOperator(op_id).call
+                    )
                     manager = data[10]
                     reward = data[12]
                     if manager.lower() == address.lower() or reward.lower() == address.lower():
@@ -136,7 +154,9 @@ class OnChainDataProvider:
             1 = ICS/Legacy EA (1.5 ETH first validator, 1.3 ETH subsequent)
         """
         try:
-            return self.csaccounting.functions.getBondCurveId(operator_id).call()
+            return await asyncio.to_thread(
+                self.csaccounting.functions.getBondCurveId(operator_id).call
+            )
         except Exception:
             # Fall back to 0 (Permissionless) if call fails
             return 0
@@ -166,8 +186,12 @@ class OnChainDataProvider:
         # 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)
+            logger.debug(f"Using deprecated curve 0 bond calculation")
             first_bond = Decimal("2.0")
-        else:  # Curve 1, 2, etc - current default curves
+        elif curve_id not in (1, 2):
+            logger.warning(f"Unknown curve_id {curve_id}, using default bond calculation")
+            first_bond = Decimal("1.5")
+        else:  # Curve 1, 2 - current default curves
             first_bond = Decimal("1.5")
 
         subsequent_bond = Decimal("1.3")
@@ -205,9 +229,9 @@ class OnChainDataProvider:
     @cached(ttl=60)
     async def get_bond_summary(self, operator_id: int) -> BondSummary:
         """Get bond summary for an operator."""
-        current, required = self.csaccounting.functions.getBondSummary(
-            operator_id
-        ).call()
+        current, required = await asyncio.to_thread(
+            self.csaccounting.functions.getBondSummary(operator_id).call
+        )
 
         current_eth = Decimal(current) / Decimal(10**18)
         required_eth = Decimal(required) / Decimal(10**18)
@@ -224,14 +248,18 @@ class OnChainDataProvider:
     @cached(ttl=60)
     async def get_distributed_shares(self, operator_id: int) -> int:
         """Get already distributed (claimed) shares for operator."""
-        return self.csfeedistributor.functions.distributedShares(operator_id).call()
+        return await asyncio.to_thread(
+            self.csfeedistributor.functions.distributedShares(operator_id).call
+        )
 
     @cached(ttl=60)
     async def shares_to_eth(self, shares: int) -> Decimal:
         """Convert stETH shares to ETH value."""
         if shares == 0:
             return Decimal(0)
-        eth_wei = self.steth.functions.getPooledEthByShares(shares).call()
+        eth_wei = await asyncio.to_thread(
+            self.steth.functions.getPooledEthByShares(shares).call
+        )
         return Decimal(eth_wei) / Decimal(10**18)
 
     async def get_signing_keys(
@@ -246,9 +274,11 @@ class OnChainDataProvider:
 
         for batch_start in range(start, start + count, batch_size):
             batch_count = min(batch_size, start + count - batch_start)
-            keys_bytes = self.csmodule.functions.getSigningKeys(
-                operator_id, batch_start, batch_count
-            ).call()
+            keys_bytes = await asyncio.to_thread(
+                self.csmodule.functions.getSigningKeys(
+                    operator_id, batch_start, batch_count
+                ).call
+            )
             # Each key is 48 bytes
             for i in range(0, len(keys_bytes), 48):
                 key = "0x" + keys_bytes[i : i + 48].hex()
@@ -256,9 +286,11 @@ class OnChainDataProvider:
 
         return keys
 
-    def get_current_log_cid(self) -> str:
+    async def get_current_log_cid(self) -> str:
         """Get the current distribution log CID from the contract."""
-        return self.csfeedistributor.functions.logCid().call()
+        return await asyncio.to_thread(
+            self.csfeedistributor.functions.logCid().call
+        )
 
     @cached(ttl=3600)  # Cache for 1 hour since historical events don't change
     async def get_distribution_log_history(
@@ -304,12 +336,14 @@ class OnChainDataProvider:
 
         # 4. Ultimate fallback: current logCid only
         try:
-            current_cid = self.get_current_log_cid()
+            current_cid = await self.get_current_log_cid()
             if current_cid:
-                current_block = self.w3.eth.block_number
+                current_block = await asyncio.to_thread(
+                    lambda: self.w3.eth.block_number
+                )
                 return [{"block": current_block, "logCid": current_cid}]
-        except Exception:
-            pass
+        except Exception as e:
+            logger.debug(f"Failed to get current log CID as fallback: {e}")
 
         return []
 
@@ -317,15 +351,18 @@ class OnChainDataProvider:
         self, start_block: int, chunk_size: int = 10000
     ) -> list[dict]:
         """Query events in smaller chunks to work around RPC limitations."""
-        current_block = self.w3.eth.block_number
+        current_block = await asyncio.to_thread(lambda: self.w3.eth.block_number)
         all_events = []
 
         for from_block in range(start_block, current_block, chunk_size):
             to_block = min(from_block + chunk_size - 1, current_block)
             try:
-                events = self.csfeedistributor.events.DistributionLogUpdated.get_logs(
-                    from_block=from_block,
-                    to_block=to_block,
+                events = await asyncio.to_thread(
+                    partial(
+                        self.csfeedistributor.events.DistributionLogUpdated.get_logs,
+                        from_block=from_block,
+                        to_block=to_block,
+                    )
                 )
                 for e in events:
                     all_events.append(
@@ -443,7 +480,7 @@ class OnChainDataProvider:
         chunk_size: int = 10000,
     ) -> list[dict]:
         """Query WithdrawalRequested events in chunks via RPC."""
-        current_block = self.w3.eth.block_number
+        current_block = await asyncio.to_thread(lambda: self.w3.eth.block_number)
         all_events = []
 
         requestor = Web3.to_checksum_address(requestor)
@@ -452,13 +489,16 @@ class OnChainDataProvider:
         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,
-                    },
+                events = await asyncio.to_thread(
+                    partial(
+                        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(
@@ -488,9 +528,9 @@ class OnChainDataProvider:
         # 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()
+            statuses = await asyncio.to_thread(
+                self.withdrawal_queue.functions.getWithdrawalStatus(request_ids).call
+            )
         except Exception:
             # If status query fails, set all as unknown
             statuses = [None] * len(events)
@@ -503,7 +543,9 @@ class OnChainDataProvider:
         for i, event in enumerate(events):
             try:
                 # Get block timestamp
-                block = self.w3.eth.get_block(event["block"])
+                block = await asyncio.to_thread(
+                    partial(self.w3.eth.get_block, event["block"])
+                )
                 timestamp = datetime.fromtimestamp(
                     block["timestamp"], tz=timezone.utc
                 ).isoformat()
@@ -542,15 +584,18 @@ class OnChainDataProvider:
                     enriched_event["claim_tx_hash"] = claim["tx_hash"]
                     # Get claim timestamp
                     try:
-                        claim_block = self.w3.eth.get_block(claim["block"])
+                        claim_block = await asyncio.to_thread(
+                            partial(self.w3.eth.get_block, claim["block"])
+                        )
                         enriched_event["claim_timestamp"] = datetime.fromtimestamp(
                             claim_block["timestamp"], tz=timezone.utc
                         ).isoformat()
-                    except Exception:
-                        pass
+                    except Exception as e:
+                        logger.debug(f"Failed to get claim timestamp for block {claim.get('block')}: {e}")
 
                 enriched.append(enriched_event)
-            except Exception:
+            except Exception as e:
+                logger.debug(f"Failed to enrich withdrawal event: {e}")
                 continue
 
         return enriched
@@ -573,16 +618,19 @@ class OnChainDataProvider:
                 return events
 
         # RPC fallback - query in chunks
-        current_block = self.w3.eth.block_number
+        current_block = await asyncio.to_thread(lambda: 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},
+                logs = await asyncio.to_thread(
+                    partial(
+                        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(
@@ -606,7 +654,7 @@ class OnChainDataProvider:
         chunk_size: int = 10000,
     ) -> list[dict]:
         """Query Transfer events in smaller chunks."""
-        current_block = self.w3.eth.block_number
+        current_block = await asyncio.to_thread(lambda: self.w3.eth.block_number)
         all_events = []
 
         from_address = Web3.to_checksum_address(from_address)
@@ -615,13 +663,16 @@ class OnChainDataProvider:
         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,
-                    },
+                events = await asyncio.to_thread(
+                    partial(
+                        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(
@@ -645,7 +696,9 @@ class OnChainDataProvider:
         for event in events:
             try:
                 # Get block timestamp
-                block = self.w3.eth.get_block(event["block"])
+                block = await asyncio.to_thread(
+                    partial(self.w3.eth.get_block, event["block"])
+                )
                 timestamp = datetime.fromtimestamp(
                     block["timestamp"], tz=timezone.utc
                 ).isoformat()

src/data/price.py

@@ -0,0 +1,46 @@
+"""Price fetching from CoinGecko API."""
+
+import logging
+import time
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+# Cache ETH price for 5 minutes
+_price_cache: dict = {"eth_usd": None, "timestamp": 0}
+CACHE_TTL = 300  # 5 minutes
+
+
+async def get_eth_price() -> float | None:
+    """Fetch current ETH price in USD from CoinGecko.
+
+    Returns:
+        ETH price in USD, or None if fetch fails
+    """
+    global _price_cache
+
+    # Check cache
+    now = time.time()
+    if _price_cache["eth_usd"] is not None and (now - _price_cache["timestamp"]) < CACHE_TTL:
+        return _price_cache["eth_usd"]
+
+    try:
+        async with httpx.AsyncClient(timeout=10.0) as client:
+            response = await client.get(
+                "https://api.coingecko.com/api/v3/simple/price",
+                params={"ids": "ethereum", "vs_currencies": "usd"},
+            )
+            if response.status_code == 200:
+                data = response.json()
+                price = data.get("ethereum", {}).get("usd")
+                if price:
+                    _price_cache["eth_usd"] = float(price)
+                    _price_cache["timestamp"] = now
+                    logger.info(f"Fetched ETH price: ${price}")
+                    return float(price)
+    except Exception as e:
+        logger.warning(f"Failed to fetch ETH price: {e}")
+
+    # Return cached value if available (even if stale)
+    return _price_cache["eth_usd"]

src/data/rewards_tree.py

@@ -1,11 +1,16 @@
 """Fetch and parse the rewards merkle tree from GitHub."""
 
+import json
+import logging
+
 import httpx
 
 from ..core.config import get_settings
 from ..core.types import RewardsInfo
 from .cache import cached
 
+logger = logging.getLogger(__name__)
+
 
 class RewardsTreeProvider:
     """Fetches rewards data from the csm-rewards repository."""
@@ -26,9 +31,19 @@ class RewardsTreeProvider:
         }
         """
         async with httpx.AsyncClient(timeout=30.0) as client:
-            response = await client.get(self.settings.rewards_proofs_url)
-            response.raise_for_status()
-            return response.json()
+            try:
+                response = await client.get(self.settings.rewards_proofs_url)
+                response.raise_for_status()
+                return response.json()
+            except httpx.HTTPStatusError as e:
+                logger.warning(f"Failed to fetch rewards tree: HTTP {e.response.status_code}")
+                return {}
+            except httpx.RequestError as e:
+                logger.warning(f"Failed to fetch rewards tree: {e}")
+                return {}
+            except json.JSONDecodeError as e:
+                logger.warning(f"Failed to parse rewards tree JSON: {e}")
+                return {}
 
     async def get_operator_rewards(self, operator_id: int) -> RewardsInfo | None:
         """Get rewards info for a specific operator."""