Upload 36 files

api_server.py

@@ -0,0 +1,512 @@
+from fastapi import FastAPI, BackgroundTasks, HTTPException
+from pydantic import BaseModel
+import uvicorn
+import asyncio
+import threading
+import time
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional
+import yaml
+import os
+from dotenv import load_dotenv
+
+from core.exchange import BybitExchange
+from core.strategy import ScalpingStrategy
+from core.risk import RiskManager
+from core.data_engine import DataEngine
+from core.trade_monitor import TradeMonitor
+from core.websockets import BybitWebSocket
+from services.logger import log, log_trade, log_performance
+from services.telegram import send_telegram
+
+load_dotenv()
+
+app = FastAPI(title="Bybit Scalping Bot API", version="1.0.0")
+
+class TradeSession(BaseModel):
+    symbol: str
+    duration_hours: int = 18
+    max_trades: Optional[int] = None
+
+class BotStatus(BaseModel):
+    is_running: bool
+    active_sessions: List[Dict]
+    total_pnl: float
+    trades_today: int
+    uptime: str
+
+# Global bot state
+bot_instances = {}
+active_sessions = {}
+session_reports = {}
+
+def load_config():
+    settings = yaml.safe_load(open("config/settings.yaml"))
+    pairs = yaml.safe_load(open("config/pairs.yaml"))["pairs"]
+    return settings, pairs
+
+def create_bot_instance(symbol: str):
+    """Create a dedicated bot instance for a symbol"""
+    settings, pairs = load_config()
+
+    exchange = BybitExchange()
+    data_engine = DataEngine()
+    strategy = ScalpingStrategy(data_engine)
+    risk_manager = RiskManager(exchange)
+    monitor = TradeMonitor(exchange, strategy, risk_manager, data_engine)
+    ws_client = BybitWebSocket(callback=lambda data: handle_ws_data(data, symbol))
+
+    return {
+        'exchange': exchange,
+        'data_engine': data_engine,
+        'strategy': strategy,
+        'risk_manager': risk_manager,
+        'monitor': monitor,
+        'ws_client': ws_client,
+        'symbol': symbol,
+        'start_time': datetime.now(),
+        'trades': [],
+        'pnl': 0.0
+    }
+
+def handle_ws_data(data, symbol):
+    """Handle WebSocket data for specific symbol"""
+    if symbol in bot_instances:
+        bot = bot_instances[symbol]
+        if "topic" in data:
+            topic = data["topic"]
+            payload = data["data"]
+
+            if topic.startswith("tickers."):
+                ticker_symbol = topic.split(".")[1]
+                if ticker_symbol == symbol:
+                    bot['data_engine'].update_price(symbol, float(payload["lastPrice"]))
+
+            elif topic.startswith("kline."):
+                parts = topic.split(".")
+                interval = parts[1]
+                ticker_symbol = parts[2]
+                if ticker_symbol == symbol:
+                    for candle in payload:
+                        candle_data = {
+                            'timestamp': candle['start'],
+                            'open': float(candle['open']),
+                            'high': float(candle['high']),
+                            'low': float(candle['low']),
+                            'close': float(candle['close']),
+                            'volume': float(candle['volume'])
+                        }
+                        bot['data_engine'].update_candle(symbol, interval, candle_data)
+
+async def run_trading_session(symbol: str, duration_hours: int, max_trades: Optional[int] = None):
+    """Run a trading session for a specific symbol"""
+    session_id = f"{symbol}_{int(time.time())}"
+
+    log(f"🚀 Starting trading session for {symbol} (Duration: {duration_hours}h)")
+
+    if symbol not in bot_instances:
+        bot_instances[symbol] = create_bot_instance(symbol)
+
+    bot = bot_instances[symbol]
+    active_sessions[session_id] = {
+        'symbol': symbol,
+        'start_time': datetime.now(),
+        'end_time': datetime.now() + timedelta(hours=duration_hours),
+        'duration_hours': duration_hours,
+        'max_trades': max_trades,
+        'trades_executed': 0,
+        'pnl': 0.0,
+        'status': 'running'
+    }
+
+    try:
+        # Start WebSocket
+        await bot['ws_client'].connect()
+        await asyncio.sleep(2)
+        await bot['ws_client'].subscribe_ticker([symbol])
+        await bot['ws_client'].subscribe_kline([symbol], ["1", "5"])
+        await bot['ws_client'].subscribe_orderbook([symbol], depth=25)
+        await bot['ws_client'].subscribe_trades([symbol])
+
+        # Start monitoring
+        monitor_task = asyncio.create_task(bot['monitor'].start_monitoring())
+
+        # Run for specified duration
+        end_time = datetime.now() + timedelta(hours=duration_hours)
+        trades_count = 0
+
+        while datetime.now() < end_time:
+            await asyncio.sleep(1)
+
+            # Check trade limits
+            if max_trades and trades_count >= max_trades:
+                log(f"🎯 Max trades reached for {symbol} session")
+                break
+
+            # Update session stats
+            session = active_sessions[session_id]
+            session['pnl'] = bot['risk_manager'].daily_pnl
+            session['trades_executed'] = len(bot['risk_manager'].trade_history)
+
+        # Stop monitoring
+        bot['monitor'].stop_monitoring()
+        await bot['ws_client'].close()
+
+        # Generate report
+        await generate_session_report(session_id)
+
+    except Exception as e:
+        log(f"❌ Error in trading session for {symbol}: {e}")
+        active_sessions[session_id]['status'] = 'error'
+
+async def generate_session_report(session_id: str):
+    """Generate and send trading session report"""
+    if session_id not in active_sessions:
+        return
+
+    session = active_sessions[session_id]
+    symbol = session['symbol']
+
+    if symbol in bot_instances:
+        bot = bot_instances[symbol]
+        risk_manager = bot['risk_manager']
+
+        # Calculate session metrics
+        total_trades = len(risk_manager.trade_history)
+        winning_trades = sum(1 for trade in risk_manager.trade_history if trade['pnl'] > 0)
+        losing_trades = total_trades - winning_trades
+        win_rate = winning_trades / total_trades if total_trades > 0 else 0
+        total_pnl = sum(trade['pnl'] for trade in risk_manager.trade_history)
+
+        # Generate report
+        report = f"""
+🏆 TRADING SESSION REPORT - {symbol}
+═══════════════════════════════════════════
+
+📊 Session Details:
+• Duration: {session['duration_hours']} hours
+• Start Time: {session['start_time'].strftime('%Y-%m-%d %H:%M:%S')}
+• End Time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+
+📈 Performance Metrics:
+• Total Trades: {total_trades}
+• Winning Trades: {winning_trades}
+• Losing Trades: {losing_trades}
+• Win Rate: {win_rate:.1%}
+• Total P&L: ${total_pnl:.2f}
+
+🎯 Risk Management:
+• Max Loss Limit: ${risk_manager.max_daily_loss}
+• Risk per Trade: {risk_manager.risk_per_trade*100}%
+• Leverage Used: {risk_manager.leverage}x
+
+💎 Trade Summary:
+"""
+
+        # Add individual trade details
+        for i, trade in enumerate(risk_manager.trade_history[-10:], 1):  # Last 10 trades
+            pnl_emoji = "🟢" if trade['pnl'] > 0 else "🔴"
+            report += f"{i}. {trade['side']} @ ${trade['entry_price']:.2f} → ${trade['exit_price']:.2f} {pnl_emoji} P&L: ${trade['pnl']:.2f}\n"
+
+        report += f"\n═══════════════════════════════════════════"
+
+        # Send to Telegram
+        send_telegram(report)
+
+        # Save report
+        session_reports[session_id] = {
+            'session': session,
+            'metrics': {
+                'total_trades': total_trades,
+                'win_rate': win_rate,
+                'total_pnl': total_pnl,
+                'winning_trades': winning_trades,
+                'losing_trades': losing_trades
+            },
+            'trades': risk_manager.trade_history,
+            'report': report
+        }
+
+        log(f"📊 Session report generated for {symbol}")
+
+    # Mark session as completed
+    session['status'] = 'completed'
+    session['end_time'] = datetime.now()
+
+@app.get("/")
+async def root():
+    """API root endpoint"""
+    return {"message": "Bybit Scalping Bot API", "version": "1.0.0", "status": "running"}
+
+@app.get("/status")
+async def get_status():
+    """Get bot status"""
+    total_pnl = 0
+    total_trades = 0
+
+    for session in active_sessions.values():
+        if session['status'] == 'running':
+            total_pnl += session.get('pnl', 0)
+            total_trades += session.get('trades_executed', 0)
+
+    return BotStatus(
+        is_running=bool(active_sessions),
+        active_sessions=[
+            {
+                'session_id': sid,
+                'symbol': session['symbol'],
+                'status': session['status'],
+                'start_time': session['start_time'].isoformat(),
+                'pnl': session.get('pnl', 0),
+                'trades': session.get('trades_executed', 0)
+            }
+            for sid, session in active_sessions.items()
+        ],
+        total_pnl=total_pnl,
+        trades_today=total_trades,
+        uptime=str(datetime.now() - datetime.fromtimestamp(time.time()))
+    )
+
+@app.post("/start/{symbol}")
+async def start_symbol_trading(symbol: str, background_tasks: BackgroundTasks, duration_hours: int = 18, max_trades: Optional[int] = None):
+    """Start trading for a specific symbol"""
+    settings, configured_pairs = load_config()
+
+    if symbol not in configured_pairs:
+        raise HTTPException(status_code=400, detail=f"Symbol {symbol} not configured. Available: {configured_pairs}")
+
+    # Check if already running
+    for session in active_sessions.values():
+        if session['symbol'] == symbol and session['status'] == 'running':
+            raise HTTPException(status_code=400, detail=f"Trading already active for {symbol}")
+
+    # Start trading session
+    background_tasks.add_task(run_trading_session, symbol, duration_hours, max_trades)
+
+    message = f"🚀 Started trading session for {symbol} ({duration_hours}h duration)"
+    send_telegram(message)
+    log(message)
+
+    return {"message": message, "symbol": symbol, "duration_hours": duration_hours}
+
+@app.post("/stop/{symbol}")
+async def stop_symbol_trading(symbol: str):
+    """Stop trading for a specific symbol"""
+    stopped_sessions = []
+
+    for session_id, session in active_sessions.items():
+        if session['symbol'] == symbol and session['status'] == 'running':
+            session['status'] = 'stopped'
+            session['end_time'] = datetime.now()
+            stopped_sessions.append(session_id)
+
+            if symbol in bot_instances:
+                bot = bot_instances[symbol]
+                bot['monitor'].stop_monitoring()
+                await bot['ws_client'].close()
+
+    if stopped_sessions:
+        message = f"🛑 Stopped trading for {symbol}"
+        send_telegram(message)
+        log(message)
+        return {"message": message, "stopped_sessions": stopped_sessions}
+    else:
+        raise HTTPException(status_code=404, detail=f"No active trading session found for {symbol}")
+
+@app.get("/sessions")
+async def get_sessions():
+    """Get all trading sessions"""
+    return {
+        "active_sessions": active_sessions,
+        "completed_sessions": session_reports
+    }
+
+@app.get("/report/{session_id}")
+async def get_session_report(session_id: str):
+    """Get detailed report for a specific session"""
+    if session_id in session_reports:
+        return session_reports[session_id]
+    else:
+        raise HTTPException(status_code=404, detail="Session report not found")
+
+@app.get("/logs/analysis")
+async def get_analysis_logs(lines: int = 50):
+    """Get recent analysis logs"""
+    try:
+        log_file = "logs/scalper.log"
+        if os.path.exists(log_file):
+            with open(log_file, 'r') as f:
+                all_lines = f.readlines()
+                # Filter for analysis-related logs
+                analysis_lines = [line for line in all_lines if any(keyword in line for keyword in [
+                    'SIGNAL', 'EMA', 'RSI', 'volume', 'orderbook', 'analysis', 'strategy'
+                ])]
+                recent_lines = analysis_lines[-lines:]
+                return {
+                    "logs": recent_lines,
+                    "count": len(recent_lines),
+                    "total_analysis_logs": len(analysis_lines)
+                }
+        else:
+            return {"error": "Log file not found", "logs": [], "count": 0}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error reading logs: {e}")
+
+@app.get("/logs/live")
+async def get_live_logs(lines: int = 20):
+    """Get recent live logs (streaming)"""
+    try:
+        log_file = "logs/scalper.log"
+        if os.path.exists(log_file):
+            with open(log_file, 'r') as f:
+                all_lines = f.readlines()
+                recent_lines = all_lines[-lines:]
+                return {
+                    "logs": recent_lines,
+                    "count": len(recent_lines),
+                    "latest_timestamp": recent_lines[-1].split(' - ')[0] if recent_lines else None
+                }
+        else:
+            return {"error": "Log file not found", "logs": [], "count": 0}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error reading logs: {e}")
+
+@app.post("/start_all")
+async def start_all_pairs(background_tasks: BackgroundTasks, duration_hours: int = 18, max_trades: Optional[int] = None):
+    """Start trading sessions for all configured pairs"""
+    settings, configured_pairs = load_config()
+
+    started_sessions = []
+    failed_sessions = []
+
+    for symbol in configured_pairs:
+        # Check if already running
+        already_running = any(session['symbol'] == symbol and session['status'] == 'running'
+                            for session in active_sessions.values())
+
+        if already_running:
+            failed_sessions.append({"symbol": symbol, "reason": "Already running"})
+            continue
+
+        try:
+            # Start trading session
+            background_tasks.add_task(run_trading_session, symbol, duration_hours, max_trades)
+            started_sessions.append({"symbol": symbol, "duration_hours": duration_hours})
+        except Exception as e:
+            failed_sessions.append({"symbol": symbol, "reason": str(e)})
+
+    message = f"🚀 Started trading sessions for {len(started_sessions)} pairs"
+    if started_sessions:
+        send_telegram(message)
+        log(message)
+
+    return {
+        "message": message,
+        "started_sessions": started_sessions,
+        "failed_sessions": failed_sessions,
+        "total_started": len(started_sessions),
+        "total_failed": len(failed_sessions)
+    }
+
+@app.post("/stop_all")
+async def stop_all_pairs():
+    """Stop trading sessions for all pairs"""
+    stopped_sessions = []
+
+    for session_id, session in list(active_sessions.items()):
+        if session['status'] == 'running':
+            session['status'] = 'stopped'
+            session['end_time'] = datetime.now()
+            stopped_sessions.append(session_id)
+
+            # Stop the actual trading
+            if session['symbol'] in bot_instances:
+                bot = bot_instances[session['symbol']]
+                bot['monitor'].stop_monitoring()
+                await bot['ws_client'].close()
+
+    if stopped_sessions:
+        message = f"🛑 Stopped all trading sessions ({len(stopped_sessions)} sessions)"
+        send_telegram(message)
+        log(message)
+        return {"message": message, "stopped_sessions": stopped_sessions}
+    else:
+        return {"message": "No active sessions to stop", "stopped_sessions": []}
+
+@app.get("/analysis/status")
+async def get_analysis_status():
+    """Get current analysis status for all active sessions"""
+    analysis_status = {}
+
+    for session_id, session in active_sessions.items():
+        if session['status'] == 'running' and session['symbol'] in bot_instances:
+            bot = bot_instances[session['symbol']]
+            symbol = session['symbol']
+
+            # Get current market data
+            try:
+                current_price = bot['data_engine'].get_prices(symbol, limit=1)
+                current_price = current_price[-1] if current_price else None
+            except:
+                current_price = None
+
+            # Get technical indicators
+            try:
+                ema_fast = bot['data_engine'].calculate_ema(symbol, "1", 9)
+                ema_slow = bot['data_engine'].calculate_ema(symbol, "1", 21)
+                rsi = bot['data_engine'].calculate_rsi(symbol, "1", 14)
+                volume_spike = bot['data_engine'].detect_volume_spike(symbol, "1", 1.3)
+                orderbook_imbalance = bot['data_engine'].get_orderbook_imbalance(symbol)
+            except:
+                ema_fast = ema_slow = rsi = volume_spike = orderbook_imbalance = None
+
+            analysis_status[symbol] = {
+                "session_id": session_id,
+                "current_price": current_price,
+                "indicators": {
+                    "ema_9": ema_fast,
+                    "ema_21": ema_slow,
+                    "rsi_14": rsi,
+                    "volume_spike": volume_spike,
+                    "orderbook_imbalance": orderbook_imbalance
+                },
+                "strategy_conditions": {
+                    "trend_up": ema_fast > ema_slow if ema_fast and ema_slow else None,
+                    "rsi_valid": 40 <= rsi <= 70 if rsi else None,
+                    "volume_confirmed": volume_spike,
+                    "orderbook_aligned": abs(orderbook_imbalance or 0) > 0.15
+                },
+                "last_update": datetime.now().isoformat()
+            }
+
+    return {
+        "analysis_status": analysis_status,
+        "active_sessions": len(analysis_status),
+        "last_updated": datetime.now().isoformat()
+    }
+
+@app.post("/emergency_stop")
+async def emergency_stop():
+    """Emergency stop all trading"""
+    stopped_sessions = []
+
+    for session_id, session in active_sessions.items():
+        if session['status'] == 'running':
+            session['status'] = 'emergency_stop'
+            session['end_time'] = datetime.now()
+            stopped_sessions.append(session_id)
+
+    # Stop all monitors
+    for bot in bot_instances.values():
+        bot['monitor'].stop_monitoring()
+        await bot['ws_client'].close()
+
+    message = f"🚨 EMERGENCY STOP activated - All trading halted"
+    send_telegram(message)
+    log(message)
+
+    return {"message": message, "stopped_sessions": stopped_sessions}
+
+if __name__ == "__main__":
+    log("🚀 Starting FastAPI server for Bybit Scalping Bot")
+    uvicorn.run(app, host="0.0.0.0", port=8000)

app.py

@@ -0,0 +1,194 @@
+import streamlit as st
+import subprocess
+import os
+import signal
+import time
+from threading import Thread
+import requests
+
+# Set page config
+st.set_page_config(
+    page_title="Scalping Bot Control",
+    page_icon="🤖",
+    layout="wide"
+)
+
+st.title("🤖 Bybit Scalping Bot Control Panel")
+
+# Sidebar
+st.sidebar.header("⚙️ Configuration")
+
+# Environment variables setup
+st.sidebar.subheader("🔑 API Configuration")
+bybit_key = st.sidebar.text_input("Bybit API Key", type="password")
+bybit_secret = st.sidebar.text_input("Bybit API Secret", type="password")
+bybit_testnet = st.sidebar.checkbox("Use Testnet", value=False)
+telegram_token = st.sidebar.text_input("Telegram Bot Token (optional)")
+telegram_chat = st.sidebar.text_input("Telegram Chat ID (optional)")
+
+if st.sidebar.button("💾 Save Configuration"):
+    # Save to .env file
+    env_content = f"""BYBIT_API_KEY={bybit_key}
+BYBIT_API_SECRET={bybit_secret}
+BYBIT_TESTNET={str(bybit_testnet).lower()}
+TELEGRAM_BOT_TOKEN={telegram_token}
+TELEGRAM_CHAT_ID={telegram_chat}
+"""
+    with open('.env', 'w') as f:
+        f.write(env_content)
+    st.sidebar.success("Configuration saved!")
+
+# Main content
+col1, col2, col3 = st.columns(3)
+
+with col1:
+    st.subheader("🚀 Start Trading")
+    symbol = st.selectbox("Symbol", ["BTCUSDT", "ETHUSDT", "SOLUSDT"])
+    duration = st.slider("Duration (hours)", 1, 24, 18)
+    max_trades = st.number_input("Max Trades (optional)", min_value=1, value=50)
+
+    if st.button("▶️ Start Trading", key="start"):
+        try:
+            response = requests.post(f"http://localhost:8000/start/{symbol}",
+                                   params={"duration_hours": duration, "max_trades": max_trades})
+            if response.status_code == 200:
+                st.success(f"✅ Started trading {symbol} for {duration} hours")
+            else:
+                st.error(f"❌ Failed to start: {response.text}")
+        except Exception as e:
+            st.error(f"❌ Error: {e}")
+
+with col2:
+    st.subheader("🛑 Stop Trading")
+    stop_symbol = st.selectbox("Symbol to Stop", ["BTCUSDT", "ETHUSDT", "SOLUSDT"], key="stop_select")
+
+    if st.button("⏹️ Stop Trading", key="stop"):
+        try:
+            response = requests.post(f"http://localhost:8000/stop/{stop_symbol}")
+            if response.status_code == 200:
+                st.success(f"✅ Stopped trading {stop_symbol}")
+            else:
+                st.error(f"❌ Failed to stop: {response.text}")
+        except Exception as e:
+            st.error(f"❌ Error: {e}")
+
+with col3:
+    st.subheader("🚨 Emergency")
+    if st.button("🚨 EMERGENCY STOP ALL", key="emergency"):
+        try:
+            response = requests.post("http://localhost:8000/emergency_stop")
+            if response.status_code == 200:
+                st.error("🚨 ALL TRADING STOPPED!")
+            else:
+                st.error(f"❌ Failed: {response.text}")
+        except Exception as e:
+            st.error(f"❌ Error: {e}")
+
+# Status section
+st.header("📊 Bot Status")
+
+if st.button("🔄 Refresh Status"):
+    try:
+        response = requests.get("http://localhost:8000/status")
+        if response.status_code == 200:
+            status = response.json()
+
+            # Overall status
+            if status["is_running"]:
+                st.success("✅ Bot is RUNNING")
+            else:
+                st.warning("⏸️ Bot is STOPPED")
+
+            st.metric("Total P&L", f"${status['total_pnl']:.2f}")
+            st.metric("Trades Today", status['trades_today'])
+
+            # Active sessions
+            if status["active_sessions"]:
+                st.subheader("🎯 Active Sessions")
+                for session in status["active_sessions"]:
+                    with st.expander(f"{session['symbol']} - {session['status'].upper()}"):
+                        st.write(f"**Session ID:** {session['session_id']}")
+                        st.write(f"**Started:** {session['start_time'][:19]}")
+                        st.write(f"**P&L:** ${session['pnl']:.2f}")
+                        st.write(f"**Trades:** {session['trades']}")
+            else:
+                st.info("No active sessions")
+
+        else:
+            st.error(f"❌ Failed to get status: {response.status_code}")
+    except Exception as e:
+        st.error(f"❌ Connection error: {e}")
+
+# Analysis section
+st.header("🔍 Live Analysis")
+
+if st.button("📊 Refresh Analysis"):
+    try:
+        response = requests.get("http://localhost:8000/analysis/status")
+        if response.status_code == 200:
+            analysis = response.json()
+
+            for symbol, data in analysis["analysis_status"].items():
+                with st.expander(f"📈 {symbol} Analysis"):
+                    col1, col2 = st.columns(2)
+
+                    with col1:
+                        st.metric("Current Price", f"${data['current_price']:.2f}" if data['current_price'] else "N/A")
+
+                        indicators = data['indicators']
+                        st.write("**Indicators:**")
+                        st.write(f"EMA 9: {indicators['ema_9']:.4f}" if indicators['ema_9'] else "EMA 9: N/A")
+                        st.write(f"EMA 21: {indicators['ema_21']:.4f}" if indicators['ema_21'] else "EMA 21: N/A")
+                        st.write(f"RSI 14: {indicators['rsi_14']:.1f}" if indicators['rsi_14'] else "RSI 14: N/A")
+
+                    with col2:
+                        conditions = data['strategy_conditions']
+                        st.write("**Strategy Conditions:**")
+                        st.write(f"📈 Trend Up: {'✅' if conditions['trend_up'] else '❌'}")
+                        st.write(f"📊 RSI Valid: {'✅' if conditions['rsi_valid'] else '❌'}")
+                        st.write(f"💥 Volume Spike: {'✅' if conditions['volume_spike'] else '❌'}")
+                        st.write(f"🎯 Orderbook OK: {'✅' if conditions['orderbook_aligned'] else '❌'}")
+
+                        all_conditions = all([conditions['trend_up'], conditions['rsi_valid'],
+                                            conditions['volume_spike'], conditions['orderbook_aligned']])
+
+                        if all_conditions:
+                            st.success("🎯 TRADE SIGNAL READY!")
+                        else:
+                            st.info("⏳ Waiting for conditions...")
+        else:
+            st.error(f"❌ Failed to get analysis: {response.status_code}")
+    except Exception as e:
+        st.error(f"❌ Connection error: {e}")
+
+# Logs section
+st.header("📋 Recent Logs")
+
+log_type = st.selectbox("Log Type", ["Live Logs", "Analysis Logs"])
+
+if st.button("📖 Refresh Logs"):
+    try:
+        if log_type == "Live Logs":
+            response = requests.get("http://localhost:8000/logs/live")
+        else:
+            response = requests.get("http://localhost:8000/logs/analysis")
+
+        if response.status_code == 200:
+            logs_data = response.json()
+
+            st.write(f"**Total {log_type}:** {logs_data['count']}")
+
+            logs_text = ""
+            for log_line in logs_data['logs'][-10:]:  # Show last 10
+                logs_text += log_line
+
+            st.code(logs_text, language="text")
+        else:
+            st.error(f"❌ Failed to get logs: {response.status_code}")
+    except Exception as e:
+        st.error(f"❌ Connection error: {e}")
+
+# Footer
+st.markdown("---")
+st.markdown("*🤖 Bybit Scalping Bot - FastAPI Control Interface*")
+st.markdown("*Made with ❤️ for automated crypto trading*")

