Update trade_manager.py

trade_manager.py

@@ -1,5 +1,5 @@
 # ============================================================
-# 🛡️ trade_manager.py (V35.2 - GEM-Architect: Volume Calculation)
+# 🛡️ trade_manager.py (V35.3 - GEM-Architect: Math & Fee Sync Fixed)
 # ============================================================
 
 import asyncio
@@ -32,7 +32,7 @@ class TradeManager:
             "stagnation": {"total": 0, "good": 0, "saved": 0.0, "missed": 0.0}
         }
         self.execution_lock = asyncio.Lock()
-        print(f"🛡️ [TradeManager V35.2] 30m-Depth Aware Engine Online.")
+        print(f"🛡️ [TradeManager V35.3] True PnL Math Active.")
 
     async def initialize_sentry_exchanges(self):
         print("🛡️ [TradeManager] Syncing state & Initializing Portfolio...")
@@ -200,10 +200,9 @@ class TradeManager:
                     except: continue 
                     
                     if d1 and d5 and d15 and len(d5) >= 6:
-                        # ✅ Calculate 30m Volume (Sum of last 6 candles of 5m)
-                        # candle format: [ts, o, h, l, c, vol]
+                        # 30m Volume for Context
                         last_6_5m = d5[-6:]
-                        vol_30m_sum = sum([float(c[5]) * float(c[4]) for c in last_6_5m]) # Approx Volume in USD
+                        vol_30m_sum = sum([float(c[5]) * float(c[4]) for c in last_6_5m]) 
                         
                         context_data = {
                             'entry_price': trade['entry_price'],
@@ -214,7 +213,7 @@ class TradeManager:
                             'system_conf': trade.get('decision_data', {}).get('system_confidence', 0.8),
                             'highest_price': float(trade['highest_price']),
                             'time_in_trade_mins': (datetime.now() - datetime.fromisoformat(trade['entry_time'])).total_seconds() / 60,
-                            'volume_30m_usd': vol_30m_sum # ✅ Pass volume info
+                            'volume_30m_usd': vol_30m_sum
                         }
 
                         decision = self.processor.consult_dual_guardians(symbol, d1, d5, d15, context_data, order_book_snapshot=d_ob)
@@ -317,6 +316,9 @@ class TradeManager:
                 await self.learning_hub.register_trade_outcome(trade_obj)
         except Exception: pass
 
+    # ==============================================================================
+    # 🔴 Exit Logic (MATH FIXED)
+    # ==============================================================================
     async def _execute_exit(self, symbol, price, reason, ai_scores=None):
         if symbol not in self.open_positions: return
         try:
@@ -324,44 +326,52 @@ class TradeManager:
             entry_price = float(trade['entry_price']); exit_price = float(price)
             entry_capital = float(trade.get('entry_capital', 100.0)); entry_fee = float(trade.get('entry_fee_usd', 0.0))
             
-            exit_val = (exit_price / entry_price) * entry_capital
-            exit_fee = exit_val * self.FEE_RATE
-            net_pnl = (exit_val - exit_fee) - entry_capital
+            # 1. Gross Calculation
+            exit_val_gross = (exit_price / entry_price) * entry_capital
+            
+            # 2. Fees
+            exit_fee = exit_val_gross * self.FEE_RATE
             total_fees = entry_fee + exit_fee
             
-            await self.smart_portfolio.register_closed_position(entry_capital, net_pnl, total_fees)
+            # 3. PnL for Portfolio (Gross PnL so portfolio handles fees correctly)
+            # Gross PnL = Difference in Asset Value
+            gross_pnl_usd = exit_val_gross - entry_capital
+            
+            # 4. PnL for Statistics (True Net PnL)
+            # True Net = Gross PnL - All Fees
+            true_net_pnl_usd = gross_pnl_usd - total_fees
+            true_net_pct = (true_net_pnl_usd / entry_capital) * 100
+            
+            # ✅ Notify Portfolio with Gross PnL (Because it subtracts fees internally)
+            # Impact on Wallet = Gross PnL - Total Fees
+            await self.smart_portfolio.register_closed_position(entry_capital, gross_pnl_usd, total_fees)
             
-            trade.update({'status': 'CLOSED', 'exit_price': exit_price, 'exit_reason': reason, 'profit_pct': (net_pnl/entry_capital)*100, 'net_pnl_usd': net_pnl, 'fees_paid_usd': total_fees})
+            trade.update({
+                'status': 'CLOSED', 'exit_price': exit_price, 'exit_reason': reason, 
+                'profit_pct': true_net_pct, 'net_pnl_usd': true_net_pnl_usd, 'fees_paid_usd': total_fees
+            })
             
+            # Update Stats with TRUE NET
             portfolio = await self.r2.get_portfolio_state_async()
             portfolio['total_trades'] = portfolio.get('total_trades', 0) + 1
-            if net_pnl >= 0:
+            if true_net_pnl_usd >= 0:
                 portfolio['winning_trades'] = portfolio.get('winning_trades', 0) + 1
-                portfolio['total_profit_usd'] = portfolio.get('total_profit_usd', 0) + net_pnl
+                portfolio['total_profit_usd'] = portfolio.get('total_profit_usd', 0) + true_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(net_pnl)
+                portfolio['total_loss_usd'] = portfolio.get('total_loss_usd', 0) + abs(true_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} | Net PnL: {(net_pnl/entry_capital)*100:.2f}% (${net_pnl:.2f}) | {reason}")
+            print(f"✅ [EXIT] {symbol} | True Net PnL: {true_net_pct:.2f}% (${true_net_pnl_usd:.2f}) | {reason}")
             self._launch_post_exit_analysis(symbol, exit_price, trade.get('exit_time'), entry_capital, ai_scores, trade)
             self.latest_guardian_log = f"✅ Closed {symbol} ({reason})"
             if symbol in self.sentry_tasks: self.sentry_tasks[symbol].cancel(); del self.sentry_tasks[symbol]
 
         except Exception as e:
             print(f"❌ [Exit Error] {e}"); 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)
-        async with self.execution_lock: await self._execute_exit(symbol, p, reason)
-
-    async def start_sentry_loops(self): await self.ensure_active_guardians()
-    async def stop_sentry_loops(self):
-        self.running = False
-        for task in self.sentry_tasks.values(): task.cancel()
+            if symbol not in self.open_positions: self.open_positions[symbol] = trade