Update data_manager.py

data_manager.py

@@ -1,14 +1,15 @@
-# data_manager.py
-import os, asyncio, httpx, json, traceback, backoff, re, time
+# data_manager.py - الإصدار المحسن مع تحليل صافي التدفق الذكي
+import os, asyncio, httpx, json, traceback, backoff, re, time, math
 from datetime import datetime, timedelta
 from functools import wraps
+from collections import defaultdict, deque
 import ccxt.pro as ccxt
 from ccxt.base.errors import RateLimitExceeded, DDoSProtection, NetworkError
 import pandas as pd
 import numpy as np
 from state import MARKET_STATE_OK
 
-# --- 🐋 نظام تتبع الحيتان المحسن مع إصلاحات APIs ---
+# --- 🐋 نظام تتبع الحيتان المحسن مع تحليل صافي التدفق ---
 class EnhancedWhaleMonitor:
     def __init__(self, contracts_db=None):
         self.http_client = httpx.AsyncClient(timeout=15.0, limits=httpx.Limits(max_connections=50, max_keepalive_connections=10))
@@ -21,7 +22,29 @@ class EnhancedWhaleMonitor:
         self.whale_threshold_usd = 100000
         self.contracts_db = contracts_db or {}
         
-        # 🔄 إحصائيات استخدام APIs
+        # قاعدة بيانات العناوين المصنفة ديناميكياً
+        self.address_labels = {}
+        self._initialize_dynamic_labels()
+        
+        # تخزين بيانات صافي التدفق
+        self.netflow_data = {
+            'ethereum': defaultdict(lambda: {
+                'inflow': deque(maxlen=288),
+                'outflow': deque(maxlen=288),
+                'netflow': deque(maxlen=288),
+                'timestamps': deque(maxlen=288),
+                'volume_24h': 0
+            }),
+            'bsc': defaultdict(lambda: {
+                'inflow': deque(maxlen=288),
+                'outflow': deque(maxlen=288), 
+                'netflow': deque(maxlen=288),
+                'timestamps': deque(maxlen=288),
+                'volume_24h': 0
+            })
+        }
+        
+        # إحصائيات استخدام APIs
         self.api_usage_stats = {
             'etherscan': {
                 'requests_today': 0,
@@ -37,7 +60,7 @@ class EnhancedWhaleMonitor:
             }
         }
         
-        # 🔄 مصادر RPC متعددة
+        # مصادر RPC متعددة
         self.rpc_endpoints = {
             'ethereum': [
                 'https://rpc.ankr.com/eth',
@@ -48,29 +71,14 @@ class EnhancedWhaleMonitor:
                 'https://bsc-dataseed.binance.org/',
                 'https://bsc-dataseed1.defibit.io/',
                 'https://bsc-dataseed1.ninicoin.io/'
-            ],
-            'polygon': [
-                'https://polygon-rpc.com/',
-                'https://rpc-mainnet.maticvigil.com',
-                'https://polygon-bor.publicnode.com'
-            ],
-            'arbitrum': [
-                'https://arb1.arbitrum.io/rpc',
-                'https://endpoints.omniatech.io/v1/arbitrum/one/public'
-            ],
-            'avalanche': [
-                'https://api.avax.network/ext/bc/C/rpc',
-                'https://avalanche.public-rpc.com'
             ]
         }
         
-        # ✅ إضافة Infura إلى القائمة إذا كان المفتاح متوفرًا
+        # إضافة Infura إذا كان المفتاح متوفرًا
         if self.infura_key:
             infura_endpoint = f"https://mainnet.infura.io/v3/{self.infura_key}"
             self.rpc_endpoints['ethereum'].insert(0, infura_endpoint)
             print(f"✅ تم تكوين Infura بنجاح - الشبكة: Ethereum")
-        else:
-            print("⚠️ مفتاح Infura غير متوفر في متغيرات البيئة - استخدام المصادر البديلة")
         
         self.current_rpc_index = {network: 0 for network in self.rpc_endpoints.keys()}
         self.rpc_failures = {network: 0 for network in self.rpc_endpoints.keys()}
@@ -78,103 +86,487 @@ class EnhancedWhaleMonitor:
         self.price_cache = {}
         self.last_scan_time = {}
         
-        # 🔧 تعيين رموز KuCoin الصحيحة للعملات
+        # رموز KuCoin للعملات
         self.kucoin_symbols = {
             'ethereum': 'ETH',
-            'bsc': 'BNB', 
-            'polygon': 'MATIC',
-            'arbitrum': 'ETH',
-            'avalanche': 'AVAX'
+            'bsc': 'BNB'
         }
-
-    def _update_api_usage_stats(self, api_name):
-        """تحديث إحصائيات استخدام API"""
-        now = datetime.now()
-        current_date = now.date()
-        
-        stats = self.api_usage_stats[api_name]
         
-        # 🔄 إعادة تعيين العداد اليومي إذا تغير التاريخ
-        if current_date != stats['last_reset']:
-            stats['requests_today'] = 0
-            stats['last_reset'] = current_date
-            print(f"🔄 إعادة تعيين عداد طلبات {api_name} اليومي")
+        print("🎯 نظام تتبع الحيتان المحسن - تحليل صافي التدفق الذكي مفعل")
+
+    def _initialize_dynamic_labels(self):
+        """تهيئة التصنيفات الديناميكية للعناوين"""
+        # فئات التصنيف
+        self.address_categories = {
+            'exchange': set(),
+            'cex': set(),
+            'dex': set(),
+            'institution': set(),
+            'whale': set(),
+            'contract': set(),
+            'unknown': set()
+        }
         
-        # 📊 تحديث طلبات الثانية
-        current_time = time.time()
-        time_diff = current_time - stats['last_request_time']
+        # أنماط العناوين للمنصات المركزية
+        self.exchange_patterns = {
+            'binance': ['0x3f5ce5fbfe3e9af3971dd833d26ba9b5c936f0be', '0xd551234ae421e3bcba99a0da6d736074f22192ff'],
+            'coinbase': ['0x71660c4005ba85c37ccec55d0c4493e66fe775d3', '0x503828976d22510aad0201ac7ec88293211d23da'],
+            'kraken': ['0x2910543af39aba0cd09dbb2d50200b3e800a63d2', '0xa160cdab225685da1d56aa342ad8841c3b53f291'],
+            'kucoin': ['0x2b5634c42055806a59e9107ed44d43c426e58258', '0x689c56aef474df92d44a1b70850f808488f9769c']
+        }
         
-        if time_diff < 1.0:
-            stats['requests_per_second'] += 1
-        else:
-            stats['requests_per_second'] = 1
-            stats['last_request_time'] = current_time
+        # تحميل العناوين الأولية
+        self._load_initial_exchange_addresses()
+
+    def _load_initial_exchange_addresses(self):
+        """تحميل عناوين المنصات المعروفة مبدئياً"""
+        for exchange, addresses in self.exchange_patterns.items():
+            for address in addresses:
+                self.address_labels[address.lower()] = 'cex'
+                self.address_categories['cex'].add(address.lower())
+                self.address_categories['exchange'].add(address.lower())
+
+    def _classify_address_dynamic(self, address, transaction_history=None):
+        """تصنيف ديناميكي للعناوين بناءً على الأنماط السلوكية"""
+        address_lower = address.lower()
         
-        stats['requests_today'] += 1
+        # التحقق من العناوين المصنفة مسبقاً
+        if address_lower in self.address_labels:
+            return self.address_labels[address_lower]
         
