Update app/app.py

app/app.py

@@ -1,15 +1,13 @@
 """
-Sentinel Arbitrage Engine - v4.0 FINAL
+Sentinel Arbitrage Engine - v5.0 FINAL (Anti-Geoblock)
 
-High-frequency arbitrage detection and AI-powered risk analysis.
+Detects on-chain vs. off-chain price discrepancies and provides AI-powered analysis.
 """
 import asyncio
 import os
 from contextlib import asynccontextmanager
 from datetime import datetime, timezone
-from typing import Dict, Optional
 import json
-
 import httpx
 from fastapi import FastAPI, Request
 from fastapi.responses import HTMLResponse, StreamingResponse
@@ -18,7 +16,7 @@ from fastapi.templating import Jinja2Templates
 from .price_fetcher import PriceFetcher
 from .arbitrage_analyzer import ArbitrageAnalyzer
 
-OPPORTUNITY_THRESHOLD = 0.003  # 0.3% price difference to trigger a signal
+OPPORTUNITY_THRESHOLD = 0.001  # 0.1% price difference to trigger a signal
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
@@ -26,51 +24,38 @@ async def lifespan(app: FastAPI):
         app.state.price_fetcher = PriceFetcher(client=client)
         app.state.arbitrage_analyzer = ArbitrageAnalyzer(client=client)
         app.state.signal_queue: asyncio.Queue = asyncio.Queue()
-
-        arbitrage_task = asyncio.create_task(run_arbitrage_detector(app, 5)) # Run every 5 seconds
+        arbitrage_task = asyncio.create_task(run_arbitrage_detector(app, 10))
         
-        print("🚀 Sentinel Arbitrage Engine started successfully.")
+        print("🚀 Sentinel Arbitrage Engine v5.0 started successfully.")
         yield
         
-        print("⏳ Shutting down arbitrage engine...")
+        print("⏳ Shutting down engine...")
         arbitrage_task.cancel()
-        try:
-            await arbitrage_task
-        except asyncio.CancelledError:
-            print("Engine shut down.")
+        try: await arbitrage_task
+        except asyncio.CancelledError: print("Engine shut down.")
 
 async def run_arbitrage_detector(app: FastAPI, interval_seconds: int):
-    last_opportunity = {}
     while True:
         await app.state.price_fetcher.update_prices_async()
         prices = app.state.price_fetcher.get_current_prices()
         
-        valid_prices = {k: v for k, v in prices.items() if v is not None}
-        if len(valid_prices) < 2:
-            await asyncio.sleep(interval_seconds)
-            continue
-            
-        min_exchange = min(valid_prices, key=valid_prices.get)
-        max_exchange = max(valid_prices, key=valid_prices.get)
-        
-        buy_price = valid_prices[min_exchange]
-        sell_price = valid_prices[max_exchange]
+        on_chain = prices.get("on_chain_pyth")
+        off_chain = prices.get("off_chain_agg")
         
-        if buy_price > 0 and (sell_price - buy_price) / buy_price > OPPORTUNITY_THRESHOLD:
-            opportunity = {
-                "id": f"{min_exchange}-{max_exchange}",
-                "buy_exchange": min_exchange.capitalize(), "buy_price": buy_price,
-                "sell_exchange": max_exchange.capitalize(), "sell_price": sell_price,
-                "spread_pct": ((sell_price - buy_price) / buy_price) * 100
-            }
-            # Only analyze if it's a new opportunity
-            if last_opportunity.get("id") != opportunity["id"]:
-                print(f"⚡️ Arbitrage Opportunity Detected: {opportunity['spread_pct']:.2f}% spread")
+        if on_chain and off_chain:
+            spread = abs(on_chain - off_chain) / off_chain
+            if spread > OPPORTUNITY_THRESHOLD:
+                opportunity = {
+                    "id": f"{int(datetime.now().timestamp())}",
+                    "on_chain_price": on_chain,
+                    "off_chain_price": off_chain,
+                    "spread_pct": spread * 100
+                }
+                print(f"⚡️ Discrepancy Detected: {opportunity['spread_pct']:.3f}%")
                 briefing = await app.state.arbitrage_analyzer.get_alpha_briefing(opportunity)
                 if briefing:
                     signal = {**opportunity, **briefing, "timestamp": datetime.now(timezone.utc).isoformat()}
                     await app.state.signal_queue.put(signal)
-                    last_opportunity = opportunity
 
         await asyncio.sleep(interval_seconds)
 
@@ -80,17 +65,18 @@ templates = Jinja2Templates(directory="templates")
 def render_signal_card(payload: dict) -> str:
     s = payload
     time_str = datetime.fromisoformat(s['timestamp']).strftime('%H:%M:%S UTC')
+    on_chain_class = "buy" if s['on_chain_price'] < s['off_chain_price'] else "sell"
+    off_chain_class = "sell" if s['on_chain_price'] < s['off_chain_price'] else "buy"
 
     return f"""
-    <tr id="trade-row-{s['id']}" hx-swap-oob="true">
-        <td><strong>BTC</strong></td>
-        <td><span class="buy">{s['buy_exchange']}</span><br>${s['buy_price']:,.2f}</td>
-        <td><span class="sell">{s['sell_exchange']}</span><br>${s['sell_price']:,.2f}</td>
+    <tr id="trade-row-{s['id']}" hx-swap-oob="afterbegin:#opportunities-table">
+        <td><strong>BTC/USD</strong></td>
+        <td><span class="{on_chain_class}">On-Chain (Pyth)</span><br>${s['on_chain_price']:,.2f}</td>
+        <td><span class="{off_chain_class}">Off-Chain (Agg)</span><br>${s['off_chain_price']:,.2f}</td>
         <td><strong>{s['spread_pct']:.3f}%</strong></td>
         <td><span class="risk-{s.get('risk', 'low').lower()}">{s.get('risk', 'N/A')}</span></td>
-        <td>{s.get('strategy', 'N/A')}</td>
-        <td><strong>${s.get('profit_usd', 0):,.2f}</strong></td>
-        <td><button class="trade-btn">Simulate Trade</button></td>
+        <td>{s.get('rationale', 'N/A')}</td>
+        <td><button class="trade-btn">{s.get('strategy', 'N/A')}</button></td>
     </tr>
     <div id="last-update-time" hx-swap-oob="true">{time_str}</div>
     """