backtester/engine.py

@@ -0,0 +1,411 @@
+import pandas as pd
+import numpy as np
+from typing import Dict, List, Optional, Any, Tuple
+import logging
+import yaml
+from datetime import datetime, timedelta
+import json
+import os
+
+from core.strategy import ScalpingStrategy
+from core.data_engine import DataEngine
+from core.risk import RiskManager
+from services.logger import log
+
+logger = logging.getLogger(__name__)
+
+class BacktestingEngine:
+    def __init__(self):
+        self.settings = yaml.safe_load(open("config/settings.yaml"))
+        self.pairs = yaml.safe_load(open("config/pairs.yaml"))["pairs"]
+
+        self.initial_balance = 1000
+        self.fee_rate = 0.001
+        self.slippage = 0.0005
+
+        self.results = {}
+
+    def load_historical_data(self, symbol: str, interval: str = "1",
+                           days: int = 30) -> Optional[pd.DataFrame]:
+        try:
+
+            periods = days * 24 * 60
+            base_price = 50000 if symbol.startswith('BTC') else 3000 if symbol.startswith('ETH') else 100
+
+            np.random.seed(42)
+
+            timestamps = pd.date_range(
+                start=datetime.now() - timedelta(days=days),
+                end=datetime.now(),
+                freq='1min'
+            )[:periods]
+
+            returns = np.random.normal(0, 0.001, periods)
+            prices = base_price * np.exp(np.cumsum(returns))
+
+            highs = prices * (1 + np.abs(np.random.normal(0, 0.002, periods)))
+            lows = prices * (1 - np.abs(np.random.normal(0, 0.002, periods)))
+            opens = np.roll(prices, 1)
+            opens[0] = base_price
+
+            volumes = np.random.lognormal(10, 1, periods)
+
+            df = pd.DataFrame({
+                'timestamp': timestamps,
+                'open': opens,
+                'high': highs,
+                'low': lows,
+                'close': prices,
+                'volume': volumes
+            })
+
+            df.set_index('timestamp', inplace=True)
+            return df
+
+        except Exception as e:
+            logger.error(f"Error loading historical data for {symbol}: {e}")
+            return None
+
+    def run_backtest(self, symbol: str, strategy_params: Optional[Dict[str, Any]] = None,
+                    start_date: Optional[datetime] = None, end_date: Optional[datetime] = None) -> Dict[str, Any]:
+        try:
+            log(f"🔄 Starting backtest for {symbol}")
+
+            df = self.load_historical_data(symbol)
+            if df is None or df.empty:
+                return {'error': f'No data available for {symbol}'}
+
+            if start_date:
+                df = df[df.index >= start_date]
+            if end_date:
+                df = df[df.index <= end_date]
+
+            if len(df) < 100:
+                return {'error': f'Insufficient data for {symbol}: {len(df)} candles'}
+
+            data_engine = DataEngine()
+            strategy = ScalpingStrategy(data_engine)
+
+            if strategy_params:
+                for key, value in strategy_params.items():
+                    if hasattr(strategy, key):
+                        setattr(strategy, key, value)
+
+            mock_exchange = MockExchange(self.fee_rate, self.slippage)
+
+            risk_manager = RiskManager(mock_exchange)
+            risk_manager.max_daily_loss = float('inf')
+
+            trades, equity_curve = self._simulate_trading(
+                df, strategy, risk_manager, mock_exchange, symbol
+            )
+
+            metrics = self._calculate_metrics(trades, equity_curve, df)
+
+            result = {
+                'symbol': symbol,
+                'total_trades': len(trades),
+                'winning_trades': sum(1 for t in trades if t['pnl'] > 0),
+                'losing_trades': sum(1 for t in trades if t['pnl'] < 0),
+                'total_pnl': sum(t['pnl'] for t in trades),
+                'max_drawdown': metrics['max_drawdown'],
+                'win_rate': metrics['win_rate'],
+                'profit_factor': metrics['profit_factor'],
+                'sharpe_ratio': metrics['sharpe_ratio'],
+                'avg_trade_duration': metrics['avg_trade_duration'],
+                'trades': trades[:50],
+                'equity_curve': equity_curve[-100:]
+            }
+
+            self.results[symbol] = result
+            log(f"✅ Backtest completed for {symbol}: {len(trades)} trades, PnL: {result['total_pnl']:.2f}")
+
+            return result
+
+        except Exception as e:
+            logger.error(f"Error in backtest for {symbol}: {e}")
+            return {'error': str(e)}
+
+    def _simulate_trading(self, df: pd.DataFrame, strategy: ScalpingStrategy,
+                         risk_manager: RiskManager, exchange: 'MockExchange',
+                         symbol: str) -> Tuple[List[Dict], List[float]]:
+        trades = []
+        equity_curve = [self.initial_balance]
+        open_position = None
+
+        for i, (timestamp, row) in enumerate(df.iterrows()):
+            current_price = row['close']
+
+            candle_data = {
+                'timestamp': timestamp.timestamp() * 1000,
+                'open': row['open'],
+                'high': row['high'],
+                'low': row['low'],
+                'close': row['close'],
+                'volume': row['volume']
+            }
+
+            historical_df = df.iloc[:i+1]
+            strategy_data_engine = DataEngine()
+
+            for j in range(max(0, i-200), i+1):
+                hist_candle = df.iloc[j]
+                hist_data = {
+                    'timestamp': df.index[j].timestamp() * 1000,
+                    'open': hist_candle['open'],
+                    'high': hist_candle['high'],
+                    'low': hist_candle['low'],
+                    'close': hist_candle['close'],
+                    'volume': hist_candle['volume']
+                }
+                strategy_data_engine.update_candle(symbol, "1", hist_data)
+
+            strategy.data_engine = strategy_data_engine
+
+            if open_position:
+
+                position_age = (timestamp - open_position['entry_time']).seconds / 60
+
+                exit_reason = None
+                if open_position['side'] == 'BUY':
+                    if current_price >= open_position['tp_price']:
+                        exit_reason = 'TP'
+                    elif current_price <= open_position['sl_price']:
+                        exit_reason = 'SL'
+                    elif position_age > 15:
+                        exit_reason = 'TIMEOUT'
+                else:
+                    if current_price <= open_position['tp_price']:
+                        exit_reason = 'TP'
+                    elif current_price >= open_position['sl_price']:
+                        exit_reason = 'SL'
+                    elif position_age > 15:
+                        exit_reason = 'TIMEOUT'
+
+                if exit_reason:
+
+                    pnl = exchange.close_position(open_position, current_price)
+                    equity_curve.append(equity_curve[-1] + pnl)
+
+                    trade = {
+                        'entry_time': open_position['entry_time'],
+                        'exit_time': timestamp,
+                        'side': open_position['side'],
+                        'entry_price': open_position['entry_price'],
+                        'exit_price': current_price,
+                        'quantity': open_position['quantity'],
+                        'pnl': pnl,
+                        'reason': exit_reason,
+                        'duration_minutes': position_age
+                    }
+                    trades.append(trade)
+
+                    open_position = None
+
+            elif i > 50:
+                signal, confidence, price = strategy.generate_signal(symbol)
+
+                if signal in ['BUY', 'SELL'] and confidence > 0.6:
+
+                    if risk_manager.validate_entry_signal(symbol, signal, confidence):
+
+                        qty = risk_manager.calculate_position_size(symbol, price, signal)
+
+                        if qty > 0:
+
+                            open_position = {
+                                'entry_time': timestamp,
+                                'side': signal,
+                                'entry_price': price,
+                                'quantity': qty,
+                                'tp_price': price * (1.025 if signal == 'BUY' else 0.975),
+                                'sl_price': price * (0.99 if signal == 'BUY' else 1.01)
+                            }
+
+        return trades, equity_curve
+
+    def _calculate_metrics(self, trades: List[Dict], equity_curve: List[float],
+                          df: pd.DataFrame) -> Dict[str, float]:
+        try:
+            if not trades:
+                return {
+                    'max_drawdown': 0.0,
+                    'win_rate': 0.0,
+                    'profit_factor': 0.0,
+                    'sharpe_ratio': 0.0,
+                    'avg_trade_duration': 0.0
+                }
+
+            peak = equity_curve[0]
+            max_drawdown = 0.0
+
+            for equity in equity_curve:
+                if equity > peak:
+                    peak = equity
+                drawdown = (peak - equity) / peak
+                max_drawdown = max(max_drawdown, drawdown)
+
+            winning_trades = [t for t in trades if t['pnl'] > 0]
+            win_rate = len(winning_trades) / len(trades) if trades else 0.0
+
+            gross_profit = sum(t['pnl'] for t in winning_trades)
+            gross_loss = abs(sum(t['pnl'] for t in trades if t['pnl'] < 0))
+            profit_factor = gross_profit / gross_loss if gross_loss > 0 else float('inf')
+
+            returns = np.diff(equity_curve) / equity_curve[:-1]
+            if len(returns) > 1 and np.std(returns) > 0:
+                sharpe_ratio = np.mean(returns) / np.std(returns) * np.sqrt(365 * 24 * 60)
+            else:
+                sharpe_ratio = 0.0
+
+            durations = [t['duration_minutes'] for t in trades]
+            avg_trade_duration = np.mean(durations) if durations else 0.0
+
+            return {
+                'max_drawdown': max_drawdown,
+                'win_rate': win_rate,
+                'profit_factor': profit_factor,
+                'sharpe_ratio': sharpe_ratio,
+                'avg_trade_duration': avg_trade_duration
+            }
+
+        except Exception as e:
+            logger.error(f"Error calculating metrics: {e}")
+            return {
+                'max_drawdown': 0.0,
+                'win_rate': 0.0,
+                'profit_factor': 0.0,
+                'sharpe_ratio': 0.0,
+                'avg_trade_duration': 0.0
+            }
+
+    def optimize_parameters(self, symbol: str, param_ranges: Dict[str, List[float]]) -> Dict[str, Any]:
+        try:
+            log(f"🎯 Starting parameter optimization for {symbol}")
+
+            best_result = None
+            best_params = None
+            best_score = -float('inf')
+
+            from itertools import product
+            param_names = list(param_ranges.keys())
+            param_values = list(param_ranges.values())
+
+            total_combinations = np.prod([len(v) for v in param_values])
+            log(f"Testing {total_combinations} parameter combinations")
+
+            for i, param_combo in enumerate(product(*param_values)):
+                param_dict = dict(zip(param_names, param_combo))
+
+                result = self.run_backtest(symbol, strategy_params=param_dict)
+
+                if 'error' not in result:
+
+                    score = result['sharpe_ratio'] - result['max_drawdown'] * 10
+
+                    if score > best_score:
+                        best_score = score
+                        best_result = result
+                        best_params = param_dict
+
+                if (i + 1) % 10 == 0:
+                    log(f"Progress: {i + 1}/{total_combinations} combinations tested")
+
+            if best_result:
+                log(f"✅ Optimization completed. Best params: {best_params}")
+                return {
+                    'best_parameters': best_params,
+                    'best_result': best_result,
+                    'optimization_score': best_score
+                }
+            else:
+                return {'error': 'No valid results found during optimization'}
+
+        except Exception as e:
+            logger.error(f"Error in parameter optimization: {e}")
+            return {'error': str(e)}
+
+    def save_results(self, filename: str = "backtest_results.json"):
+        try:
+            os.makedirs("backtest_results", exist_ok=True)
+            filepath = f"backtest_results/{filename}"
+
+            with open(filepath, 'w') as f:
+                json.dump(self.results, f, indent=2, default=str)
+
+            log(f"💾 Results saved to {filepath}")
+
+        except Exception as e:
+            logger.error(f"Error saving results: {e}")
+
+    def load_results(self, filename: str = "backtest_results.json") -> Dict[str, Any]:
+        try:
+            filepath = f"backtest_results/{filename}"
+
+            if os.path.exists(filepath):
+                with open(filepath, 'r') as f:
+                    self.results = json.load(f)
+                log(f"📂 Results loaded from {filepath}")
+                return self.results
+            else:
+                return {}
+
+        except Exception as e:
+            logger.error(f"Error loading results: {e}")
+            return {}
+
+    def generate_report(self, symbol: str) -> str:
+        try:
+            if symbol not in self.results:
+                return f"No backtest results found for {symbol}"
+
+            result = self.results[symbol]
+
+            report = f
+
+            for i, trade in enumerate(result['trades'][-5:]):
+                report += f"{i+1}. {trade['side']} {trade['quantity']:.3f} @ {trade['entry_price']:.2f} -> {trade['exit_price']:.2f} (PnL: ${trade['pnl']:.2f})\n"
+
+            return report
+
+        except Exception as e:
+            logger.error(f"Error generating report: {e}")
+            return f"Error generating report: {e}"
+
+class MockExchange:
+
+    def __init__(self, fee_rate: float = 0.001, slippage: float = 0.0005):
+        self.fee_rate = fee_rate
+        self.slippage = slippage
+
+    def get_balance(self):
+        return [{"coin": "USDT", "walletBalance": "10000"}]
+
+    def get_positions(self):
+        return []
+
+    def calculate_position_size(self, symbol, entry_price, side):
+        return 0.01
+
+    def validate_entry_signal(self, symbol, signal, confidence):
+        return True
+
+    def close_position(self, position, exit_price):
+        entry_price = position['entry_price']
+        quantity = position['quantity']
+        side = position['side']
+
+        if side == 'BUY':
+            exit_price *= (1 - self.slippage)
+        else:
+            exit_price *= (1 + self.slippage)
+
+        if side == 'BUY':
+            pnl = (exit_price - entry_price) / entry_price * quantity
+        else:
+            pnl = (entry_price - exit_price) / entry_price * quantity
+
+        fee = abs(pnl) * self.fee_rate
+        pnl -= fee
+
+        return pnl

config/pairs.yaml

@@ -0,0 +1,4 @@
+pairs:
+  - BTCUSDT
+  - ETHUSDT
+  - SOLUSDT

config/settings.yaml

@@ -0,0 +1,17 @@
+trading:
+  leverage: 20
+  tp_percent: 0.025
+  sl_percent: 0.01
+  trailing_tp: true
+
+strategy:
+  interval: "1"
+  rsi_period: 14
+  ema_fast: 9
+  ema_slow: 21
+
+risk:
+  risk_per_trade: 0.02
+
+telegram:
+  enabled: true

core/data_engine.py

@@ -0,0 +1,241 @@
+import pandas as pd
+import numpy as np
+from collections import deque
+import logging
+import time
+import yaml
+
+logger = logging.getLogger(__name__)
+
+class DataEngine:
+    def __init__(self):
+        self.settings = yaml.safe_load(open("config/settings.yaml"))
+
+        self.price_buffers = {}
+        self.volume_buffers = {}
+
+        self.candle_buffers = {}
+
+        self.indicators_cache = {}
+
+        self.max_price_buffer = 1000
+        self.max_candle_buffer = 200
+
+        pairs = yaml.safe_load(open("config/pairs.yaml"))["pairs"]
+        for pair in pairs:
+            self._init_buffers(pair)
+
+    def _init_buffers(self, symbol):
+        self.price_buffers[symbol] = deque(maxlen=self.max_price_buffer)
+        self.volume_buffers[symbol] = deque(maxlen=self.max_price_buffer)
+
+        intervals = ["1", "5", "15"]
+        for interval in intervals:
+            key = f"{symbol}_{interval}"
+            self.candle_buffers[key] = deque(maxlen=self.max_candle_buffer)
+            self.indicators_cache[key] = {}
+
+    def update_price(self, symbol, price, volume=0):
+        self.price_buffers[symbol].append(float(price))
+        if volume > 0:
+            self.volume_buffers[symbol].append(float(volume))
+
+    def update_candle(self, symbol, interval, candle_data):
+        key = f"{symbol}_{interval}"
+
+        if isinstance(candle_data, dict):
+            candle = {
+                'timestamp': int(candle_data.get('timestamp', candle_data.get('start', time.time() * 1000))),
+                'open': float(candle_data['open']),
+                'high': float(candle_data['high']),
+                'low': float(candle_data['low']),
+                'close': float(candle_data['close']),
+                'volume': float(candle_data.get('volume', 0))
+            }
+        elif isinstance(candle_data, list):
+
+            candle = {
+                'timestamp': int(candle_data[0]),
+                'open': float(candle_data[1]),
+                'high': float(candle_data[2]),
+                'low': float(candle_data[3]),
+                'close': float(candle_data[4]),
+                'volume': float(candle_data[5])
+            }
+        else:
+            logger.error(f"Invalid candle data format: {candle_data}")
+            return
+
+        self.candle_buffers[key].append(candle)
+
+        self.update_price(symbol, candle['close'], candle['volume'])
+
+        self.indicators_cache[key] = {}
+
+    def get_prices(self, symbol, limit=100):
+        return list(self.price_buffers.get(symbol, deque()))[-limit:]
+
+    def get_candles(self, symbol, interval="1", limit=100):
+        key = f"{symbol}_{interval}"
+        candles = list(self.candle_buffers.get(key, deque()))[-limit:]
+
+        if not candles:
+            return pd.DataFrame()
+
+        df = pd.DataFrame(candles)
+        df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
+        df.set_index('timestamp', inplace=True)
+
+        return df
+
+    def calculate_ema(self, symbol, interval="1", period=9):
+        key = f"{symbol}_{interval}"
+        cache_key = f"ema_{period}"
+
+        if cache_key in self.indicators_cache[key]:
+            return self.indicators_cache[key][cache_key]
+
+        df = self.get_candles(symbol, interval, limit=period * 2)
+        if df.empty or len(df) < period:
+            return None
+
+        ema = df['close'].ewm(span=period, adjust=False).mean()
+        self.indicators_cache[key][cache_key] = ema.iloc[-1] if not ema.empty else None
+
+        return ema.iloc[-1]
+
+    def calculate_rsi(self, symbol, interval="1", period=14):
+        key = f"{symbol}_{interval}"
+        cache_key = f"rsi_{period}"
+
+        if cache_key in self.indicators_cache[key]:
+            return self.indicators_cache[key][cache_key]
+
+        df = self.get_candles(symbol, interval, limit=period * 3)
+        if df.empty or len(df) < period + 1:
+            return None
+
+        delta = df['close'].diff()
+        gain = (delta.where(delta > 0, 0)).rolling(window=period).mean()
+        loss = (-delta.where(delta < 0, 0)).rolling(window=period).mean()
+
+        rs = gain / loss
+        rsi = 100 - (100 / (1 + rs))
+
+        self.indicators_cache[key][cache_key] = rsi.iloc[-1] if not rsi.empty else None
+
+        return rsi.iloc[-1]
+
+    def calculate_adx(self, symbol, interval="1", period=14):
+        key = f"{symbol}_{interval}"
+        cache_key = f"adx_{period}"
+
+        if cache_key in self.indicators_cache[key]:
+            return self.indicators_cache[key][cache_key]
+
+        df = self.get_candles(symbol, interval, limit=period * 3)
+        if df.empty or len(df) < period + 1:
+            return None
+
+        df['hl'] = df['high'] - df['low']
+        df['hc'] = np.abs(df['high'] - df['close'].shift(1))
+        df['lc'] = np.abs(df['low'] - df['close'].shift(1))
+        df['tr'] = df[['hl', 'hc', 'lc']].max(axis=1)
+
+        df['dm_plus'] = np.where((df['high'] - df['high'].shift(1)) > (df['low'].shift(1) - df['low']),
+                                np.maximum(df['high'] - df['high'].shift(1), 0), 0)
+        df['dm_minus'] = np.where((df['low'].shift(1) - df['low']) > (df['high'] - df['high'].shift(1)),
+                                 np.maximum(df['low'].shift(1) - df['low'], 0), 0)
+
+        df['di_plus'] = 100 * (df['dm_plus'].rolling(window=period).mean() / df['tr'].rolling(window=period).mean())
+        df['di_minus'] = 100 * (df['dm_minus'].rolling(window=period).mean() / df['tr'].rolling(window=period).mean())
+
+        df['dx'] = 100 * np.abs(df['di_plus'] - df['di_minus']) / (df['di_plus'] + df['di_minus'])
+        adx = df['dx'].rolling(window=period).mean()
+
+        self.indicators_cache[key][cache_key] = adx.iloc[-1] if not adx.empty else None
+
+        return adx.iloc[-1]
+
+    def get_orderbook_imbalance(self, symbol, orderbook_data=None):
+        if orderbook_data is None:
+
+            return 0.0
+
+        bids = orderbook_data.get('b', [])
+        asks = orderbook_data.get('a', [])
+
+        bid_volume = sum(float(bid[1]) for bid in bids[:10])
+        ask_volume = sum(float(ask[1]) for ask in asks[:10])
+
+        total_volume = bid_volume + ask_volume
+        if total_volume == 0:
+            return 0.0
+
+        imbalance = (bid_volume - ask_volume) / total_volume
+
+        return imbalance
+
+    def get_spread(self, symbol, orderbook_data=None):
+        if orderbook_data is None:
+            return 0.0
+
+        bids = orderbook_data.get('b', [])
+        asks = orderbook_data.get('a', [])
+
+        if not bids or not asks:
+            return 0.0
+
+        best_bid = float(bids[0][0])
+        best_ask = float(asks[0][0])
+
+        spread = (best_ask - best_bid) / best_bid
+        return spread
+
+    def detect_volume_spike(self, symbol, interval="1", threshold=2.0):
+        df = self.get_candles(symbol, interval, limit=20)
+        if df.empty or len(df) < 5:
+            return False
+
+        current_volume = df['volume'].iloc[-1]
+        avg_volume = df['volume'].iloc[:-1].mean()
+
+        if avg_volume == 0:
+            return False
+
+        return (current_volume / avg_volume) > threshold
+
+    def get_price_change_rate(self, symbol, periods=5):
+        prices = self.get_prices(symbol, limit=periods + 1)
+        if len(prices) < periods + 1:
+            return 0.0
+
+        old_price = prices[0]
+        new_price = prices[-1]
+
+        if old_price == 0:
+            return 0.0
+
+        return (new_price - old_price) / old_price
+
+    def clear_cache(self, symbol=None, interval=None):
+        if symbol and interval:
+            key = f"{symbol}_{interval}"
+            if key in self.indicators_cache:
+                self.indicators_cache[key] = {}
+        elif symbol:
+
+            for key in list(self.indicators_cache.keys()):
+                if key.startswith(f"{symbol}_"):
+                    self.indicators_cache[key] = {}
+        else:
+
+            self.indicators_cache = {}
+
+    def get_buffer_status(self):
+        status = {
+            'price_buffers': {symbol: len(buffer) for symbol, buffer in self.price_buffers.items()},
+            'candle_buffers': {key: len(buffer) for key, buffer in self.candle_buffers.items()},
+            'indicators_cache': {key: list(cache.keys()) for key, cache in self.indicators_cache.items()}
+        }
+        return status