-        # 🚨 التحقق من الحدود
-        if api_name == 'etherscan':
-            if stats['requests_today'] > 90000:  # تحذير عند الاقتراب من 90,000
-                print(f"🚨 تحذير: طلبات {api_name} اليومية تقترب من الحد ({stats['requests_today']}/100,000)")
-            if stats['requests_per_second'] > 4:  # تحذير عند الاقتراب من 4/ثانية
-                print(f"🚨 تحذير: طلبات {api_name} في الثانية تقترب من الحد ({stats['requests_per_second']}/5)")
+        # تصنيف بناءً على أنماط المعاملات
+        if transaction_history:
+            if self._detect_exchange_pattern(transaction_history):
+                self.address_labels[address_lower] = 'suspected_cex'
+                self.address_categories['cex'].add(address_lower)
+                return 'suspected_cex'
+            
+            if self._detect_whale_pattern(transaction_history):
+                self.address_labels[address_lower] = 'suspected_whale'
+                self.address_categories['whale'].add(address_lower)
+                return 'suspected_whale'
+            
+            if self._detect_contract_pattern(transaction_history):
+                self.address_labels[address_lower] = 'contract_user'
+                self.address_categories['contract'].add(address_lower)
+                return 'contract_user'
         
-        elif api_name == 'infura':
-            if stats['requests_today'] > 2500000:
-                print(f"🚨 تحذير: طلبات {api_name} اليومية تقترب من الحد ({stats['requests_today']}/3,000,000)")
-            if stats['requests_per_second'] > 450:
-                print(f"🚨 تحذير: طلبات {api_name} في الثانية تقترب من الحد ({stats['requests_per_second']}/500)")
+        # إذا لم يتم التصنيف، نضيفه للمجهول
+        self.address_labels[address_lower] = 'unknown'
+        self.address_categories['unknown'].add(address_lower)
+        return 'unknown'
 
-    async def _api_rate_limit_delay(self, api_name):
-        """تأخير ذكي لتجنب تجاوز حدود API"""
-        stats = self.api_usage_stats[api_name]
+    def _detect_exchange_pattern(self, transactions):
+        """اكتشاف نمط المنصات"""
+        if len(transactions) < 10:
+            return False
         
-        if api_name == 'etherscan':
-            # التحقق من طلبات الثانية
-            if stats['requests_per_second'] > 4:
-                delay = 0.2 * (stats['requests_per_second'] - 4)
-                print(f"⏳ تأخير {delay:.2f} ثانية لـ {api_name} لتجنب rate limiting")
-                await asyncio.sleep(delay)
-            
-            # التحقق من الطلبات اليومية
-            if stats['requests_today'] > 95000:
-                print(f"🚨 تجاوز الحد اليومي لطلبات {api_name}، استخدام المصادر البديلة")
-                return True
+        unique_senders = set()
+        unique_receivers = set()
         
-        elif api_name == 'infura':
-            if stats['requests_per_second'] > 400:
-                delay = 0.1 * (stats['requests_per_second'] - 400)
-                print(f"⏳ تأخير {delay:.2f} ثانية لـ {api_name} لتجنب rate limiting")
-                await asyncio.sleep(delay)
-            
-            if stats['requests_today'] > 2800000:
-                print(f"🚨 تجاوز الحد اليومي لطلبات {api_name}، استخدام المصادر البديلة")
-                return True
+        for tx in transactions[-20:]:
+            if 'from' in tx:
+                unique_senders.add(tx['from'])
+            if 'to' in tx:
+                unique_receivers.add(tx['to'])
+        
+        if len(unique_senders) > 15 and len(unique_receivers) < 5:
+            return True
         
         return False
 
-    def _get_next_rpc_endpoint(self, network):
-        """الحصول على عنوان RPC التالي"""
-        if network not in self.rpc_endpoints:
-            return None
+    def _detect_whale_pattern(self, transactions):
+        """اكتشاف نمط الحيتان"""
+        large_txs = [tx for tx in transactions if tx.get('value_usd', 0) > 100000]
+        return len(large_txs) >= 3
+
+    def _detect_contract_pattern(self, transactions):
+        """اكتشاف نمط العقود"""
+        contract_interactions = [tx for tx in transactions if tx.get('to', '') and len(tx.get('to', '')) == 42 and tx.get('input', '0x') != '0x']
+        return len(contract_interactions) > len(transactions) * 0.7
+
+    def _is_exchange_address(self, address):
+        """التحقق إذا كان العنوان ينتمي لمنصة"""
+        address_lower = address.lower()
+        return (address_lower in self.address_categories['cex'] or 
+                address_lower in self.address_categories['exchange'] or
+                self.address_labels.get(address_lower) in ['cex', 'suspected_cex'])
+
+    async def _update_netflow_metrics(self, network, token_symbol, from_address, to_address, value_usd, transaction_hash):
+        """تحديث مقاييس صافي التدفق مع التصنيف الذكي"""
+        try:
+            # تصنيف العناوين
+            from_label = self._classify_address_dynamic(from_address)
+            to_label = self._classify_address_dynamic(to_address)
             
-        endpoints = self.rpc_endpoints[network]
-        if not endpoints:
+            # تحديث التدفق الداخل إلى المنصات
+            if self._is_exchange_address(to_address):
+                if token_symbol not in self.netflow_data[network]:
+                    self._initialize_token_metrics(network, token_symbol)
+                
+                self.netflow_data[network][token_symbol]['inflow'].append(value_usd)
+                self.netflow_data[network][token_symbol]['timestamps'].append(datetime.now())
+                
+                print(f"📥 تدفق إلى منصة: {value_usd:,.0f} USD ({token_symbol})")
+            
+            # تحديث التدفق الخارج من المنصات
+            if self._is_exchange_address(from_address):
+                if token_symbol not in self.netflow_data[network]:
+                    self._initialize_token_metrics(network, token_symbol)
+                
+                self.netflow_data[network][token_symbol]['outflow'].append(value_usd)
+                self.netflow_data[network][token_symbol]['timestamps'].append(datetime.now())
+                
+                print(f"📤 تدفق من منصة: {value_usd:,.0f} USD ({token_symbol})")
+            
+            # حساب صافي التدفق الحالي
+            if token_symbol in self.netflow_data[network]:
+                current_inflow = sum(list(self.netflow_data[network][token_symbol]['inflow'])[-12:])
+                current_outflow = sum(list(self.netflow_data[network][token_symbol]['outflow'])[-12:])
+                current_netflow = current_inflow - current_outflow
+                
+                self.netflow_data[network][token_symbol]['netflow'].append(current_netflow)
+                
+        except Exception as e:
+            print(f"⚠️ خطأ في تحديث مقاييس صافي التدفق: {e}")
+
+    def _initialize_token_metrics(self, network, token_symbol):
+        """تهيئة مقاييس الرمز المميز"""
+        self.netflow_data[network][token_symbol] = {
+            'inflow': deque(maxlen=288),
+            'outflow': deque(maxlen=288),
+            'netflow': deque(maxlen=288),
+            'timestamps': deque(maxlen=288),
+            'volume_24h': 0
+        }
+
+    def _calculate_netflow_zscore(self, network, token_symbol, window_hours=24):
+        """حساب Z-score لصافي التدفق"""
+        try:
+            if token_symbol not in self.netflow_data[network]:
+                return 0
+            
+            data = self.netflow_data[network][token_symbol]
+            netflow_values = list(data['netflow'])
+            
+            if len(netflow_values) < 10:
+                return 0
+            
+            window_size = min(len(netflow_values), window_hours * 12)
+            recent_values = netflow_values[-window_size:]
+            
+            if len(recent_values) < 5:
+                return 0
+            
+            mean_val = np.mean(recent_values)
+            std_val = np.std(recent_values)
+            
+            if std_val == 0:
+                return 0
+            
+            current_netflow = recent_values[-1] if recent_values else 0
+            zscore = (current_netflow - mean_val) / std_val
+            
+            return zscore
+            
+        except Exception as e:
+            print(f"⚠️ خطأ في حساب Z-score: {e}")
+            return 0
+
+    def _generate_netflow_signal(self, network, token_symbol):
+        """توليد إشارات تداول بناءً على صافي التدفق"""
+        try:
+            if token_symbol not in self.netflow_data[network]:
+                return None
+            
+            data = self.netflow_data[network][token_symbol]
+            netflow_values = list(data['netflow'])
+            
+            if len(netflow_values) < 12:
+                return None
+            
+            recent_inflow = sum(list(data['inflow'])[-12:])
+            recent_outflow = sum(list(data['outflow'])[-12:])
+            recent_netflow = recent_inflow - recent_outflow
+            
+            zscore = self._calculate_netflow_zscore(network, token_symbol)
+            
+            signal = {
+                'symbol': token_symbol,
+                'network': network,
+                'netflow_1h': recent_netflow,
+                'inflow_1h': recent_inflow,
+                'outflow_1h': recent_outflow,
+                'z_score': zscore,
+                'timestamp': datetime.now().isoformat()
+            }
+            
+            if recent_netflow < -500000 and zscore < -2.5:
+                signal.update({
+                    'action': 'STRONG_SELL',
+                    'confidence': min(0.95, abs(zscore) / 3),
+                    'reason': f'تدفق بيعي قوي: ${abs(recent_netflow):,.0f} إلى المنصات',
+                    'critical_alert': abs(recent_netflow) > 1000000
+                })
+                return signal
+            
+            elif recent_netflow < -100000 and zscore < -1.5:
+                signal.update({
+                    'action': 'SELL',
+                    'confidence': min(0.8, abs(zscore) / 2),
+                    'reason': f'تدفق بيعي: ${abs(recent_netflow):,.0f} إلى المنصات',
+                    'critical_alert': False
+                })
+                return signal
+            
+            elif recent_netflow > 500000 and zscore > 2.5:
+                signal.update({
+                    'action': 'STRONG_BUY',
+                    'confidence': min(0.95, zscore / 3),
+                    'reason': f'تدفق شرائي قوي: ${recent_netflow:,.0f} من المنصات',
+                    'critical_alert': recent_netflow > 1000000
+                })
+                return signal
+            
+            elif recent_netflow > 100000 and zscore > 1.5:
+                signal.update({
+                    'action': 'BUY',
+                    'confidence': min(0.8, zscore / 2),
+                    'reason': f'تدفق شرائي: ${recent_netflow:,.0f} من المنصات',
+                    'critical_alert': False
+                })
+                return signal
+            
+            signal.update({
+                'action': 'HOLD',
+                'confidence': 0.5,
+                'reason': f'تدفق متوازن: ${recent_netflow:,.0f}',
+                'critical_alert': False
+            })
+            return signal
+            
+        except Exception as e:
+            print(f"⚠️ خطأ في توليد إشارة التداول: {e}")
             return None
