Add Market feature with manual trading and P&L tracking, rename Live Trading to Trading Bot

live_trading.py

@@ -160,24 +160,40 @@ def get_portfolio_value():
 
 
 def get_recent_trades_from_db(user_email: str, limit: int = 20) -> List[dict]:
-    """Get recent trades from database"""
+    """Get recent trades from database - only bot trades (excludes manual trades)"""
     try:
         with Session(engine) as session:
+            # Filter out manual trades by excluding session_ids starting with "manual_"
             statement = select(Trade).where(
-                Trade.user_email == user_email
+                Trade.user_email == user_email,
+                ~Trade.session_id.startswith("manual_")
             ).order_by(Trade.executed_at.desc()).limit(limit)
             trades = session.exec(statement).all()
             
-            return [{
-                'symbol': t.symbol,
-                'side': t.side,
-                'price': t.price,
-                'quantity': t.quantity,
-                'total': t.total,
-                'pnl': t.pnl,
-                'time': t.executed_at.isoformat()
-            } for t in trades]
+            result = []
+            for t in trades:
+                trade_dict = {
+                    'symbol': t.symbol,
+                    'side': t.side,
+                    'price': t.price,
+                    'quantity': t.quantity,
+                    'total': t.total,
+                    'pnl': t.pnl,
+                    'time': t.executed_at.isoformat()
+                }
+                
+                # Calculate pnl_percent for SELL trades
+                if t.side == "SELL" and t.pnl is not None and t.total > 0:
+                    # PnL percent = (pnl / cost_basis) * 100
+                    cost_basis = t.total - t.pnl
+                    if cost_basis > 0:
+                        trade_dict['pnl_percent'] = (t.pnl / cost_basis) * 100
+                
+                result.append(trade_dict)
+            
+            return result
     except Exception as e:
+        print(f"Error getting bot trades: {e}")
         return []
 
 

main.py

