Smart contract integration + UI polish

.github/workflows/backend-tests.yml

@@ -53,6 +53,7 @@ jobs:
     - name: Test
       env:
         DATABASE_URL: postgresql+asyncpg://postgres:postgres@localhost:5432/test_db
+        PERPLEXITY_API_KEY: ${{ secrets.PERPLEXITY_API_KEY }}
       run: pytest -v --cov=app --cov-report=xml
 
     - name: Upload coverage

backend/app/agents/scheduler.py

@@ -658,6 +658,8 @@ async def _update_tournament_rankings_async() -> Dict[str, Any]:
         }
 
 
+
+
 # ============================================================================
 # CRASH RECOVERY TASKS
 # ============================================================================

backend/app/api/deps.py

@@ -5,26 +5,26 @@
 SECRET_KEY = os.getenv("SECRET_KEY", "dev-secret-key")
 ALGORITHM = "HS256"
 
-def get_current_user(authorization: str = Header(...)) -> dict:
+def get_current_user(authorization: str = Header(None)) -> dict:
     """Verify JWT token"""
-    if not authorization.startswith("Bearer "):
-        raise HTTPException(401, "Invalid authorization header")
-    
+    if not authorization or not authorization.startswith("Bearer "):
+        raise HTTPException(401, "Missing or invalid authorization header")
+
     token = authorization.split(" ")[1]
-    
+
     try:
         payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
         user_address: str = payload.get("sub")
         role: str = payload.get("role")
-        
+
         if user_address is None:
             raise HTTPException(401, "Invalid token")
-            
+
         return {"address": user_address, "role": role}
     except JWTError:
         raise HTTPException(401, "Invalid token")
 
 def require_admin(user: dict = Depends(get_current_user)) -> dict:
     if user.get("role") != "admin":
         raise HTTPException(403, "Admin access required")
-    return user
+    return user

backend/app/api/main.py

@@ -4,10 +4,9 @@
 try:
     from .routers import tournament, agent, agent_state, trade, bet, auth, market_data
 except ImportError:
-    from routers import tournament, agent, agent_state, trade, bet, auth, market_data
+    from app.api.routers import tournament, agent, agent_state, trade, bet, auth, market_data
 from os import getenv
 import uvicorn
-from contextlib import asynccontextmanager
 
 
 APPLICATION_PORT = 8000
@@ -26,7 +25,7 @@
     allow_headers=["*"],  # Allow all headers
 )
 
-# Register routers
+# Register Routers
 app.include_router(tournament.router, prefix="/tournaments", tags=["Tournaments"])
 app.include_router(agent.router, prefix="/agents", tags=["Agents"])
 app.include_router(agent_state.router, prefix="/agent-states", tags=["Agent States"])
@@ -38,7 +37,7 @@
 
 @app.get("/")
 def root():
-    return {"message": "Agonus API running 🚀"}
+    return {"message": "Agonus API running"}
 
 
 if __name__ == "__main__":

backend/app/api/routers/agent.py

