Update app.py

app.py

@@ -5,6 +5,7 @@ import ssl
 import struct
 import logging
 import time
+import asyncio
 from datetime import datetime
 import requests
 from fastapi import FastAPI, Request, Form, HTTPException
@@ -65,28 +66,53 @@ def load_tokens():
         except Exception as e:
             logger.error(f"Failed to load tokens: {e}")
     
-    # Fallback to CTRADER_REFRESH_TOKEN env var if set
+    # Fallback to environment secrets if token file doesn't exist
     env_refresh = os.environ.get("CTRADER_REFRESH_TOKEN")
+    env_access = os.environ.get("CTRADER_ACCESS_TOKEN")
     env_acc_id = os.environ.get("CTRADER_ACCOUNT_ID")
-    if env_refresh:
-        logger.info("Using refresh token from environment secrets")
+    if env_refresh or env_access:
+        logger.info("Using tokens from environment secrets")
         return {
-            "refresh_token": env_refresh.strip(),
-            "access_token": "",
-            "account_id": env_acc_id.strip() if env_acc_id else ""
+            "refresh_token": env_refresh.strip() if env_refresh else "",
+            "access_token": env_access.strip() if env_access else "",
+            "account_id": env_acc_id.strip() if env_acc_id else "",
+            "updated_at": time.time()
         }
     return None
 
 # Helper: Exchange authorization code or refresh token
 def fetch_token_from_api(payload):
     url = "https://openapi.ctrader.com/apps/token"
-    res = requests.get(url, params=payload)
-    if res.status_code == 200:
-        data = res.json()
-        logger.info("Token request successful")
-        return data
-    else:
-        logger.error(f"Token exchange failed: {res.text}")
+    headers = {
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+        "Accept": "application/json, text/plain, */*"
+    }
+    
+    # Attempt 1: GET request with custom headers
+    try:
+        res = requests.get(url, params=payload, headers=headers, timeout=10)
+        if res.status_code == 200:
+            data = res.json()
+            logger.info("Token request successful (GET)")
+            return data
+    except Exception as e:
+        logger.warning(f"GET token request exception: {e}")
+
+    # Attempt 2: POST request fallback with form-encoded data
+    try:
+        res = requests.post(url, data=payload, headers=headers, timeout=10)
+        if res.status_code == 200:
+            data = res.json()
+            logger.info("Token request successful (POST)")
+            return data
+        elif res.status_code == 429:
+            logger.warning("cTrader API rate limited (HTTP 429). Cloudflare/WAF blocked request.")
+            return None
+        else:
+            logger.error(f"Token exchange failed (HTTP {res.status_code}): {res.text[:200]}")
+            return None
+    except Exception as e:
+        logger.error(f"POST token request exception: {e}")
         return None
 
 # Helper: Send protocol buffer message over SSL Socket
@@ -230,6 +256,71 @@ def resolve_symbol_id(ssl_sock, account_id, symbol_name):
             break
     return None
 
