Update trade_manager.py

trade_manager.py

@@ -1,4 +1,4 @@
-# trade_manager.py (V23.10 - GEM-Architect: Data Depth Fix)
+# trade_manager.py (V24.0 - GEM-Architect: Realistic Sim & Fees)
 
 import asyncio
 import uuid
@@ -19,6 +19,9 @@ class TradeManager:
         self.sentry_tasks = {}
         self.running = True
         
+        # إعدادات الرسوم (0.1% لكل عملية)
+        self.FEE_RATE = 0.001 
+        
         self.ai_stats = {
             "hybrid": {"total": 0, "good": 0, "saved": 0.0, "missed": 0.0},
             "v2":     {"total": 0, "good": 0, "saved": 0.0, "missed": 0.0},
@@ -26,7 +29,7 @@ class TradeManager:
         }
         
         self.execution_lock = asyncio.Lock()
-        print(f"🛡️ [TradeManager V23.10] Initialized (Data Depth Boosted).")
+        print(f"🛡️ [TradeManager V24.0] Initialized (High/Low Sim + Fees Enabled).")
 
     async def initialize_sentry_exchanges(self):
         print("🛡️ [TradeManager] Syncing state with R2...")
@@ -60,7 +63,7 @@ class TradeManager:
             if symbol in self.open_positions or symbol in self.watchlist:
                 continue
 
-            # ✅ [FIX] زيادة البيانات هنا أيضاً للقناص
+            # التحقق من القناص مع بيانات كافية
             ohlcv_task = self.data_manager.get_latest_ohlcv(symbol, '1m', 1000) 
             ob_task = self.data_manager.get_order_book_snapshot(symbol)
             ohlcv_1m, order_book = await asyncio.gather(ohlcv_task, ob_task)
@@ -99,15 +102,25 @@ class TradeManager:
                 await self._execute_entry_from_signal(best_signal['symbol'], best_signal)
 
     # ==============================================================================
-    # 🎯 Entry Execution
+    # 🎯 Entry Execution (With Fee Calculation)
     # ==============================================================================
     async def _execute_entry_from_signal(self, symbol, signal_data):
         try:
             trade_id = str(uuid.uuid4())
+            
+            # تحديد سعر الدخول
             current_price = float(signal_data.get('current_price', 0.0))
             if current_price <= 0.0:
                  current_price = await self.data_manager.get_latest_price_async(symbol)
 
+            # جلب حجم المحفظة لحساب الرسوم الأولية
+            portfolio = await self.r2.get_portfolio_state_async()
+            current_capital = float(portfolio.get('current_capital_usd', 100.0))
+            
+            # حساب الرسوم المتوقعة للدخول
+            # ملاحظة: نفترض أننا ندخل بكامل رأس المال المتاح في المحاكاة الحالية
+            entry_fee_usd = current_capital * self.FEE_RATE
+
             l2_result = signal_data.get('l2_sniper_result', {})
             tp_price = float(signal_data.get('tp_price') or 0.0)
             sl_price = float(signal_data.get('sl_price') or 0.0)
@@ -129,6 +142,9 @@ class TradeManager:
                 'strategy': 'Hybrid_Titan_V1', 
                 'l1_score': float(signal_data.get('enhanced_final_score', 0.0)), 
                 'l2_sniper_confidence': float(l2_result.get('confidence_prob', 0.0)),