+
+    async def _scan_single_evm_network(self, network):
+        """مسح شبكة EVM واحدة مع تحليل صافي التدفق"""
+        whale_alerts = []
+        trading_signals = []
         
-        # 🔄 التدوير العادي للمصادر
-        index = self.current_rpc_index[network]
-        endpoint = endpoints[index]
-        self.current_rpc_index[network] = (index + 1) % len(endpoints)
+        try:
+            price_usd = await self._get_native_coin_price(network)
+            if price_usd is None:
+                print(f"⚠️ سعر {network} غير متوفر، تخطي المسح")
+                return [], []
+
+            latest_block_hex = await self._call_rpc_async(network, 'eth_blockNumber')
+            if not latest_block_hex: 
+                return [], []
+            
+            latest_block = int(latest_block_hex, 16)
+            blocks_to_scan = 15
+            scanned_blocks = 0
+            
+            for block_offset in range(blocks_to_scan):
+                block_number = latest_block - block_offset
+                if block_number < 0:
+                    break
+                    
+                block_data = await self._call_rpc_async(network, 'eth_getBlockByNumber', [hex(block_number), True])
+                if not block_data or 'transactions' not in block_data:
+                    continue
+                
+                scanned_blocks += 1
+                
+                block_timestamp_hex = block_data.get('timestamp', '0x0')
+                block_timestamp = int(block_timestamp_hex, 16)
+                block_time = datetime.fromtimestamp(block_timestamp)
+                time_ago = datetime.now() - block_time
+
+                for tx in block_data.get('transactions', []):
+                    value_wei = int(tx.get('value', '0x0'), 16)
+                    if value_wei > 0:
+                        value_native = value_wei / 1e18
+                        value_usd = value_native * price_usd
+                        
+                        if value_usd >= self.whale_threshold_usd:
+                            from_address = tx.get('from', '')
+                            to_address = tx.get('to', '')
+                            tx_hash = tx.get('hash', '')
+                            
+                            await self._update_netflow_metrics(network, 'NATIVE', from_address, to_address, value_usd, tx_hash)
+                            
+                            from_label = self._classify_address_dynamic(from_address)
+                            to_label = self._classify_address_dynamic(to_address)
+                            
+                            whale_alerts.append({
+                                'network': network, 
+                                'value_usd': value_usd,
+                                'from': from_address,
+                                'to': to_address,
+                                'from_label': from_label,
+                                'to_label': to_label,
+                                'hash': tx_hash,
+                                'block_number': block_number,
+                                'timestamp': block_timestamp,
+                                'human_time': block_time.isoformat(),
+                                'minutes_ago': time_ago.total_seconds() / 60,
+                                'transaction_type': 'native_transfer',
+                                'flow_direction': 'TO_EXCHANGE' if self._is_exchange_address(to_address) else 
+                                                 'FROM_EXCHANGE' if self._is_exchange_address(from_address) else 'UNKNOWN'
+                            })
+                            
+                if block_offset % 3 == 0:
+                    await asyncio.sleep(0.1)
+                    
+            signal = self._generate_netflow_signal(network, 'NATIVE')
+            if signal:
+                trading_signals.append(signal)
+                    
+            print(f"✅ مسح {network}: {scanned_blocks} كتل، {len(whale_alerts)} تنبيهات، {len(trading_signals)} إشارات")
+                    
+        except Exception as e:
+            print(f"⚠️ خطأ في مسح شبكة {network}: {e}")
+            
+        return whale_alerts, trading_signals
+
+    async def get_general_whale_activity(self):
+        """الوظيفة الرئيسية لمراقبة الحيتان"""
+        print("🌊 بدء مراقبة الحيتان وتحليل صافي التدفق...")
         