+# Helper: Get volume limits for a symbol from broker
+def get_symbol_volume_limits(ssl_sock, account_id, symbol_id):
+    """Query the broker for the symbol's volume limits.
+    Returns dict with maxVolume, minVolume, stepVolume in protocol units (units * 100), or empty dict."""
+    result = {}
+    try:
+        req = ProtoOASymbolByIdReq()
+        req.ctidTraderAccountId = int(account_id)
+        req.symbolId.append(int(symbol_id))
+        send_proto_message(ssl_sock, req, 2116)
+        
+        while True:
+            proto_msg = receive_proto_message(ssl_sock)
+            if not proto_msg:
+                break
+            if proto_msg.payloadType == 2117:  # ProtoOASymbolByIdRes
+                res = ProtoOASymbolByIdRes()
+                res.ParseFromString(proto_msg.payload)
+                for sym in res.symbol:
+                    if hasattr(sym, 'maxVolume') and sym.maxVolume:
+                        result['maxVolume'] = sym.maxVolume
+                    if hasattr(sym, 'minVolume') and sym.minVolume:
+                        result['minVolume'] = sym.minVolume
+                    if hasattr(sym, 'stepVolume') and sym.stepVolume:
+                        result['stepVolume'] = sym.stepVolume
+                    logger.info(f"Symbol {symbol_id} volume limits: max={result.get('maxVolume', 'N/A')}, min={result.get('minVolume', 'N/A')}, step={result.get('stepVolume', 'N/A')} protocol units")
+                break
+    except Exception as e:
+        logger.warning(f"Could not fetch volume limits for symbol {symbol_id}: {e}")
+    return result
+
+# Helper: Place market order with automatic volume reduction on "Not enough funds"
+def place_market_order_smart(ssl_sock, account_id, symbol_id, trade_side, volume, min_volume=100, step_volume=100):
+    """Try placing an order. If 'Not enough funds', halve volume and retry until min_volume."""
+    attempt = 0
+    try_volume = volume
+    
+    while try_volume >= min_volume:
+        attempt += 1
+        # Round down to nearest step
+        if step_volume > 0:
+            try_volume = (try_volume // step_volume) * step_volume
+        if try_volume < min_volume:
+            break
+            
+        logger.info(f"Order attempt {attempt}: volume={try_volume} protocol units ({try_volume / 100:.2f} units)")
+        res = place_market_order(ssl_sock, account_id, symbol_id, trade_side, int(try_volume))
+        
+        if res.get('status') == 'success':
+            if attempt > 1:
+                logger.info(f"Order succeeded on attempt {attempt} with reduced volume {try_volume}")
+            return res
+        
+        error_msg = res.get('message', '')
+        if 'not enough funds' in error_msg.lower() or 'Not enough' in error_msg:
+            # Halve the volume and retry
+            try_volume = try_volume // 2
+            logger.info(f"Not enough funds — reducing volume to {try_volume} and retrying...")
+        else:
+            # Different error, don't retry
+            return res
+    
+    return {"status": "error", "message": f"Not enough funds even at minimum volume ({min_volume} protocol units = {min_volume/100:.2f} units)"}
+
+
 # Helper: Fetch Account Balance/Details
 def get_trader_details(ssl_sock, account_id):
     req = ProtoOATraderReq()
@@ -368,8 +459,13 @@ def place_market_order(ssl_sock, account_id, symbol_id, trade_side, volume, posi
             logger.info(f"place_market_order: Received other payloadType: {proto_msg.payloadType}")
     return {"status": "error", "message": "No execution response received"}
 
+# Rate-limit guard: track last refresh attempt to avoid hammering the API
+_last_refresh_attempt = 0
+REFRESH_COOLDOWN = 60  # seconds between refresh attempts
+
 # Helper: Refresh tokens and return active ones
 def get_valid_tokens():
+    global _last_refresh_attempt
     tokens = load_tokens()
     if not tokens:
         return None
@@ -379,7 +475,14 @@ def get_valid_tokens():
     updated_at = tokens.get("updated_at", 0)
     
     # Only refresh if the access token is missing or older than 24 hours (86400 seconds)
+    # AND we haven't tried refreshing in the last REFRESH_COOLDOWN seconds
     if not access_token or (time.time() - updated_at > 86400):
+        if time.time() - _last_refresh_attempt < REFRESH_COOLDOWN:
+            logger.info(f"Skipping token refresh (cooldown: {REFRESH_COOLDOWN - (time.time() - _last_refresh_attempt):.0f}s remaining)")
+            if access_token:
+                return tokens
+            return None
+        _last_refresh_attempt = time.time()
         if refresh_token:
             payload = {
                 "grant_type": "refresh_token",
@@ -460,8 +563,10 @@ def get_valid_tokens():
 
 @app.get("/", response_class=HTMLResponse)
 async def dashboard(request: Request):
-    tokens = get_valid_tokens()
-    is_authenticated = tokens is not None
+    # Dashboard uses load_tokens() directly — NO refresh call.
+    # This prevents health checks from hammering the cTrader API.
+    tokens = load_tokens()
+    is_authenticated = tokens is not None and bool(tokens.get("access_token"))
     account_id = tokens.get("account_id", "") if is_authenticated else ""
     access_token = tokens.get("access_token", "") if is_authenticated else ""
     
@@ -872,8 +977,8 @@ async def webhook(request: Request):
     ticker = data.get("ticker", "").upper()
     price = data.get("price")
     
-    if action not in ["BUY", "SELL", "STOP-TRADE", "CLOSE"]:
-        raise HTTPException(status_code=400, detail="Invalid action. Must be BUY, SELL, STOP-TRADE, or CLOSE")
+    if action not in ["BUY", "SELL", "STOP-TRADE", "CLOSE", "ANCHOR"]:
+        raise HTTPException(status_code=400, detail="Invalid action. Must be BUY, SELL, STOP-TRADE, CLOSE, or ANCHOR")
         
     # Load and refresh tokens
     tokens = get_valid_tokens()
@@ -884,7 +989,7 @@ async def webhook(request: Request):
     access_token = tokens["access_token"]
     
     log_time = datetime.now().strftime("%H:%M:%S")
-    color = "#60a5fa" if action == "BUY" else "#f87171" if action == "SELL" else "#fb923c" if action == "CLOSE" else "#94a3b8"
+    color = "#60a5fa" if action == "BUY" else "#f87171" if action == "SELL" else "#fb923c" if action == "CLOSE" else "#FF9800" if action == "ANCHOR" else "#94a3b8"
     
     try:
         # Establish SSL Socket connection to cTrader Open API
@@ -900,6 +1005,16 @@ async def webhook(request: Request):
         positions = get_open_positions(ssl_sock, account_id)
         symbol_positions = [p for p in positions if p.tradeData.symbolId == symbol_id]
         
+        # Auto-clamp volume to broker's max for this symbol and get min/step
+        effective_volume = current_trade_volume
+        vol_limits = get_symbol_volume_limits(ssl_sock, account_id, symbol_id)
+        max_vol = vol_limits.get('maxVolume')
+        min_vol = vol_limits.get('minVolume', 100)  # default 1 unit
+        step_vol = vol_limits.get('stepVolume', 100)  # default 1 unit
+        if max_vol and effective_volume > max_vol:
+            logger.info(f"Clamping volume from {effective_volume} to {max_vol} (broker max for {ticker})")
+            effective_volume = max_vol
+        
         execution_msg = ""
         
         if action == "BUY":
@@ -913,7 +1028,7 @@ async def webhook(request: Request):
             else:
                 # Open new BUY position (existing positions stay untouched — only stop-trade/end-trade closes them)
                 logger.info(f"Opening new Long position... ({losing_count} losing BUY(s) open, limit {MAX_LOSING_POSITIONS})")
-                res = place_market_order(ssl_sock, account_id, symbol_id, ProtoOATradeSide.BUY, current_trade_volume)
+                res = place_market_order_smart(ssl_sock, account_id, symbol_id, ProtoOATradeSide.BUY, effective_volume, min_vol, step_vol)
                 execution_msg = f"Opened BUY position for {ticker}. Order Result: {res.get('status')} {res.get('message', '')}"
             
         elif action == "SELL":
@@ -927,7 +1042,7 @@ async def webhook(request: Request):
             else:
                 # Open new SELL position (existing positions stay untouched — only stop-trade/end-trade closes them)
                 logger.info(f"Opening new Short position... ({losing_count} losing SELL(s) open, limit {MAX_LOSING_POSITIONS})")
-                res = place_market_order(ssl_sock, account_id, symbol_id, ProtoOATradeSide.SELL, current_trade_volume)
+                res = place_market_order_smart(ssl_sock, account_id, symbol_id, ProtoOATradeSide.SELL, effective_volume, min_vol, step_vol)
                 execution_msg = f"Opened SELL position for {ticker}. Order Result: {res.get('status')} {res.get('message', '')}"
             
         elif action == "CLOSE":
@@ -979,6 +1094,42 @@ async def webhook(request: Request):
             else:
                 execution_msg = f"No open positions on {ticker} to close."
                 
+        elif action == "ANCHOR":
+            # ANCHOR = consolidation detected. Open opposite trade, wait 5 sec, then close ALL.
+            anchor_direction = data.get("direction", "").upper()
+            
+            # Step 1: Open the opposite (hedging) trade
+            if anchor_direction == "BUY":
+                logger.info(f"ANCHOR: Opening hedging BUY on {ticker}...")
+                res = place_market_order_smart(ssl_sock, account_id, symbol_id, ProtoOATradeSide.BUY, effective_volume, min_vol, step_vol)
+                logger.info(f"ANCHOR: Hedging BUY opened. Result: {res.get('status')} {res.get('message', '')}")
+            elif anchor_direction == "SELL":
+                logger.info(f"ANCHOR: Opening hedging SELL on {ticker}...")
+                res = place_market_order_smart(ssl_sock, account_id, symbol_id, ProtoOATradeSide.SELL, effective_volume, min_vol, step_vol)
+                logger.info(f"ANCHOR: Hedging SELL opened. Result: {res.get('status')} {res.get('message', '')}")
+            else:
+                logger.warning(f"ANCHOR: No direction specified, skipping hedge trade.")
+            
+            # Step 2: Wait 5 seconds for the hedge trade to fully settle
+            ssl_sock.close()
+            logger.info(f"ANCHOR: Waiting 5 seconds before closing all positions on {ticker}...")
+            await asyncio.sleep(5)
+            
+            # Step 3: Reconnect and close ALL positions on this symbol
+            ssl_sock = get_authenticated_socket(account_id, access_token)
+            symbol_id = resolve_symbol_id(ssl_sock, account_id, ticker)
+            positions = get_open_positions(ssl_sock, account_id)
+            symbol_positions = [p for p in positions if p.tradeData.symbolId == symbol_id]
+            
+            closed_count = 0
+            for p in symbol_positions:
+                side = ProtoOATradeSide.SELL if p.tradeData.tradeSide == 1 else ProtoOATradeSide.BUY
+                logger.info(f"ANCHOR: Closing {'BUY' if p.tradeData.tradeSide == 1 else 'SELL'} position {p.positionId}")
+                place_market_order(ssl_sock, account_id, symbol_id, side, p.tradeData.volume, position_id=p.positionId)
+                closed_count += 1
+            
+            execution_msg = f"ANCHOR: Opened hedging {anchor_direction}, then closed {closed_count} position(s) on {ticker}. Consolidation neutralized."
+                
         ssl_sock.close()
         
         # Log to in-memory dashboard logs