@@ -36,7 +36,6 @@ async def get_agent_stats(agent_id: UUID, session: AsyncSession = Depends(get_db
     if not agent:
         raise HTTPException(status_code=404, detail="Agent Not Found")
 
-    # Return the stats JSON field
     return agent.stats
 
 
@@ -47,14 +46,12 @@ async def create_agent(
     admin: dict = Depends(require_admin),
 ):
     """POST route for creating a new agent (admin only)"""
-    # Create Agent model from schema, excluding None values to use model defaults
     agent_dict = agent_data.model_dump(exclude_none=True)
 
-    # Ensure stats and memory have default values if not provided
-    if 'stats' not in agent_dict:
-        agent_dict['stats'] = {}
-    if 'memory' not in agent_dict:
-        agent_dict['memory'] = {}
+    if "stats" not in agent_dict:
+        agent_dict["stats"] = {}
+    if "memory" not in agent_dict:
+        agent_dict["memory"] = {}
 
     agent = Agent(**agent_dict)
 
@@ -76,7 +73,6 @@ async def update_agent(
     if not db_agent:
         raise HTTPException(status_code=404, detail="Agent Not Found")
 
-    # Update only provided fields
     update_data = agent_data.model_dump(exclude_unset=True)
 
     for key, value in update_data.items():
@@ -101,7 +97,6 @@ async def update_agent_stats(
     if not agent:
         raise HTTPException(status_code=404, detail="Agent Not Found")
 
-    # Merge new stats with existing stats
     agent.stats = {**agent.stats, **stats}
 
     session.add(agent)
@@ -123,7 +118,6 @@ async def update_agent_memory(
     if not agent:
         raise HTTPException(status_code=404, detail="Agent Not Found")
 
-    # Merge new memory with existing memory
     agent.memory = {**agent.memory, **memory}
 
     session.add(agent)
@@ -139,15 +133,12 @@ async def delete_agent(
     session: AsyncSession = Depends(get_db),
     admin: dict = Depends(require_admin),
 ):
-    """DELETE route for deleting an agent (admin only - use with caution)"""
+    """DELETE route for deleting an agent (admin only)"""
     agent = await session.get(Agent, agent_id)
     if not agent:
         raise HTTPException(status_code=404, detail="Agent Not Found")
 
-    # Note: This will fail if agent has related trades/bets due to foreign keys
-    # Consider soft delete instead (add 'active' boolean field)
     await session.delete(agent)
     await session.commit()
 
     return {"message": f"Agent {agent_id} deleted successfully"}
-

backend/app/api/routers/auth.py

@@ -11,37 +11,56 @@
 SECRET_KEY = os.getenv("SECRET_KEY", "dev-secret-key")
 ALGORITHM = "HS256"
 
+# Load admin addresses from env
 raw_addresses = os.getenv("ADMIN_ADDRESSES", "")
-ADMIN_ADDRESSES = set(addr.strip().lower() for addr in raw_addresses.split(",") if addr.strip())
+ADMIN_ADDRESSES = {
+    addr.strip().lower() for addr in raw_addresses.split(",") if addr.strip()
+}
+
 
 class WalletSignIn(BaseModel):
     address: str
     signature: str
 
-@router.post("/wallet")  # Changed from /wallet-signin
+
+@router.post("/wallet")
 def wallet_auth(data: WalletSignIn) -> dict:
-    """Sign in with wallet and return JWT"""
-
+    """
+    Verify wallet signature and return JWT.
+    Used for login on the frontend.
+    """
+
     # Verify signature
     message = "Sign in to Agonus"
+
     try:
         w3 = Web3()
         encoded_message = encode_defunct(text=message)
-        recovered_address = w3.eth.account.recover_message(encoded_message, signature=data.signature)
-
+
+        recovered_address = w3.eth.account.recover_message(
+            encoded_message, signature=data.signature
+        )
+
         if recovered_address.lower() != data.address.lower():
-            raise HTTPException(401, "Invalid signature")
+            raise HTTPException(status_code=401, detail="Invalid signature")
+
     except Exception as e:
-        raise HTTPException(401, f"Signature verification failed: {str(e)}")
-    
-    # Check role and issue JWT
+        raise HTTPException(status_code=401, detail=f"Signature verification failed: {str(e)}")
+
+    # Determine role
     role = "admin" if data.address.lower() in ADMIN_ADDRESSES else "user"
-
+    print(f"[AUTH] Wallet: {data.address.lower()}, ADMIN_ADDRESSES: {ADMIN_ADDRESSES}, Role: {role}")
+
+    # Generate JWT
     expire = datetime.utcnow() + timedelta(hours=24)
     token = jwt.encode(
-        {"sub": data.address.lower(), "role": role, "exp": expire},
+        {
+            "sub": data.address.lower(),
+            "role": role,
+            "exp": expire,
+        },
         SECRET_KEY,
-        algorithm=ALGORITHM
+        algorithm=ALGORITHM,
     )
-    
+
     return {"access_token": token, "token_type": "bearer"}

backend/app/api/routers/bet.py

@@ -1,4 +1,5 @@
 from fastapi import APIRouter, Depends, HTTPException
+from datetime import timezone
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import select
 from uuid import UUID
@@ -20,10 +21,11 @@ async def list_bets(session: AsyncSession = Depends(get_db)):
     return bets
 
 
-# IMPORTANT: This route must come BEFORE /{bet_id} to avoid path conflicts
+# IMPORTANT: This route must come BEFORE /{bet_id}
 @router.get("/my-bets", response_model=list[BetResponse])
 async def get_user_bets(
-    session: AsyncSession = Depends(get_db), user: dict = Depends(get_current_user)
+    session: AsyncSession = Depends(get_db),
+    user: dict = Depends(get_current_user)
 ):
     """GET route for current user's bets"""
     statement = select(Bet).where(Bet.user_address == user["address"])
@@ -48,11 +50,14 @@ async def create_bet(
     user: dict = Depends(get_current_user),
 ):
     """POST route for creating a new bet"""
-    # Override user_address with authenticated user's address
-    bet_dict = bet_data.model_dump()
-    bet_dict["user_address"] = user[
-        "address"
-    ]  # Ensure user can only bet for themselves
+    bet_dict = bet_data.model_dump(exclude_unset=True)
+    bet_dict["user_address"] = user["address"]  # Force bet ownership
+
+    # Remove fields not in the database model
+    bet_dict.pop("tx_hash", None)
+    # Store naive UTC if DB column is TIMESTAMP WITHOUT TIME ZONE
+    if "placed_at" in bet_dict and bet_dict["placed_at"] is not None:
+        bet_dict["placed_at"] = bet_dict["placed_at"].replace(tzinfo=None)
 
     bet = Bet(**bet_dict)
 
@@ -64,9 +69,11 @@ async def create_bet(
 
 @router.patch("/{bet_id}/settle", response_model=BetResponse)
 async def settle_bet(
-    bet_id: UUID, payout: float, session: AsyncSession = Depends(get_db)
+    bet_id: UUID,
+    payout: float,
+    session: AsyncSession = Depends(get_db),
 ):
-    """PATCH route for settling a bet (admin/system use)"""
+    """PATCH route for settling a bet"""
     bet = await session.get(Bet, bet_id)
     if not bet:
         raise HTTPException(status_code=404, detail="Bet Not Found")
@@ -80,20 +87,20 @@ async def settle_bet(
     session.add(bet)
     await session.commit()
     await session.refresh(bet)
-
     return bet
 
 
 @router.put("/{bet_id}", response_model=BetResponse)
 async def update_bet(
-    bet_id: UUID, bet_data: BetUpdate, session: AsyncSession = Depends(get_db)
+    bet_id: UUID,
+    bet_data: BetUpdate,
+    session: AsyncSession = Depends(get_db),
 ):
-    """PUT route for updating a bet (typically only for settling)"""
+    """PUT route for updating a bet"""
     db_bet = await session.get(Bet, bet_id)
     if not db_bet:
         raise HTTPException(status_code=404, detail="Bet Not Found")
 
-    # Update only provided fields
     update_data = bet_data.model_dump(exclude_unset=True)
 
     for key, value in update_data.items():
@@ -102,13 +109,12 @@ async def update_bet(
     session.add(db_bet)
     await session.commit()
     await session.refresh(db_bet)
-
     return db_bet
 
 
 @router.delete("/{bet_id}")
 async def delete_bet(bet_id: UUID, session: AsyncSession = Depends(get_db)):
-    """DELETE route for deleting a bet (use with caution - breaks audit trail)"""
+    """DELETE route for deleting a bet"""
     bet = await session.get(Bet, bet_id)
     if not bet:
         raise HTTPException(status_code=404, detail="Bet Not Found")

backend/app/api/routers/market_data.py

@@ -2,7 +2,8 @@
 import requests
 from typing import Optional
 
-router = APIRouter()
+# Add correct prefix + tag so API documentation is clean
+router = APIRouter(prefix="/market-data", tags=["Market Data"])
 
 
 @router.get("/prices")
@@ -15,13 +16,11 @@ async def get_market_prices(
 ):
     """GET route for live cryptocurrency prices from CoinGecko API"""
     try:
-        # Clean up token list
         token_list = [t.strip() for t in tokens.split(",") if t.strip()]
 
         if not token_list:
             raise HTTPException(status_code=400, detail="No tokens specified")
 
-        # Call CoinGecko API
         url = "https://api.coingecko.com/api/v3/simple/price"
         params = {
             "ids": ",".join(token_list),
@@ -36,7 +35,6 @@ async def get_market_prices(
 
         data = response.json()
 
-        # Transform response to be more frontend-friendly
         result = {}
         for token_id in token_list:
             if token_id in data:
@@ -73,7 +71,6 @@ async def get_single_price(
 ):
     """GET route for a single token's current price"""
     try:
-        # Call CoinGecko API
         url = "https://api.coingecko.com/api/v3/simple/price"
         params = {
             "ids": token.lower(),