@@ -428,4 +428,202 @@ def get_simulated_session(session_id: str, current_user: str = Depends(get_curre
     status = get_simulated_session_status(session_id)
     if "error" in status:
         raise HTTPException(status_code=404, detail=status["error"])
-    return status
+    return status
+
+
+# --- MANUAL TRADING ROUTES (Market Page) ---
+
+class ManualBuyRequest(BaseModel):
+    symbol: str  # e.g., 'BTC', 'ETH'
+    usdt_amount: float  # Amount in USDT to spend
+
+class ManualSellRequest(BaseModel):
+    symbol: str  # e.g., 'BTC', 'ETH'
+    quantity: float  # Amount of asset to sell
+
+class ManualSellPercentRequest(BaseModel):
+    symbol: str  # e.g., 'BTC', 'ETH'
+    percentage: float  # Percentage of holdings to sell (0-100)
+
+
+@app.post("/api/market/buy")
+def manual_buy(req: ManualBuyRequest, current_user: str = Depends(get_current_user)):
+    """
+    Execute a manual buy order from the Market page.
+    This is independent from automated trading bot strategies.
+    Updates portfolio and creates trade log entry.
+    """
+    from manual_trading import execute_manual_buy
+    from database import initialize_portfolio_if_empty
+    
+    # Ensure user has portfolio initialized
+    initialize_portfolio_if_empty(user_email=current_user)
+    
+    # Validate input
+    if req.usdt_amount <= 0:
+        raise HTTPException(status_code=400, detail="Amount must be positive")
+    
+    if req.usdt_amount < 1:
+        raise HTTPException(status_code=400, detail="Minimum buy amount is 1 USDT")
+    
+    success, trade_info, error = execute_manual_buy(
+        symbol=req.symbol,
+        usdt_amount=req.usdt_amount,
+        user_email=current_user
+    )
+    
+    if not success:
+        raise HTTPException(status_code=400, detail=error)
+    
+    return {
+        "success": True,
+        "message": f"Successfully bought {trade_info['quantity']:.8f} {req.symbol}",
+        "trade": trade_info
+    }
+
+
+@app.post("/api/market/sell")
+def manual_sell(req: ManualSellRequest, current_user: str = Depends(get_current_user)):
+    """
+    Execute a manual sell order from the Market page.
+    This is independent from automated trading bot strategies.
+    Updates portfolio and creates trade log entry.
+    """
+    from manual_trading import execute_manual_sell
+    from database import initialize_portfolio_if_empty
+    
+    # Ensure user has portfolio initialized
+    initialize_portfolio_if_empty(user_email=current_user)
+    
+    # Validate input
+    if req.quantity <= 0:
+        raise HTTPException(status_code=400, detail="Quantity must be positive")
+    
+    success, trade_info, error = execute_manual_sell(
+        symbol=req.symbol,
+        quantity=req.quantity,
+        user_email=current_user
+    )
+    
+    if not success:
+        raise HTTPException(status_code=400, detail=error)
+    
+    return {
+        "success": True,
+        "message": f"Successfully sold {trade_info['quantity']:.8f} {req.symbol}",
+        "trade": trade_info
+    }
+
+
+@app.post("/api/market/sell-percent")
+def manual_sell_percent(req: ManualSellPercentRequest, current_user: str = Depends(get_current_user)):
+    """
+    Sell a percentage of holdings for a specific asset.
+    Useful for quick "Sell 25%", "Sell 50%", "Sell All" actions.
+    """
+    from manual_trading import execute_manual_sell, get_user_balance
+    from database import initialize_portfolio_if_empty
+    
+    # Ensure user has portfolio initialized
+    initialize_portfolio_if_empty(user_email=current_user)
+    
+    # Validate percentage
+    if req.percentage <= 0 or req.percentage > 100:
+        raise HTTPException(status_code=400, detail="Percentage must be between 0 and 100")
+    
+    # Get current balance
+    balance = get_user_balance(req.symbol.upper(), current_user)
+    if balance <= 0:
+        raise HTTPException(status_code=400, detail=f"No {req.symbol} holdings to sell")
+    
+    # Calculate quantity to sell
+    quantity_to_sell = balance * (req.percentage / 100)
+    
+    success, trade_info, error = execute_manual_sell(
+        symbol=req.symbol,
+        quantity=quantity_to_sell,
+        user_email=current_user
+    )
+    
+    if not success:
+        raise HTTPException(status_code=400, detail=error)
+    
+    return {
+        "success": True,
+        "message": f"Successfully sold {req.percentage}% ({trade_info['quantity']:.8f}) {req.symbol}",
+        "trade": trade_info
+    }
+
+
+@app.get("/api/market/trades")
+def get_manual_trades(limit: int = 50, current_user: str = Depends(get_current_user)):
+    """Get manual trade history for the current user"""
+    from manual_trading import get_manual_trade_history
+    
+    trades = get_manual_trade_history(current_user, limit)
+    return {"trades": trades}
+
+
+@app.get("/api/market/prices")
+def get_market_prices(current_user: str = Depends(get_current_user)):
+    """
+    Get current prices for all supported assets.
+    Useful for initial page load before WebSocket connects.
+    """
+    from manual_trading import get_prices_for_assets
+    
+    prices = get_prices_for_assets()
+    return {"prices": prices}
+
+
+@app.get("/api/market/assets")
+def get_supported_assets(current_user: str = Depends(get_current_user)):
+    """Get list of supported assets for manual trading"""
+    from manual_trading import SUPPORTED_ASSETS
+    
+    assets = [
+        {"symbol": "BTC", "name": "Bitcoin", "logo": "₿", "color": "#F7931A"},
+        {"symbol": "ETH", "name": "Ethereum", "logo": "Ξ", "color": "#627EEA"},
+        {"symbol": "SOL", "name": "Solana", "logo": "◎", "color": "#14F195"},
+        {"symbol": "LINK", "name": "Chainlink", "logo": "⬡", "color": "#2A5ADA"},
+        {"symbol": "DOGE", "name": "Dogecoin", "logo": "Ð", "color": "#C2A633"},
+        {"symbol": "BNB", "name": "BNB", "logo": "⬡", "color": "#F3BA2F"},
+    ]
+    
+    return {"assets": [a for a in assets if a["symbol"] in SUPPORTED_ASSETS]}
+
+
+@app.get("/api/market/cost-basis/{symbol}")
+def get_cost_basis(symbol: str, current_user: str = Depends(get_current_user)):
+    """
+    Get the average cost basis and investment info for a specific asset.
+    Used to show estimated PnL before selling.
+    """
+    from manual_trading import get_asset_cost_basis, get_current_price_from_binance, TRADING_FEE
+    
+    cost_info = get_asset_cost_basis(symbol.upper(), current_user)
+    
+    # Get current price to calculate unrealized PnL
+    current_price = get_current_price_from_binance(symbol.upper(), "USDT")
+    
+    if current_price and cost_info['balance'] > 0:
+        current_value = current_price * cost_info['balance']
+        fee_estimate = current_value * TRADING_FEE
+        net_value = current_value - fee_estimate
+        unrealized_pnl = net_value - cost_info['total_invested']
+        unrealized_pnl_percent = ((net_value / cost_info['total_invested']) - 1) * 100 if cost_info['total_invested'] > 0 else 0.0
+    else:
+        current_value = 0.0
+        unrealized_pnl = 0.0
+        unrealized_pnl_percent = 0.0
+    
+    return {
+        "symbol": symbol.upper(),
+        "balance": cost_info['balance'],
+        "avg_cost_basis": cost_info['avg_cost_basis'],
+        "total_invested": cost_info['total_invested'],
+        "current_price": current_price,
+        "current_value": current_value,
+        "unrealized_pnl": unrealized_pnl,
+        "unrealized_pnl_percent": unrealized_pnl_percent
+    }

manual_trading.py

@@ -0,0 +1,593 @@
+"""
+Manual Trading Service
+Handles manual buy/sell operations for the Market page
+Operates independently from automated trading bot strategies
+"""
+from typing import Optional, Tuple, List
+from datetime import datetime
+from sqlmodel import Session, select
+from database import engine
+from models import PortfolioAsset, Trade
+import uuid
+
+# Trading fee (0.1% as typical exchange fee)
+TRADING_FEE = 0.001
+
+# Supported trading pairs for manual trading
+SUPPORTED_ASSETS = ["BTC", "ETH", "SOL", "LINK", "DOGE", "BNB"]
+
+
+def get_current_price_from_binance(symbol: str, quote: str = "USDT") -> Optional[float]:
+    """
+    Fetch current market price from Binance API
+    
+    Args:
+        symbol: Base asset (e.g., 'BTC', 'ETH')
+        quote: Quote asset (e.g., 'USDT')
+    
+    Returns:
+        Current price or None if error
+    """
+    try:
+        from binance.client import Client
+        import os
+        from dotenv import load_dotenv
+        
+        load_dotenv()
+        
+        api_key = os.getenv("BINANCE_API_KEY", "")
+        api_secret = os.getenv("BINANCE_SECRET_KEY", "")
+        
+        client = Client(api_key, api_secret, testnet=True)
+        trading_pair = f"{symbol}{quote}"
+        ticker = client.get_symbol_ticker(symbol=trading_pair)
+        return float(ticker['price'])
+    except Exception as e:
+        print(f"[ManualTrading] Binance fetch failed for {symbol}/{quote}: {e}")
+        
+        # Fallback to Yahoo Finance
+        try:
+            import yfinance as yf
+            ticker_symbol = f"{symbol}-USD"
+            ticker = yf.Ticker(ticker_symbol)
+            price_data = ticker.history(period="1d", interval="1m")
+            
+            if not price_data.empty:
+                return float(price_data['Close'].iloc[-1])
+            return None
+        except Exception as yf_error:
+            print(f"[ManualTrading] Yahoo Finance fallback failed: {yf_error}")
+            return None
+
+
+def get_user_balance(symbol: str, user_email: str) -> float:
+    """
+    Get current balance of an asset from user's portfolio
+    
+    Args:
+        symbol: Asset symbol (e.g., 'USDT', 'BTC')
+        user_email: User identifier
+    
+    Returns:
+        Current balance (0.0 if asset not found)
+    """
+    with Session(engine) as session:
+        statement = select(PortfolioAsset).where(
+            PortfolioAsset.symbol == symbol,
+            PortfolioAsset.user_email == user_email
+        )
+        asset = session.exec(statement).first()
+        return asset.balance if asset else 0.0
+
+
+def get_asset_cost_basis(symbol: str, user_email: str) -> dict:
+    """
+    Get the average cost basis and investment info for an asset
+    
+    Args:
+        symbol: Asset symbol (e.g., 'BTC', 'ETH')
+        user_email: User identifier
+    
+    Returns:
+        Dict with avg_cost_basis, total_invested, and balance
+    """
+    with Session(engine) as session:
+        statement = select(PortfolioAsset).where(
+            PortfolioAsset.symbol == symbol,
+            PortfolioAsset.user_email == user_email
+        )
+        asset = session.exec(statement).first()
+        
+        if asset:
+            return {
+                'symbol': symbol,
+                'balance': asset.balance,
+                'avg_cost_basis': getattr(asset, 'avg_cost_basis', 0.0) or 0.0,
+                'total_invested': getattr(asset, 'total_invested', 0.0) or 0.0
+            }
+        return {
+            'symbol': symbol,
+            'balance': 0.0,
+            'avg_cost_basis': 0.0,
+            'total_invested': 0.0
+        }
+
+
+def record_trade(
+    session: Session,
+    user_email: str,
+    symbol: str,
+    side: str,
+    price: float,
+    quantity: float,
+    total: float,
+    fee: float = 0.0,
+    pnl: Optional[float] = None
+) -> Trade:
+    """
+    Record a trade in the database
+    
+    Args:
+        session: Database session
+        user_email: User identifier
+        symbol: Trading pair (e.g., 'BTCUSDT')
+        side: 'BUY' or 'SELL'
+        price: Execution price
+        quantity: Amount traded
+        total: Total value in quote currency
+        fee: Trading fee
+        pnl: Profit/Loss (for SELL trades)
+    
+    Returns:
+        Created Trade object
+    """
+    trade = Trade(
+        session_id=f"manual_{uuid.uuid4().hex[:8]}",
+        user_email=user_email,
+        symbol=symbol,
+        side=side,
+        price=price,
+        quantity=quantity,
+        total=total,
+        pnl=pnl,
+        order_id=f"MANUAL_{uuid.uuid4().hex[:12].upper()}",
+        executed_at=datetime.now()
+    )
+    session.add(trade)
+    return trade
+
+
+def execute_manual_buy(
+    symbol: str,
+    usdt_amount: float,
+    user_email: str,
+    current_price: Optional[float] = None
+) -> Tuple[bool, Optional[dict], Optional[str]]:
+    """
+    Execute a manual BUY order
+    
+    Args:
+        symbol: Asset to buy (e.g., 'BTC', 'ETH')
+        usdt_amount: Amount in USDT to spend
+        user_email: User identifier
+        current_price: Optional price (fetched if not provided)
+    
+    Returns:
+        Tuple of (success: bool, trade_info: dict or None, error_message: str or None)
+    """
+    # Validate symbol
+    if symbol.upper() not in SUPPORTED_ASSETS:
+        return False, None, f"Asset {symbol} is not supported for manual trading"
+    
+    symbol = symbol.upper()
+    
+    # Get current market price if not provided
+    price = current_price or get_current_price_from_binance(symbol, "USDT")
+    if price is None:
+        return False, None, f"Could not fetch price for {symbol}/USDT"
+    
+    # Calculate quantity to buy and fees
+    fee = usdt_amount * TRADING_FEE
+    usdt_after_fee = usdt_amount - fee
+    quantity_to_buy = usdt_after_fee / price
+    
+    # Check if user has enough USDT
+    usdt_balance = get_user_balance("USDT", user_email)
+    
+    if usdt_balance < usdt_amount:
+        return False, None, f"Insufficient USDT balance. Required: {usdt_amount:.2f}, Available: {usdt_balance:.2f}"
+    
+    # Execute trade in database transaction
+    try:
+        with Session(engine) as session:
+            # Deduct USDT
+            usdt_stmt = select(PortfolioAsset).where(
+                PortfolioAsset.symbol == "USDT",
+                PortfolioAsset.user_email == user_email
+            )
+            usdt_asset = session.exec(usdt_stmt).first()
+            usdt_asset.balance -= usdt_amount
+            session.add(usdt_asset)
+            
+            # Add purchased asset and update cost basis
+            asset_stmt = select(PortfolioAsset).where(
+                PortfolioAsset.symbol == symbol,
+                PortfolioAsset.user_email == user_email
+            )
+            asset = session.exec(asset_stmt).first()
+            
+            if asset:
+                # Calculate new weighted average cost basis
+                old_balance = asset.balance
+                old_total_invested = getattr(asset, 'total_invested', 0.0) or 0.0
+                new_total_invested = old_total_invested + usdt_amount
+                new_balance = old_balance + quantity_to_buy
+                
+                # Weighted average: (old_invested + new_invested) / new_total_quantity
+                asset.avg_cost_basis = new_total_invested / new_balance if new_balance > 0 else 0.0
+                asset.total_invested = new_total_invested
+                asset.balance = new_balance
+                session.add(asset)
+            else:
+                new_asset = PortfolioAsset(
+                    symbol=symbol,
+                    balance=quantity_to_buy,
+                    user_email=user_email,
+                    avg_cost_basis=usdt_amount / quantity_to_buy if quantity_to_buy > 0 else 0.0,
+                    total_invested=usdt_amount
+                )
+                session.add(new_asset)
+                asset = new_asset
+            
+            # Record the trade
+            trade = record_trade(
+                session=session,
+                user_email=user_email,
+                symbol=f"{symbol}USDT",
+                side="BUY",
+                price=price,
+                quantity=quantity_to_buy,
+                total=usdt_amount,
+                fee=fee
+            )
+            
+            session.commit()
+            
+            trade_info = {
+                'order_id': trade.order_id,
+                'symbol': f"{symbol}USDT",
+                'side': 'BUY',
+                'price': price,
+                'quantity': quantity_to_buy,
+                'usdt_spent': usdt_amount,
+                'fee': fee,
+                'net_quantity': quantity_to_buy,
+                'executed_at': trade.executed_at.isoformat(),
+                'new_balance': {
+                    'USDT': usdt_asset.balance,
+                    symbol: asset.balance if asset else quantity_to_buy
+                }
+            }
+            
+            print(f"[ManualTrading] ✅ BUY executed: {quantity_to_buy:.8f} {symbol} @ ${price:.2f}")
+            print(f"  Spent: ${usdt_amount:.2f} USDT (Fee: ${fee:.4f})")
+            
+            return True, trade_info, None
+            
+    except Exception as e:
+        print(f"[ManualTrading] ❌ BUY transaction failed: {e}")
+        return False, None, f"Transaction failed: {str(e)}"
+
+
+def execute_manual_sell(
+    symbol: str,
+    quantity: float,
+    user_email: str,
+    current_price: Optional[float] = None
+) -> Tuple[bool, Optional[dict], Optional[str]]:
+    """
+    Execute a manual SELL order
+    
+    Args:
+        symbol: Asset to sell (e.g., 'BTC', 'ETH')
+        quantity: Amount of asset to sell
+        user_email: User identifier
+        current_price: Optional price (fetched if not provided)
+    
+    Returns:
+        Tuple of (success: bool, trade_info: dict or None, error_message: str or None)
+    """
+    # Validate symbol
+    if symbol.upper() not in SUPPORTED_ASSETS:
+        return False, None, f"Asset {symbol} is not supported for manual trading"
+    
+    symbol = symbol.upper()
+    
+    # Get current market price if not provided
+    price = current_price or get_current_price_from_binance(symbol, "USDT")
+    if price is None:
+        return False, None, f"Could not fetch price for {symbol}/USDT"
+    
+    # Check if user has enough of the asset to sell
+    asset_balance = get_user_balance(symbol, user_email)
+    
+    if asset_balance < quantity:
+        return False, None, f"Insufficient {symbol} balance. Required: {quantity:.8f}, Available: {asset_balance:.8f}"
+    
+    # Calculate proceeds after fee
+    gross_proceeds = price * quantity
+    fee = gross_proceeds * TRADING_FEE
+    net_proceeds = gross_proceeds - fee
+    
+    # Execute trade in database transaction
+    try:
+        with Session(engine) as session:
+            # Deduct sold asset and calculate PnL
+            asset_stmt = select(PortfolioAsset).where(
+                PortfolioAsset.symbol == symbol,
+                PortfolioAsset.user_email == user_email
+            )
+            asset = session.exec(asset_stmt).first()
+            
+            # Calculate PnL based on cost basis
+            avg_cost_basis = getattr(asset, 'avg_cost_basis', 0.0) or 0.0
+            total_invested = getattr(asset, 'total_invested', 0.0) or 0.0
+            
+            # Cost of the sold portion
+            cost_of_sold = avg_cost_basis * quantity
+            # PnL = What we received - What we paid (including fees)
+            pnl = net_proceeds - cost_of_sold
+            pnl_percent = ((net_proceeds / cost_of_sold) - 1) * 100 if cost_of_sold > 0 else 0.0
+            
+            # Update asset balance and total invested
+            old_balance = asset.balance
+            new_balance = old_balance - quantity
+            
+            # Proportionally reduce total invested
+            if old_balance > 0:
+                proportion_sold = quantity / old_balance
+                invested_sold = total_invested * proportion_sold
+                asset.total_invested = total_invested - invested_sold
+            else:
+                asset.total_invested = 0.0
+            
+            asset.balance = new_balance
+            # Keep avg_cost_basis the same (it's still relevant for remaining holdings)
+            session.add(asset)
+            
+            # Add USDT proceeds
+            usdt_stmt = select(PortfolioAsset).where(
+                PortfolioAsset.symbol == "USDT",
+                PortfolioAsset.user_email == user_email
+            )
+            usdt_asset = session.exec(usdt_stmt).first()
+            
+            if usdt_asset:
+                usdt_asset.balance += net_proceeds
+                session.add(usdt_asset)
+            else:
+                new_usdt = PortfolioAsset(
+                    symbol="USDT",
+                    balance=net_proceeds,
+                    user_email=user_email
+                )
+                session.add(new_usdt)
+            
+            # Record the trade with PnL
+            trade = record_trade(
+                session=session,
+                user_email=user_email,
+                symbol=f"{symbol}USDT",
+                side="SELL",
+                price=price,
+                quantity=quantity,
+                total=net_proceeds,
+                fee=fee,
+                pnl=pnl
+            )
+            
+            session.commit()
+            
+            trade_info = {
+                'order_id': trade.order_id,
+                'symbol': f"{symbol}USDT",
+                'side': 'SELL',
+                'price': price,
+                'quantity': quantity,
+                'gross_proceeds': gross_proceeds,
+                'fee': fee,
+                'net_proceeds': net_proceeds,
+                'avg_cost_basis': avg_cost_basis,
+                'cost_of_sold': cost_of_sold,
+                'pnl': pnl,
+                'pnl_percent': pnl_percent,
+                'executed_at': trade.executed_at.isoformat(),
+                'new_balance': {
+                    'USDT': usdt_asset.balance if usdt_asset else net_proceeds,
+                    symbol: asset.balance
+                }
+            }
+            
+            pnl_emoji = "📈" if pnl >= 0 else "📉"
+            print(f"[ManualTrading] ✅ SELL executed: {quantity:.8f} {symbol} @ ${price:.2f}")
+            print(f"  Received: ${net_proceeds:.2f} USDT (Fee: ${fee:.4f})")
+            print(f"  {pnl_emoji} PnL: ${pnl:.2f} ({pnl_percent:+.2f}%)")
+            
+            return True, trade_info, None
+            
+    except Exception as e:
+        print(f"[ManualTrading] ❌ SELL transaction failed: {e}")
+        return False, None, f"Transaction failed: {str(e)}"
+
+
+def get_manual_trade_history(user_email: str, limit: int = 50) -> List[dict]:
+    """
+    Get manual trade history for a user
+    
+    Args:
+        user_email: User identifier
+        limit: Maximum number of trades to return
+    
+    Returns:
+        List of trade dictionaries
+    """
+    with Session(engine) as session:
+        statement = select(Trade).where(
+            Trade.user_email == user_email,
+            Trade.session_id.startswith("manual_")
+        ).order_by(Trade.executed_at.desc()).limit(limit)
+        
+        trades = session.exec(statement).all()
+        
+        result = []
+        for trade in trades:
+            # Calculate pnl_percent for sell trades
+            pnl_percent = None
+            if trade.side == "SELL" and trade.pnl is not None:
+                # cost_basis = total - pnl (what we got minus profit = what we paid)
+                cost_basis = trade.total - trade.pnl
+                if cost_basis > 0:
+                    pnl_percent = (trade.pnl / cost_basis) * 100
+            
+            result.append({
+                'id': trade.id,
+                'order_id': trade.order_id,
+                'symbol': trade.symbol,
+                'side': trade.side,
+                'price': trade.price,
+                'quantity': trade.quantity,
+                'total': trade.total,
+                'pnl': trade.pnl,
+                'pnl_percent': pnl_percent,
+                'time': trade.executed_at.isoformat() if trade.executed_at else None
+            })
+        
+        return result
+
+
+def get_prices_for_assets(assets: List[str] = None) -> dict:
+    """
+    Get current prices for multiple assets
+    
+    Args:
+        assets: List of asset symbols (defaults to SUPPORTED_ASSETS)
+    
+    Returns:
+        Dictionary mapping symbol to price data
+    """
+    if assets is None:
+        assets = SUPPORTED_ASSETS
+    
+    prices = {}
+    for asset in assets:
+        price = get_current_price_from_binance(asset, "USDT")
+        if price:
+            prices[asset] = {
+                'symbol': asset,
+                'price': price,
+                'pair': f"{asset}USDT"
+            }
+    
+    return prices
+
+
+# ============================================
+# PLACEHOLDER: Real Binance Order Execution
+# ============================================
+
+def execute_binance_order(
+    symbol: str,
+    side: str,  # 'BUY' or 'SELL'
+    order_type: str,  # 'MARKET', 'LIMIT'
+    quantity: float,
+    price: Optional[float] = None,  # Required for LIMIT orders
+    api_key: Optional[str] = None,
+    api_secret: Optional[str] = None
+) -> Tuple[bool, Optional[dict], Optional[str]]:
+    """
+    PLACEHOLDER: Execute a real order on Binance exchange
+    
+    This function is a placeholder for when you want to execute
+    real orders on Binance. Uncomment and configure the code below.
+    
+    Args:
+        symbol: Trading pair (e.g., 'BTCUSDT')
+        side: 'BUY' or 'SELL'
+        order_type: 'MARKET' or 'LIMIT'
+        quantity: Amount to trade
+        price: Limit price (required for LIMIT orders)
+        api_key: Binance API key
+        api_secret: Binance API secret
+    
+    Returns:
+        Tuple of (success: bool, order_info: dict or None, error_message: str or None)
+    """
+    
+    # ===== UNCOMMENT THIS CODE TO ENABLE REAL TRADING =====
+    #
+    # from binance.client import Client
+    # from binance.exceptions import BinanceAPIException
+    # import os
+    # from dotenv import load_dotenv
+    #
+    # load_dotenv()
+    #
+    # # Use provided keys or fall back to environment variables
+    # key = api_key or os.getenv("BINANCE_API_KEY")
+    # secret = api_secret or os.getenv("BINANCE_SECRET_KEY")
+    #
+    # if not key or not secret:
+    #     return False, None, "Binance API credentials not configured"
+    #
+    # try:
+    #     client = Client(key, secret)
+    #     
+    #     if order_type == 'MARKET':
+    #         if side == 'BUY':
+    #             order = client.create_order(
+    #                 symbol=symbol,
+    #                 side=Client.SIDE_BUY,
+    #                 type=Client.ORDER_TYPE_MARKET,
+    #                 quantity=quantity
+    #             )
+    #         else:
+    #             order = client.create_order(
+    #                 symbol=symbol,
+    #                 side=Client.SIDE_SELL,
+    #                 type=Client.ORDER_TYPE_MARKET,
+    #                 quantity=quantity
+    #             )
+    #     elif order_type == 'LIMIT':
+    #         if price is None:
+    #             return False, None, "Price required for LIMIT orders"
+    #         
+    #         if side == 'BUY':
+    #             order = client.create_order(
+    #                 symbol=symbol,
+    #                 side=Client.SIDE_BUY,
+    #                 type=Client.ORDER_TYPE_LIMIT,
+    #                 timeInForce=Client.TIME_IN_FORCE_GTC,
+    #                 quantity=quantity,
+    #                 price=str(price)
+    #             )
+    #         else:
+    #             order = client.create_order(
+    #                 symbol=symbol,
+    #                 side=Client.SIDE_SELL,
+    #                 type=Client.ORDER_TYPE_LIMIT,
+    #                 timeInForce=Client.TIME_IN_FORCE_GTC,
+    #                 quantity=quantity,
+    #                 price=str(price)
+    #             )
+    #     
+    #     return True, order, None
+    #     
+    # except BinanceAPIException as e:
+    #     return False, None, f"Binance API Error: {e.message}"
+    # except Exception as e:
+    #     return False, None, f"Order execution failed: {str(e)}"
+    #
+    # ===== END OF REAL TRADING CODE =====
+    
+    # For now, return a message indicating this is a placeholder
+    return False, None, "Real Binance trading not enabled. Using simulated trading."

models.py

@@ -44,4 +44,6 @@ class PortfolioAsset(SQLModel, table=True):
     """Internal simulated wallet for paper trading"""
     symbol: str = Field(primary_key=True)  # e.g., 'USDT', 'BTC', 'ETH'
     user_email: str = Field(primary_key=True, index=True)  # Support multi-user portfolios
-    balance: float = Field(default=0.0)
+    balance: float = Field(default=0.0)
+    avg_cost_basis: float = Field(default=0.0)  # Average buy price per unit
+    total_invested: float = Field(default=0.0)  # Total USDT invested in this asset