core/exchange.py

@@ -0,0 +1,186 @@
+from pybit.unified_trading import HTTP
+from dotenv import load_dotenv
+import os
+import yaml
+import time
+import logging
+
+load_dotenv()
+logger = logging.getLogger(__name__)
+
+class BybitExchange:
+    def __init__(self):
+        self.settings = yaml.safe_load(open("config/settings.yaml"))
+
+        API_KEY = os.getenv("BYBIT_API_KEY")
+        API_SECRET = os.getenv("BYBIT_API_SECRET")
+        TESTNET = os.getenv("BYBIT_TESTNET", "true").lower() == "true"
+
+        if not API_KEY or not API_SECRET:
+            raise Exception("API keys missing in .env")
+
+        self.session = HTTP(
+            api_key=API_KEY,
+            api_secret=API_SECRET,
+            testnet=TESTNET
+        )
+
+        self.max_retries = 3
+        self.retry_delay = 1
+
+    def _retry_request(self, func, *args, **kwargs):
+        for attempt in range(self.max_retries):
+            try:
+                response = func(*args, **kwargs)
+                if "retCode" in response and response["retCode"] == 0:
+                    return response
+                else:
+                    logger.warning(f"API call failed: {response}")
+                    if attempt < self.max_retries - 1:
+                        time.sleep(self.retry_delay * (attempt + 1))
+                        continue
+                    raise Exception(f"API call failed after {self.max_retries} attempts: {response}")
+            except Exception as e:
+                logger.error(f"API request error: {e}")
+                if attempt < self.max_retries - 1:
+                    time.sleep(self.retry_delay * (attempt + 1))
+                    continue
+                raise e
+
+    def get_balance(self):
+        response = self._retry_request(self.session.get_wallet_balance, accountType="UNIFIED")
+        return response["result"]["list"][0]["coin"]
+
+    def get_positions(self, symbol=None):
+        params = {"category": "linear"}
+        if symbol:
+            params["symbol"] = symbol
+
+        response = self._retry_request(self.session.get_positions, **params)
+        return response["result"]["list"]
+
+    def set_leverage(self, symbol, leverage=None):
+        lev = leverage or self.settings["trading"]["leverage"]
+        response = self._retry_request(
+            self.session.set_leverage,
+            category="linear",
+            symbol=symbol,
+            buyLeverage=str(lev),
+            sellLeverage=str(lev)
+        )
+        return response
+
+    def market_order(self, symbol, side, qty, reduce_only=False):
+        params = {
+            "category": "linear",
+            "symbol": symbol,
+            "side": side.upper(),
+            "orderType": "Market",
+            "qty": str(qty)
+        }
+
+        if reduce_only:
+            params["reduceOnly"] = True
+
+        response = self._retry_request(self.session.place_order, **params)
+        return response["result"]
+
+    def limit_order(self, symbol, side, qty, price, reduce_only=False):
+        params = {
+            "category": "linear",
+            "symbol": symbol,
+            "side": side.upper(),
+            "orderType": "Limit",
+            "qty": str(qty),
+            "price": str(price)
+        }
+
+        if reduce_only:
+            params["reduceOnly"] = True
+
+        response = self._retry_request(self.session.place_order, **params)
+        return response["result"]
+
+    def set_tp_sl(self, symbol, side, entry_price, tp_price, sl_price):
+        response = self._retry_request(
+            self.session.set_trading_stop,
+            category="linear",
+            symbol=symbol,
+            takeProfit=str(tp_price),
+            stopLoss=str(sl_price),
+            tpTriggerBy="LastPrice",
+            slTriggerBy="LastPrice"
+        )
+        return response
+
+    def cancel_order(self, symbol, order_id=None):
+        params = {"category": "linear", "symbol": symbol}
+        if order_id:
+            params["orderId"] = order_id
+
+        response = self._retry_request(self.session.cancel_order, **params)
+        return response["result"]
+
+    def cancel_all_orders(self, symbol=None):
+        params = {"category": "linear"}
+        if symbol:
+            params["symbol"] = symbol
+
+        response = self._retry_request(self.session.cancel_all_orders, **params)
+        return response["result"]
+
+    def close_position(self, symbol):
+        positions = self.get_positions(symbol)
+        if not positions:
+            return None
+
+        position = positions[0]
+        size = float(position["size"])
+
+        if size > 0:
+
+            return self.market_order(symbol, "Sell", size, reduce_only=True)
+        elif size < 0:
+
+            return self.market_order(symbol, "Buy", abs(size), reduce_only=True)
+
+        return None
+
+    def get_active_orders(self, symbol=None):
+        params = {"category": "linear"}
+        if symbol:
+            params["symbol"] = symbol
+
+        response = self._retry_request(self.session.get_open_orders, **params)
+        return response["result"]["list"]
+
+    def get_kline_data(self, symbol, interval="1", limit=200):
+        response = self._retry_request(
+            self.session.get_kline,
+            category="linear",
+            symbol=symbol,
+            interval=interval,
+            limit=limit
+        )
+        return response["result"]["list"]
+
+    def get_orderbook(self, symbol, limit=25):
+        response = self._retry_request(
+            self.session.get_orderbook,
+            category="linear",
+            symbol=symbol,
+            limit=limit
+        )
+        return response["result"]
+
+    def get_ticker(self, symbol):
+        response = self._retry_request(
+            self.session.get_tickers,
+            category="linear",
+            symbol=symbol
+        )
+        return response["result"]["list"][0]
+
+    def get_server_time(self):
+        response = self._retry_request(self.session.get_server_time)
+        return response["result"]["timeSecond"]

core/indicators.py

@@ -0,0 +1,254 @@
+import pandas as pd
+import numpy as np
+from typing import Optional, List, Dict, Any
+import logging
+
+logger = logging.getLogger(__name__)
+
+class TechnicalIndicators:
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def sma(data: pd.Series, period: int) -> pd.Series:
+        return data.rolling(window=period).mean()
+
+    @staticmethod
+    def ema(data: pd.Series, period: int) -> pd.Series:
+        return data.ewm(span=period, adjust=False).mean()
+
+    @staticmethod
+    def rsi(data: pd.Series, period: int = 14) -> pd.Series:
+        delta = data.diff()
+        gain = (delta.where(delta > 0, 0)).rolling(window=period).mean()
+        loss = (-delta.where(delta < 0, 0)).rolling(window=period).mean()
+
+        rs = gain / loss
+        rsi = 100 - (100 / (1 + rs))
+
+        return rsi
+
+    @staticmethod
+    def macd(data: pd.Series, fast_period: int = 12, slow_period: int = 26, signal_period: int = 9) -> Dict[str, pd.Series]:
+        fast_ema = TechnicalIndicators.ema(data, fast_period)
+        slow_ema = TechnicalIndicators.ema(data, slow_period)
+
+        macd_line = fast_ema - slow_ema
+        signal_line = TechnicalIndicators.ema(macd_line, signal_period)
+        histogram = macd_line - signal_line
+
+        return {
+            'macd': macd_line,
+            'signal': signal_line,
+            'histogram': histogram
+        }
+
+    @staticmethod
+    def bollinger_bands(data: pd.Series, period: int = 20, std_dev: float = 2.0) -> Dict[str, pd.Series]:
+        sma = TechnicalIndicators.sma(data, period)
+        std = data.rolling(window=period).std()
+
+        upper_band = sma + (std * std_dev)
+        lower_band = sma - (std * std_dev)
+
+        return {
+            'upper': upper_band,
+            'middle': sma,
+            'lower': lower_band
+        }
+
+    @staticmethod
+    def adx(high: pd.Series, low: pd.Series, close: pd.Series, period: int = 14) -> pd.Series:
+
+        hl = high - low
+        hc = np.abs(high - close.shift(1))
+        lc = np.abs(low - close.shift(1))
+        tr = pd.concat([hl, hc, lc], axis=1).max(axis=1)
+
+        dm_plus = np.where((high - high.shift(1)) > (low.shift(1) - low),
+                          np.maximum(high - high.shift(1), 0), 0)
+        dm_minus = np.where((low.shift(1) - low) > (high - high.shift(1)),
+                           np.maximum(low.shift(1) - low), 0)
+
+        tr_smooth = tr.rolling(window=period).mean()
+        dm_plus_smooth = pd.Series(dm_plus).rolling(window=period).mean()
+        dm_minus_smooth = pd.Series(dm_minus).rolling(window=period).mean()
+
+        di_plus = 100 * (dm_plus_smooth / tr_smooth)
+        di_minus = 100 * (dm_minus_smooth / tr_smooth)
+
+        dx = 100 * np.abs(di_plus - di_minus) / (di_plus + di_minus)
+        adx = dx.rolling(window=period).mean()
+
+        return adx
+
+    @staticmethod
+    def stochastic_oscillator(high: pd.Series, low: pd.Series, close: pd.Series,
+                            k_period: int = 14, d_period: int = 3) -> Dict[str, pd.Series]:
+        lowest_low = low.rolling(window=k_period).min()
+        highest_high = high.rolling(window=k_period).max()
+
+        k_percent = 100 * ((close - lowest_low) / (highest_high - lowest_low))
+        d_percent = k_percent.rolling(window=d_period).mean()
+
+        return {
+            'k': k_percent,
+            'd': d_percent
+        }
+
+    @staticmethod
+    def williams_r(high: pd.Series, low: pd.Series, close: pd.Series, period: int = 14) -> pd.Series:
+        highest_high = high.rolling(window=period).max()
+        lowest_low = low.rolling(window=period).min()
+
+        williams_r = -100 * ((highest_high - close) / (highest_high - lowest_low))
+
+        return williams_r
+
+    @staticmethod
+    def cci(high: pd.Series, low: pd.Series, close: pd.Series, period: int = 20) -> pd.Series:
+        typical_price = (high + low + close) / 3
+        sma_tp = TechnicalIndicators.sma(typical_price, period)
+        mad = lambda x: np.mean(np.abs(x - x.mean()))
+        mean_deviation = typical_price.rolling(window=period).apply(mad, raw=False)
+
+        cci = (typical_price - sma_tp) / (0.015 * mean_deviation)
+
+        return cci
+
+    @staticmethod
+    def atr(high: pd.Series, low: pd.Series, close: pd.Series, period: int = 14) -> pd.Series:
+        hl = high - low
+        hc = np.abs(high - close.shift(1))
+        lc = np.abs(low - close.shift(1))
+        tr = pd.concat([hl, hc, lc], axis=1).max(axis=1)
+
+        atr = tr.rolling(window=period).mean()
+
+        return atr
+
+    @staticmethod
+    def ichimoku_cloud(high: pd.Series, low: pd.Series, conversion_period: int = 9,
+                      base_period: int = 26, span_b_period: int = 52,
+                      lagging_period: int = 26) -> Dict[str, pd.Series]:
+
+        conversion_line = (high.rolling(window=conversion_period).max() +
+                          low.rolling(window=conversion_period).min()) / 2
+
+        base_line = (high.rolling(window=base_period).max() +
+                    low.rolling(window=base_period).min()) / 2
+
+        leading_span_a = ((conversion_line + base_line) / 2).shift(lagging_period)
+
+        leading_span_b = ((high.rolling(window=span_b_period).max() +
+                          low.rolling(window=span_b_period).min()) / 2).shift(lagging_period)
+
+        lagging_span = close.shift(-lagging_period)
+
+        return {
+            'conversion_line': conversion_line,
+            'base_line': base_line,
+            'leading_span_a': leading_span_a,
+            'leading_span_b': leading_span_b,
+            'lagging_span': lagging_span
+        }
+
+    @staticmethod
+    def fibonacci_retracements(high: pd.Series, low: pd.Series) -> Dict[str, float]:
+        max_high = high.max()
+        min_low = low.min()
+        diff = max_high - min_low
+
+        levels = {
+            '0.0': max_high,
+            '0.236': max_high - 0.236 * diff,
+            '0.382': max_high - 0.382 * diff,
+            '0.5': max_high - 0.5 * diff,
+            '0.618': max_high - 0.618 * diff,
+            '0.786': max_high - 0.786 * diff,
+            '1.0': min_low
+        }
+
+        return levels
+
+    @staticmethod
+    def detect_crossover(fast_series: pd.Series, slow_series: pd.Series) -> Dict[str, bool]:
+
+        crossed_above = (fast_series.shift(1) <= slow_series.shift(1)) & (fast_series > slow_series)
+
+        crossed_below = (fast_series.shift(1) >= slow_series.shift(1)) & (fast_series < slow_series)
+
+        return {
+            'crossed_above': crossed_above.iloc[-1] if not crossed_above.empty else False,
+            'crossed_below': crossed_below.iloc[-1] if not crossed_below.empty else False
+        }
+
+    @staticmethod
+    def volume_profile(volume: pd.Series, price: pd.Series, bins: int = 50) -> Dict[str, Any]:
+
+        price_min, price_max = price.min(), price.max()
+        price_bins = np.linspace(price_min, price_max, bins)
+
+        volume_profile = []
+        for i in range(len(price_bins) - 1):
+            mask = (price >= price_bins[i]) & (price < price_bins[i + 1])
+            bin_volume = volume[mask].sum()
+            volume_profile.append({
+                'price_level': (price_bins[i] + price_bins[i + 1]) / 2,
+                'volume': bin_volume
+            })
+
+        poc = max(volume_profile, key=lambda x: x['volume'])['price_level']
+
+        total_volume = sum(x['volume'] for x in volume_profile)
+        sorted_profile = sorted(volume_profile, key=lambda x: x['volume'], reverse=True)
+
+        cumulative_volume = 0
+        value_area_high = None
+        value_area_low = None
+
+        for level in sorted_profile:
+            cumulative_volume += level['volume']
+            if cumulative_volume >= total_volume * 0.7:
+                break
+
+        in_value_area = sorted([x for x in volume_profile if x['volume'] > 0],
+                              key=lambda x: x['volume'], reverse=True)[:len([x for x in sorted_profile if cumulative_volume >= total_volume * 0.7])]
+
+        if in_value_area:
+            prices_in_va = [x['price_level'] for x in in_value_area]
+            value_area_high = max(prices_in_va)
+            value_area_low = min(prices_in_va)
+
+        return {
+            'volume_profile': volume_profile,
+            'poc': poc,
+            'value_area_high': value_area_high,
+            'value_area_low': value_area_low
+        }
+
+    @staticmethod
+    def order_flow_imbalance(orderbook: Dict) -> Dict[str, float]:
+        if not orderbook or 'b' not in orderbook or 'a' not in orderbook:
+            return {'imbalance': 0.0, 'bid_pressure': 0.0, 'ask_pressure': 0.0}
+
+        bids = orderbook['b'][:10]
+        asks = orderbook['a'][:10]
+
+        bid_volume = sum(float(bid[1]) for bid in bids)
+        ask_volume = sum(float(ask[1]) for ask in asks)
+
+        total_volume = bid_volume + ask_volume
+
+        if total_volume == 0:
+            return {'imbalance': 0.0, 'bid_pressure': 0.0, 'ask_pressure': 0.0}
+
+        imbalance = (bid_volume - ask_volume) / total_volume
+        bid_pressure = bid_volume / total_volume
+        ask_pressure = ask_volume / total_volume
+
+        return {
+            'imbalance': imbalance,
+            'bid_pressure': bid_pressure,
+            'ask_pressure': ask_pressure
+        }

core/risk.py

@@ -0,0 +1,267 @@
+import logging
+from typing import Dict, List, Optional, Tuple, Any
+import yaml
+import time
+from datetime import datetime, timedelta
+
+logger = logging.getLogger(__name__)
+
+class RiskManager:
+    def __init__(self, exchange_client):
+        self.exchange = exchange_client
+        self.settings = yaml.safe_load(open("config/settings.yaml"))
+        self.leverage = self.settings["trading"]["leverage"]
+        self.tp_percent = self.settings["trading"]["tp_percent"]
+        self.sl_percent = self.settings["trading"]["sl_percent"]
+        self.risk_per_trade = self.settings["risk"]["risk_per_trade"]
+        self.max_daily_loss = 100
+        self.daily_pnl = 0.0
+        self.daily_trades = 0
+        self.max_daily_trades = 50
+        self.max_open_positions = 1
+        self.min_order_size = 0.001
+        self.open_positions = {}
+        self.emergency_stop = False
+        self.last_reset_time = datetime.now()
+        self.trade_history = []
+        self.win_count = 0
+        self.loss_count = 0
+
+    def calculate_position_size(self, symbol: str, entry_price: float, side: str) -> float:
+        try:
+            balance_data = self.exchange.get_balance()
+            if not balance_data:
+                logger.error("Failed to get account balance")
+                return 0.0
+            usdt_balance = 0.0
+            for coin in balance_data:
+                if coin.get("coin") == "USDT":
+                    usdt_balance = float(coin.get("walletBalance", 0))
+                    break
+            if usdt_balance <= 0:
+                logger.warning("Insufficient USDT balance")
+                return 0.0
+            risk_amount = usdt_balance * self.risk_per_trade
+            sl_distance = entry_price * self.sl_percent
+            position_size = risk_amount / (sl_distance * self.leverage)
+            position_size = max(position_size, self.min_order_size)
+            if self.daily_pnl < -self.max_daily_loss:
+                logger.warning(f"Daily loss limit reached: {self.daily_pnl}")
+                return 0.0
+            if self.daily_trades >= self.max_daily_trades:
+                logger.warning("Max daily trades reached")
+                return 0.0
+            if symbol in self.open_positions:
+                logger.warning(f"Position already open for {symbol}")
+                return 0.0
+            position_size = self._validate_position_size(symbol, position_size, entry_price)
+            logger.info(f"Calculated position size: {position_size:.4f} for {symbol}")
+            return position_size
+        except Exception as e:
+            logger.error(f"Error calculating position size: {e}")
+            return 0.0
+
+    def _validate_position_size(self, symbol: str, size: float, price: float) -> float:
+        try:
+            min_size = 0.001
+            max_size = 100.0
+            validated_size = max(min_size, min(size, max_size))
+            if symbol.startswith('BTC'):
+                validated_size = round(validated_size, 3)
+            elif symbol.startswith('ETH'):
+                validated_size = round(validated_size, 2)
+            else:
+                validated_size = round(validated_size, 1)
+            return validated_size
+        except Exception as e:
+            logger.error(f"Error validating position size: {e}")
+            return 0.0
+
+    def validate_entry_signal(self, symbol: str, signal: str, confidence: float) -> bool:
+        try:
+            if self.emergency_stop:
+                logger.warning("Emergency stop activated")
+                return False
+            min_confidence = 0.6
+            if confidence < min_confidence:
+                logger.info(f"Signal confidence too low: {confidence}")
+                return False
+            if symbol in self.open_positions:
+                logger.warning(f"Position already exists for {symbol}")
+                return False
+            if not self._check_market_conditions(symbol):
+                return False
+            if self._is_high_volatility(symbol):
+                logger.warning(f"High volatility detected for {symbol}")
+                return False
+            return True
+        except Exception as e:
+            logger.error(f"Error validating entry signal: {e}")
+            return False
+
+    def _check_market_conditions(self, symbol: str) -> bool:
+        try:
+            ticker = self.exchange.get_ticker(symbol)
+            if not ticker:
+                return False
+            volume_24h = float(ticker.get("volume24h", 0))
+            if volume_24h < 100000:
+                logger.warning(f"Low volume for {symbol}: {volume_24h}")
+                return False
+            bid_price = float(ticker.get("bid1Price", 0))
+            ask_price = float(ticker.get("ask1Price", 0))
+            if bid_price == 0 or ask_price == 0:
+                return False
+            spread = (ask_price - bid_price) / bid_price
+            max_spread = 0.001
+            if spread > max_spread:
+                logger.warning(f"Spread too wide for {symbol}: {spread}")
+                return False
+            return True
+        except Exception as e:
+            logger.error(f"Error checking market conditions: {e}")
+            return False
+
+    def _is_high_volatility(self, symbol: str) -> bool:
+        try:
+            prices = self.exchange.get_kline_data(symbol, interval="1", limit=10)
+            if not prices or len(prices) < 5:
+                return True
+            high = max(float(candle[2]) for candle in prices)
+            low = min(float(candle[3]) for candle in prices)
+            current_price = float(prices[-1][4])
+            volatility = (high - low) / current_price
+            high_vol_threshold = 0.02
+            return volatility > high_vol_threshold
+        except Exception as e:
+            logger.error(f"Error checking volatility: {e}")
+            return True
+
+    def update_position(self, symbol: str, position_data: Dict[str, Any]):
+        try:
+            self.open_positions[symbol] = {
+                'entry_time': datetime.now(),
+                'entry_price': float(position_data.get('avgPrice', 0)),
+                'size': float(position_data.get('qty', 0)),
+                'side': position_data.get('side', ''),
+                'leverage': self.leverage
+            }
+            logger.info(f"Position updated for {symbol}: {self.open_positions[symbol]}")
+        except Exception as e:
+            logger.error(f"Error updating position for {symbol}: {e}")
+
+    def close_position(self, symbol: str, reason: str = "manual"):
+        try:
+            if symbol not in self.open_positions:
+                logger.warning(f"No position found for {symbol}")
+                return False
+            position = self.open_positions[symbol]
+            exit_price = self.exchange.get_ticker(symbol)
+            if exit_price:
+                exit_price = float(exit_price.get("lastPrice", 0))
+                entry_price = position['entry_price']
+                if position['side'] == 'Buy':
+                    pnl = (exit_price - entry_price) / entry_price * position['size'] * self.leverage
+                else:
+                    pnl = (entry_price - exit_price) / entry_price * position['size'] * self.leverage
+                self.daily_pnl += pnl
+                if pnl > 0:
+                    self.win_count += 1
+                else:
+                    self.loss_count += 1
+                self._record_trade(symbol, position, exit_price, pnl, reason)
+            del self.open_positions[symbol]
+            self.daily_trades += 1
+            logger.info(f"Position closed for {symbol}, reason: {reason}")
+            return True
+        except Exception as e:
+            logger.error(f"Error closing position for {symbol}: {e}")
+            return False
+
+    def _record_trade(self, symbol: str, position: Dict, exit_price: float, pnl: float, reason: str):
+        try:
+            trade = {
+                'symbol': symbol,
+                'entry_time': position['entry_time'],
+                'exit_time': datetime.now(),
+                'entry_price': position['entry_price'],
+                'exit_price': exit_price,
+                'size': position['size'],
+                'side': position['side'],
+                'pnl': pnl,
+                'reason': reason,
+                'leverage': position['leverage']
+            }
+            self.trade_history.append(trade)
+            if len(self.trade_history) > 1000:
+                self.trade_history = self.trade_history[-1000:]
+        except Exception as e:
+            logger.error(f"Error recording trade: {e}")
+
+    def check_tp_sl_hit(self, symbol: str) -> Optional[str]:
+        try:
+            if symbol not in self.open_positions:
+                return None
+            position = self.open_positions[symbol]
+            current_price = self.exchange.get_ticker(symbol)
+            if not current_price:
+                return None
+            current_price = float(current_price.get("lastPrice", 0))
+            entry_price = position['entry_price']
+            if position['side'] == 'Buy':
+                tp_price = entry_price * (1 + self.tp_percent)
+                sl_price = entry_price * (1 - self.sl_percent)
+                if current_price >= tp_price:
+                    return "TP"
+                elif current_price <= sl_price:
+                    return "SL"
+            else:
+                tp_price = entry_price * (1 - self.tp_percent)
+                sl_price = entry_price * (1 + self.sl_percent)
+                if current_price <= tp_price:
+                    return "TP"
+                elif current_price >= sl_price:
+                    return "SL"
+            return None
+        except Exception as e:
+            logger.error(f"Error checking TP/SL for {symbol}: {e}")
+            return None
+
+    def emergency_stop_all(self):
+        try:
+            self.emergency_stop = True
+            for symbol in list(self.open_positions.keys()):
+                self.exchange.close_position(symbol)
+                self.close_position(symbol, "emergency_stop")
+            logger.critical("Emergency stop activated - all positions closed")
+        except Exception as e:
+            logger.error(f"Error in emergency stop: {e}")
+
+    def reset_daily_stats(self):
+        try:
+            now = datetime.now()
+            if now.date() > self.last_reset_time.date():
+                self.daily_pnl = 0.0
+                self.daily_trades = 0
+                self.last_reset_time = now
+                logger.info("Daily statistics reset")
+        except Exception as e:
+            logger.error(f"Error resetting daily stats: {e}")
+
+    def get_risk_status(self) -> Dict[str, Any]:
+        try:
+            total_trades = self.win_count + self.loss_count
+            win_rate = self.win_count / total_trades if total_trades > 0 else 0.0
+            status = {
+                'emergency_stop': self.emergency_stop,
+                'open_positions': len(self.open_positions),
+                'daily_pnl': self.daily_pnl,
+                'daily_trades': self.daily_trades,
+                'win_rate': win_rate,
+                'total_trades': total_trades,
+                'positions': list(self.open_positions.keys())
+            }
+            return status
+        except Exception as e:
+            logger.error(f"Error getting risk status: {e}")
+            return {'error': str(e)}

