Update app/main.py

app/main.py

@@ -1,8 +1,8 @@
 """
-Sentinel Arbitrage Engine - v16.0 FINAL (Correct Object Naming)
+Sentinel Arbitrage Engine - v19.0 FINAL (Correct Mounting Architecture)
 
-This is the definitive version with the correct object names to match
-the startup script, ensuring a successful launch.
+This version uses the official, correct architecture for combining FastAPI and
+Socket.IO, resolving the 'mount' attribute error permanently.
 """
 import asyncio
 import os
@@ -16,27 +16,32 @@ import socketio
 from fastapi import FastAPI
 from fastapi.staticfiles import StaticFiles
 
+# --- RELATIVE IMPORTS ---
+# This assumes your project is structured with an 'app' package.
 from .price_fetcher import PriceFetcher
 from .arbitrage_analyzer import ArbitrageAnalyzer
 
 OPPORTUNITY_THRESHOLD = 0.0015
 
-# --- Socket.IO Server Setup ---
+# --- SOCKET.IO SERVER SETUP ---
+# Create the server instance that will handle all real-time communication.
 sio = socketio.AsyncServer(async_mode='asgi', cors_allowed_origins='*')
 
-# --- Background Engine ---
+# --- BACKGROUND ENGINE ---
 async def run_arbitrage_detector(price_fetcher, analyzer):
-    # This logic is correct and does not need to change.
+    """The core engine loop; detects opportunities and emits them via Socket.IO."""
     while True:
         try:
             await price_fetcher.update_prices_async()
             all_prices = price_fetcher.get_all_prices()
             for asset, prices in all_prices.items():
-                pyth_price, chainlink_price = prices.get("pyth"), prices.get("chainlink_agg")
+                pyth_price = prices.get("pyth")
+                chainlink_price = prices.get("chainlink_agg")
                 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()
+                        # Simple throttle to avoid spamming Gemini for the same opportunity
                         if not hasattr(analyzer, 'last_call') or current_time - analyzer.last_call.get(asset, 0) > 60:
                             analyzer.last_call = getattr(analyzer, 'last_call', {})
                             analyzer.last_call[asset] = current_time
@@ -51,37 +56,32 @@ async def run_arbitrage_detector(price_fetcher, analyzer):
             print(f"❌ ERROR in engine loop: {e}")
         await asyncio.sleep(15)
 
-# --- FastAPI Lifespan (for background task) ---
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    print("🚀 Initializing Sentinel Arbitrage Engine v16.0...")
-    async with httpx.AsyncClient() as client:
-        price_fetcher = PriceFetcher(client)
-        arbitrage_analyzer = ArbitrageAnalyzer(client)
+# --- FASTAPI APP & LIFESPAN ---
+# This is the correct way to manage the background task with Socket.IO
+@sio.on('connect')
+async def connect(sid, environ):
+    print(f"✅ Client connected: {sid}")
+    # Start the engine only when the first user connects.
+    if not hasattr(sio, 'background_task') or sio.background_task.done():
+        print("🚀 First client connected. Starting Sentinel Engine...")
+        # Note: We create clients here as they are not easily shared across lifespan contexts
+        price_fetcher = PriceFetcher(httpx.AsyncClient())
+        arbitrage_analyzer = ArbitrageAnalyzer(httpx.AsyncClient())
         sio.background_task = sio.start_background_task(run_arbitrage_detector, price_fetcher, arbitrage_analyzer)
-        print("✅ Engine is online and hunting for opportunities.")
-        yield
-        print("⏳ Shutting down engine...")
-        sio.background_task.cancel()
-        try: await sio.background_task
-        except asyncio.CancelledError: print("Engine shut down gracefully.")
-
-# --- FastAPI App & Socket.IO Mount ---
-# THE FIX: We name the main FastAPI instance 'app' to match the startup script.
-app = FastAPI(lifespan=lifespan)
 
-# The primary app is the Socket.IO server, which wraps our FastAPI app.
-# The startup script should point to THIS object.
-app = socketio.ASGIApp(sio, other_asgi_app=app)
+@sio.on('disconnect')
+def disconnect(sid):
+    print(f"🔥 Client disconnected: {sid}")
 
-# Serve the static files. This route is now handled by the wrapped app.
-sio.mount("/", StaticFiles(directory="static", html=True), name="static")
+# --- FINAL APP ASSEMBLY ---
+# 1. Create the main FastAPI instance.
+app = FastAPI()
 
+# 2. Create the Socket.IO ASGI application.
+socket_app = socketio.ASGIApp(sio)
 
-@sio.event
-async def connect(sid, environ):
-    print(f"✅ Client connected: {sid}")
+# 3. Mount the Socket.IO app onto the FastAPI app at the correct path.
+app.mount("/socket.io", socket_app)
 
-@sio.event
-async def disconnect(sid):
-    print(f"🔥 Client disconnected: {sid}")
+# 4. Mount the StaticFiles directory to serve index.html at the root.
+app.mount("/", StaticFiles(directory="static", html=True), name="static")