-        return endpoint
+        try:
+            tasks = []
+            networks_to_scan = ['ethereum', 'bsc']
+            for network in networks_to_scan:
+                tasks.append(self._scan_single_evm_network(network))
+            
+            results = await asyncio.gather(*tasks, return_exceptions=True)
+            
+            all_alerts = []
+            all_signals = []
+            successful_networks = 0
+            
+            for res in results:
+                if isinstance(res, tuple) and len(res) == 2:
+                    alerts, signals = res
+                    all_alerts.extend(alerts)
+                    all_signals.extend(signals)
+                    successful_networks += 1
+
+            all_alerts.sort(key=lambda x: x['timestamp'], reverse=True)
+            
+            total_volume = sum(alert['value_usd'] for alert in all_alerts)
+            alert_count = len(all_alerts)
+            
+            exchange_inflow = sum(alert['value_usd'] for alert in all_alerts 
+                                if alert['flow_direction'] == 'TO_EXCHANGE')
+            exchange_outflow = sum(alert['value_usd'] for alert in all_alerts 
+                                 if alert['flow_direction'] == 'FROM_EXCHANGE')
+            net_exchange_flow = exchange_inflow - exchange_outflow
+            
+            critical_signals = [s for s in all_signals if s.get('critical_alert', False)]
+            
+            if not all_alerts:
+                return {
+                    'data_available': False,
+                    'description': 'غير متوفر - لم يتم اكتشاف نشاط حيتان كبير',
+                    'critical_alert': False, 
+                    'sentiment': 'UNKNOWN',
+                    'total_volume_usd': 0, 
+                    'transaction_count': 0,
+                    'data_quality': 'HIGH',
+                    'networks_scanned': successful_networks,
+                    'trading_signals': all_signals,
+                    'netflow_analysis': {
+                        'inflow_to_exchanges': 0,
+                        'outflow_from_exchanges': 0,
+                        'net_flow': 0,
+                        'flow_direction': 'BALANCED'
+                    }
+                }
+            
+            latest_alert = all_alerts[0] if all_alerts else None
+            latest_time_info = f"آخر نشاط منذ {latest_alert['minutes_ago']:.1f} دقيقة" if latest_alert else ""
+            
+            if net_exchange_flow < -1000000:
+                sentiment = 'BEARISH'
+                flow_description = f"ضغط بيعي قوي: ${abs(net_exchange_flow):,.0f} إلى المنصات"
+                market_impact = "HIGH"
+            elif net_exchange_flow < -500000:
+                sentiment = 'SLIGHTLY_BEARISH'
+                flow_description = f"ضغط بيعي: ${abs(net_exchange_flow):,.0f} إلى المنصات" 
+                market_impact = "MEDIUM"
+            elif net_exchange_flow > 1000000:
+                sentiment = 'BULLISH'
+                flow_description = f"تراكم شرائي قوي: ${net_exchange_flow:,.0f} من المنصات"
+                market_impact = "HIGH"
+            elif net_exchange_flow > 500000:
+                sentiment = 'SLIGHTLY_BULLISH'
+                flow_description = f"تراكم شرائي: ${net_exchange_flow:,.0f} من المنصات"
+                market_impact = "MEDIUM"
+            else:
+                sentiment = 'NEUTRAL'
+                flow_description = f"تدفق متوازن: ${net_exchange_flow:,.0f} صافي"
+                market_impact = "LOW"
+                
+            critical_alert = (
+                total_volume > 10_000_000 or 
+                any(tx['value_usd'] > 5_000_000 for tx in all_alerts) or
+                abs(net_exchange_flow) > 5_000_000 or
+                len(critical_signals) > 0
+            )
+
+            description = f"تم اكتشاف {alert_count} معاملة حوت بإجمالي ${total_volume:,.0f} عبر {successful_networks} شبكات. {flow_description}. {latest_time_info}"
+
+            return {
+                'data_available': True, 
+                'description': description,
+                'critical_alert': critical_alert, 
+                'sentiment': sentiment,
+                'market_impact': market_impact,
+                'total_volume_usd': total_volume, 
+                'transaction_count': alert_count,
+                'netflow_analysis': {
+                    'inflow_to_exchanges': exchange_inflow,
+                    'outflow_from_exchanges': exchange_outflow, 
+                    'net_flow': net_exchange_flow,
+                    'flow_direction': 'TO_EXCHANGES' if net_exchange_flow < 0 else 'FROM_EXCHANGES',
+                    'market_impact': market_impact
+                },
+                'recent_alerts': all_alerts[:10],
+                'latest_activity': latest_alert['human_time'] if latest_alert else None,
+                'trading_signals': all_signals,
+                'critical_signals_count': len(critical_signals),
+                'address_classification_stats': {
+                    'total_classified': len(self.address_labels),
+                    'exchange_addresses': len(self.address_categories['cex']),
+                    'whale_addresses': len(self.address_categories['whale']),
+                    'unknown_addresses': len(self.address_categories['unknown'])
+                },
+                'data_quality': 'HIGH',
+                'networks_scanned': successful_networks
+            }
+            
+        except Exception as e:
+            print(f"❌ فشل مراقبة الحيتان العامة: {e}")
+            return {
+                'data_available': False,
+                'description': f'غير متوفر - فشل في مراقبة الحيتان: {str(e)}',
+                'critical_alert': False, 
+                'sentiment': 'UNKNOWN',
+                'total_volume_usd': 0, 
+                'transaction_count': 0,
+                'data_quality': 'LOW',
+                'error': str(e),
+                'trading_signals': []
+            }
 
     async def _get_native_coin_price(self, network):
-        """جلب الأسعار من KuCoin (عام) مع إصلاح الرموز"""
+        """جلب الأسعار من مصادر حقيقية"""
         now = time.time()
         cache_key = f"{network}_price"
         
-        # التحقق من التخزين المؤقت (5 دقائق)
         if cache_key in self.price_cache and (now - self.price_cache[cache_key]['timestamp']) < 300:
             return self.price_cache[cache_key]['price']
 
@@ -183,13 +575,11 @@ class EnhancedWhaleMonitor:
             return await self._get_price_from_coingecko_fallback(network)
 
         try:
-            # 🔄 المحاولة الأولى: KuCoin (عام)
             price = await self._get_price_from_kucoin(symbol)
             if price and price > 0:
                 self.price_cache[cache_key] = {'price': price, 'timestamp': now, 'source': 'kucoin'}
                 return price
                 
-            # 🔄 المحاولة الثانية: CoinGecko
             price = await self._get_price_from_coingecko_fallback(network)
             if price and price > 0:
                 self.price_cache[cache_key] = {'price': price, 'timestamp': now, 'source': 'coingecko'}
@@ -202,15 +592,13 @@ class EnhancedWhaleMonitor:
             return None
 
     async def _get_price_from_kucoin(self, symbol):
-        """جلب السعر من KuCoin (عام بدون API key)"""
+        """جلب السعر من KuCoin"""
         try:
-            # 🔧 استخدام KuCoin بدون API keys (عام)
             exchange = ccxt.kucoin({
                 'sandbox': False,
                 'enableRateLimit': True
             })
             
-            # 🔧 المحاولة برمز USDT أولاً
             trading_symbol = f"{symbol}/USDT"
             try:
                 ticker = await exchange.fetch_ticker(trading_symbol)
@@ -233,10 +621,7 @@ class EnhancedWhaleMonitor:
         """الاحتياطي: جلب السعر من CoinGecko"""
         coin_map = {
             'ethereum': 'ethereum', 
-            'bsc': 'binancecoin', 
-            'polygon': 'matic-network',
-            'arbitrum': 'ethereum',
-            'avalanche': 'avalanche-2'
+            'bsc': 'binancecoin'
         }
         
         coin_id = coin_map.get(network)
@@ -258,7 +643,7 @@ class EnhancedWhaleMonitor:
             return None
 
     async def _call_rpc_async(self, network, method, params=[]):
-        """اتصال RPC غير متزامن مع إدارة ذكية للطلبات"""
+        """اتصال RPC غير متزامن"""
         max_retries = 2
         
         for attempt in range(max_retries):
@@ -268,14 +653,11 @@ class EnhancedWhaleMonitor:
                 return None
                 
             try:
-                # 🎯 إدارة طلبات Infura
                 if 'infura' in endpoint and self.infura_key:
                     self._update_api_usage_stats('infura')
                     
                     if await self._api_rate_limit_delay('infura'):
                         continue
-                    
-                    print(f"🌐 استخدام Infura للشبكة {network}")
                 
                 payload = {"jsonrpc": "2.0", "method": method, "params": params, "id": 1}
                 
@@ -285,11 +667,11 @@ class EnhancedWhaleMonitor:
                     response = await client.post(endpoint, json=payload)
                     
                     if response.status_code == 401:
-                        print(f"🔐 خطأ مصادقة في {endpoint} - تخطي هذا المصدر")
+                        print(f"🔐 خطأ مصادقة في {endpoint}")
                         self.rpc_failures[network] += 1
                         continue
                     elif response.status_code == 429:
-                        print(f"⏳ Rate limit على {endpoint} - تأخير وإعادة المحاولة")
+                        print(f"⏳ Rate limit على {endpoint}")
                         await asyncio.sleep(2 * (attempt + 1))
                         continue
                         
@@ -301,20 +683,20 @@ class EnhancedWhaleMonitor:
                     
             except httpx.HTTPStatusError as e:
                 if e.response.status_code == 429:
