Update app/app.py

app/app.py

@@ -1,96 +1,96 @@
 """
-Sentinel Arbitrage Engine - v10.0 OMEGA
+Sentinel Arbitrage Engine - v11.0 FINAL (Multi-Asset)
 
-A complete architectural overhaul using FastAPI-SocketIO for guaranteed,
-real-time signal delivery. This is the definitive money-spinning engine.
+Detects and analyzes price dislocations for multiple assets across
+decentralized oracles.
 """
 import asyncio
 import os
 from contextlib import asynccontextmanager
-import json
-import time
 from datetime import datetime, timezone
-
+import json
 import httpx
-import socketio
-from fastapi import FastAPI
-from fastapi.staticfiles import StaticFiles
+from fastapi import FastAPI, Request
+from fastapi.responses import HTMLResponse, StreamingResponse
+from fastapi.templating import Jinja2Templates
 
-# --- RELATIVE IMPORTS FOR PACKAGE STRUCTURE ---
 from .price_fetcher import PriceFetcher
 from .arbitrage_analyzer import ArbitrageAnalyzer
 from .broker import signal_broker
 
-OPPORTUNITY_THRESHOLD = 0.001
+OPPORTUNITY_THRESHOLD = 0.0015  # 0.15% price difference to trigger a signal
 
-# --- Socket.IO Server Setup ---
-sio = socketio.AsyncServer(async_mode='asgi', cors_allowed_origins='*')
-socket_app = socketio.ASGIApp(sio)
-
-# --- Application Lifespan ---
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    print("🚀 Initializing Sentinel Arbitrage Engine v10.0...")
+    # This setup remains the same, but the logic it runs is now multi-asset.
     async with httpx.AsyncClient() as client:
         app.state.price_fetcher = PriceFetcher(client)
         app.state.arbitrage_analyzer = ArbitrageAnalyzer(client)
-        
-        arbitrage_task = asyncio.create_task(
-            run_arbitrage_detector(app.state.price_fetcher, app.state.arbitrage_analyzer)
-        )
-        
-        print("✅ Engine is online and hunting for opportunities.")
+        arbitrage_task = asyncio.create_task(run_arbitrage_detector(app))
+        print("🚀 Sentinel Arbitrage Engine v11.0 (Multi-Asset) started.")
         yield
-        
         print("⏳ Shutting down engine...")
         arbitrage_task.cancel()
         try: await arbitrage_task
-        except asyncio.CancelledError: print("Engine shut down gracefully.")
+        except asyncio.CancelledError: print("Engine shut down.")
 
-async def run_arbitrage_detector(price_fetcher, analyzer):
-    """The core engine loop. Directly emits events via Socket.IO."""
-    last_opportunity_time = 0
+async def run_arbitrage_detector(app: FastAPI):
     while True:
-        try:
-            await price_fetcher.update_prices_async()
-            prices = price_fetcher.get_current_prices()
-            
+        await app.state.price_fetcher.update_prices_async()
+        all_prices = app.state.price_fetcher.get_all_prices()
+        
+        for asset, prices in all_prices.items():
             pyth_price = prices.get("pyth")
             chainlink_price = prices.get("chainlink_agg")
             
-            if pyth_price and chainlink_price:
+            if pyth_price and chainlink_price and pyth_price > 0:
                 spread = abs(pyth_price - chainlink_price) / chainlink_price
                 if spread > OPPORTUNITY_THRESHOLD:
-                    current_time = time.time()
-                    if current_time - last_opportunity_time > 30: # Throttle Gemini calls
-                        last_opportunity_time = current_time
-                        opportunity = {
-                            "pyth_price": pyth_price, "chainlink_price": chainlink_price, "spread_pct": spread * 100
-                        }
-                        print(f"⚡️ Discrepancy Detected: {opportunity['spread_pct']:.3f}%")
-                        briefing = await analyzer.get_alpha_briefing(opportunity)
-                        if briefing:
-                            signal = {**opportunity, **briefing, "timestamp": datetime.now(timezone.utc).isoformat()}
-                            await sio.emit('new_signal', signal)
-                            print(f"✅ Signal Emitted: {signal['strategy']}")
-        except Exception as e:
-            print(f"❌ ERROR in engine loop: {e}")
+                    opportunity = {
+                        "asset": asset,
+                        "pyth_price": pyth_price, "chainlink_price": chainlink_price,
+                        "spread_pct": spread * 100
+                    }
+                    print(f"⚡️ Dislocation for {asset}: {opportunity['spread_pct']:.3f}%")
+                    briefing = await app.state.arbitrage_analyzer.get_alpha_briefing(asset, opportunity)
+                    if briefing:
+                        signal = {**opportunity, **briefing, "timestamp": datetime.now(timezone.utc).isoformat()}
+                        await signal_broker.queue.put(signal)
 
         await asyncio.sleep(15)
 
-# --- FastAPI App Setup ---
-app = FastAPI(lifespan=lifespan)
-
-@sio.event
-async def connect(sid, environ):
-    print(f"✅ Client connected: {sid}")
+app = FastAPI(title="Sentinel Arbitrage Engine", lifespan=lifespan)
+templates = Jinja2Templates(directory="templates")
 
-@sio.event
-async def disconnect(sid):
-    print(f"🔥 Client disconnected: {sid}")
+def render_signal_card(payload: dict) -> str:
+    s = payload
+    time_str = datetime.fromisoformat(s['timestamp']).strftime('%H:%M:%S UTC')
+    pyth_class = "buy" if s['pyth_price'] < s['chainlink_price'] else "sell"
+    chainlink_class = "sell" if s['pyth_price'] < s['chainlink_price'] else "buy"
+    
+    return f"""
+    <tr hx-swap-oob="afterbegin:#opportunities-table">
+        <td><strong>{s['asset']}/USD</strong></td>
+        <td><span class="{pyth_class}">Pyth Network</span><br>${s['pyth_price']:,.2f}</td>
+        <td><span class="{chainlink_class}">Chainlink Agg.</span><br>${s['chainlink_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('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>
+    """
 
-# Mount the Socket.IO app on a specific path
-app.mount('/socket.io', socket_app)
+@app.get("/", response_class=HTMLResponse)
+async def serve_dashboard(request: Request):
+    return templates.TemplateResponse("index.html", {"request": request})
 
-# Serve the static files (like index.html) from the 'static' directory
-app.mount("/", StaticFiles(directory="static", html=True), name="static")
+@app.get("/api/signals/stream")
+async def signal_stream(request: Request):
+    async def event_generator():
+        while True:
+            payload = await signal_broker.queue.get()
+            html_card = render_signal_card(payload)
+            data_payload = html_card.replace('\n', ' ').strip()
+            yield f"event: message\ndata: {data_payload}\n\n"
+    return StreamingResponse(event_generator(), media_type="text/event-stream")