core/strategy.py

@@ -0,0 +1,190 @@
+import pandas as pd
+import numpy as np
+import logging
+from typing import Dict, List, Optional, Tuple, Any
+from core.indicators import TechnicalIndicators
+from core.data_engine import DataEngine
+import yaml
+
+logger = logging.getLogger(__name__)
+
+class ScalpingStrategy:
+    def __init__(self, data_engine: DataEngine):
+        self.data_engine = data_engine
+        self.settings = yaml.safe_load(open("config/settings.yaml"))
+        self.ema_fast_period = self.settings["strategy"]["ema_fast"]
+        self.ema_slow_period = self.settings["strategy"]["ema_slow"]
+        self.rsi_period = self.settings["strategy"]["rsi_period"]
+        self.strategy_weights = {
+            'ema_momentum': 0.4,
+            'breakout': 0.35,
+            'pullback': 0.25
+        }
+        self.min_confidence = 0.6
+
+    def generate_signal(self, symbol: str, interval: str = "1") -> Tuple[str, float, float]:
+        try:
+            current_price = self.data_engine.get_prices(symbol, limit=1)
+            if not current_price:
+                return "NEUTRAL", 0.0, 0.0
+            current_price = current_price[-1]
+            ema_signal, ema_conf = self._ema_momentum_strategy(symbol, interval)
+            breakout_signal, breakout_conf = self._breakout_strategy(symbol, interval)
+            pullback_signal, pullback_conf = self._pullback_strategy(symbol, interval)
+            buy_signals = []
+            sell_signals = []
+            if ema_signal == "BUY":
+                buy_signals.append(ema_conf * self.strategy_weights['ema_momentum'])
+            elif ema_signal == "SELL":
+                sell_signals.append(ema_conf * self.strategy_weights['ema_momentum'])
+            if breakout_signal == "BUY":
+                buy_signals.append(breakout_conf * self.strategy_weights['breakout'])
+            elif breakout_signal == "SELL":
+                sell_signals.append(breakout_conf * self.strategy_weights['breakout'])
+            if pullback_signal == "BUY":
+                buy_signals.append(pullback_conf * self.strategy_weights['pullback'])
+            elif pullback_signal == "SELL":
+                sell_signals.append(pullback_conf * self.strategy_weights['pullback'])
+            buy_strength = sum(buy_signals) if buy_signals else 0.0
+            sell_strength = sum(sell_signals) if sell_signals else 0.0
+            if buy_strength > self.min_confidence and buy_strength > sell_strength:
+                final_confidence = min(buy_strength, 1.0)
+                return "BUY", final_confidence, current_price
+            elif sell_strength > self.min_confidence and sell_strength > buy_strength:
+                final_confidence = min(sell_strength, 1.0)
+                return "SELL", final_confidence, current_price
+            else:
+                return "NEUTRAL", 0.0, current_price
+        except Exception as e:
+            logger.error(f"Error generating signal for {symbol}: {e}")
+            return "NEUTRAL", 0.0, 0.0
+
+    def _ema_momentum_strategy(self, symbol: str, interval: str) -> Tuple[str, float]:
+        try:
+            df = self.data_engine.get_candles(symbol, interval, limit=50)
+            if df.empty or len(df) < self.ema_slow_period + 5:
+                return "NEUTRAL", 0.0
+            ema_fast = self.data_engine.calculate_ema(symbol, interval, self.ema_fast_period)
+            ema_slow = self.data_engine.calculate_ema(symbol, interval, self.ema_slow_period)
+            rsi = self.data_engine.calculate_rsi(symbol, interval, self.rsi_period)
+            if ema_fast is None or ema_slow is None or rsi is None:
+                return "NEUTRAL", 0.0
+            ema_fast_prev = df['close'].ewm(span=self.ema_fast_period, adjust=False).mean().iloc[-2]
+            ema_slow_prev = df['close'].ewm(span=self.ema_slow_period, adjust=False).mean().iloc[-2]
+            crossover_up = ema_fast_prev <= ema_slow_prev and ema_fast > ema_slow
+            crossover_down = ema_fast_prev >= ema_slow_prev and ema_fast < ema_slow
+            rsi_oversold = rsi < 35
+            rsi_overbought = rsi > 65
+            orderbook_imbalance = self.data_engine.get_orderbook_imbalance(symbol)
+            confidence = 0.0
+            signal = "NEUTRAL"
+            if crossover_up and rsi_oversold and orderbook_imbalance > 0.1:
+                confidence = 0.8
+                signal = "BUY"
+            elif crossover_down and rsi_overbought and orderbook_imbalance < -0.1:
+                confidence = 0.8
+                signal = "SELL"
+            return signal, confidence
+        except Exception as e:
+            logger.error(f"EMA momentum strategy error for {symbol}: {e}")
+            return "NEUTRAL", 0.0
+
+    def _breakout_strategy(self, symbol: str, interval: str) -> Tuple[str, float]:
+        try:
+            df = self.data_engine.get_candles(symbol, interval, limit=20)
+            if df.empty or len(df) < 10:
+                return "NEUTRAL", 0.0
+            volume_spike = self.data_engine.detect_volume_spike(symbol, interval, threshold=1.8)
+            price_change_rate = self.data_engine.get_price_change_rate(symbol, periods=3)
+            spread = self.data_engine.get_spread(symbol)
+            orderbook_imbalance = self.data_engine.get_orderbook_imbalance(symbol)
+            recent_high = df['high'].tail(5).max()
+            recent_low = df['low'].tail(5).min()
+            current_price = df['close'].iloc[-1]
+            breakout_up = current_price > recent_high * 1.001
+            breakout_down = current_price < recent_low * 0.999
+            confidence = 0.0
+            signal = "NEUTRAL"
+            if breakout_up and volume_spike and price_change_rate > 0.002 and orderbook_imbalance > 0.15:
+                confidence = 0.75
+                signal = "BUY"
+            elif breakout_down and volume_spike and price_change_rate < -0.002 and orderbook_imbalance < -0.15:
+                confidence = 0.75
+                signal = "SELL"
+            return signal, confidence
+        except Exception as e:
+            logger.error(f"Breakout strategy error for {symbol}: {e}")
+            return "NEUTRAL", 0.0
+
+    def _pullback_strategy(self, symbol: str, interval: str) -> Tuple[str, float]:
+        try:
+            df = self.data_engine.get_candles(symbol, interval, limit=30)
+            if df.empty or len(df) < 20:
+                return "NEUTRAL", 0.0
+            ema_21 = df['close'].ewm(span=21, adjust=False).mean()
+            ema_slope = ema_21.diff().iloc[-1]
+            uptrend = ema_slope > 0
+            downtrend = ema_slope < 0
+            ema_9 = df['close'].ewm(span=9, adjust=False).mean().iloc[-1]
+            current_price = df['close'].iloc[-1]
+            price_to_ema_ratio = current_price / ema_9
+            recent_volume = df['volume'].tail(5).mean()
+            previous_volume = df['volume'].tail(10).head(5).mean()
+            volume_trend = recent_volume / previous_volume if previous_volume > 0 else 1.0
+            pullback_up = uptrend and price_to_ema_ratio < 0.995
+            pullback_down = downtrend and price_to_ema_ratio > 1.005
+            volume_decrease_on_pullback = volume_trend < 0.8
+            volume_increase_on_continuation = volume_trend > 1.2
+            confidence = 0.0
+            signal = "NEUTRAL"
+            if pullback_up and volume_decrease_on_pullback:
+                if volume_increase_on_continuation and current_price > ema_9:
+                    confidence = 0.7
+                    signal = "BUY"
+            elif pullback_down and volume_decrease_on_pullback:
+                if volume_increase_on_continuation and current_price < ema_9:
+                    confidence = 0.7
+                    signal = "SELL"
+            return signal, confidence
+        except Exception as e:
+            logger.error(f"Pullback strategy error for {symbol}: {e}")
+            return "NEUTRAL", 0.0
+
+    def get_strategy_status(self, symbol: str) -> Dict[str, Any]:
+        try:
+            status = {
+                'symbol': symbol,
+                'timestamp': pd.Timestamp.now(),
+                'strategies': {}
+            }
+            ema_signal, ema_conf = self._ema_momentum_strategy(symbol)
+            breakout_signal, breakout_conf = self._breakout_strategy(symbol)
+            pullback_signal, pullback_conf = self._pullback_strategy(symbol)
+            status['strategies'] = {
+                'ema_momentum': {
+                    'signal': ema_signal,
+                    'confidence': ema_conf
+                },
+                'breakout': {
+                    'signal': breakout_signal,
+                    'confidence': breakout_conf
+                },
+                'pullback': {
+                    'signal': pullback_signal,
+                    'confidence': pullback_conf
+                }
+            }
+            current_price = self.data_engine.get_prices(symbol, limit=1)
+            status['current_price'] = current_price[-1] if current_price else None
+            ema_fast = self.data_engine.calculate_ema(symbol, "1", self.ema_fast_period)
+            ema_slow = self.data_engine.calculate_ema(symbol, "1", self.ema_slow_period)
+            rsi = self.data_engine.calculate_rsi(symbol, "1", self.rsi_period)
+            status['indicators'] = {
+                'ema_fast': ema_fast,
+                'ema_slow': ema_slow,
+                'rsi': rsi
+            }
+            return status
+        except Exception as e:
+            logger.error(f"Error getting strategy status for {symbol}: {e}")
+            return {'error': str(e)}

core/trade_monitor.py

@@ -0,0 +1,232 @@
+import asyncio
+import logging
+import time
+from typing import Dict, List, Optional, Any
+from datetime import datetime, timedelta
+import yaml
+
+from core.exchange import BybitExchange
+from core.strategy import ScalpingStrategy
+from core.risk import RiskManager
+from core.data_engine import DataEngine
+from services.logger import log, log_trade, log_error, log_performance
+
+logger = logging.getLogger(__name__)
+
+class TradeMonitor:
+    def __init__(self, exchange: BybitExchange, strategy: ScalpingStrategy,
+                 risk_manager: RiskManager, data_engine: DataEngine):
+        self.exchange = exchange
+        self.strategy = strategy
+        self.risk_manager = risk_manager
+        self.data_engine = data_engine
+
+        self.settings = yaml.safe_load(open("config/settings.yaml"))
+        self.pairs = yaml.safe_load(open("config/pairs.yaml"))["pairs"]
+
+        self.is_running = False
+        self.monitoring_interval = 2
+        self.last_signal_check = {}
+        self.signal_cooldown = 30
+
+        self.performance_check_interval = 300
+        self.last_performance_check = datetime.now()
+
+    async def start_monitoring(self):
+        self.is_running = True
+        log("🚀 Starting trade monitoring loop")
+
+        try:
+            while self.is_running:
+                await self._monitoring_cycle()
+                await asyncio.sleep(self.monitoring_interval)
+
+        except Exception as e:
+            log_error("monitoring_loop", f"Monitoring loop crashed: {e}")
+            self.is_running = False
+
+    def stop_monitoring(self):
+        self.is_running = False
+        log("🛑 Trade monitoring stopped")
+
+    async def _monitoring_cycle(self):
+        try:
+
+            self.risk_manager.reset_daily_stats()
+
+            await self._check_open_positions()
+
+            await self._check_signals()
+
+            await self._periodic_performance_check()
+
+            self._health_check()
+
+        except Exception as e:
+            log_error("monitoring_cycle", f"Error in monitoring cycle: {e}")
+
+    async def _check_open_positions(self):
+        try:
+            positions = self.exchange.get_positions()
+
+            for position in positions:
+                symbol = position.get("symbol")
+                if not symbol:
+                    continue
+
+                size = float(position.get("size", 0))
+
+                if abs(size) < 0.001:
+                    continue
+
+                exit_reason = self.risk_manager.check_tp_sl_hit(symbol)
+
+                if exit_reason:
+                    log(f"🎯 {exit_reason} hit for {symbol}")
+
+                    close_result = self.exchange.close_position(symbol)
+
+                    if close_result:
+
+                        self.risk_manager.close_position(symbol, exit_reason)
+
+                        exit_price = float(close_result.get("avgPrice", 0))
+                        log_trade(symbol, "CLOSE", abs(size), exit_price,
+                                reason=exit_reason)
+
+                        self.last_signal_check[symbol] = datetime.now() - timedelta(seconds=self.signal_cooldown)
+
+                    else:
+                        log_error("position_close", f"Failed to close position for {symbol}")
+
+        except Exception as e:
+            log_error("position_check", f"Error checking positions: {e}")
+
+    async def _check_signals(self):
+        try:
+            current_time = datetime.now()
+
+            for symbol in self.pairs:
+
+                last_check = self.last_signal_check.get(symbol)
+                if last_check and (current_time - last_check).seconds < self.signal_cooldown:
+                    continue
+
+                signal, confidence, price = self.strategy.generate_signal(symbol)
+
+                if signal in ["BUY", "SELL"]:
+
+                    if self.risk_manager.validate_entry_signal(symbol, signal, confidence):
+                        await self._execute_signal(symbol, signal, confidence, price)
+
+                self.last_signal_check[symbol] = current_time
+
+        except Exception as e:
+            log_error("signal_check", f"Error checking signals: {e}")
+
+    async def _execute_signal(self, symbol: str, signal: str, confidence: float, price: float):
+        try:
+            log(f"📈 Executing {signal} signal for {symbol} at {price} (conf: {confidence:.2f})")
+
+            qty = self.risk_manager.calculate_position_size(symbol, price, signal)
+
+            if qty <= 0:
+                log(f"❌ Invalid position size for {symbol}: {qty}")
+                return
+
+            self.exchange.set_leverage(symbol)
+
+            order = self.exchange.market_order(symbol, signal, qty)
+
+            if order:
+                entry_price = float(order.get("avgPrice", price))
+
+                tp_percent = self.settings["trading"]["tp_percent"]
+                sl_percent = self.settings["trading"]["sl_percent"]
+
+                if signal == "BUY":
+                    tp_price = entry_price * (1 + tp_percent)
+                    sl_price = entry_price * (1 - sl_percent)
+                else:
+                    tp_price = entry_price * (1 - tp_percent)
+                    sl_price = entry_price * (1 + sl_percent)
+
+                tp_sl_result = self.exchange.set_tp_sl(symbol, signal, entry_price, tp_price, sl_price)
+
+                if tp_sl_result:
+                    log(f"✅ TP/SL set for {symbol}: TP={tp_price:.4f}, SL={sl_price:.4f}")
+
+                    self.risk_manager.update_position(symbol, order)
+
+                    log_trade(symbol, signal, qty, entry_price, "MARKET")
+
+                else:
+                    log_error("tp_sl_setup", f"Failed to set TP/SL for {symbol}")
+
+                    self.exchange.close_position(symbol)
+
+            else:
+                log_error("order_execution", f"Failed to execute order for {symbol}")
+
+        except Exception as e:
+            log_error("signal_execution", f"Error executing signal for {symbol}: {e}")
+
+    async def _periodic_performance_check(self):
+        try:
+            current_time = datetime.now()
+
+            if (current_time - self.last_performance_check).seconds >= self.performance_check_interval:
+
+                risk_status = self.risk_manager.get_risk_status()
+
+                from services.logger import logger_instance
+                trade_stats = logger_instance.get_trade_statistics()
+
+                performance_data = {
+                    **risk_status,
+                    **trade_stats
+                }
+
+                log_performance("ALL", "5min", performance_data)
+
+                self.last_performance_check = current_time
+
+                if risk_status.get('daily_pnl', 0) < -self.risk_manager.max_daily_loss:
+                    log("🚨 Daily loss limit reached - activating emergency stop")
+                    self.risk_manager.emergency_stop_all()
+
+        except Exception as e:
+            log_error("performance_check", f"Error in performance check: {e}")
+
+    def _health_check(self):
+        try:
+
+            server_time = self.exchange.get_server_time()
+            if not server_time:
+                log_error("health_check", "Exchange connection unhealthy")
+
+            buffer_status = self.data_engine.get_buffer_status()
+
+            for symbol, buffers in buffer_status.get('price_buffers', {}).items():
+                if buffers < 10:
+                    log(f"⚠️  Low price buffer for {symbol}: {buffers} points")
+
+        except Exception as e:
+            log_error("health_check", f"Health check error: {e}")
+
+    def get_monitoring_status(self) -> Dict[str, Any]:
+        try:
+            return {
+                'is_running': self.is_running,
+                'monitoring_interval': self.monitoring_interval,
+                'active_symbols': len(self.pairs),
+                'open_positions': len(self.risk_manager.open_positions),
+                'last_performance_check': self.last_performance_check.isoformat(),
+                'signal_cooldowns': {
+                    symbol: self.last_signal_check.get(symbol).isoformat()
+                    for symbol in self.last_signal_check.keys()
+                    if self.last_signal_check.get(symbol)
+                }
+            }
+        except Exception as e:
+            return {'error': str(e)}

core/websockets.py