-                    print(f"⚠️ Rate limit على {endpoint} لـ {network}. المحاولة {attempt + 1}/{max_retries}")
+                    print(f"⚠️ Rate limit على {endpoint} لـ {network}")
                     self.rpc_failures[network] += 1
                     await asyncio.sleep(3 * (attempt + 1))
                     continue
                 elif e.response.status_code == 401:
-                    print(f"🔐 خطأ مصادقة في {endpoint} - تخطي هذا المصدر")
+                    print(f"🔐 خطأ مصادقة في {endpoint}")
                     self.rpc_failures[network] += 1
                     continue
                 else:
-                    print(f"⚠️ خطأ HTTP {e.response.status_code} ف�� {endpoint} لـ {network}: {e}")
+                    print(f"⚠️ خطأ HTTP {e.response.status_code} في {endpoint}")
                     self.rpc_failures[network] += 1
                     
             except Exception as e:
-                print(f"⚠️ فشل اتصال RPC لـ {network} على {endpoint}: {e}")
+                print(f"⚠️ فشل اتصال RPC لـ {network}: {e}")
                 self.rpc_failures[network] += 1
                 
             if attempt < max_retries - 1:
@@ -323,145 +705,80 @@ class EnhancedWhaleMonitor:
         print(f"❌ فشل جميع محاولات RPC لـ {network}")
         return None
 
-    async def _scan_single_evm_network(self, network):
-        """مسح شبكة EVM واحدة مع تحسين كفاءة الطلبات"""
-        whale_alerts = []
-        try:
-            price_usd = await self._get_native_coin_price(network)
-            if price_usd is None:
-                print(f"⚠️ سعر {network} غير متوفر، تخطي المسح")
-                return []
-
-            latest_block_hex = await self._call_rpc_async(network, 'eth_blockNumber')
-            if not latest_block_hex: 
-                return []
-            
-            latest_block = int(latest_block_hex, 16)
-            
-            blocks_to_scan = 10
-            scanned_blocks = 0
-            
-            for block_offset in range(blocks_to_scan):
-                block_number = latest_block - block_offset
-                if block_number < 0:
-                    break
-                    
-                block_data = await self._call_rpc_async(network, 'eth_getBlockByNumber', [hex(block_number), True])
-                if not block_data or 'transactions' not in block_data:
-                    continue
-                
-                scanned_blocks += 1
-                
-                block_timestamp_hex = block_data.get('timestamp', '0x0')
-                block_timestamp = int(block_timestamp_hex, 16)
-                block_time = datetime.fromtimestamp(block_timestamp)
-                time_ago = datetime.now() - block_time
-
-                for tx in block_data.get('transactions', []):
-                    value_wei = int(tx.get('value', '0x0'), 16)
-                    if value_wei > 0:
-                        value_native = value_wei / 1e18
-                        value_usd = value_native * price_usd
-                        if value_usd >= self.whale_threshold_usd:
-                            whale_alerts.append({
-                                'network': network, 
-                                'value_usd': value_usd,
-                                'from': tx.get('from'), 
-                                'to': tx.get('to'), 
-                                'hash': tx.get('hash'),
-                                'block_number': block_number,
-                                'timestamp': block_timestamp,
-                                'human_time': block_time.isoformat(),
-                                'minutes_ago': time_ago.total_seconds() / 60,
-                                'transaction_type': 'native_transfer'
-                            })
-                            
-                if block_offset % 3 == 0:
-                    await asyncio.sleep(0.2)
-                    
-            print(f"✅ مسح {network}: {scanned_blocks} كتل، {len(whale_alerts)} تنبيهات")
-                    
-        except Exception as e:
-            print(f"⚠️ خطأ في مسح شبكة {network}: {e}")
+    def _get_next_rpc_endpoint(self, network):
+        """الحصول على عنوان RPC التالي"""
+        if network not in self.rpc_endpoints:
+            return None
             
-        return whale_alerts
+        endpoints = self.rpc_endpoints[network]
+        if not endpoints:
+            return None
+        
+        index = self.current_rpc_index[network]
+        endpoint = endpoints[index]
+        self.current_rpc_index[network] = (index + 1) % len(endpoints)
+        
+        return endpoint
 
-    async def get_general_whale_activity(self):
-        """الوظيفة الرئيسية لمراقبة الحيتان"""
-        print("🌊 بدء مراقبة الحيتان عبر الشبكات المتعددة...")
+    def _update_api_usage_stats(self, api_name):
+        """تحديث إحصائيات استخدام API"""
+        now = datetime.now()
+        current_date = now.date()
         
-        try:
-            tasks = []
-            networks_to_scan = ['ethereum', 'bsc']
-            for network in networks_to_scan:
-                tasks.append(self._scan_single_evm_network(network))
-            
-            results = await asyncio.gather(*tasks, return_exceptions=True)
-            
-            all_alerts = []
-            successful_networks = 0
-            
-            for res in results:
-                if isinstance(res, list):
-                    all_alerts.extend(res)
-                    successful_networks += 1
+        stats = self.api_usage_stats[api_name]
+        
+        if current_date != stats['last_reset']:
+            stats['requests_today'] = 0
+            stats['last_reset'] = current_date
+        
+        current_time = time.time()
+        time_diff = current_time - stats['last_request_time']
+        
+        if time_diff < 1.0:
+            stats['requests_per_second'] += 1
+        else:
+            stats['requests_per_second'] = 1
+            stats['last_request_time'] = current_time
+        
+        stats['requests_today'] += 1
+        
+        if api_name == 'etherscan':
+            if stats['requests_today'] > 90000:
+                print(f"🚨 تحذير: طلبات {api_name} اليومية تقترب من الحد")
+            if stats['requests_per_second'] > 4:
+                print(f"🚨 تحذير: طلبات {api_name} في الثانية تقترب من الحد")
+        
+        elif api_name == 'infura':
+            if stats['requests_today'] > 2500000:
+                print(f"🚨 تحذير: طلبات {api_name} اليومية تقترب من الحد")
+            if stats['requests_per_second'] > 450:
+                print(f"🚨 تحذير: طلبات {api_name} في الثانية تقترب من الحد")
 
-            all_alerts.sort(key=lambda x: x['timestamp'], reverse=True)
-            
-            total_volume = sum(alert['value_usd'] for alert in all_alerts)
-            alert_count = len(all_alerts)
-            
-            if not all_alerts:
-                return {
-                    'data_available': False,
-                    'description': 'لم يتم اكتشاف نشاط حيتان كبير على الشبكات المراقبة',
-                    'critical_alert': False, 
-                    'sentiment': 'UNKNOWN',
-                    'total_volume_usd': 0, 
-                    'transaction_count': 0,
-                    'data_quality': 'HIGH',
-                    'networks_scanned': successful_networks
-                }
+    async def _api_rate_limit_delay(self, api_name):
+        """تأخير ذكي لتجنب تجاوز حدود API"""
+        stats = self.api_usage_stats[api_name]
+        
+        if api_name == 'etherscan':
+            if stats['requests_per_second'] > 4:
+                delay = 0.2 * (stats['requests_per_second'] - 4)
+                print(f"⏳ تأخير {delay:.2f} ثانية لـ {api_name}")
+                await asyncio.sleep(delay)
             