+                # تخزين بيانات الرسوم ورأس المال عند الدخول
+                'entry_capital': current_capital,
+                'entry_fee_usd': entry_fee_usd,
                 'decision_data': {
                     'components': signal_data.get('components', {}),
                     'sniper_analysis': l2_result,
@@ -140,73 +156,101 @@ class TradeManager:
             self.open_positions[symbol] = new_trade
             if self.watchlist: self.watchlist.clear()
             
-            portfolio = await self.r2.get_portfolio_state_async()
             if portfolio.get('first_trade_timestamp') is None:
                 portfolio['first_trade_timestamp'] = new_trade['entry_time']
                 await self.r2.save_portfolio_state_async(portfolio)
+            
             await self.r2.save_open_trades_async(list(self.open_positions.values()))
             
             if symbol in self.sentry_tasks: self.sentry_tasks[symbol].cancel()
             self.sentry_tasks[symbol] = asyncio.create_task(self._guardian_loop(symbol))
             
-            print(f"✅ [ENTRY] {symbol} @ {current_price} | TP: {tp_price} | SL: {sl_price}")
+            print(f"✅ [ENTRY] {symbol} @ {current_price} | Cap: ${current_capital:.2f} | Fee: ${entry_fee_usd:.3f}")
 
         except Exception as e:
             print(f"❌ [Entry Error] {symbol}: {e}")
             traceback.print_exc()
 
     # ==============================================================================
-    # 🛡️ Hybrid Sentry (FIXED SECTION)
+    # 🛡️ Hybrid Sentry (Updated: High/Low Candle Check)
     # ==============================================================================
     async def _guardian_loop(self, symbol: str):
-        print(f"🛡️ [Sentry] Guarding {symbol}...")
+        print(f"🛡️ [Sentry] Guarding {symbol} (High/Low Simulation Mode)...")
         last_ai_check_time = 0
         
         while self.running and symbol in self.open_positions:
             try:
-                await asyncio.sleep(2) 
+                # انتظار قصير للتحديث
+                await asyncio.sleep(1) 
+                
                 trade = self.open_positions.get(symbol)
                 if not trade: break 
 
-                current_price = await self.data_manager.get_latest_price_async(symbol)
-                if current_price == 0.0: continue 
-
-                # Hard TP/SL Check
-                if current_price >= trade['tp_price']:
+                # -------------------------------------------------------------
+                # 1. جلب بيانات الشموع للتحقق من الذيول (Wicks)
+                # -------------------------------------------------------------
+                # نجلب آخر شمعتين لضمان تغطية الشمعة الحالية والمكتملة حديثاً
+                ohlcv = await self.data_manager.get_latest_ohlcv(symbol, '1m', limit=2)
+                current_ticker_price = await self.data_manager.get_latest_price_async(symbol)
+
+                if not ohlcv:
+                    continue
+
+                # الشمعة الأخيرة (الحالية)
+                current_candle = ohlcv[-1]
+                # [timestamp, open, high, low, close, volume]
+                candle_high = current_candle[2]
+                candle_low = current_candle[3]
+                
+                # استخدام السعر الأعلى بين التيكر والشمعة لضمان عدم تفويت أي قمة لحظية
+                max_price_seen = max(current_ticker_price, candle_high)
+                min_price_seen = min(current_ticker_price, candle_low)
+
+                # -------------------------------------------------------------
+                # 2. التحقق من الأهداف (Simulated Limit Orders)
+                # -------------------------------------------------------------
+                
+                # أ) تحقق من الهدف (Take Profit)
+                if max_price_seen >= trade['tp_price']:
+                    print(f"🎯 [TP HIT] Price {max_price_seen} touched Target {trade['tp_price']}")
                     async with self.execution_lock:
-                        await self._execute_exit(symbol, current_price, "TP_HIT_HARD")
+                        # الخروج بسعر الهدف تماماً كما يفعل الأمر المعلق
+                        await self._execute_exit(symbol, trade['tp_price'], "TP_HIT_SIMULATED")
                     break 
-                if current_price <= trade['sl_price']:
+
+                # ب) تحقق من وقف الخسارة (Stop Loss)
+                if min_price_seen <= trade['sl_price']:
+                    print(f"🛑 [SL HIT] Price {min_price_seen} touched Stop {trade['sl_price']}")
                     async with self.execution_lock:
-                        await self._execute_exit(symbol, current_price, "SL_HIT_HARD")
+                        # الخروج بسعر الوقف
+                        await self._execute_exit(symbol, trade['sl_price'], "SL_HIT_SIMULATED")
                     break 
 
-                # AI Guardian Check
+                # -------------------------------------------------------------
+                # 3. التدقيق الذكي (AI Guardian)
+                # -------------------------------------------------------------
                 if time.time() - last_ai_check_time > 60:
-                    # ✅ [CRITICAL FIX] زيادة عدد الشموع لتجاوز EMA200 Warm-up
-                    t1 = self.data_manager.get_latest_ohlcv(symbol, '1m', 1000) # كان 300
-                    t5 = self.data_manager.get_latest_ohlcv(symbol, '5m', 500)  # كان 200
-                    t15 = self.data_manager.get_latest_ohlcv(symbol, '15m', 500) # كان 100
+                    t1 = self.data_manager.get_latest_ohlcv(symbol, '1m', 1000)
+                    t5 = self.data_manager.get_latest_ohlcv(symbol, '5m', 500)
+                    t15 = self.data_manager.get_latest_ohlcv(symbol, '15m', 500)
                     d1, d5, d15 = await asyncio.gather(t1, t5, t15)
                     
-                    # التحقق من أن البيانات كافية بعد الحسابات
                     if d1 and d5 and d15 and len(d1) >= 500:
                         decision = self.processor.consult_guardian(d1, d5, d15, trade['entry_price'])
                         action = decision.get('action', 'HOLD')
                         scores = decision.get('scores', {})
                         
-                        # طباعة التشخيص (اختياري لملف التداول)
-                        # v2_val = int(scores.get('v2', 0.0) * 100)
-                        # v3_val = int(scores.get('v3', 0.0) * 100)
-                        # print(f"   🕵️ [Sentry check] {symbol} | V2:{v2_val} V3:{v3_val} | {action}")
-
                         if action in ['EXIT_HARD', 'EXIT_SOFT']:
                             print(f"🤖 [Guardian] {action}: {decision.get('reason')}")
                             async with self.execution_lock:
-                                await self._execute_exit(symbol, current_price, f"AI_{action}", ai_scores=scores)
+                                # في حالة الخروج الذكي، نستخدم السعر الحالي للتنفيذ (Market Order)
+                                await self._execute_exit(symbol, current_ticker_price, f"AI_{action}", ai_scores=scores)
                             break
                     last_ai_check_time = time.time()
+                    
+                    # تحديث وقت آخر نشاط للصفقة
                     self.open_positions[symbol]['last_update'] = datetime.now().isoformat()
+                    
             except asyncio.CancelledError: break
             except Exception as e:
                 print(f"❌ [Sentry Error] {symbol}: {e}")
@@ -253,41 +297,75 @@ class TradeManager:
             print(f"⚠️ [Ghost/Learning Error] {e}")
 
     # ==============================================================================
-    # 🔴 Exit Logic
+    # 🔴 Exit Logic (Net PnL with Fees)
     # ==============================================================================
     async def _execute_exit(self, symbol, price, reason, ai_scores=None):
         if symbol not in self.open_positions: return
         try:
             trade = self.open_positions.pop(symbol) 
-            entry = float(trade['entry_price'])
-            exit_p = float(price)
-            profit_pct = ((exit_p - entry) / entry)
             
-            trade.update({'status': 'CLOSED', 'exit_price': exit_p, 'exit_reason': reason, 'profit_pct': profit_pct*100})
-
+            entry_price = float(trade['entry_price'])
+            exit_price = float(price)
+            
+            # استرجاع رأس المال عند الدخول ورسوم الدخول
+            entry_capital = float(trade.get('entry_capital', 100.0)) # Fallback if missing
+            entry_fee_usd = float(trade.get('entry_fee_usd', 0.0))
+            
+            # حساب قيمة الخروج قبل خصم رسوم الخروج
+            # معادلة التغير: (سعر الخروج / سعر الدخول) * رأس المال
+            exit_value_gross = (exit_price / entry_price) * entry_capital
+            
+            # حساب رسوم الخروج
+            exit_fee_usd = exit_value_gross * self.FEE_RATE
+            
+            # القيمة الصافية النهائية (Net Value)
+            net_exit_value = exit_value_gross - exit_fee_usd
+            
+            # صافي الربح/الخسارة بالدولار (يشمل خصم رسوم الدخول والخروج)
+            # Net PnL = القيمة النهائية - (رأس المال الأصلي + رسوم الدخول المدفوعة سابقاً)
+            # ملاحظة: رسوم الدخول خُصمت ضمنياً لأننا نستخدم رأس المال الكامل، لذا الحسبة الأدق:
+            # الربح الصافي = ما تبقى في اليد (Net Exit) - ما كان في اليد قبل الدخول (Entry Capital)
+            net_pnl_usd = net_exit_value - entry_capital 
+            
+            # نسبة الربح الصافي
+            net_profit_pct = (net_pnl_usd / entry_capital) * 100
+            
+            # تحديث بيانات الصفقة
+            trade.update({
+                'status': 'CLOSED', 
+                'exit_price': exit_price, 
+                'exit_reason': reason, 
+                'profit_pct': net_profit_pct,
+                'net_pnl_usd': net_pnl_usd,
+                'fees_paid_usd': entry_fee_usd + exit_fee_usd
+            })
+
+            # تحديث المحفظة
             portfolio = await self.r2.get_portfolio_state_async()
-            curr_cap = float(portfolio.get('current_capital_usd', 100.0))
-            pnl_usd = curr_cap * profit_pct
-            new_cap = curr_cap + pnl_usd
+            current_total_cap = float(portfolio.get('current_capital_usd', 100.0))
+            
+            # رأس المال الجديد = رأس المال القديم + صافي الربح/الخسارة
+            new_cap = current_total_cap + net_pnl_usd
             
             portfolio['current_capital_usd'] = new_cap
             portfolio['total_trades'] = portfolio.get('total_trades', 0) + 1
-            if pnl_usd >= 0:
+            
+            if net_pnl_usd >= 0:
                 portfolio['winning_trades'] = portfolio.get('winning_trades', 0) + 1
-                portfolio['total_profit_usd'] = portfolio.get('total_profit_usd', 0) + pnl_usd
+                portfolio['total_profit_usd'] = portfolio.get('total_profit_usd', 0) + net_pnl_usd
                 trade['result'] = 'WIN'
             else:
                 portfolio['losing_trades'] = portfolio.get('losing_trades', 0) + 1
-                portfolio['total_loss_usd'] = portfolio.get('total_loss_usd', 0) + abs(pnl_usd)
+                portfolio['total_loss_usd'] = portfolio.get('total_loss_usd', 0) + abs(net_pnl_usd)
                 trade['result'] = 'LOSS'
 
             await self.r2.save_portfolio_state_async(portfolio)
             await self.r2.save_open_trades_async(list(self.open_positions.values()))
             await self.r2.append_to_closed_trades_history(trade)
             
-            print(f"✅ [EXIT] {symbol} | PnL: {trade['profit_pct']:.2f}% | Cap: ${new_cap:.2f}")
+            print(f"✅ [EXIT] {symbol} | Net PnL: {net_profit_pct:.2f}% (${net_pnl_usd:.2f}) | Fees: ${entry_fee_usd+exit_fee_usd:.3f} | Cap: ${new_cap:.2f}")
 
-            self._launch_post_exit_analysis(symbol, exit_p, trade.get('exit_time'), curr_cap, ai_scores, trade)
+            self._launch_post_exit_analysis(symbol, exit_price, trade.get('exit_time'), entry_capital, ai_scores, trade)
 
             if symbol in self.sentry_tasks:
                 self.sentry_tasks[symbol].cancel()
@@ -295,7 +373,10 @@ class TradeManager:
 
         except Exception as e:
             print(f"❌ [Exit Error] {e}")
-            self.open_positions[symbol] = trade 
+            traceback.print_exc()
+            # في حالة الخطأ نعيد الصفقة للقائمة لتجنب ضياعها
+            if symbol not in self.open_positions:
+                 self.open_positions[symbol] = trade 
 
     async def force_exit_by_manager(self, symbol, reason):
         p = await self.data_manager.get_latest_price_async(symbol)