@@ -0,0 +1,274 @@
+import asyncio
+import json
+import websockets
+import logging
+from dotenv import load_dotenv
+import os
+import yaml
+import time
+from collections import defaultdict
+
+load_dotenv()
+logger = logging.getLogger(__name__)
+
+class BybitWebSocket:
+    def __init__(self, callback=None):
+        self.settings = yaml.safe_load(open("config/settings.yaml"))
+        TESTNET = os.getenv("BYBIT_TESTNET", "true").lower() == "true"
+
+        self.ws_url = "wss://stream-testnet.bybit.com/v5/public/linear" if TESTNET else "wss://stream.bybit.com/v5/public/linear"
+        self.private_ws_url = "wss://stream-testnet.bybit.com/v5/private" if TESTNET else "wss://stream.bybit.com/v5/private"
+
+        self.callback = callback
+        self.subscriptions = set()
+        self.data_buffers = defaultdict(list)
+
+        self.websocket = None
+        self.private_websocket = None
+        self.is_connected = False
+        self.is_private_connected = False
+        self.reconnect_delay = 1
+        self.max_reconnect_delay = 60
+        self.heartbeat_interval = 20
+
+        self.latest_prices = {}
+        self.orderbooks = {}
+        self.trades = defaultdict(list)
+        self.tickers = {}
+
+    async def connect(self):
+        while True:
+            try:
+                logger.info(f"Connecting to Bybit WebSocket: {self.ws_url}")
+                self.websocket = await websockets.connect(self.ws_url)
+                self.is_connected = True
+                logger.info("WebSocket connected successfully")
+
+                asyncio.create_task(self._heartbeat())
+
+                if self.subscriptions:
+                    await self._resubscribe()
+
+                await self._message_handler()
+
+            except Exception as e:
+                logger.error(f"WebSocket connection error: {e}")
+                self.is_connected = False
+                await self._reconnect()
+
+    async def connect_private(self):
+        API_KEY = os.getenv("BYBIT_API_KEY")
+        API_SECRET = os.getenv("BYBIT_API_SECRET")
+
+        if not API_KEY or not API_SECRET:
+            logger.warning("Private WebSocket not available - API keys missing")
+            return
+
+        while True:
+            try:
+                logger.info(f"Connecting to private WebSocket: {self.private_ws_url}")
+                self.private_websocket = await websockets.connect(self.private_ws_url)
+                self.is_private_connected = True
+                logger.info("Private WebSocket connected successfully")
+
+                await self._authenticate_private()
+
+                await self._subscribe_private()
+
+                await self._private_message_handler()
+
+            except Exception as e:
+                logger.error(f"Private WebSocket connection error: {e}")
+                self.is_private_connected = False
+                await asyncio.sleep(self.reconnect_delay)
+                continue
+
+    async def _authenticate_private(self):
+
+        pass
+
+    async def _subscribe_private(self):
+
+        subscriptions = [
+            {"op": "subscribe", "args": ["position.linear"]},
+            {"op": "subscribe", "args": ["order.linear"]},
+            {"op": "subscribe", "args": ["wallet"]}
+        ]
+
+        for sub in subscriptions:
+            await self.private_websocket.send(json.dumps(sub))
+            logger.info(f"Subscribed to private channel: {sub}")
+
+    async def subscribe_ticker(self, symbols):
+        if isinstance(symbols, str):
+            symbols = [symbols]
+
+        args = [f"tickers.{symbol}" for symbol in symbols]
+        subscription = {"op": "subscribe", "args": args}
+
+        await self.websocket.send(json.dumps(subscription))
+        self.subscriptions.add(("ticker", tuple(symbols)))
+        logger.info(f"Subscribed to tickers: {symbols}")
+
+    async def subscribe_kline(self, symbols, intervals=None):
+        if isinstance(symbols, str):
+            symbols = [symbols]
+        if intervals is None:
+            intervals = ["1", "5"]
+
+        args = []
+        for symbol in symbols:
+            for interval in intervals:
+                args.append(f"kline.{interval}.{symbol}")
+
+        subscription = {"op": "subscribe", "args": args}
+        await self.websocket.send(json.dumps(subscription))
+        self.subscriptions.add(("kline", tuple(symbols), tuple(intervals)))
+        logger.info(f"Subscribed to klines: {symbols} - {intervals}")
+
+    async def subscribe_orderbook(self, symbols, depth=25):
+        if isinstance(symbols, str):
+            symbols = [symbols]
+
+        args = [f"orderbook.{depth}.{symbol}" for symbol in symbols]
+        subscription = {"op": "subscribe", "args": args}
+
+        await self.websocket.send(json.dumps(subscription))
+        self.subscriptions.add(("orderbook", tuple(symbols), depth))
+        logger.info(f"Subscribed to orderbook: {symbols} depth={depth}")
+
+    async def subscribe_trades(self, symbols):
+        if isinstance(symbols, str):
+            symbols = [symbols]
+
+        args = [f"publicTrade.{symbol}" for symbol in symbols]
+        subscription = {"op": "subscribe", "args": args}
+
+        await self.websocket.send(json.dumps(subscription))
+        self.subscriptions.add(("trades", tuple(symbols)))
+        logger.info(f"Subscribed to trades: {symbols}")
+
+    async def _resubscribe(self):
+        for sub in self.subscriptions:
+            sub_type = sub[0]
+            if sub_type == "ticker":
+                await self.subscribe_ticker(list(sub[1]))
+            elif sub_type == "kline":
+                await self.subscribe_kline(list(sub[1]), list(sub[2]))
+            elif sub_type == "orderbook":
+                await self.subscribe_orderbook(list(sub[1]), sub[2])
+            elif sub_type == "trades":
+                await self.subscribe_trades(list(sub[1]))
+
+    async def _heartbeat(self):
+        while self.is_connected:
+            try:
+                ping_msg = {"op": "ping"}
+                await self.websocket.send(json.dumps(ping_msg))
+                await asyncio.sleep(self.heartbeat_interval)
+            except Exception as e:
+                logger.error(f"Heartbeat error: {e}")
+                break
+
+    async def _message_handler(self):
+        try:
+            async for message in self.websocket:
+                try:
+                    data = json.loads(message)
+
+                    if "topic" in data:
+                        await self._process_message(data)
+                    elif data.get("op") == "pong":
+
+                        pass
+                    elif "success" in data:
+                        if data["success"]:
+                            logger.info("Subscription successful")
+                        else:
+                            logger.error(f"Subscription failed: {data}")
+
+                except json.JSONDecodeError as e:
+                    logger.error(f"Invalid JSON received: {e}")
+                except Exception as e:
+                    logger.error(f"Message processing error: {e}")
+
+        except websockets.exceptions.ConnectionClosed:
+            logger.warning("WebSocket connection closed")
+            self.is_connected = False
+
+    async def _private_message_handler(self):
+        try:
+            async for message in self.private_websocket:
+                try:
+                    data = json.loads(message)
+                    await self._process_private_message(data)
+                except Exception as e:
+                    logger.error(f"Private message processing error: {e}")
+        except websockets.exceptions.ConnectionClosed:
+            logger.warning("Private WebSocket connection closed")
+            self.is_private_connected = False
+
+    async def _process_message(self, data):
+        topic = data["topic"]
+        payload = data["data"]
+
+        if topic.startswith("tickers."):
+            symbol = topic.split(".")[1]
+            self.tickers[symbol] = payload
+            self.latest_prices[symbol] = float(payload["lastPrice"])
+
+        elif topic.startswith("orderbook."):
+            symbol = topic.split(".")[2]
+            self.orderbooks[symbol] = payload
+
+        elif topic.startswith("publicTrade."):
+            symbol = topic.split(".")[1]
+            self.trades[symbol].extend(payload)
+
+            self.trades[symbol] = self.trades[symbol][-100:]
+
+        elif topic.startswith("kline."):
+            parts = topic.split(".")
+            interval = parts[1]
+            symbol = parts[2]
+
+            key = f"{symbol}_{interval}"
+            self.data_buffers[key].extend(payload)
+
+            self.data_buffers[key] = self.data_buffers[key][-200:]
+
+        if self.callback:
+            await self.callback(data)
+
+    async def _process_private_message(self, data):
+
+        if self.callback:
+            await self.callback(data)
+
+    async def _reconnect(self):
+        self.reconnect_delay = min(self.reconnect_delay * 2, self.max_reconnect_delay)
+        logger.info(f"Reconnecting in {self.reconnect_delay} seconds...")
+        await asyncio.sleep(self.reconnect_delay)
+
+    def get_latest_price(self, symbol):
+        return self.latest_prices.get(symbol)
+
+    def get_orderbook(self, symbol):
+        return self.orderbooks.get(symbol)
+
+    def get_recent_trades(self, symbol, limit=10):
+        return self.trades.get(symbol, [])[-limit:]
+
+    def get_kline_buffer(self, symbol, interval="1", limit=100):
+        key = f"{symbol}_{interval}"
+        return self.data_buffers.get(key, [])[-limit:]
+
+    async def close(self):
+        if self.websocket:
+            await self.websocket.close()
+        if self.private_websocket:
+            await self.private_websocket.close()
+
+        self.is_connected = False
+        self.is_private_connected = False
+        logger.info("WebSocket connections closed")

logs/errors.json

@@ -0,0 +1,272 @@
+[
+  {
+    "timestamp": "2026-01-08T08:37:38.988990",
+    "type": "position_check",
+    "message": "Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:37:38).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T08:37:45.564716",
+    "type": "position_check",
+    "message": "Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:37:45).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T08:37:52.709415",
+    "type": "position_check",
+    "message": "Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:37:52).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T08:37:59.344576",
+    "type": "position_check",
+    "message": "Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:37:59).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T08:38:05.892083",
+    "type": "position_check",
+    "message": "Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:05).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T08:38:12.476775",
+    "type": "position_check",
+    "message": "Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:12).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T08:38:19.571827",
+    "type": "position_check",
+    "message": "Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:19).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T08:38:26.173805",
+    "type": "position_check",
+    "message": "Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:26).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T08:38:32.720932",
+    "type": "position_check",
+    "message": "Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:32).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T08:38:39.330812",
+    "type": "position_check",
+    "message": "Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:39).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T08:38:45.991815",
+    "type": "position_check",
+    "message": "Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:45).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T08:38:52.621013",
+    "type": "position_check",
+    "message": "Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:52).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T08:38:59.185389",
+    "type": "position_check",
+    "message": "Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:59).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T08:39:05.774305",
+    "type": "position_check",
+    "message": "Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:05).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T08:39:12.350832",
+    "type": "position_check",
+    "message": "Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:12).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T08:39:18.855515",
+    "type": "position_check",
+    "message": "Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:18).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T08:39:25.602026",
+    "type": "position_check",
+    "message": "Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:25).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T08:39:32.308813",
+    "type": "position_check",
+    "message": "Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:32).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T08:39:38.808382",
+    "type": "position_check",
+    "message": "Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:38).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T08:39:45.490647",
+    "type": "position_check",
+    "message": "Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:45).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T08:39:52.341720",
+    "type": "position_check",
+    "message": "Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:52).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T08:39:59.324708",
+    "type": "position_check",
+    "message": "Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:59).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T08:40:05.833493",
+    "type": "position_check",
+    "message": "Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:40:05).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T08:40:12.406886",
+    "type": "position_check",
+    "message": "Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:40:12).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T08:40:18.962761",
+    "type": "position_check",
+    "message": "Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:40:18).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T08:40:25.469095",
+    "type": "position_check",
+    "message": "Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:40:25).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T09:18:16.855872",
+    "type": "position_check",
+    "message": "Error checking positions: HTTPSConnectionPool(host='api.bybit.com', port=443): Max retries exceeded with url: /v5/position/list?category=linear (Caused by NameResolutionError(\"<urllib3.connection.HTTPSConnection object at 0x7fa8c7dadbe0>: Failed to resolve 'api.bybit.com' ([Errno -3] Temporary failure in name resolution)\"))",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T09:18:27.774079",
+    "type": "position_check",
+    "message": "Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:18:27).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T09:18:34.383041",
+    "type": "position_check",
+    "message": "Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:18:34).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T09:18:40.634319",
+    "type": "position_check",
+    "message": "Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:18:40).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T09:18:46.921983",
+    "type": "position_check",
+    "message": "Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:18:46).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T09:18:53.245499",
+    "type": "position_check",
+    "message": "Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:18:53).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T09:18:59.867702",
+    "type": "position_check",
+    "message": "Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:18:59).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T09:19:06.148693",
+    "type": "position_check",
+    "message": "Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:06).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T09:19:12.462576",
+    "type": "position_check",
+    "message": "Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:12).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T09:19:18.734882",
+    "type": "position_check",
+    "message": "Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:18).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T09:19:25.030983",
+    "type": "position_check",
+    "message": "Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:25).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T09:19:31.982889",
+    "type": "position_check",
+    "message": "Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:31).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T09:19:38.288181",
+    "type": "position_check",
+    "message": "Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:38).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T09:19:44.958179",
+    "type": "position_check",
+    "message": "Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:44).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T09:19:51.266450",
+    "type": "position_check",
+    "message": "Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:51).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T09:19:57.588008",
+    "type": "position_check",
+    "message": "Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:57).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T09:20:03.853308",
+    "type": "position_check",
+    "message": "Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:20:03).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T09:20:10.119147",
+    "type": "position_check",
+    "message": "Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:20:10).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  },
+  {
+    "timestamp": "2026-01-08T09:20:16.416108",
+    "type": "position_check",
+    "message": "Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:20:16).\nRequest \u2192 GET https://api.bybit.com/v5/position/list: category=linear.",
+    "details": {}
+  }
+]

logs/errors.log

@@ -0,0 +1,241 @@
+2026-01-08 08:34:07,556 - ERROR - WEBSOCKET_START: Failed to start WebSocket: 'NoneType' object has no attribute 'send'
+2026-01-08 08:34:12,589 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:34:12).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:34:19,229 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:34:19).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:34:25,791 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:34:25).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:34:32,336 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:34:32).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:34:38,925 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:34:38).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:34:45,531 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:34:45).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:34:52,116 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:34:52).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:34:58,727 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:34:58).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:35:05,343 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:35:05).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:35:12,672 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:35:12).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:35:19,332 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:35:19).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:35:28,860 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:35:28).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:35:35,409 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:35:35).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:35:41,937 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:35:41).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:35:48,456 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:35:48).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:35:55,276 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:35:55).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:36:01,846 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:36:01).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:36:08,368 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:36:08).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:36:15,048 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:36:15).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:36:21,919 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:36:21).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:36:28,439 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:36:28).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:36:34,976 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:36:34).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:36:41,540 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:36:41).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:36:48,068 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:36:48).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:36:54,593 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:36:54).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:37:01,148 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:37:01).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:37:07,681 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:37:07).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:37:14,180 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:37:14).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:37:20,706 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:37:20).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:37:27,277 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:37:27).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:37:33,795 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:37:33).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:37:38,993 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:37:38).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:37:40,377 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:37:40).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:37:45,565 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:37:45).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:37:46,986 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:37:46).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:37:52,709 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:37:52).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:37:53,526 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:37:53).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:37:59,349 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:37:59).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:38:00,095 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:00).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:38:05,892 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:05).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:38:06,687 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:06).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:38:12,478 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:12).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:38:13,349 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:13).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:38:19,573 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:19).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:38:20,395 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:20).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:38:26,178 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:26).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:38:26,976 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:26).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:38:32,722 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:32).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:38:33,526 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:33).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:38:39,332 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:39).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:38:40,099 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:40).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:38:45,994 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:45).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:38:46,691 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:46).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:38:52,626 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:52).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:38:53,552 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:53).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:38:59,186 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:59).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:39:00,123 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:00).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:39:05,847 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:05).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:39:06,742 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:06).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:39:12,351 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:12).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:39:13,238 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:13).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:39:18,856 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:18).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:39:19,812 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:19).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:39:25,602 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:25).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:39:26,333 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:26).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:39:32,309 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:32).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:39:32,992 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:32).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:39:38,808 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:38).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:39:39,878 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:39).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:39:45,492 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:45).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:39:46,402 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:46).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:39:52,342 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:52).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:39:52,896 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:52).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:39:59,328 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:59).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:39:59,702 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:59).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:40:05,835 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:40:05).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:40:06,262 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:40:06).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:40:12,407 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:40:12).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:40:12,801 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:40:12).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:40:18,963 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:40:18).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:40:19,325 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:40:19).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:40:25,470 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:40:25).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:40:25,835 - ERROR - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:40:25).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:18:16,857 - ERROR - POSITION_CHECK: Error checking positions: HTTPSConnectionPool(host='api.bybit.com', port=443): Max retries exceeded with url: /v5/position/list?category=linear (Caused by NameResolutionError("<urllib3.connection.HTTPSConnection object at 0x7fa8c7dadbe0>: Failed to resolve 'api.bybit.com' ([Errno -3] Temporary failure in name resolution)"))
+2026-01-08 09:18:17,152 - ERROR - POSITION_CHECK: Error checking positions: HTTPSConnectionPool(host='api.bybit.com', port=443): Max retries exceeded with url: /v5/position/list?category=linear (Caused by NameResolutionError("<urllib3.connection.HTTPSConnection object at 0x7f87b3572900>: Failed to resolve 'api.bybit.com' ([Errno -3] Temporary failure in name resolution)"))
+2026-01-08 09:18:27,355 - ERROR - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:18:27).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:18:27,775 - ERROR - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:18:27).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:18:33,629 - ERROR - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:18:33).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:18:34,384 - ERROR - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:18:34).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:18:39,888 - ERROR - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:18:39).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:18:40,635 - ERROR - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:18:40).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:18:46,160 - ERROR - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:18:46).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:18:46,923 - ERROR - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:18:46).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:18:52,447 - ERROR - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:18:52).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:18:53,247 - ERROR - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:18:53).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:18:58,713 - ERROR - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:18:58).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:18:59,869 - ERROR - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:18:59).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:19:04,983 - ERROR - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:04).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:19:06,149 - ERROR - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:06).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:19:11,307 - ERROR - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:11).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:19:12,464 - ERROR - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:12).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:19:17,567 - ERROR - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:17).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:19:18,735 - ERROR - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:18).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:19:23,898 - ERROR - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:23).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:19:25,033 - ERROR - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:25).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:19:30,217 - ERROR - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:30).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:19:31,983 - ERROR - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:31).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:19:36,549 - ERROR - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:36).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:19:38,289 - ERROR - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:38).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:19:42,883 - ERROR - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:42).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:19:44,959 - ERROR - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:44).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:19:49,179 - ERROR - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:49).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:19:51,268 - ERROR - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:51).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:19:56,099 - ERROR - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:56).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:19:57,589 - ERROR - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:57).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:20:02,381 - ERROR - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:20:02).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:20:03,854 - ERROR - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:20:03).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:20:08,654 - ERROR - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:20:08).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:20:10,120 - ERROR - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:20:10).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:20:15,315 - ERROR - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:20:15).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:20:16,417 - ERROR - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:20:16).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.

logs/performance.jsonl

@@ -0,0 +1,3 @@
+{"timestamp": "2026-01-08T08:39:06.743107", "symbol": "ALL", "period": "5min", "metrics": {"emergency_stop": false, "open_positions": 0, "daily_pnl": 0.0, "daily_trades": 0, "win_rate": 0.0, "total_trades": 0, "positions": [], "total_pnl": 0.0}}
+{"timestamp": "2026-01-08T09:18:16.924852", "symbol": "ALL", "period": "5min", "metrics": {"emergency_stop": false, "open_positions": 0, "daily_pnl": 0.0, "daily_trades": 0, "win_rate": 0.0, "total_trades": 0, "positions": [], "total_pnl": 0.0}}
+{"timestamp": "2026-01-08T09:18:17.152621", "symbol": "ALL", "period": "5min", "metrics": {"emergency_stop": false, "open_positions": 0, "daily_pnl": 0.0, "daily_trades": 0, "win_rate": 0.0, "total_trades": 0, "positions": [], "total_pnl": 0.0}}

logs/scalper.log