-            latest_alert = all_alerts[0] if all_alerts else None
-            latest_time_info = f"آخر نشاط منذ {latest_alert['minutes_ago']:.1f} دقيقة" if latest_alert else ""
-                
-            sentiment = 'BULLISH' if total_volume > 5_000_000 else 'SLIGHTLY_BULLISH' if total_volume > 1_000_000 else 'NEUTRAL'
-            critical = total_volume > 10_000_000 or any(tx['value_usd'] > 5_000_000 for tx in all_alerts)
-
-            description = f"تم اكتشاف {alert_count} معاملة حوت بإجمالي ${total_volume:,.0f} عبر {successful_networks} شبكات. {latest_time_info}"
-            print(f"✅ {description}")
-
-            return {
-                'data_available': True, 
-                'description': description,
-                'critical_alert': critical, 
-                'sentiment': sentiment,
-                'total_volume_usd': total_volume, 
-                'transaction_count': alert_count,
-                'recent_alerts': all_alerts[:5],
-                'latest_activity': latest_alert['human_time'] if latest_alert else None,
-                'time_analysis': {
-                    'oldest_minutes': max(alert['minutes_ago'] for alert in all_alerts) if all_alerts else 0,
-                    'newest_minutes': min(alert['minutes_ago'] for alert in all_alerts) if all_alerts else 0,
-                    'average_minutes': sum(alert['minutes_ago'] for alert in all_alerts) / len(all_alerts) if all_alerts else 0
-                },
-                'data_quality': 'HIGH',
-                'networks_scanned': successful_networks
-            }
+            if stats['requests_today'] > 95000:
+                print(f"🚨 تجاوز الحد اليومي لطلبات {api_name}")
+                return True
+        
+        elif api_name == 'infura':
+            if stats['requests_per_second'] > 400:
+                delay = 0.1 * (stats['requests_per_second'] - 400)
+                print(f"⏳ تأخير {delay:.2f} ثانية لـ {api_name}")
+                await asyncio.sleep(delay)
             
-        except Exception as e:
-            print(f"❌ فشل مراقبة الحيتان العامة: {e}")
-            return {
-                'data_available': False,
-                'description': f'فشل في مراقبة الحيتان: {str(e)}',
-                'critical_alert': False, 
-                'sentiment': 'UNKNOWN',
-                'total_volume_usd': 0, 
-                'transaction_count': 0,
-                'data_quality': 'LOW',
-                'error': str(e)
-            }
+            if stats['requests_today'] > 2800000:
+                print(f"🚨 تجاوز الحد اليومي لطلبات {api_name}")
+                return True
+        
+        return False
 
     async def get_symbol_specific_whale_data(self, symbol, contract_address=None):
         """جلب بيانات الحيتان الخاصة بعملة محددة"""
@@ -474,7 +791,7 @@ class EnhancedWhaleMonitor:
             if not contract_address:
                 return await self._scan_networks_for_symbol(symbol, base_symbol)
             
-            print(f"🔍 جلب بيانات الحيتان لـ {symbol} مع العقد: {contract_address[:10]}...")
+            print(f"🔍 جلب بيانات الحيتان لـ {symbol}")
             
             api_data = await self._get_combined_api_data(contract_address)
             
