Update app/price_fetcher.py

app/price_fetcher.py

@@ -1,62 +1,95 @@
 """
-A high-availability price fetcher using a decentralized oracle (Pyth)
-and a reliable data aggregator to bypass geoblocking.
+A high-throughput, fault-tolerant, multi-source price fetcher engine.
+Designed to bypass rate-limiting and ensure constant data flow.
 """
 import asyncio
 import logging
-from typing import Dict, Optional
+from typing import Dict, Optional, List
 import httpx
+import os
+import statistics
 
 logger = logging.getLogger(__name__)
 
 class PriceFetcher:
-    # Pyth provides real-time, on-chain prices. We will use their public API.
-    # We will fetch BTC/USD.
+    # Pyth for our on-chain data
     PYTH_URL = "https://hermes.pyth.network/v2/updates/price/latest?ids[]=e62df6c8b4a85fe1a67db44dc12de5db330f7ac66b72dc658afedf0f4a415B43"
 
-    # A reliable aggregator that is not typically geoblocked.
-    AGGREGATOR_URL = "https://api.coingecko.com/api/v3/simple/price?ids=bitcoin&vs_currencies=usd"
+    # A list of our off-chain aggregator sources
+    AGGREGATOR_SOURCES = {
+        "coingecko": "https://api.coingecko.com/api/v3/simple/price?ids=bitcoin&vs_currencies=usd",
+        "coincap": "https://api.coincap.io/v2/assets/bitcoin",
+    }
+    
+    # Use Pro API if a key is provided as a secret
+    COINGECKO_PRO_URL = "https://pro-api.coingecko.com/api/v3/simple/price?ids=bitcoin&vs_currencies=usd"
 
     def __init__(self, client: httpx.AsyncClient):
         self.client = client
         self._prices: Dict[str, Optional[float]] = {"on_chain_pyth": None, "off_chain_agg": None}
         self._lock = asyncio.Lock()
+        self.coingecko_api_key = os.getenv("COINGECKO_API_KEY")
 
     async def _fetch_pyth(self) -> Optional[float]:
         try:
             resp = await self.client.get(self.PYTH_URL, timeout=5)
             resp.raise_for_status()
-            data = resp.json()
-            # The price is in the 'parsed' part of the response
-            price_data = data['parsed'][0]['price']
-            # Price is given with an exponent, e.g., price=119123, expo=-2 -> 1191.23
-            # But for BTC/USD, the expo is -8, and price is in sats. We need to adjust.
-            price = int(price_data['price']) / (10 ** abs(int(price_data['expo'])))
-            return price
-        except Exception as e:
-            logger.error(f"❌ Failed to fetch from Pyth: {e}")
-            return None
+            price_data = resp.json()['parsed'][0]['price']
+            return int(price_data['price']) / (10 ** abs(int(price_data['expo'])))
+        except Exception:
+            return None # Fail silently, we have other sources
 
-    async def _fetch_aggregator(self) -> Optional[float]:
+    async def _fetch_aggregator(self, name: str, url: str) -> Optional[float]:
         try:
-            resp = await self.client.get(self.AGGREGATOR_URL, timeout=5)
+            headers = {}
+            if name == "coingecko" and self.coingecko_api_key:
+                url = self.COINGECKO_PRO_URL
+                headers["X-Cg-Pro-Api-Key"] = self.coingecko_api_key
+            
+            resp = await self.client.get(url, timeout=5, headers=headers)
+            if resp.status_code == 429: # Explicitly handle rate limiting
+                logger.warning(f"⚠️ Rate limited by {name}. Skipping.")
+                return None
             resp.raise_for_status()
-            return float(resp.json()['bitcoin']['usd'])
+            data = resp.json()
+
+            if name == "coingecko": return float(data['bitcoin']['usd'])
+            if name == "coincap": return float(data['data']['priceUsd'])
+            
         except Exception as e:
-            logger.error(f"❌ Failed to fetch from Aggregator: {e}")
-            return None
+            logger.error(f"❌ Failed to fetch from {name}: {e}")
+        return None
+
+    def _get_sane_average(self, prices: List[float]) -> Optional[float]:
+        """Calculates the average price, discarding outliers."""
+        if not prices: return None
+        if len(prices) < 3: return statistics.mean(prices)
+        
+        # For 3 or more sources, discard any price that is more than 2%
+        # different from the median, then average the rest.
+        median = statistics.median(prices)
+        sane_prices = [p for p in prices if abs(p - median) / median < 0.02]
+        
+        if not sane_prices: return median # Fallback to median if all are outliers
+        return statistics.mean(sane_prices)
 
     async def update_prices_async(self):
+        # Fetch all sources concurrently
         pyth_task = self._fetch_pyth()
-        agg_task = self._fetch_aggregator()
+        agg_tasks = [self._fetch_aggregator(name, url) for name, url in self.AGGREGATOR_SOURCES.items()]
+        
+        results = await asyncio.gather(pyth_task, *agg_tasks)
+        
+        pyth_price = results[0]
+        agg_prices = [p for p in results[1:] if p is not None]
         
-        pyth_price, agg_price = await asyncio.gather(pyth_task, agg_task)
+        sane_agg_price = self._get_sane_average(agg_prices)
         
         async with self._lock:
             self._prices["on_chain_pyth"] = pyth_price
-            self._prices["off_chain_agg"] = agg_price
+            self._prices["off_chain_agg"] = sane_agg_price
         
-        logger.info(f"✅ Prices updated: {self._prices}")
+        logger.info(f"✅ Prices updated: On-Chain={pyth_price}, Off-Chain Agg={sane_agg_price} (from {len(agg_prices)} sources)")
 
     def get_current_prices(self) -> Dict[str, Optional[float]]:
         return self._prices.copy()