@@ -0,0 +1,512 @@
+2026-01-08 08:34:03,664 - scalper - INFO - log:205 - 🚀 Starting Bybit Scalping Bot v1.0.0
+2026-01-08 08:34:03,664 - scalper - INFO - log:205 - 📊 Trading pairs: BTCUSDT, ETHUSDT, SOLUSDT
+2026-01-08 08:34:03,664 - scalper - INFO - log:205 - ⚙️  Leverage: 20x
+2026-01-08 08:34:03,665 - scalper - INFO - log:205 - 🎯 Take Profit: 2.5%
+2026-01-08 08:34:03,665 - scalper - INFO - log:205 - 🛡️  Stop Loss: 1.0%
+2026-01-08 08:34:05,536 - scalper - INFO - log:205 - ✅ Exchange client initialized
+2026-01-08 08:34:05,542 - scalper - INFO - log:205 - ✅ Data engine initialized
+2026-01-08 08:34:05,547 - scalper - INFO - log:205 - ✅ Trading strategy initialized
+2026-01-08 08:34:05,550 - scalper - INFO - log:205 - ✅ Risk manager initialized
+2026-01-08 08:34:05,553 - scalper - INFO - log:205 - ✅ Trade monitor initialized
+2026-01-08 08:34:05,554 - scalper - INFO - log:205 - ✅ WebSocket client initialized
+2026-01-08 08:34:07,556 - scalper - ERROR - log_error:125 - WEBSOCKET_START: Failed to start WebSocket: 'NoneType' object has no attribute 'send'
+2026-01-08 08:34:07,556 - scalper - INFO - log:205 - ▶️  Bot is now active and monitoring markets
+2026-01-08 08:34:07,556 - scalper - INFO - log:205 - 🚀 Starting trade monitoring loop
+2026-01-08 08:34:12,214 - scalper - INFO - log:205 - 🛑 Shutdown signal received
+2026-01-08 08:34:12,589 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:34:12).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:34:12,972 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:34:12,973 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:34:12,973 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:34:19,229 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:34:19).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:34:19,633 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:34:19,633 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:34:19,633 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:34:25,791 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:34:25).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:34:26,166 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:34:26,168 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:34:26,169 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:34:32,336 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:34:32).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:34:32,720 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:34:32,721 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:34:32,721 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:34:38,925 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:34:38).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:34:39,304 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:34:39,304 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:34:39,305 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:34:45,531 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:34:45).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:34:45,939 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:34:45,942 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:34:45,944 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:34:52,116 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:34:52).
+Request �� GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:34:52,509 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:34:52,510 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:34:52,510 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:34:58,727 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:34:58).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:34:59,145 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:34:59,146 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:34:59,146 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:35:05,343 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:35:05).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:35:06,035 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:35:06,037 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:35:06,038 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:35:12,672 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:35:12).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:35:13,089 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:35:13,089 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:35:13,090 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:35:19,332 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:35:19).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:35:19,743 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:35:19,743 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:35:19,744 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:35:28,860 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:35:28).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:35:29,262 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:35:29,262 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:35:29,262 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:35:35,409 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:35:35).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:35:35,769 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:35:35,770 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:35:35,770 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:35:41,937 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:35:41).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:35:42,304 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:35:42,304 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:35:42,304 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:35:48,456 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:35:48).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:35:49,140 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:35:49,140 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:35:49,140 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:35:55,276 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:35:55).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:35:55,667 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:35:55,667 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:35:55,667 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:36:01,846 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:36:01).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:36:02,251 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:36:02,252 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:36:02,252 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:36:08,368 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:36:08).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:36:08,763 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:36:08,763 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:36:08,763 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:36:15,048 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:36:15).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:36:15,426 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:36:15,427 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:36:15,427 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:36:21,919 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:36:21).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:36:22,283 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:36:22,283 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:36:22,283 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:36:28,439 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:36:28).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:36:28,820 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:36:28,820 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:36:28,820 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:36:34,976 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:36:34).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:36:35,344 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:36:35,344 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:36:35,344 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:36:41,540 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:36:41).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:36:41,923 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:36:41,924 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:36:41,924 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:36:48,068 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:36:48).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:36:48,446 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:36:48,446 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:36:48,446 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:36:54,593 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:36:54).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:36:54,964 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:36:54,965 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:36:54,965 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:37:01,148 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:37:01).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:37:01,533 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:37:01,534 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:37:01,534 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:37:07,681 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:37:07).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:37:08,058 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:37:08,059 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:37:08,059 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:37:14,180 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:37:14).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:37:14,563 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:37:14,563 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:37:14,563 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:37:20,706 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:37:20).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:37:21,084 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:37:21,084 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:37:21,084 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:37:27,277 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:37:27).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:37:27,643 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:37:27,644 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:37:27,644 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:37:31,042 - scalper - INFO - log:205 - 🚀 Starting Bybit Scalping Bot v1.0.0
+2026-01-08 08:37:31,043 - scalper - INFO - log:205 - 📊 Trading pairs: BTCUSDT, ETHUSDT, SOLUSDT
+2026-01-08 08:37:31,043 - scalper - INFO - log:205 - ⚙️  Leverage: 20x
+2026-01-08 08:37:31,043 - scalper - INFO - log:205 - 🎯 Take Profit: 2.5%
+2026-01-08 08:37:31,043 - scalper - INFO - log:205 - 🛡️  Stop Loss: 1.0%
+2026-01-08 08:37:32,181 - scalper - INFO - log:205 - ✅ Exchange client initialized
+2026-01-08 08:37:32,187 - scalper - INFO - log:205 - ✅ Data engine initialized
+2026-01-08 08:37:32,191 - scalper - INFO - log:205 - ✅ Trading strategy initialized
+2026-01-08 08:37:32,194 - scalper - INFO - log:205 - ✅ Risk manager initialized
+2026-01-08 08:37:32,196 - scalper - INFO - log:205 - ✅ Trade monitor initialized
+2026-01-08 08:37:32,199 - scalper - INFO - log:205 - ✅ WebSocket client initialized
+2026-01-08 08:37:33,795 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:37:33).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:37:34,168 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:37:34,168 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:37:34,168 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:37:34,201 - scalper - INFO - log:205 - ✅ WebSocket subscriptions active
+2026-01-08 08:37:34,201 - scalper - INFO - log:205 - ▶️  Bot is now active and monitoring markets
+2026-01-08 08:37:34,202 - scalper - INFO - log:205 - 🚀 Starting trade monitoring loop
+2026-01-08 08:37:38,993 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:37:38).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:37:39,367 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:37:39,367 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:37:39,367 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:37:40,377 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:37:40).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:37:40,747 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:37:40,748 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:37:40,748 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:37:44,764 - scalper - INFO - log:205 - 🛑 Shutdown signal received
+2026-01-08 08:37:45,565 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:37:45).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:37:46,986 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:37:46).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:37:47,355 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:37:47,355 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:37:47,356 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:37:52,709 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:37:52).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:37:53,526 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:37:53).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:37:53,939 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:37:53,940 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:37:53,941 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:37:59,349 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:37:59).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:38:00,095 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:00).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:38:00,463 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:38:00,463 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:38:00,464 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:38:05,892 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:05).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:38:06,687 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:06).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:38:07,103 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:38:07,103 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:38:07,104 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:38:12,478 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:12).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:38:13,349 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:13).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:38:13,741 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:38:13,742 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:38:13,742 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:38:19,573 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:19).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:38:20,395 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:20).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:38:20,789 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:38:20,790 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:38:20,791 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:38:26,178 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:26).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:38:26,976 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:26).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:38:27,386 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:38:27,386 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:38:27,386 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:38:32,722 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:32).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:38:33,526 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:33).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:38:33,896 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:38:33,896 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:38:33,896 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:38:39,332 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:39).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:38:40,099 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:40).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:38:40,484 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:38:40,489 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:38:40,489 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:38:45,994 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:45).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:38:46,691 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:46).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:38:47,063 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:38:47,064 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:38:47,064 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:38:52,626 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:52).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:38:53,552 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:53).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:38:53,979 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:38:53,985 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:38:53,987 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:38:59,186 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:38:59).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:39:00,123 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:00).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:39:00,571 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:39:00,582 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:39:00,582 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:39:05,847 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:05).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:39:06,742 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:06).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:39:06,743 - scalper - INFO - log_performance:140 - PERFORMANCE - ALL (5min): emergency_stop: 0.00, open_positions: 0.00, daily_pnl: 0.00, daily_trades: 0.00, win_rate: 0.00, total_trades: 0.00, positions: [], total_pnl: 0.00
+2026-01-08 08:39:07,112 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:39:07,112 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:39:07,112 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:39:12,351 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:12).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:39:13,238 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:13).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:39:13,615 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:39:13,615 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:39:13,615 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:39:18,856 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:18).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:39:19,812 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:19).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:39:20,180 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:39:20,181 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:39:20,181 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:39:25,602 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:25).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:39:26,333 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:26).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:39:26,716 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:39:26,716 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:39:26,716 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:39:32,309 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:32).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:39:32,992 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:32).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:39:33,690 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:39:33,690 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:39:33,690 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:39:38,808 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:38).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:39:39,878 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:39).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:39:40,254 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:39:40,254 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:39:40,255 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:39:45,492 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:45).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:39:46,402 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:46).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:39:46,780 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:39:46,780 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:39:46,780 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:39:52,342 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:52).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:39:52,896 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:52).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:39:53,272 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:39:53,272 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:39:53,272 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:39:59,328 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:59).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:39:59,702 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:39:59).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:40:00,070 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:40:00,071 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:40:00,071 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:40:05,835 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:40:05).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:40:06,262 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:40:06).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:40:06,649 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:40:06,650 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:40:06,650 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:40:12,407 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:40:12).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:40:12,801 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:40:12).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:40:13,171 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:40:13,172 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:40:13,172 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:40:18,963 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:40:18).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:40:19,325 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:40:19).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:40:19,710 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:40:19,710 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:40:19,711 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 08:40:25,470 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:40:25).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:40:25,835 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Missing some parameters that must be filled in, symbol or settleCoin (ErrCode: 10001) (ErrTime: 14:40:25).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 08:40:26,222 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 08:40:26,222 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 08:40:26,222 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 09:18:16,857 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: HTTPSConnectionPool(host='api.bybit.com', port=443): Max retries exceeded with url: /v5/position/list?category=linear (Caused by NameResolutionError("<urllib3.connection.HTTPSConnection object at 0x7fa8c7dadbe0>: Failed to resolve 'api.bybit.com' ([Errno -3] Temporary failure in name resolution)"))
+2026-01-08 09:18:16,925 - scalper - INFO - log_performance:140 - PERFORMANCE - ALL (5min): emergency_stop: 0.00, open_positions: 0.00, daily_pnl: 0.00, daily_trades: 0.00, win_rate: 0.00, total_trades: 0.00, positions: [], total_pnl: 0.00
+2026-01-08 09:18:17,152 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: HTTPSConnectionPool(host='api.bybit.com', port=443): Max retries exceeded with url: /v5/position/list?category=linear (Caused by NameResolutionError("<urllib3.connection.HTTPSConnection object at 0x7f87b3572900>: Failed to resolve 'api.bybit.com' ([Errno -3] Temporary failure in name resolution)"))
+2026-01-08 09:18:17,152 - scalper - INFO - log_performance:140 - PERFORMANCE - ALL (5min): emergency_stop: 0.00, open_positions: 0.00, daily_pnl: 0.00, daily_trades: 0.00, win_rate: 0.00, total_trades: 0.00, positions: [], total_pnl: 0.00
+2026-01-08 09:18:20,913 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 09:18:20,913 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 09:18:20,913 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 09:18:27,355 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:18:27).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:18:27,661 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 09:18:27,661 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 09:18:27,661 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 09:18:27,775 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:18:27).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:18:33,629 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:18:33).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:18:33,942 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 09:18:33,942 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 09:18:33,942 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 09:18:34,384 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:18:34).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:18:39,888 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:18:39).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:18:40,197 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 09:18:40,198 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 09:18:40,198 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 09:18:40,635 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:18:40).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:18:46,160 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:18:46).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:18:46,478 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 09:18:46,478 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 09:18:46,479 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 09:18:46,923 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:18:46).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:18:52,447 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:18:52).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:18:52,763 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 09:18:52,763 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 09:18:52,764 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 09:18:53,247 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:18:53).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:18:58,713 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:18:58).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:18:59,036 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 09:18:59,036 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 09:18:59,037 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 09:18:59,869 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:18:59).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:19:04,983 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:04).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:19:05,321 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 09:19:05,322 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 09:19:05,322 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 09:19:06,149 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:06).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:19:11,307 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:11).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:19:11,621 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 09:19:11,621 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 09:19:11,621 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 09:19:12,464 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:12).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:19:17,567 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:17).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:19:17,875 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 09:19:17,875 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 09:19:17,875 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 09:19:18,735 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:18).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:19:23,898 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:23).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:19:24,249 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 09:19:24,249 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 09:19:24,250 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 09:19:25,033 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:25).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:19:30,217 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:30).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:19:30,551 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 09:19:30,551 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 09:19:30,552 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 09:19:31,983 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:31).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:19:36,549 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:36).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:19:36,882 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 09:19:36,882 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 09:19:36,882 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 09:19:38,289 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:38).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:19:42,883 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:42).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:19:43,200 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 09:19:43,201 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 09:19:43,201 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 09:19:44,959 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:44).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:19:49,179 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:49).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:19:49,815 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 09:19:49,815 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 09:19:49,815 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 09:19:51,268 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:51).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:19:56,099 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:56).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:19:56,432 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 09:19:56,432 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 09:19:56,432 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 09:19:57,589 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:19:57).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:20:02,381 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:20:02).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:20:02,695 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 09:20:02,696 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 09:20:02,696 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 09:20:03,432 - scalper - INFO - log:205 - 🛑 Shutdown signal received
+2026-01-08 09:20:03,434 - scalper - INFO - log:205 - 🛑 Shutdown signal received
+2026-01-08 09:20:03,854 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:20:03).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:20:08,654 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:20:08).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:20:09,284 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 09:20:09,286 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 09:20:09,287 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 09:20:10,120 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:20:10).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:20:15,315 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:20:15).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:20:15,631 - scalper - INFO - log:205 - ⚠️  Low price buffer for BTCUSDT: 0 points
+2026-01-08 09:20:15,632 - scalper - INFO - log:205 - ⚠️  Low price buffer for ETHUSDT: 0 points
+2026-01-08 09:20:15,632 - scalper - INFO - log:205 - ⚠️  Low price buffer for SOLUSDT: 0 points
+2026-01-08 09:20:16,417 - scalper - ERROR - log_error:125 - POSITION_CHECK: Error checking positions: Unmatched IP, please check your API key's bound IP addresses. (ErrCode: 10010) (ErrTime: 15:20:16).
+Request → GET https://api.bybit.com/v5/position/list: category=linear.
+2026-01-08 09:33:54,347 - scalper - INFO - log:205 - 🚀 Starting FastAPI server for Bybit Scalping Bot
+2026-01-08 09:38:22,572 - scalper - INFO - log:205 - 🚀 Starting FastAPI server for Bybit Scalping Bot
+2026-01-08 09:39:30,629 - scalper - INFO - log:205 - 🚀 Started trading session for BTCUSDT (18h duration)
+2026-01-08 09:39:30,631 - scalper - INFO - log:205 - 🚀 Starting trading session for BTCUSDT (Duration: 18h)
+2026-01-08 10:39:14,500 - scalper - INFO - log:205 - 🛑 Trade monitoring stopped
+2026-01-08 10:39:15,586 - scalper - INFO - log:205 - 🛑 Stopped trading for BTCUSDT

main.py

@@ -0,0 +1,143 @@
+#!/usr/bin/env python3
+"""
+Bybit Scalping Bot - FastAPI Control Interface
+
+This bot now uses FastAPI for remote control instead of direct command line operation.
+Use the API endpoints to start/stop trading sessions for individual pairs.
+
+API Endpoints:
+- GET  /status           - Get bot status
+- POST /start/{symbol}   - Start trading for a symbol (18h default)
+- POST /stop/{symbol}    - Stop trading for a symbol
+- GET  /sessions         - Get all trading sessions
+- GET  /report/{session_id} - Get session report
+- POST /emergency_stop   - Emergency stop all trading
+
+Examples:
+- Start BTC trading: POST /start/BTCUSDT
+- Stop ETH trading: POST /stop/ETHUSDT
+- Check status: GET /status
+"""
+
+import sys
+import subprocess
+import os
+
+def show_usage():
+    print("""
+🚀 Bybit Scalping Bot - FastAPI Control Interface
+═══════════════════════════════════════════════════
+
+📡 API SERVER CONTROL:
+• Start API Server: python api_server.py
+• Server runs on: http://localhost:8000
+
+🔗 API ENDPOINTS:
+
+GET /status
+   Returns current bot status and active sessions
+
+POST /start/{symbol}?duration_hours=18
+   Start trading session for specific symbol
+   Examples:
+   • POST /start/BTCUSDT
+   • POST /start/ETHUSDT?duration_hours=24
+
+POST /stop/{symbol}
+   Stop trading session for specific symbol
+   Example: POST /stop/BTCUSDT
+
+GET /sessions
+   Get all trading sessions (active and completed)
+
+GET /report/{session_id}
+   Get detailed report for a completed session
+
+POST /emergency_stop
+   Emergency stop all trading sessions
+
+🧪 TESTING & BACKTESTING:
+
+python main.py backtest
+   Run backtesting for all configured pairs
+
+python test_api_raw.py
+   Test API connectivity
+
+📊 CONFIGURED PAIRS:
+• BTCUSDT
+• ETHUSDT
+• SOLUSDT
+
+⚙️  TRADING PARAMETERS:
+• Leverage: 20x
+• Take Profit: 2.5%
+• Stop Loss: 1%
+• Risk per Trade: 2%
+• Strategy: EMA 9/21 + RSI 14 + Volume + Orderbook
+
+📱 TELEGRAM ALERTS:
+Configure in .env file for trade notifications
+
+═══════════════════════════════════════════════════
+""")
+
+def run_backtest():
+    """Run backtesting mode"""
+    from backtester.engine import BacktestingEngine
+    from services.logger import log
+    import yaml
+
+    log("🔬 Starting backtesting mode")
+
+    settings = yaml.safe_load(open("config/settings.yaml"))
+    pairs = yaml.safe_load(open("config/pairs.yaml"))["pairs"]
+
+    backtester = BacktestingEngine()
+    results = {}
+
+    for symbol in pairs:
+        log(f"📊 Backtesting {symbol}...")
+        result = backtester.run_backtest(symbol)
+        results[symbol] = result
+
+        if 'error' not in result:
+            log(f"✅ {symbol}: {result['total_trades']} trades, PnL: ${result['total_pnl']:.2f}, Win Rate: {result['win_rate']:.1%}")
+        else:
+            log(f"❌ {symbol}: {result['error']}")
+
+    backtester.save_results()
+
+    log("\n" + "="*50)
+    log("BACKTESTING REPORT")
+    log("="*50)
+
+    for symbol in pairs:
+        if symbol in results and 'error' not in results[symbol]:
+            report = backtester.generate_report(symbol)
+            print(report)
+
+def start_api_server():
+    """Start the FastAPI server"""
+    print("🚀 Starting FastAPI server...")
+    print("📡 Server will be available at: http://localhost:8000")
+    print("📖 API documentation at: http://localhost:8000/docs")
+    print()
+    try:
+        subprocess.run([sys.executable, "api_server.py"])
+    except KeyboardInterrupt:
+        print("\n👋 API server stopped")
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1:
+        if sys.argv[1] == "backtest":
+            run_backtest()
+        elif sys.argv[1] == "api":
+            start_api_server()
+        elif sys.argv[1] == "help" or sys.argv[1] == "-h":
+            show_usage()
+        else:
+            print(f"❌ Unknown command: {sys.argv[1]}")
+            print("Use 'python main.py help' for available commands")
+    else:
+        show_usage()

requirements.txt

@@ -0,0 +1,17 @@
+python-dotenv
+pybit
+pandas
+numpy
+pyyaml
+requests
+websockets
+asyncio
+ccxt
+ta
+plotly
+matplotlib
+seaborn
+scikit-learn
+fastapi
+uvicorn
+streamlit

services/logger.py

@@ -0,0 +1,226 @@
+import logging
+import logging.handlers
+import json
+import os
+from datetime import datetime
+from typing import Dict, Any, Optional
+import yaml
+
+try:
+    settings = yaml.safe_load(open("config/settings.yaml"))
+except:
+    settings = {"telegram": {"enabled": False}}
+
+class ScalperLogger:
+    def __init__(self):
+        self.setup_logging()
+        self.trade_logs = []
+        self.signal_logs = []
+        self.error_logs = []
+
+    def setup_logging(self):
+        os.makedirs("logs", exist_ok=True)
+        self.logger = logging.getLogger('scalper')
+        self.logger.setLevel(logging.DEBUG)
+        self.logger.handlers.clear()
+        console_handler = logging.StreamHandler()
+        console_handler.setLevel(logging.INFO)
+        console_formatter = logging.Formatter(
+            '%(asctime)s - %(levelname)s - %(message)s'
+        )
+        console_handler.setFormatter(console_formatter)
+        self.logger.addHandler(console_handler)
+        file_handler = logging.handlers.RotatingFileHandler(
+            'logs/scalper.log',
+            maxBytes=10*1024*1024,
+            backupCount=5
+        )
+        file_handler.setLevel(logging.DEBUG)
+        file_formatter = logging.Formatter(
+            '%(asctime)s - %(name)s - %(levelname)s - %(funcName)s:%(lineno)d - %(message)s'
+        )
+        file_handler.setFormatter(file_formatter)
+        self.logger.addHandler(file_handler)
+        trade_handler = logging.handlers.RotatingFileHandler(
+            'logs/trades.log',
+            maxBytes=5*1024*1024,
+            backupCount=3
+        )
+        trade_handler.setLevel(logging.INFO)
+        trade_formatter = logging.Formatter(
+            '%(asctime)s - TRADE - %(message)s'
+        )
+        trade_handler.setFormatter(trade_formatter)
+        trade_handler.addFilter(self._trade_filter)
+        self.logger.addHandler(trade_handler)
+        error_handler = logging.handlers.RotatingFileHandler(
+            'logs/errors.log',
+            maxBytes=5*1024*1024,
+            backupCount=3
+        )
+        error_handler.setLevel(logging.ERROR)
+        error_formatter = logging.Formatter(
+            '%(asctime)s - ERROR - %(message)s'
+        )
+        error_handler.setFormatter(error_formatter)
+        self.logger.addHandler(error_handler)
+
+    def _trade_filter(self, record):
+        return 'TRADE' in record.getMessage() or 'SIGNAL' in record.getMessage()
+
+    def log_signal(self, symbol: str, signal: str, confidence: float, price: float,
+                   strategy_details: Optional[Dict[str, Any]] = None):
+        try:
+            signal_data = {
+                'timestamp': datetime.now().isoformat(),
+                'symbol': symbol,
+                'signal': signal,
+                'confidence': confidence,
+                'price': price,
+                'strategy_details': strategy_details or {}
+            }
+            self.signal_logs.append(signal_data)
+            if len(self.signal_logs) > 1000:
+                self.signal_logs = self.signal_logs[-1000:]
+            self._save_signals_to_file()
+            self.logger.info(f"SIGNAL - {symbol}: {signal} (conf: {confidence:.2f}) at {price}")
+        except Exception as e:
+            self.logger.error(f"Error logging signal: {e}")
+
+    def log_trade(self, symbol: str, side: str, qty: float, price: float,
+                  order_type: str = "MARKET", pnl: Optional[float] = None,
+                  reason: str = "signal"):
+        try:
+            trade_data = {
+                'timestamp': datetime.now().isoformat(),
+                'symbol': symbol,
+                'side': side,
+                'quantity': qty,
+                'price': price,
+                'order_type': order_type,
+                'pnl': pnl,
+                'reason': reason
+            }
+            self.trade_logs.append(trade_data)
+            if len(self.trade_logs) > 1000:
+                self.trade_logs = self.trade_logs[-1000:]
+            self._save_trades_to_file()
+            pnl_str = f" (PnL: {pnl:.2f})" if pnl is not None else ""
+            self.logger.info(f"TRADE - {symbol}: {side} {qty} at {price}{pnl_str}")
+        except Exception as e:
+            self.logger.error(f"Error logging trade: {e}")
+
+    def log_error(self, error_type: str, message: str, details: Optional[Dict[str, Any]] = None):
+        try:
+            error_data = {
+                'timestamp': datetime.now().isoformat(),
+                'type': error_type,
+                'message': message,
+                'details': details or {}
+            }
+            self.error_logs.append(error_data)
+            if len(self.error_logs) > 500:
+                self.error_logs = self.error_logs[-500:]
+            self._save_errors_to_file()
+            self.logger.error(f"{error_type.upper()}: {message}")
+        except Exception as e:
+            print(f"Critical logging error: {e}")
+
+    def log_performance(self, symbol: str, period: str, metrics: Dict[str, Any]):
+        try:
+            perf_data = {
+                'timestamp': datetime.now().isoformat(),
+                'symbol': symbol,
+                'period': period,
+                'metrics': metrics
+            }
+            self._save_performance_to_file(perf_data)
+            metrics_str = ", ".join([f"{k}: {v:.2f}" if isinstance(v, (int, float)) else f"{k}: {v}"
+                                   for k, v in metrics.items()])
+            self.logger.info(f"PERFORMANCE - {symbol} ({period}): {metrics_str}")
+        except Exception as e:
+            self.logger.error(f"Error logging performance: {e}")
+
+    def _save_signals_to_file(self):
+        try:
+            with open('logs/signals.json', 'w') as f:
+                json.dump(self.signal_logs, f, indent=2)
+        except Exception as e:
+            self.logger.error(f"Error saving signals: {e}")
+
+    def _save_trades_to_file(self):
+        try:
+            with open('logs/trades.json', 'w') as f:
+                json.dump(self.trade_logs, f, indent=2)
+        except Exception as e:
+            self.logger.error(f"Error saving trades: {e}")
+
+    def _save_errors_to_file(self):
+        try:
+            with open('logs/errors.json', 'w') as f:
+                json.dump(self.error_logs, f, indent=2)
+        except Exception as e:
+            print(f"Error saving errors: {e}")
+
+    def _save_performance_to_file(self, perf_data: Dict[str, Any]):
+        try:
+            with open('logs/performance.jsonl', 'a') as f:
+                json.dump(perf_data, f)
+                f.write('\n')
+        except Exception as e:
+            self.logger.error(f"Error saving performance: {e}")
+
+    def get_recent_signals(self, limit: int = 50) -> list:
+        return self.signal_logs[-limit:]
+
+    def get_recent_trades(self, limit: int = 50) -> list:
+        return self.trade_logs[-limit:]
+
+    def get_error_summary(self) -> Dict[str, int]:
+        summary = {}
+        for error in self.error_logs:
+            error_type = error.get('type', 'unknown')
+            summary[error_type] = summary.get(error_type, 0) + 1
+        return summary
+
+    def get_trade_statistics(self) -> Dict[str, Any]:
+        if not self.trade_logs:
+            return {'total_trades': 0, 'win_rate': 0.0, 'total_pnl': 0.0}
+        total_trades = len(self.trade_logs)
+        winning_trades = sum(1 for trade in self.trade_logs if trade.get('pnl', 0) > 0)
+        total_pnl = sum(trade.get('pnl', 0) for trade in self.trade_logs)
+        return {
+            'total_trades': total_trades,
+            'win_rate': winning_trades / total_trades if total_trades > 0 else 0.0,
+            'total_pnl': total_pnl,
+            'avg_pnl_per_trade': total_pnl / total_trades if total_trades > 0 else 0.0
+        }
+
+logger_instance = ScalperLogger()
+
+def log(message: str, level: str = "info"):
+    if level.lower() == "debug":
+        logger_instance.logger.debug(message)
+    elif level.lower() == "info":
+        logger_instance.logger.info(message)
+    elif level.lower() == "warning":
+        logger_instance.logger.warning(message)
+    elif level.lower() == "error":
+        logger_instance.logger.error(message)
+    elif level.lower() == "critical":
+        logger_instance.logger.critical(message)
+
+def log_signal(symbol: str, signal: str, confidence: float, price: float,
+               strategy_details: Optional[Dict[str, Any]] = None):
+    logger_instance.log_signal(symbol, signal, confidence, price, strategy_details)
+
+def log_trade(symbol: str, side: str, qty: float, price: float,
+              order_type: str = "MARKET", pnl: Optional[float] = None,
+              reason: str = "signal"):
+    logger_instance.log_trade(symbol, side, qty, price, order_type, pnl, reason)
+
+def log_error(error_type: str, message: str, details: Optional[Dict[str, Any]] = None):
+    logger_instance.log_error(error_type, message, details)
+
+def log_performance(symbol: str, period: str, metrics: Dict[str, Any]):
+    logger_instance.log_performance(symbol, period, metrics)