@@ -488,7 +805,7 @@ class EnhancedWhaleMonitor:
             print(f"❌ فشل جلب بيانات الحيتان لـ {symbol}: {e}")
             return {
                 'data_available': False,
-                'description': f'خطأ في جلب بيانات الحيتان: {str(e)}',
+                'description': f'غير متوفر - خطأ في جلب بيانات الحيتان',
                 'total_volume': 0,
                 'transfer_count': 0,
                 'source': 'error'
@@ -501,7 +818,7 @@ class EnhancedWhaleMonitor:
         if self.moralis_key:
             tasks.append(self._get_moralis_token_data(contract_address))
         if self.etherscan_key:
-            tasks.append(self._get_etherscan_token_data_v2(contract_address))  # 🔄 استخدام الإصدار V2
+            tasks.append(self._get_etherscan_token_data_v2(contract_address))
         
         if not tasks:
             return []
@@ -516,47 +833,42 @@ class EnhancedWhaleMonitor:
         return all_transfers
 
     async def _get_etherscan_token_data_v2(self, contract_address):
-        """🔧 إصلاح: جلب بيانات Etherscan باستخدام الإصدار V2 من API"""
+        """جلب بيانات Etherscan"""
         if not self.etherscan_key:
             return []
             
         try:
-            # 🔄 تحديث إحصائيات الاستخدام
             self._update_api_usage_stats('etherscan')
             
-            # ⏳ التحقق من حدود الاستخدام
             if await self._api_rate_limit_delay('etherscan'):
                 print("⚠️ تجاوز حدود Etherscan، تخطي الطلب")
                 return []
             
-            # 🔧 استخدام معاملات الإصدار V2 حسب الوثائق
             params = {
                 "module": "account",
                 "action": "tokentx",
                 "contractaddress": contract_address,
                 "page": 1,
-                "offset": 10,  # تقليل العدد لتوفير الطلبات
+                "offset": 10,
                 "sort": "desc",
                 "apikey": self.etherscan_key
             }
             
-            # 🔧 استخدام base URL الصحيح
             base_url = "https://api.etherscan.io/api"
             
-            print(f"🔍 جلب بيانات Etherscan V2 للعقد: {contract_address[:10]}...")
+            print(f"🔍 جلب بيانات Etherscan للعقد: {contract_address[:10]}...")
             
             async with httpx.AsyncClient(timeout=10.0) as client:
                 response = await client.get(base_url, params=params)
                 
                 if response.status_code == 429:
-                    print("⏳ تجاوز حد معدل Etherscan، تأخير الطلبات المستقبلية")
+                    print("⏳ تجاوز حد معدل Etherscan")
                     await asyncio.sleep(2)
                     return []
                 
                 response.raise_for_status()
                 data = response.json()
                 
-                # 🔧 التحقق من استجابة API
                 if data.get('status') == '1' and data.get('message') == 'OK':
                     result = data.get('result', [])
                     print(f"✅ بيانات Etherscan: {len(result)} تحويل")
@@ -582,7 +894,7 @@ class EnhancedWhaleMonitor:
             response = await self.http_client.get(
                 f"https://deep-index.moralis.io/api/v2/erc20/{contract_address}/transfers",
                 headers={"X-API-Key": self.moralis_key},
-                params={"chain": "eth", "limit": 10}  # تقليل العدد
+                params={"chain": "eth", "limit": 10}
             )
             
             if response.status_code == 200:
@@ -597,7 +909,136 @@ class EnhancedWhaleMonitor:
             print(f"⚠️ Moralis API error: {e}")
             return []
 
-    # ... باقي الدوال تبقى كما كانت ...
+    async def _enrich_api_data_with_timing(self, api_data):
+        """إثراء بيانات API بتوقيتات إضافية"""
+        enriched_data = []
+        for transfer in api_data:
+            try:
+                if 'timeStamp' in transfer:
+                    timestamp = int(transfer['timeStamp'])
+                elif 'block_timestamp' in transfer:
+                    timestamp = int(transfer['block_timestamp'])
+                else:
+                    timestamp = int(time.time())
+                
+                transfer_time = datetime.fromtimestamp(timestamp)
+                time_ago = datetime.now() - transfer_time
+                
+                enriched_transfer = {
+                    **transfer,
+                    'human_time': transfer_time.isoformat(),
+                    'minutes_ago': time_ago.total_seconds() / 60,
+                    'timestamp': timestamp
+                }
+                enriched_data.append(enriched_transfer)
+                
+            except Exception as e:
+                print(f"⚠️ خطأ في إثراء بيانات التحويل: {e}")
+                continue
+                
+        return enriched_data
+
+    def _analyze_symbol_specific_data(self, enriched_data, symbol):
+        """تحليل بيانات الرمز المحدد"""
+        if not enriched_data:
+            return {
+                'data_available': False,
+                'description': f'غير متوفر - لا توجد بيانات تحويل لـ {symbol}',
+                'total_volume': 0,
+                'transfer_count': 0,
+                'source': 'no_data'
+            }
+        
+        try:
+            volumes = []
+            large_transfers = []
+            
+            for transfer in enriched_data:
+                value = float(transfer.get('value', 0))
+                volumes.append(value)
+                
+                if value > 10000:
+                    large_transfers.append(transfer)
+            
+            total_volume = sum(volumes)
+            transfer_count = len(volumes)
+            avg_volume = total_volume / transfer_count if transfer_count > 0 else 0
+            
+            latest_transfer = max(enriched_data, key=lambda x: x['timestamp'])
+            oldest_transfer = min(enriched_data, key=lambda x: x['timestamp'])
+            time_range_hours = (latest_transfer['timestamp'] - oldest_transfer['timestamp']) / 3600
+            
+            if len(large_transfers) > 5:
+                activity_level = 'HIGH'
+                description = f"نشاط حيتان مرتفع لـ {symbol}: {len(large_transfers)} تحويل كبير"
+            elif len(large_transfers) > 2:
+                activity_level = 'MEDIUM'
+                description = f"نشاط حيتان متوسط لـ {symbol}: {len(large_transfers)} تحويل كبير"
+            else:
+                activity_level = 'LOW'
+                description = f"نشاط حيتان منخفض لـ {symbol}: {len(large_transfers)} تحويل كبير"
+            
+            return {
+                'data_available': True,
+                'description': description,
+                'total_volume': total_volume,
+                'transfer_count': transfer_count,
+                'average_volume': avg_volume,
+                'large_transfers_count': len(large_transfers),
+                'activity_level': activity_level,
+                'latest_transfer_time': latest_transfer['human_time'],
+                'time_range_hours': time_range_hours,
+                'source': 'api_combined',
+                'recent_large_transfers': large_transfers[:5]
+            }
+            
+        except Exception as e:
+            print(f"❌ خطأ في تحليل بيانات {symbol}: {e}")
+            return {
+                'data_available': False,
+                'description': f'غير متوفر - خطأ في تحليل البيانات',
+                'total_volume': 0,
+                'transfer_count': 0,
+                'source': 'error'
+            }
+
+    async def _find_contract_address(self, symbol):
+        """البحث عن عنوان العقد للرمز المحدد"""
+        symbol_lower = symbol.lower()
+        for key, address in self.contracts_db.items():
+            if symbol_lower in key.lower():
+                return address
+        
+        print(f"🔍 لم يتم العثور على عقد لـ {symbol} في قاعدة البيانات")
+        return None
+
+    async def _scan_networks_for_symbol(self, symbol, base_symbol):
+        """مسح الشبكات للعثور على الرمز"""
+        print(f"🔍 مسح الشبكات للعثور على {symbol}...")
+        
+        networks_to_scan = ['ethereum', 'bsc']
+        
+        for network in networks_to_scan:
+            try:
+                price = await self._get_native_coin_price(network)
+                if price:
+                    print(f"✅ تم العثور على {symbol} على شبكة {network} بسعر ${price:.2f}")
+                    return {
+                        'data_available': True,
+                        'description': f'تم اكتشاف {symbol} على شبكة {network}',
+                        'network': network,
+                        'price_usd': price,
+                        'source': 'network_scan'
+                    }
+            except Exception as e:
+                print(f"⚠️ فشل مسح {network} لـ {symbol}: {e}")
+                continue
+        
+        return {
+            'data_available': False,
+            'description': f'غير متوفر - لم يتم العثور على {symbol} على أي شبكة',
+            'source': 'not_found'
+        }
 
     def get_api_usage_stats(self):
         """الحصول على إحصائيات استخدام APIs"""
@@ -632,12 +1073,10 @@ class DataManager:
     def __init__(self, contracts_db):
         self.contracts_db = contracts_db or {}
         
-        # 🔧 استخدام KuCoin بدون API keys (عام)
         try:
             self.exchange = ccxt.kucoin({
                 'sandbox': False,
                 'enableRateLimit': True
-                # لا حاجة لـ API keys للاستخدام العام
             })
             self.exchange.rateLimit = 800
             print("✅ تم تهيئة KuCoin (الوضع العام)")
@@ -654,29 +1093,16 @@ class DataManager:
     async def initialize(self):
         self.http_client = httpx.AsyncClient(timeout=20.0)
         
-        # التحقق من توفر مفاتيح API
         api_status = {
             'KUCOIN': '🟢 عام (بدون مفتاح)',
             'MORALIS_KEY': "🟢 متوفر" if os.getenv('MORALIS_KEY') else "🔴 غير متوفر",
-            'ETHERSCAN_KEY': "🟢 متوفر" if os.getenv('ETHERSCAN_KEY') else "🔴 غير متوفر",
+            'ETHERSCAN_KEY': "🟢 متوفر" if os.getenv('ETHERSCAN_KEY') else "🔴 غير متوفر", 
             'INFURA_KEY': "🟢 متوفر" if os.getenv('INFURA_KEY') else "🔴 غير متوفر"
         }
         
-        print("✅ DataManager initialized - API Status:")
+        print("✅ DataManager initialized - تحليل صافي التدفق المتقدم")
         for key, status in api_status.items():
             print(f"   {key}: {status}")
-            
-        # عرض حدود الاستخدام
-        api_limits = {
-            'Etherscan': '5/ثانية, 100,000/يوم',
-            'Infura': '500/ثانية, 3,000,000/يوم', 
-            'KuCoin': 'عام (بدون حدود)',
-            'CoinGecko': '50/دقيقة'
-        }
-        
-        print("📊 حدود استخدام APIs:")
-        for api, limit in api_limits.items():
-            print(f"   {api}: {limit}")
     
     async def close(self):
         if self.http_client: 
@@ -685,7 +1111,7 @@ class DataManager:
             await self.exchange.close()
 
     async def get_sentiment_safe_async(self):
-        """جلب بيانات المشاعر مع مصادر احتياطية"""
+        """جلب بيانات المشاعر من مصادر حقيقية"""
         max_retries = 2
         for attempt in range(max_retries):
             try:
@@ -713,7 +1139,7 @@ class DataManager:
         return None
 
     async def get_market_context_async(self):
-        """جلب سياق السوق مع تتبع استخدام APIs"""
+        """جلب سياق السوق من مصادر حقيقية"""
         max_retries = 2
         for attempt in range(max_retries):
             try:
@@ -742,6 +1168,8 @@ class DataManager:
 
                 market_trend = self._determine_market_trend(bitcoin_price, sentiment_data, general_whale_activity)
                 
+                trading_decision = self._analyze_advanced_trading_signals(general_whale_activity, sentiment_data)
+                
                 market_context = {
                     'timestamp': datetime.now().isoformat(),
                     'bitcoin_price_usd': bitcoin_price,
@@ -750,23 +1178,34 @@ class DataManager:
                     'sentiment_class': sentiment_data.get('feargreed_class') if sentiment_data else 'UNKNOWN',
                     'general_whale_activity': general_whale_activity or {
                         'data_available': False,
-                        'description': 'فشل في مراقبة الحيتان',
+                        'description': 'غير متوفر - فشل في مراقبة الحيتان',
                         'critical_alert': False,
-                        'sentiment': 'UNKNOWN'
+                        'sentiment': 'UNKNOWN',
+                        'trading_signals': []
                     },
                     'market_trend': market_trend,
+                    'trading_decision': trading_decision,
                     'btc_sentiment': self._get_btc_sentiment(bitcoin_price),
                     'data_sources': {
                         'prices': bitcoin_price is not None and ethereum_price is not None,
                         'sentiment': sentiment_data is not None,
-                        'general_whale_data': general_whale_activity.get('data_available', False) if general_whale_activity else False
+                        'general_whale_data': general_whale_activity.get('data_available', False) if general_whale_activity else False,
+                        'netflow_analysis': general_whale_activity.get('netflow_analysis', {}).get('market_impact', 'UNKNOWN') if general_whale_activity else 'UNKNOWN'
                     },
                     'data_quality': 'HIGH',
-                    'api_usage': self.whale_monitor.get_api_usage_stats()
+                    'risk_assessment': self._assess_market_risk(general_whale_activity, sentiment_data)
                 }
                 
                 print(f"📊 سياق السوق: BTC=${bitcoin_price:,.0f}, ETH=${ethereum_price:,.0f}")
                 
+                if general_whale_activity and general_whale_activity.get('netflow_analysis'):
+                    netflow = general_whale_activity['netflow_analysis']
+                    print(f"📈 تحليل التدفق: صافي ${netflow['net_flow']:,.0f}")
+                
+                if general_whale_activity and general_whale_activity.get('trading_signals'):
+                    for signal in general_whale_activity['trading_signals']:
+                        print(f"🎯 {signal['action']}: {signal['reason']}")
+                
                 return market_context
                 
             except Exception as e:
@@ -776,6 +1215,104 @@ class DataManager:
 
         return self._get_minimal_market_context()
 
+    def _analyze_advanced_trading_signals(self, whale_activity, sentiment_data):
+        """تحليل إشارات التداول المتقدمة"""
+        if not whale_activity or not whale_activity.get('data_available'):
+            return {
+                'action': 'HOLD',
+                'confidence': 0.0,
+                'reason': 'غير متوفر - لا توجد بيانات كافية عن الحيتان',
+                'risk_level': 'UNKNOWN'
+            }
+        
+        signals = whale_activity.get('trading_signals', [])
+        netflow_analysis = whale_activity.get('netflow_analysis', {})
+        whale_sentiment = whale_activity.get('sentiment', 'NEUTRAL')
+        
+        strongest_signal = None
+        for signal in signals:
+            if not strongest_signal or signal.get('confidence', 0) > strongest_signal.get('confidence', 0):
+                strongest_signal = signal
+        
+        if strongest_signal and strongest_signal.get('confidence', 0) > 0.7:
+            action = strongest_signal['action']
+            reason = strongest_signal['reason']
+            confidence = strongest_signal['confidence']
+            
+            if 'STRONG_' in action:
+                risk_level = 'HIGH' if 'SELL' in action else 'LOW'
+            else:
+                risk_level = 'MEDIUM' if 'SELL' in action else 'LOW'
+            
+            return {
+                'action': action,
+                'confidence': confidence,
+                'reason': reason,
+                'risk_level': risk_level,
+                'source': 'netflow_analysis'
+            }
+        
+        net_flow = netflow_analysis.get('net_flow', 0)
+        flow_direction = netflow_analysis.get('flow_direction', 'BALANCED')
+        
+        if flow_direction == 'TO_EXCHANGES' and abs(net_flow) > 500000:
+            return {
+                'action': 'SELL',
+                'confidence': 0.6,
+                'reason': f'تدفق بيعي إلى المنصات: ${abs(net_flow):,.0f}',
+                'risk_level': 'MEDIUM',
+                'source': 'netflow_direction'
+            }
+        elif flow_direction == 'FROM_EXCHANGES' and net_flow > 500000:
+            return {
+                'action': 'BUY',
+                'confidence': 0.6,
+                'reason': f'تراكم شرائي من المنصات: ${net_flow:,.0f}',
+                'risk_level': 'LOW', 
+                'source': 'netflow_direction'
+            }
+        
+        return {
+            'action': 'HOLD',
+            'confidence': 0.5,
+            'reason': f'أنماط التدفق طبيعية - مشاعر الحيتان: {whale_sentiment}',
+            'risk_level': 'LOW',
+            'source': 'balanced_flow'
+        }
+
+    def _assess_market_risk(self, whale_activity, sentiment_data):
+        """تقييم مخاطر السوق"""
+        risk_factors = []
+        risk_score = 0
+        
+        if whale_activity and whale_activity.get('data_available'):
+            if whale_activity.get('critical_alert', False):
+                risk_factors.append("نشاط حيتان حرج")
+                risk_score += 3
+            
+            netflow = whale_activity.get('netflow_analysis', {})
+            if netflow.get('flow_direction') == 'TO_EXCHANGES' and abs(netflow.get('net_flow', 0)) > 1000000:
+                risk_factors.append("تدفق بيعي كبير إلى المنصات")
+                risk_score += 2
+            
+            if whale_activity.get('sentiment') == 'BEARISH':
+                risk_factors.append("مشاعر حيتان هبوطية")
+                risk_score += 1
+        
+        if sentiment_data and sentiment_data.get('feargreed_value', 50) < 30:
+            risk_factors.append("مخاوف السوق عالية")
+            risk_score += 2
+        elif sentiment_data and sentiment_data.get('feargreed_value', 50) > 70:
+            risk_factors.append("جشع السوق مرتفع")
+            risk_score += 1
+        
+        if risk_score >= 4:
+            return {'level': 'HIGH', 'score': risk_score, 'factors': risk_factors}
+        elif risk_score >= 2:
+            return {'level': 'MEDIUM', 'score': risk_score, 'factors': risk_factors}
+        else:
+            return {'level': 'LOW', 'score': risk_score, 'factors': risk_factors}
+
     def _get_btc_sentiment(self, bitcoin_price):
         """تحديد اتجاه البيتكوين"""
         if bitcoin_price is None:
@@ -788,7 +1325,7 @@ class DataManager:
             return 'NEUTRAL'
 
     async def _get_prices_with_fallback(self):
-        """جلب الأسعار مع KuCoin العام"""
+        """جلب الأسعار من مصادر حقيقية"""
         try:
             prices = await self._get_prices_from_kucoin_safe()
             if prices.get('bitcoin') and prices.get('ethereum'):
@@ -805,7 +1342,7 @@ class DataManager:
             return {'bitcoin': None, 'ethereum': None}
 
     async def _get_prices_from_kucoin_safe(self):
-        """جلب الأسعار من KuCoin (عام)"""
+        """جلب الأسعار من KuCoin"""
         if not self.exchange:
             return {'bitcoin': None, 'ethereum': None}
             
@@ -869,13 +1406,13 @@ class DataManager:
             'timestamp': datetime.now().isoformat(),
             'data_available': False,
             'data_sources': {'prices': False, 'sentiment': False, 'general_whale_data': False},
-            'error': 'فشل في جلب بيانات السوق من المصادر الخارجية',
+            'error': 'غير متوفر - فشل في جلب بيانات السوق من المصادر الخارجية',
             'market_trend': 'UNKNOWN',
             'btc_sentiment': 'UNKNOWN',
             'data_quality': 'LOW',
             'general_whale_activity': {
                 'data_available': False,
-                'description': 'فشل في مراقبة الحيتان',
+                'description': 'غير متوفر - فشل في مراقبة الحيتان',
                 'critical_alert': False,
                 'sentiment': 'UNKNOWN'
             },
@@ -883,7 +1420,7 @@ class DataManager:
             'ethereum_price_usd': None,
             'fear_and_greed_index': None,
             'sentiment_class': 'UNKNOWN',
-            'missing_data': ['أسعار البيتكوين', 'أسعار الإيثيريوم', 'بيانات المشاعر', 'بيانات الحيتان']
+            'missing_data': ['غير متوفر - أسعار البيتكوين', 'غير متوفر - أسعار الإيثيريوم', 'غير متوفر - بيانات المشاعر', 'غير متوفر - بيانات الحيتان']
         }
 
     def _determine_market_trend(self, bitcoin_price, sentiment_data, whale_activity):
@@ -936,8 +1473,6 @@ class DataManager:
             print(f"⚠️ خطأ في تحديد اتجاه السوق: {e}")
             return "UNKNOWN"
 
-    # ... باقي دوال DataManager تبقى كما هي ...
-
     def get_performance_stats(self):
         """الحصول على إحصائيات الأداء"""
         total_attempts = self.fetch_stats['successful_fetches'] + self.fetch_stats['failed_fetches']
@@ -958,4 +1493,8 @@ class DataManager:
         
         return stats
 
-print("✅ Enhanced Data Manager Loaded - KUCOIN PUBLIC + ETHERSCAN V2 FIX + API RATE LIMITING")
+    async def get_symbol_specific_whale_data(self, symbol, contract_address=None):
+        """جلب بيانات الحيتان الخاصة بعملة محددة"""
+        return await self.whale_monitor.get_symbol_specific_whale_data(symbol, contract_address)
+
+print("✅ Enhanced Data Manager Loaded - جميع البيانات حقيقية")