Update app/app.py

app/app.py

@@ -1,13 +1,14 @@
 """
-Sentinel TradeFlow Protocol — v3.0 FINAL
+Sentinel Arbitrage Engine - v4.0 FINAL
 
-This is the definitive, robust version of the application, designed for
-guaranteed functionality and a superior user experience.
+High-frequency arbitrage detection and AI-powered risk 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
@@ -15,113 +16,96 @@ from fastapi.responses import HTMLResponse, StreamingResponse
 from fastapi.templating import Jinja2Templates
 
 from .price_fetcher import PriceFetcher
-from .gemini_analyzer import GeminiAnalyzer
-from newsapi import NewsApiClient
+from .arbitrage_analyzer import ArbitrageAnalyzer
+
+OPPORTUNITY_THRESHOLD = 0.003  # 0.3% price difference to trigger a signal
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     async with httpx.AsyncClient() as client:
-        app.state.price_fetcher = PriceFetcher(client=client, coins=["bitcoin", "ethereum", "dogecoin"])
-        app.state.gemini_analyzer = GeminiAnalyzer(client=client)
-        app.state.news_api = NewsApiClient(api_key=os.getenv("NEWS_API_KEY"))
+        app.state.price_fetcher = PriceFetcher(client=client)
+        app.state.arbitrage_analyzer = ArbitrageAnalyzer(client=client)
         app.state.signal_queue: asyncio.Queue = asyncio.Queue()
 
-        price_task = asyncio.create_task(run_periodic_updates(app.state.price_fetcher, 30))
-        news_task = asyncio.create_task(run_periodic_news_analysis(app, 300))
+        arbitrage_task = asyncio.create_task(run_arbitrage_detector(app, 5)) # Run every 5 seconds
         
-        print("🚀 Sentinel TradeFlow Protocol v3.0 FINAL started successfully.")
+        print("🚀 Sentinel Arbitrage Engine started successfully.")
         yield
         
-        print("⏳ Shutting down background tasks...")
-        price_task.cancel()
-        news_task.cancel()
+        print("⏳ Shutting down arbitrage engine...")
+        arbitrage_task.cancel()
         try:
-            await asyncio.gather(price_task, news_task)
+            await arbitrage_task
         except asyncio.CancelledError:
-            print("Background tasks cancelled.")
-
-async def run_periodic_updates(fetcher: PriceFetcher, interval_seconds: int):
-    while True:
-        await fetcher.update_prices_async()
-        await asyncio.sleep(interval_seconds)
+            print("Engine shut down.")
 
-async def run_periodic_news_analysis(app: FastAPI, interval_seconds: int):
-    processed_urls = set()
+async def run_arbitrage_detector(app: FastAPI, interval_seconds: int):
+    last_opportunity = {}
     while True:
-        print("📰 Fetching news...")
-        try:
-            top_headlines = app.state.news_api.get_everything(
-                q='(crypto OR bitcoin OR ethereum) AND (regulation OR partnership OR hack OR update OR adoption)',
-                language='en', sort_by='publishedAt', page_size=10
-            )
-            articles = top_headlines.get('articles', [])
-            print(f"📰 Found {len(articles)} articles.")
+        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
             
-            analyzer: GeminiAnalyzer = app.state.gemini_analyzer
-            for article in reversed(articles):
-                title = article.get('title')
-                url = article.get('url')
-                if title and "[Removed]" not in title and url not in processed_urls:
-                    print(f"✨ Analyzing: '{title}'")
-                    analysis = await analyzer.analyze_text(title)
-                    if not analysis.get("error"):
-                        analysis['url'] = url
-                        analysis['timestamp'] = datetime.now(timezone.utc).isoformat()
-                        await app.state.signal_queue.put(analysis)
-                        processed_urls.add(url)
-                        print(f"✅ Queued: '{title}'")
-        except Exception as e:
-            print(f"❌ CRITICAL ERROR in news loop: {e}")
+        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]
+        
+        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")
+                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)
 
-app = FastAPI(title="Sentinel TradeFlow Protocol", lifespan=lifespan)
+app = FastAPI(title="Sentinel Arbitrage Engine", lifespan=lifespan)
 templates = Jinja2Templates(directory="templates")
 
 def render_signal_card(payload: dict) -> str:
     s = payload
-    url = s.get('url', '#')
-    summary = s.get('summary', 'N/A')
     time_str = datetime.fromisoformat(s['timestamp']).strftime('%H:%M:%S UTC')
-    
-    # This entire block will be sent as a single data payload
+
     return f"""
-    <div id="last-signal-time" hx-swap-oob="true">{time_str}</div>
-    <div class="card impact-{s.get('impact', 'low').lower()}" hx-swap-oob="afterbegin:#signal-container">
-        <header class="card-header">
-            <span>{s.get('topic', 'General News')}</span>
-            <span>{', '.join(s.get('entities', []))}</span>
-        </header>
-        <blockquote><a href="{url}" target="_blank" rel="noopener noreferrer">{summary}</a></blockquote>
-        <footer><strong>Sentiment:</strong> <span class="sentiment-{s.get('sentiment', 'neutral').lower()}">{s.get('sentiment')} ({s.get('sentiment_score', 0):.2f})</span> • <strong>Impact:</strong> {s.get('impact')}</footer>
-    </div>
+    <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>
+        <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>
+    </tr>
+    <div id="last-update-time" hx-swap-oob="true">{time_str}</div>
     """
 
 @app.get("/", response_class=HTMLResponse)
 async def serve_dashboard(request: Request):
     return templates.TemplateResponse("index.html", {"request": request})
 
-@app.get("/api/prices", response_class=HTMLResponse)
-async def get_prices_fragment(request: Request):
-    prices = request.app.state.price_fetcher.get_current_prices()
-    return HTMLResponse("".join(
-        f"<span>{c.capitalize()}: <strong>${p:,.2f}</strong></span>" if isinstance(p, (int, float))
-        else f"<span>{c.capitalize()}: <strong>{p}</strong></span>"
-        for c, p in prices.items()
-    ))
-
 @app.get("/api/signals/stream")
 async def signal_stream(request: Request):
     queue: asyncio.Queue = request.app.state.signal_queue
     async def event_generator():
-        # --- THE GUARANTEED "HELLO" MESSAGE ---
-        welcome_html = "<div id='signal-container' hx-swap-oob='innerHTML'></div>"
-        yield f"event: message\ndata: {welcome_html}\n\n"
-        
         while True:
             payload = await 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")