services/telegram.py

@@ -0,0 +1,21 @@
+import os
+import requests
+from dotenv import load_dotenv
+import yaml
+
+load_dotenv()
+settings = yaml.safe_load(open("config/settings.yaml"))
+
+BOT_TOKEN = os.getenv("TELEGRAM_BOT_TOKEN")
+CHAT_ID = os.getenv("TELEGRAM_CHAT_ID")
+
+def send_telegram(msg):
+    if not settings["telegram"]["enabled"]:
+        return
+
+    if not BOT_TOKEN or not CHAT_ID:
+        print("[WARNING] Telegram not configured.")
+        return
+
+    url = f"https://api.telegram.org/bot{BOT_TOKEN}/sendMessage"
+    requests.post(url, data={"chat_id": CHAT_ID, "text": msg})

test/MAINNET_STATUS.md

@@ -0,0 +1,16 @@
+# 🚀 MAINNET CONFIGURATION COMPLETE
+
+✅ API Connection: WORKING
+✅ Account Balance: ACCESSIBLE  
+✅ Position Monitoring: WORKING
+✅ Order Monitoring: WORKING
+⚠️  Order Creation: BLOCKED (Symbol whitelisting)
+
+The bot is ready for monitoring and analysis on mainnet!
+For live trading, BTCUSDT needs to be whitelisted for your API key.
+
+Current .env configuration:
+- BYBIT_TESTNET=false (Mainnet enabled)
+- API credentials loaded
+
+Ready to run: python3 main.py

test/README.md

@@ -0,0 +1,481 @@
+# Bybit Scalping Bot 🤖
+
+A production-ready cryptocurrency scalping bot that trades BTCUSDT, ETHUSDT, and SOLUSDT using multiple sophisticated strategies with 20x leverage and automated risk management.
+
+![Python](https://img.shields.io/badge/python-3.8+-blue.svg)
+![License](https://img.shields.io/badge/license-MIT-green.svg)
+![Status](https://img.shields.io/badge/status-production--ready-brightgreen.svg)
+
+## ⚡ Features
+
+- **Multi-Strategy Trading**: Three advanced scalping strategies (EMA Momentum, Breakout, Pullback)
+- **20x Leverage**: Configurable leverage with automatic position sizing
+- **Automated TP/SL**: Take profit at 2.5%, stop loss at 1%
+- **Real-Time Data**: WebSocket streaming for ultra-fast signal generation
+- **Risk Management**: Dynamic position sizing, daily loss limits, volatility filters
+- **Backtesting Engine**: Historical performance analysis and parameter optimization
+- **Comprehensive Logging**: Detailed trade logs, performance metrics, error tracking
+- **Telegram Notifications**: Real-time trade alerts and bot status updates
+- **Production Ready**: Error handling, reconnection logic, graceful shutdown
+
+## 🚀 Quick Start
+
+### 1. Environment Setup
+
+```bash
+# Clone the repository
+git clone <repository-url>
+cd scalper
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Copy environment template
+cp .env.example .env
+```
+
+### 2. API Configuration
+
+1. Create a Bybit account at [bybit.com](https://bybit.com)
+2. Generate API keys in Account > API Management
+3. **Required Permissions:**
+   - ✅ **Unified Trading Account** → Read & Trade
+   - ✅ **USDC Derivatives** → Read & Trade
+   - ✅ **Spot** → Read & Trade
+4. **Important**: Add your IP address to the whitelist
+
+Edit `.env` file:
+```env
+BYBIT_API_KEY=your_api_key_here
+BYBIT_API_SECRET=your_api_secret_here
+BYBIT_TESTNET=false  # Use false for mainnet
+TELEGRAM_BOT_TOKEN=your_telegram_bot_token_here  # Optional
+TELEGRAM_CHAT_ID=your_chat_id_here  # Optional
+```
+
+### 3. Start API Server
+
+```bash
+# Start the FastAPI control server
+python3 api_server.py
+```
+
+Server will be available at: **http://localhost:8000**
+
+### 4. Control Trading via API
+
+#### Start Trading for BTC (18 hours default):
+```bash
+curl -X POST http://localhost:8000/start/BTCUSDT
+```
+
+#### Start Trading for ETH (custom duration):
+```bash
+curl -X POST "http://localhost:8000/start/ETHUSDT?duration_hours=24"
+```
+
+#### Check Bot Status:
+```bash
+curl http://localhost:8000/status
+```
+
+#### Stop Trading:
+```bash
+curl -X POST http://localhost:8000/stop/BTCUSDT
+```
+
+### 5. Run Backtest
+
+```bash
+python3 main.py backtest
+```
+
+## 📡 FastAPI Control Interface
+
+The bot uses FastAPI for remote control, allowing you to start/stop trading sessions for individual pairs.
+
+### API Endpoints
+
+#### `GET /status`
+Get current bot status and active sessions.
+```bash
+curl http://localhost:8000/status
+```
+
+#### `POST /start/{symbol}`
+Start trading session for a specific symbol.
+```bash
+# Default 18 hours
+curl -X POST http://localhost:8000/start/BTCUSDT
+
+# Custom duration
+curl -X POST "http://localhost:8000/start/ETHUSDT?duration_hours=24"
+
+# Limited trades
+curl -X POST "http://localhost:8000/start/SOLUSDT?duration_hours=12&max_trades=50"
+```
+
+#### `POST /stop/{symbol}`
+Stop trading session for a specific symbol.
+```bash
+curl -X POST http://localhost:8000/stop/BTCUSDT
+```
+
+#### `GET /sessions`
+Get all trading sessions (active and completed).
+```bash
+curl http://localhost:8000/sessions
+```
+
+#### `GET /report/{session_id}`
+Get detailed report for a completed session.
+```bash
+curl http://localhost:8000/report/BTCUSDT_1703123456
+```
+
+#### `POST /start_all`
+Start trading sessions for ALL configured pairs simultaneously.
+```bash
+# Start all pairs (BTC, ETH, SOL) for 18 hours
+curl -X POST "http://localhost:8000/start_all"
+
+# Custom duration for all pairs
+curl -X POST "http://localhost:8000/start_all?duration_hours=24"
+```
+
+#### `POST /stop_all`
+Stop trading sessions for ALL pairs.
+```bash
+curl -X POST http://localhost:8000/stop_all
+```
+
+#### `GET /logs/analysis`
+Get recent analysis logs (strategy signals, indicator values).
+```bash
+curl "http://localhost:8000/logs/analysis"
+curl "http://localhost:8000/logs/analysis?lines=100"
+```
+
+#### `GET /logs/live`
+Get recent live logs (all bot activities).
+```bash
+curl "http://localhost:8000/logs/live"
+curl "http://localhost:8000/logs/live?lines=50"
+```
+
+#### `GET /analysis/status`
+Get real-time analysis status for all active sessions.
+```bash
+curl "http://localhost:8000/analysis/status"
+```
+
+#### `POST /emergency_stop`
+Emergency stop all trading sessions.
+```bash
+curl -X POST http://localhost:8000/emergency_stop
+```
+
+### Interactive API Documentation
+
+When the server is running, visit: **http://localhost:8000/docs**
+
+This provides an interactive Swagger UI to test all endpoints.
+
+### Example Workflow
+
+```bash
+# 1. Start API server
+python3 api_server.py
+
+# 2. Start BTC trading for 18 hours
+curl -X POST http://localhost:8000/start/BTCUSDT
+
+# 3. Check status
+curl http://localhost:8000/status
+
+# 4. Start ETH trading for 24 hours
+curl -X POST "http://localhost:8000/start/ETHUSDT?duration_hours=24"
+
+# 5. Stop BTC trading
+curl -X POST http://localhost:8000/stop/BTCUSDT
+
+# 6. Get final reports
+curl http://localhost:8000/sessions
+```
+
+## 📊 Trading Strategies
+
+### 1. EMA Momentum Scalping
+- **Entry**: EMA9 crosses above EMA21 in bullish direction
+- **Confirmation**: RSI oversold (<35) + bid dominance in orderbook
+- **Exit**: 2.5% profit or 1% stop loss
+
+### 2. Breakout Scalper
+- **Entry**: Price breaks above recent highs with volume spike
+- **Confirmation**: Spread contraction + orderbook imbalance
+- **Exit**: Time-based (5-15 min) or TP/SL hit
+
+### 3. Pullback Scalper
+- **Entry**: Price retraces to EMA21 in trending market
+- **Confirmation**: Volume decreases on pullback, increases on continuation
+- **Exit**: Trend continuation signal or timeout
+
+## 🏗️ Architecture
+
+```
+scalper/
+├── main.py                 # Entry point
+├── config/
+│   ├── settings.yaml      # Trading parameters
+│   └── pairs.yaml         # Trading pairs
+├── core/
+│   ├── exchange.py        # Bybit API wrapper
+│   ├── strategy.py        # Trading strategies
+│   ├── risk.py           # Risk management
+│   ├── data_engine.py     # Data storage & indicators
+│   ├── trade_monitor.py   # Trade monitoring loop
+│   └── websockets.py      # Real-time data streaming
+├── services/
+│   ├── logger.py          # Logging system
+│   └── telegram.py        # Telegram notifications
+├── backtester/
+│   └── engine.py          # Backtesting engine
+├── logs/                  # Log files
+├── backtest_results/      # Backtest outputs
+└── requirements.txt       # Dependencies
+```
+
+## ⚙️ Configuration
+
+### Trading Parameters
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `leverage` | 20 | Trading leverage |
+| `tp_percent` | 0.025 | Take profit percentage |
+| `sl_percent` | 0.01 | Stop loss percentage |
+| `risk_per_trade` | 0.02 | Risk per trade (% of balance) |
+
+### Strategy Parameters
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `interval` | "1" | Candle interval (minutes) |
+| `rsi_period` | 14 | RSI calculation period |
+| `ema_fast` | 9 | Fast EMA period |
+| `ema_slow` | 21 | Slow EMA period |
+
+## 🔬 Backtesting
+
+Run comprehensive backtests to evaluate strategy performance:
+
+```bash
+python main.py backtest
+```
+
+### Backtest Metrics
+- **Win Rate**: Percentage of profitable trades
+- **Profit Factor**: Gross profit / Gross loss
+- **Max Drawdown**: Largest peak-to-valley decline
+- **Sharpe Ratio**: Risk-adjusted returns
+- **Average Trade Duration**: Typical trade holding time
+
+### Parameter Optimization
+
+The backtester includes grid search optimization for:
+- EMA periods
+- RSI thresholds
+- Risk percentages
+- Timeframe settings
+
+## 📈 Risk Management
+
+### Safety Features
+- **Daily Loss Limits**: Automatic stop when daily loss exceeds threshold
+- **Volatility Filters**: Skip trading during high volatility periods
+- **Spread Filters**: Avoid wide spreads that increase slippage
+- **Position Limits**: Maximum one position per symbol
+- **Emergency Stop**: Manual override capability
+
+### Position Sizing
+```python
+risk_amount = balance * risk_per_trade
+position_size = risk_amount / (sl_distance * leverage)
+```
+
+## 🌐 WebSocket Integration
+
+Real-time data streams for ultra-fast execution:
+- **Tickers**: Price updates every 100ms
+- **Klines**: 1-minute and 5-minute candles
+- **Orderbook**: Top 25 bids/asks with depth
+- **Trades**: Recent market trades
+- **Auto-Reconnect**: Handles connection drops gracefully
+
+## 📊 Monitoring & Logging
+
+### Log Files
+- `logs/scalper.log`: General application logs
+- `logs/trades.log`: Trade execution logs
+- `logs/errors.log`: Error tracking
+- `logs/signals.json`: Trading signals
+- `logs/performance.jsonl`: Performance metrics
+
+### Telegram Alerts
+Configure for real-time notifications:
+- Trade executions
+- Strategy signals
+- Error alerts
+- Daily performance summaries
+
+## 🚀 Deployment
+
+### Local Machine
+```bash
+# Run in background
+nohup python main.py &
+```
+
+### VPS Deployment (Recommended)
+```bash
+# Install dependencies
+sudo apt update
+sudo apt install python3 python3-pip tmux
+
+# Clone and setup
+git clone <repository-url>
+cd scalper
+pip install -r requirements.txt
+
+# Run with process manager
+tmux new -s scalper
+python main.py
+# Ctrl+B, D to detach
+```
+
+### Process Manager (PM2)
+```bash
+npm install -g pm2
+pm2 start main.py --name scalper
+pm2 startup
+pm2 save
+```
+
+## 🔧 Troubleshooting
+
+### Common Issues
+
+**API Connection Failed**
+```bash
+# Check API keys in .env
+cat .env
+# Verify testnet setting
+# Check Bybit API status
+```
+
+**WebSocket Disconnection**
+- Automatic reconnection is built-in
+- Check internet connection
+- Verify Bybit service status
+
+**No Trading Signals**
+```bash
+# Check market conditions
+python -c "from core.data_engine import DataEngine; de = DataEngine(); print(de.get_buffer_status())"
+# Verify strategy parameters
+# Check volatility filters
+```
+
+**Position Not Opening**
+- Verify account balance
+- Check risk management settings
+- Review API permissions
+
+### Debug Mode
+```bash
+# Enable debug logging
+export LOG_LEVEL=DEBUG
+python main.py
+```
+
+## 📈 Performance Optimization
+
+### Strategy Tuning
+1. Run backtests with different parameters
+2. Optimize for specific market conditions
+3. Adjust risk parameters based on drawdown
+
+### Hardware Requirements
+- **CPU**: 2+ cores recommended
+- **RAM**: 2-4 GB sufficient
+- **Network**: Stable internet connection
+- **Storage**: 1GB for logs and data
+
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Add tests for new functionality
+4. Submit a pull request
+
+## 📜 License
+
+MIT License - see [LICENSE](LICENSE) file for details.
+
+## ⚠️ Disclaimer
+
+**This software is for educational and research purposes only. Trading cryptocurrencies involves substantial risk of loss and is not suitable for every investor. Past performance does not guarantee future results. Please test thoroughly and use at your own risk.**
+
+### Risk Warnings
+- **Leverage Trading**: 20x leverage can amplify both gains and losses
+- **Market Volatility**: Crypto markets can be highly volatile
+- **Technical Risks**: Software bugs, internet outages, API issues
+- **Financial Risk**: Never invest more than you can afford to lose
+
+## 🆘 Support
+
+- **Issues**: Open a GitHub issue
+- **Documentation**: Check this README and inline code comments
+- **Community**: Join crypto trading communities for general advice
+
+---
+
+## 🌐 **Hugging Face Deployment**
+
+### **Deploy to Hugging Face Spaces**
+
+1. **Create Space**: Go to [hf.co/spaces](https://hf.co/spaces) → "Create new Space"
+   - **Name**: `your-scalping-bot`
+   - **SDK**: `Docker`
+   - **Storage**: `Small`
+
+2. **Repository Setup**:
+   ```bash
+   # Push your code to GitHub
+   git add .
+   git commit -m "Scalping bot deployment"
+   git push origin main
+   ```
+
+3. **Connect Repository**: In Space settings → "Connect Repository"
+   - Enter your GitHub URL
+   - Branch: `main`
+
+4. **Public URL**: You'll get a URL like:
+   ```
+   https://yourusername-your-scalping-bot.hf.space
+   ```
+   **This is your public IP for remote access!**
+
+5. **Configure API Keys**: Use the web interface to set your Bybit credentials
+
+### **Hugging Face Features**
+- 🌐 **Public web dashboard** with real-time analysis
+- 📊 **Interactive charts** and performance metrics
+- 🎛️ **One-click trading** controls
+- 📱 **Mobile-friendly** interface
+- 🔄 **Auto-scaling** and uptime monitoring
+
+---
+
+**Happy Trading! 🚀**

test/get_chat_id.py

@@ -0,0 +1,124 @@
+#!/usr/bin/env python3
+"""
+Get Telegram Chat ID for bot notifications
+Run this script, then send a message to your bot
+"""
+
+import requests
+import time
+
+# Your bot token
+BOT_TOKEN = "8555333979:AAH_oCYvbXEt6IQ0-qbFdb9kSjdqpyIJcqA"
+BASE_URL = f"https://api.telegram.org/bot{BOT_TOKEN}"
+
+def get_bot_info():
+    """Get bot information"""
+    try:
+        response = requests.get(f"{BASE_URL}/getMe")
+        if response.status_code == 200:
+            bot_info = response.json()
+            if bot_info['ok']:
+                print("🤖 Bot Information:")
+                print(f"   Name: {bot_info['result']['first_name']}")
+                print(f"   Username: @{bot_info['result']['username']}")
+                print(f"   Can read messages: {bot_info['result']['can_read_all_group_messages']}")
+                return True
+        print(f"❌ Failed to get bot info: {response.text}")
+        return False
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        return False
+
+def get_updates():
+    """Get recent updates (messages) to extract chat ID"""
+    try:
+        response = requests.get(f"{BASE_URL}/getUpdates", timeout=30)
+        if response.status_code == 200:
+            updates = response.json()
+            if updates['ok'] and updates['result']:
+                print("\n📨 Recent Messages:")
+                for update in updates['result'][-5:]:  # Show last 5 messages
+                    if 'message' in update:
+                        message = update['message']
+                        chat = message['chat']
+                        from_user = message.get('from', {})
+
+                        print(f"\n💬 Message from: {from_user.get('first_name', 'Unknown')}")
+                        print(f"   Chat ID: {chat['id']}")
+                        print(f"   Chat Type: {chat['type']}")
+                        print(f"   Message: {message.get('text', 'N/A')}")
+                        print(f"   Time: {time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(message['date']))}")
+
+                        if chat['type'] == 'private':
+                            print(f"\n🎯 YOUR CHAT ID: {chat['id']}")
+                            print("   Use this in your .env file as TELEGRAM_CHAT_ID")
+                            return chat['id']
+                print("\n💡 No recent messages found. Send a message to your bot and run this again.")
+                return None
+            else:
+                print("\n💡 No messages received yet. Please:")
+                print("   1. Open Telegram")
+                print("   2. Find your bot: Search for the username shown above")
+                print("   3. Send any message to the bot")
+                print("   4. Run this script again")
+                return None
+        else:
+            print(f"❌ Failed to get updates: {response.text}")
+            return None
+    except Exception as e:
+        print(f"❌ Error getting updates: {e}")
+        return None
+
+def send_test_message(chat_id):
+    """Send a test message to confirm chat ID works"""
+    try:
+        message = "✅ Telegram integration test successful! Your chat ID is working."
+        data = {
+            'chat_id': chat_id,
+            'text': message
+        }
+        response = requests.post(f"{BASE_URL}/sendMessage", data=data)
+        if response.status_code == 200:
+            print("\n📤 Test message sent! Check your Telegram.")
+            return True
+        else:
+            print(f"❌ Failed to send test message: {response.text}")
+            return False
+    except Exception as e:
+        print(f"❌ Error sending test message: {e}")
+        return False
+
+def main():
+    print("🔍 Telegram Chat ID Finder")
+    print("=" * 40)
+
+    if not get_bot_info():
+        print("❌ Bot token is invalid. Please check your token.")
+        return
+
+    print("\n⏳ Waiting for messages... (you have 30 seconds)")
+    print("📱 Please send a message to your bot now...")
+
+    chat_id = get_updates()
+
+    if chat_id:
+        print(f"\n🎉 Found your Chat ID: {chat_id}")
+
+        if send_test_message(chat_id):
+            print("\n✅ Setup complete!")
+            print("\n📝 Add this to your .env file:")
+            print(f"TELEGRAM_BOT_TOKEN={BOT_TOKEN}")
+            print(f"TELEGRAM_CHAT_ID={chat_id}")
+
+            print("\n📄 Or update your existing .env:")
+            print("TELEGRAM_CHAT_ID=your_chat_id_here")
+            print(f"             ↑ replace with: {chat_id}")
+        else:
+            print("\n⚠️ Chat ID found but test message failed.")
+            print("   You can still use the chat ID, but double-check your setup.")
+    else:
+        print("\n❌ No chat ID found.")
+        print("   Make sure to send a message to your bot and run this script again.")
+
+if __name__ == "__main__":
+    main()

test/huggingface_README.md

@@ -0,0 +1,318 @@
+# 🚀 Deploy Scalping Bot on Hugging Face Spaces
+
+## Prerequisites
+
+1. **Hugging Face Account**: Create account at [huggingface.co](https://huggingface.co)
+2. **API Credentials**: Your Bybit API keys ready
+3. **Git Repository**: Push your code to GitHub/GitLab
+
+## Step 1: Create Hugging Face Space
+
+1. Go to [huggingface.co/spaces](https://huggingface.co/spaces)
+2. Click "Create new Space"
+3. Choose:
+   - **Space name**: `your-scalping-bot`
+   - **License**: Apache-2.0
+   - **SDK**: **Docker** (for full control)
+   - **Storage**: Small (sufficient)
+
+## Step 2: Repository Structure
+
+Your repository should look like:
+```
+your-scalping-bot/
+├── app.py              # Streamlit/FastAPI app
+├── requirements.txt    # Dependencies
+├── packages.txt        # System packages (if needed)
+├── config/
+│   ├── settings.yaml
+│   └── pairs.yaml
+├── core/
+│   ├── exchange.py
+│   ├── strategy.py
+│   └── ...
+├── services/
+│   └── ...
+└── README.md
+```
+
+## Step 3: Create app.py
+
+```python
+import streamlit as st
+import subprocess
+import os
+import signal
+import time
+from threading import Thread
+import requests
+
+# Set page config
+st.set_page_config(
+    page_title="Scalping Bot Control",
+    page_icon="🤖",
+    layout="wide"
+)
+
+st.title("🤖 Bybit Scalping Bot Control Panel")
+
+# Sidebar
+st.sidebar.header("⚙️ Configuration")
+
+# Environment variables setup
+st.sidebar.subheader("🔑 API Configuration")
+bybit_key = st.sidebar.text_input("Bybit API Key", type="password")
+bybit_secret = st.sidebar.text_input("Bybit API Secret", type="password")
+bybit_testnet = st.sidebar.checkbox("Use Testnet", value=False)
+telegram_token = st.sidebar.text_input("Telegram Bot Token (optional)")
+telegram_chat = st.sidebar.text_input("Telegram Chat ID (optional)")
+
+if st.sidebar.button("💾 Save Configuration"):
+    # Save to .env file
+    env_content = f"""BYBIT_API_KEY={bybit_key}
+BYBIT_API_SECRET={bybit_secret}
+BYBIT_TESTNET={str(bybit_testnet).lower()}
+TELEGRAM_BOT_TOKEN={telegram_token}
+TELEGRAM_CHAT_ID={telegram_chat}
+"""
+    with open('.env', 'w') as f:
+        f.write(env_content)
+    st.sidebar.success("Configuration saved!")
+
+# Main content
+col1, col2, col3 = st.columns(3)
+
+with col1:
+    st.subheader("🚀 Start Trading")
+    symbol = st.selectbox("Symbol", ["BTCUSDT", "ETHUSDT", "SOLUSDT"])
+    duration = st.slider("Duration (hours)", 1, 24, 18)
+    max_trades = st.number_input("Max Trades (optional)", min_value=1, value=50)
+
+    if st.button("▶️ Start Trading", key="start"):
+        try:
+            response = requests.post(f"http://localhost:8000/start/{symbol}",
+                                   params={"duration_hours": duration, "max_trades": max_trades})
+            if response.status_code == 200:
+                st.success(f"✅ Started trading {symbol} for {duration} hours")
+            else:
+                st.error(f"❌ Failed to start: {response.text}")
+        except Exception as e:
+            st.error(f"❌ Error: {e}")
+
+with col2:
+    st.subheader("🛑 Stop Trading")
+    stop_symbol = st.selectbox("Symbol to Stop", ["BTCUSDT", "ETHUSDT", "SOLUSDT"], key="stop_select")
+
+    if st.button("⏹️ Stop Trading", key="stop"):
+        try:
+            response = requests.post(f"http://localhost:8000/stop/{stop_symbol}")
+            if response.status_code == 200:
+                st.success(f"✅ Stopped trading {stop_symbol}")
+            else:
+                st.error(f"❌ Failed to stop: {response.text}")
+        except Exception as e:
+            st.error(f"❌ Error: {e}")
+
+with col3:
+    st.subheader("🚨 Emergency")
+    if st.button("🚨 EMERGENCY STOP ALL", key="emergency"):
+        try:
+            response = requests.post("http://localhost:8000/emergency_stop")
+            if response.status_code == 200:
+                st.error("🚨 ALL TRADING STOPPED!")
+            else:
+                st.error(f"❌ Failed: {response.text}")
+        except Exception as e:
+            st.error(f"❌ Error: {e}")
+
+# Status section
+st.header("📊 Bot Status")
+
+if st.button("🔄 Refresh Status"):
+    try:
+        response = requests.get("http://localhost:8000/status")
+        if response.status_code == 200:
+            status = response.json()
+
+            # Overall status
+            if status["is_running"]:
+                st.success("✅ Bot is RUNNING")
+            else:
+                st.warning("⏸️ Bot is STOPPED")
+
+            st.metric("Total P&L", f"${status['total_pnl']:.2f}")
+            st.metric("Trades Today", status['trades_today'])
+
+            # Active sessions
+            if status["active_sessions"]:
+                st.subheader("🎯 Active Sessions")
+                for session in status["active_sessions"]:
+                    with st.expander(f"{session['symbol']} - {session['status'].upper()}"):
+                        st.write(f"**Session ID:** {session['session_id']}")
+                        st.write(f"**Started:** {session['start_time'][:19]}")
+                        st.write(f"**P&L:** ${session['pnl']:.2f}")
+                        st.write(f"**Trades:** {session['trades']}")
+            else:
+                st.info("No active sessions")
+
+        else:
+            st.error(f"❌ Failed to get status: {response.status_code}")
+    except Exception as e:
+        st.error(f"❌ Connection error: {e}")
+
+# Analysis section
+st.header("🔍 Live Analysis")
+
+if st.button("📊 Refresh Analysis"):
+    try:
+        response = requests.get("http://localhost:8000/analysis/status")
+        if response.status_code == 200:
+            analysis = response.json()
+
+            for symbol, data in analysis["analysis_status"].items():
+                with st.expander(f"📈 {symbol} Analysis"):
+                    col1, col2 = st.columns(2)
+
+                    with col1:
+                        st.metric("Current Price", f"${data['current_price']:.2f}" if data['current_price'] else "N/A")
+
+                        indicators = data['indicators']
+                        st.write("**Indicators:**")
+                        st.write(f"EMA 9: {indicators['ema_9']:.4f}" if indicators['ema_9'] else "EMA 9: N/A")
+                        st.write(f"EMA 21: {indicators['ema_21']:.4f}" if indicators['ema_21'] else "EMA 21: N/A")
+                        st.write(f"RSI 14: {indicators['rsi_14']:.1f}" if indicators['rsi_14'] else "RSI 14: N/A")
+
+                    with col2:
+                        conditions = data['strategy_conditions']
+                        st.write("**Strategy Conditions:**")
+                        st.write(f"📈 Trend Up: {'✅' if conditions['trend_up'] else '❌'}")
+                        st.write(f"📊 RSI Valid: {'✅' if conditions['rsi_valid'] else '❌'}")
+                        st.write(f"💥 Volume Spike: {'✅' if conditions['volume_spike'] else '❌'}")
+                        st.write(f"🎯 Orderbook OK: {'✅' if conditions['orderbook_aligned'] else '❌'}")
+
+                        all_conditions = all([conditions['trend_up'], conditions['rsi_valid'],
+                                            conditions['volume_spike'], conditions['orderbook_aligned']])
+
+                        if all_conditions:
+                            st.success("🎯 TRADE SIGNAL READY!")
+                        else:
+                            st.info("⏳ Waiting for conditions...")
+        else:
+            st.error(f"❌ Failed to get analysis: {response.status_code}")
+    except Exception as e:
+        st.error(f"❌ Connection error: {e}")
+
+# Logs section
+st.header("📋 Recent Logs")
+
+log_type = st.selectbox("Log Type", ["Live Logs", "Analysis Logs"])
+
+if st.button("📖 Refresh Logs"):
+    try:
+        if log_type == "Live Logs":
+            response = requests.get("http://localhost:8000/logs/live")
+        else:
+            response = requests.get("http://localhost:8000/logs/analysis")
+
+        if response.status_code == 200:
+            logs_data = response.json()
+
+            st.write(f"**Total {log_type}:** {logs_data['count']}")
+
+            logs_text = ""
+            for log_line in logs_data['logs'][-10:]:  # Show last 10
+                logs_text += log_line
+
+            st.code(logs_text, language="text")
+        else:
+            st.error(f"❌ Failed to get logs: {response.status_code}")
+    except Exception as e:
+        st.error(f"❌ Connection error: {e}")
+
+# Footer
+st.markdown("---")
+st.markdown("*🤖 Bybit Scalping Bot - FastAPI Control Interface*")
+st.markdown("*Made with ❤️ for automated crypto trading*")
+```
+
+## Step 4: Create requirements.txt
+
+```txt
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+streamlit==1.28.1
+requests==2.31.0
+python-dotenv==1.0.0
+pybit==5.7.0
+pyyaml==6.0.1
+pandas==2.1.3
+numpy==1.26.2
+websockets==12.0
+```
+
+## Step 5: Create packages.txt (Optional)
+
+```
+# No system packages needed
+```
+
+## Step 6: Deploy to Hugging Face
+
+1. **Push to Git**: Commit and push your code to a Git repository
+2. **Connect Space**: In your Hugging Face Space settings:
+   - Go to "Settings" → "Connect Repository"
+   - Enter your repository URL
+   - Set branch to `main`
+3. **Auto-deploy**: Hugging Face will automatically build and deploy
+
+## Step 7: Access Your Bot
+
+Once deployed, you'll get a public URL like:
+```
+https://yourusername-your-scalping-bot.hf.space
+```
+
+This will be your **public IP/URL** for accessing the bot remotely!
+
+## Step 8: Start the Bot
+
+In your Hugging Face Space:
+1. ✅ Configure API keys in the sidebar
+2. ✅ Click "Start Trading" for your desired pairs
+3. ✅ Monitor analysis in real-time
+4. ✅ View logs and performance
+
+## 🔒 Security Notes
+
+- **Never expose real API keys** in public repositories
+- **Use environment variables** for sensitive data
+- **Consider IP restrictions** on your Bybit API keys
+- **Monitor your bot regularly** via the web interface
+
+## 🌐 Public Access
+
+Your bot will be accessible worldwide via:
+```
+https://[your-username]-[space-name].hf.space
+```
+
+This serves as your **public IP address** for remote access!
+
+## 💡 Usage Examples
+
+```bash
+# Direct API calls (replace with your HF Space URL)
+curl -X POST "https://your-bot.hf.space/start/BTCUSDT"
+curl "https://your-bot.hf.space/status"
+curl "https://your-bot.hf.space/analysis/status"
+```
+
+## 🎉 You're Done!
+
+Your scalping bot is now hosted on Hugging Face with:
+- 🌐 **Public web interface**
+- 📊 **Real-time analysis dashboard**
+- 🎛️ **Remote control via API**
+- 📱 **Mobile-friendly interface**
+
+**Happy trading!** 🚀🤖

test/test_api.py

@@ -0,0 +1,167 @@
+#!/usr/bin/env python3
+import os
+from dotenv import load_dotenv
+from pybit.unified_trading import HTTP
+
+load_dotenv()
+
+def test_public_endpoints():
+    print("Testing public API endpoints...")
+    try:
+        session = HTTP(testnet=True)
+
+        server_time = session.get_server_time()
+        print(f"✅ Server time: {server_time['result']['timeSecond']}")
+
+        ticker = session.get_tickers(category="linear", symbol="BTCUSDT")
+        if ticker['result']['list']:
+            price = ticker['result']['list'][0]['lastPrice']
+            print(f"✅ BTCUSDT price: ${price}")
+
+        kline = session.get_kline(
+            category="linear",
+            symbol="BTCUSDT",
+            interval="1",
+            limit=1
+        )
+        if kline['result']['list']:
+            print("✅ Kline data retrieved successfully")
+
+        instruments = session.get_instruments_info(category="linear", symbol="BTCUSDT")
+        if instruments['result']['list']:
+            print("✅ Instrument info retrieved successfully")
+
+        return True
+    except Exception as e:
+        print(f"❌ Public API test failed: {e}")
+        return False
+
+def test_private_endpoints():
+    print("\nTesting private API endpoints...")
+
+    API_KEY = os.getenv("BYBIT_API_KEY")
+    API_SECRET = os.getenv("BYBIT_API_SECRET")
+    TESTNET = os.getenv("BYBIT_TESTNET", "true").lower() == "true"
+
+    print(f"API Key configured: {'Yes' if API_KEY else 'No'}")
+    print(f"API Secret configured: {'Yes' if API_SECRET else 'No'}")
+    print(f"Using {'TESTNET' if TESTNET else 'MAINNET'}")
+
+    if not API_KEY or not API_SECRET:
+        print("❌ ERROR: API credentials not found in .env file")
+        print("Please set BYBIT_API_KEY and BYBIT_API_SECRET in your .env file")
+        return False
+
+    if API_KEY == "your_api_key_here" or API_SECRET == "your_api_secret_here":
+        print("❌ ERROR: API credentials are still set to default placeholder values")
+        print("Please update .env with your actual Bybit API credentials")
+        return False
+
+    try:
+        session = HTTP(
+            api_key=API_KEY,
+            api_secret=API_SECRET,
+            testnet=TESTNET
+        )
+
+        print("✅ HTTP client initialized with API credentials")
+
+        balance_success = False
+        positions_success = False
+        orders_success = False
+
+        try:
+            balance = session.get_wallet_balance(accountType="UNIFIED")
+            print(f"✅ Account balance retrieved: {len(balance['result']['list'])} coins")
+
+            for coin in balance['result']['list']:
+                if coin['coin'] == 'USDT':
+                    print(f"   USDT Balance: {coin.get('walletBalance', '0')}")
+
+            balance_success = True
+
+        except Exception as e:
+            print(f"❌ Balance check failed: {e}")
+            print("   Trying CONTRACT account type...")
+
+            try:
+                balance = session.get_wallet_balance(accountType="CONTRACT")
+                print(f"✅ Contract account balance retrieved: {len(balance['result']['list'])} coins")
+                balance_success = True
+            except Exception as e2:
+                print(f"❌ Contract balance also failed: {e2}")
+                print("   Common causes:")
+                print("   - API key lacks balance viewing permissions")
+                print("   - Invalid API credentials")
+                print("   - Account not funded on testnet")
+                print("   - Check API key permissions in Bybit dashboard")
+
+        try:
+            positions = session.get_positions(category="linear")
+            print(f"✅ Positions retrieved: {len(positions['result']['list'])} positions")
+            positions_success = True
+        except Exception as e:
+            print(f"❌ Positions check failed: {e}")
+            print("   This requires 'View Positions' permission")
+
+        try:
+            orders = session.get_open_orders(category="linear")
+            print(f"✅ Open orders retrieved: {len(orders['result']['list'])} orders")
+            orders_success = True
+        except Exception as e:
+            print(f"❌ Orders check failed: {e}")
+            print("   This requires 'View Orders' permission")
+
+        if balance_success and positions_success and orders_success:
+            print("🎉 All private API endpoints working!")
+            return True
+        else:
+            print("⚠️  Some private API endpoints failed")
+            print("   For trading bot to work, you need:")
+            print("   - Valid API credentials")
+            print("   - API key with permissions: View Account Balance, View Positions, View Orders")
+            print("   - API key with permissions: Trade (for placing orders)")
+            print("   - Funded testnet account (if using testnet)")
+            return False
+
+    except Exception as e:
+        print(f"❌ Private API connection failed: {e}")
+        return False
+
+def main():
+    print("🔍 Bybit API Connection Test")
+    print("=" * 40)
+
+    public_ok = test_public_endpoints()
+    private_ok = test_private_endpoints()
+
+    print("\n" + "=" * 40)
+    print("📊 Test Results:")
+
+    if public_ok:
+        print("✅ Public API: Working")
+    else:
+        print("❌ Public API: Failed")
+
+    if private_ok:
+        print("✅ Private API: Working")
+        print("🎉 All API tests passed! Ready for trading.")
+        return True
+    else:
+        print("❌ Private API: Failed")
+        print("\n🔧 To fix private API issues:")
+        print("1. Go to Bybit account > API Management")
+        print("2. Ensure your API key has these permissions:")
+        print("   - 'Unified Trading Account' - Read & Trade")
+        print("   - 'USDC Derivatives' - Read & Trade (if using USDC)")
+        print("   - 'Spot' - Read & Trade (if using spot)")
+        print("3. Make sure your account is upgraded to Unified Trading Account")
+        print("4. Fund your testnet account with USDT:")
+        print("   - Go to Bybit testnet faucet or transfer from mainnet")
+        print("   - Minimum 10 USDT recommended for testing")
+        print("5. Verify API credentials in .env file are correct")
+        return False
+
+if __name__ == "__main__":
+    success = main()
+    exit(0 if success else 1)

test/test_api_client.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+"""
+FastAPI Client Test - Test the scalping bot API endpoints
+"""
+
+import requests
+import time
+import json
+
+BASE_URL = "http://localhost:8000"
+
+def test_endpoint(method, endpoint, data=None, params=None):
+    """Test an API endpoint"""
+    try:
+        url = f"{BASE_URL}{endpoint}"
+
+        if method == "GET":
+            response = requests.get(url, params=params)
+        elif method == "POST":
+            response = requests.post(url, json=data, params=params)
+        else:
+            print(f"❌ Unsupported method: {method}")
+            return None
+
+        print(f"\n{method} {endpoint}")
+        print(f"Status: {response.status_code}")
+
+        if response.status_code == 200:
+            try:
+                result = response.json()
+                print("✅ Success")
+                return result
+            except:
+                print(f"Response: {response.text[:200]}...")
+                return response.text
+        else:
+            print(f"❌ Error: {response.text}")
+            return None
+
+    except Exception as e:
+        print(f"❌ Connection Error: {e}")
+        return None
+
+def main():
+    print("🧪 FastAPI Client Test")
+    print("=" * 40)
+
+    # Test 1: Get status
+    print("\n1️⃣ Testing /status endpoint...")
+    status = test_endpoint("GET", "/status")
+    if status:
+        print(f"   Bot running: {status.get('is_running', 'Unknown')}")
+        print(f"   Active sessions: {len(status.get('active_sessions', []))}")
+
+    # Test 2: Get root
+    print("\n2️⃣ Testing / root endpoint...")
+    root = test_endpoint("GET", "/")
+
+    # Test 3: Try to start BTC trading (will fail if server not running)
+    print("\n3️⃣ Testing /start/BTCUSDT endpoint...")
+    start_result = test_endpoint("POST", "/start/BTCUSDT", params={"duration_hours": 1})
+    if start_result:
+        print("   BTC trading session started!")
+    else:
+        print("   (Expected to fail if API server not running)")
+
+    # Test 4: Get sessions
+    print("\n4️⃣ Testing /sessions endpoint...")
+    sessions = test_endpoint("GET", "/sessions")
+
+    print("\n" + "=" * 40)
+    print("📊 Test Complete")
+    print("\nTo run the API server:")
+    print("  python3 api_server.py")
+    print("\nTo start trading:")
+    print("  curl -X POST http://localhost:8000/start/BTCUSDT")
+    print("\nTo check status:")
+    print("  curl http://localhost:8000/status")
+
+if __name__ == "__main__":
+    main()

test/test_api_raw.py

@@ -0,0 +1,176 @@
+import requests
+import time
+import hashlib
+import hmac
+import uuid
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+api_key = os.getenv("BYBIT_API_KEY")
+secret_key = os.getenv("BYBIT_API_SECRET")
+httpClient = requests.Session()
+recv_window = str(5000)
+url = "https://api.bybit.com"
+
+def HTTP_Request(endPoint, method, payload, Info):
+    global time_stamp
+    time_stamp = str(int(time.time() * 10 ** 3))
+    signature = genSignature(payload)
+    headers = {
+        'X-BAPI-API-KEY': api_key,
+        'X-BAPI-SIGN': signature,
+        'X-BAPI-SIGN-TYPE': '2',
+        'X-BAPI-TIMESTAMP': time_stamp,
+        'X-BAPI-RECV-WINDOW': recv_window,
+        'Content-Type': 'application/json'
+    }
+    if(method == "POST"):
+        response = httpClient.request(method, url + endPoint, headers=headers, data=payload)
+    else:
+        response = httpClient.request(method, url + endPoint + "?" + payload, headers=headers)
+    print(f"\n{Info}:")
+    print(f"Status Code: {response.status_code}")
+    print(f"Response: {response.text}")
+    print(f"Elapsed Time: {response.elapsed}")
+    return response
+
+def genSignature(payload):
+    param_str = str(time_stamp) + api_key + recv_window + payload
+    hash = hmac.new(bytes(secret_key, "utf-8"), param_str.encode("utf-8"), hashlib.sha256)
+    signature = hash.hexdigest()
+    return signature
+
+def test_wallet_balance():
+    print("Testing Wallet Balance...")
+    endpoint = "/v5/account/wallet-balance"
+    method = "GET"
+    params = 'accountType=UNIFIED'
+    response = HTTP_Request(endpoint, method, params, "Wallet Balance")
+
+    # Parse response to check for specific errors
+    try:
+        import json
+        resp_data = json.loads(response.text) if response.text else {}
+        ret_code = resp_data.get('retCode', -1)
+        ret_msg = resp_data.get('retMsg', 'Unknown error')
+
+        if ret_code == 0:
+            return True
+        else:
+            print(f"   API Error: {ret_code} - {ret_msg}")
+            return False
+    except:
+        return response.status_code == 200
+
+def test_positions():
+    print("Testing Positions...")
+    endpoint = "/v5/position/list"
+    method = "GET"
+    params = 'category=linear&settleCoin=USDT'
+    response = HTTP_Request(endpoint, method, params, "Positions")
+    return parse_api_response(response)
+
+def test_create_order():
+    print("Testing Order Creation...")
+    print("Note: Order creation may fail due to symbol whitelisting or insufficient balance")
+    print("This is normal for testing - the bot will handle this gracefully")
+
+    endpoint = "/v5/order/create"
+    method = "POST"
+    orderLinkId = uuid.uuid4().hex
+
+    # Try market order with minimum viable amount
+    params = f'{{"category":"linear","symbol":"BTCUSDT","side":"Buy","orderType":"Limit","qty":"0.001","price":"84100","timeInForce":"GTC","orderLinkId":"{orderLinkId}"}}'
+    response = HTTP_Request(endpoint, method, params, "Create Order (Market)")
+    success = parse_api_response(response)
+
+    if not success:
+        print("   Market order failed - this is expected if symbol not whitelisted or insufficient balance")
+        print("   The bot can still function for monitoring and analysis")
+
+    return success, orderLinkId
+
+def test_get_orders():
+    print("Testing Get Orders...")
+    endpoint = "/v5/order/realtime"
+    method = "GET"
+    params = 'category=linear&settleCoin=USDT'
+    response = HTTP_Request(endpoint, method, params, "Get Orders")
+    return parse_api_response(response)
+
+def parse_api_response(response):
+    """Parse API response and return success status"""
+    try:
+        import json
+        resp_data = json.loads(response.text) if response.text else {}
+        ret_code = resp_data.get('retCode', -1)
+        ret_msg = resp_data.get('retMsg', 'Unknown error')
+
+        if ret_code == 0:
+            return True
+        else:
+            print(f"   API Error: {ret_code} - {ret_msg}")
+            return False
+    except Exception as e:
+        print(f"   Parse Error: {e}")
+        return response.status_code == 200
+
+def main():
+    print("🔍 Bybit API Raw HTTP Test")
+    print("=" * 50)
+
+    if not api_key or not secret_key:
+        print("❌ API credentials not found!")
+        return
+
+    print(f"API Key: {api_key[:10]}...")
+    print(f"Secret Key: {secret_key[:10]}...")
+    print(f"Testnet URL: {url}")
+
+    tests = [
+        ("Wallet Balance", test_wallet_balance),
+        ("Positions", test_positions),
+        ("Get Orders", test_get_orders),
+    ]
+
+    results = []
+    for test_name, test_func in tests:
+        try:
+            success = test_func()
+            results.append((test_name, success))
+            print(f"✅ {test_name}: {'PASS' if success else 'FAIL'}")
+        except Exception as e:
+            print(f"❌ {test_name}: ERROR - {e}")
+            results.append((test_name, False))
+
+    # Test order creation (optional)
+    try:
+        print("\nTesting Order Creation (will fail safely if no balance)...")
+        order_success, order_id = test_create_order()
+        results.append(("Create Order", order_success))
+    except Exception as e:
+        print(f"❌ Create Order: ERROR - {e}")
+        results.append(("Create Order", False))
+
+    print("\n" + "=" * 50)
+    print("📊 Test Results:")
+    passed = sum(1 for _, success in results if success)
+    total = len(results)
+
+    for test_name, success in results:
+        status = "✅ PASS" if success else "❌ FAIL"
+        print(f"  {test_name}: {status}")
+
+    print(f"\n🎯 Overall: {passed}/{total} tests passed")
+
+    if passed == total:
+        print("🎉 All API tests passed! Ready for trading.")
+    elif passed > 0:
+        print("⚠️  Some tests passed. Check permissions and account setup.")
+    else:
+        print("❌ All tests failed. Check API credentials and permissions.")
+
+if __name__ == "__main__":
+    main()