Update whale_news_data.py

whale_news_data.py

@@ -99,17 +99,21 @@ class EnhancedWhaleMonitor:
         self.price_cache = {}
         self.last_scan_time = {}
         
-        self.contract_cache = {}
-        self.symbol_networks = {}
+        self.contract_cache = {}  # كاش جديد للعقود
+        self.symbol_networks = {}  # تتبع الشبكات المناسبة للرموز
         
         self.pattern_performance = {}
         self.pattern_success_rates = {}
         
         if self.r2_service:
             asyncio.create_task(self._load_pattern_performance())
+            
+        # تحميل العقود من R2 إذا كان متوفراً
+        if self.r2_service:
             asyncio.create_task(self._load_contracts_from_r2())
 
     def _validate_api_keys(self):
+        """التحقق من صحة مفاتيح API"""
         print("🔍 التحقق من صحة مفاتيح API...")
         
         if self.moralis_key:
@@ -134,6 +138,7 @@ class EnhancedWhaleMonitor:
                 print("✅ مفتاح Infura صالح")
 
     async def _is_valid_infura_key(self):
+        """التحقق من أن مفتاح Infura صالح"""
         if not self.infura_key:
             return False
             
@@ -148,11 +153,13 @@ class EnhancedWhaleMonitor:
             return False
 
     async def _load_contracts_from_r2(self):
+        """تحميل قاعدة بيانات العقود من R2"""
         try:
             key = "contracts_database.json"
             response = self.r2_service.s3_client.get_object(Bucket="trading", Key=key)
             contracts_data = json.loads(response['Body'].read())
             
+            # تحديث قاعدة البيانات المحلية
             self.contracts_db.update(contracts_data)
             print(f"✅ تم تحميل {len(contracts_data)} عقد من R2")
             
@@ -188,6 +195,7 @@ class EnhancedWhaleMonitor:
 
     async def _load_pattern_performance(self):
         if not self.r2_service:
+            print("⚠️ R2 Service غير متوفر لتحميل بيانات الأنماط")
             return
             
         try:
@@ -199,9 +207,12 @@ class EnhancedWhaleMonitor:
             print(f"✅ تم تحميل بيانات أداء الأنماط: {len(self.pattern_performance)} نمط")
         except Exception as e:
             print(f"⚠️ لم يتم العثور على بيانات أداء الأنماط: {e}")
+            self.pattern_performance = {}
+            self.pattern_success_rates = {}
 
     async def _save_pattern_performance(self):
         if not self.r2_service:
+            print("⚠️ R2 Service غير متوفر لحفظ بيانات الأنماط")
             return
             
         try:
@@ -217,209 +228,838 @@ class EnhancedWhaleMonitor:
             self.r2_service.s3_client.put_object(
                 Bucket="trading", Key=key, Body=data_json, ContentType="application/json"
             )
+            print(f"✅ تم حفظ بيانات أداء الأنماط: {len(self.pattern_performance)} نمط")
         except Exception as e:
             print(f"❌ فشل حفظ بيانات أداء الأنماط: {e}")
 
-    async def _find_contract_address_enhanced(self, symbol):
-        base_symbol = symbol.split("/")[0] if '/' in symbol else symbol
-        symbol_lower = base_symbol.lower()
+    def _classify_address_dynamic(self, address, transaction_history=None):
+        try:
+            if not isinstance(address, str):
+                address = str(address)
+                
+            address_lower = address.lower()
+            
+            if address_lower in self.address_labels:
+                return self.address_labels[address_lower]
+            
+            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'
+            
+            self.address_labels[address_lower] = 'unknown'
+            self.address_categories['unknown'].add(address_lower)
+            return 'unknown'
+        except Exception as e:
+            print(f"❌ خطأ في تصنيف العنوان: {e}")
+            return 'unknown'
+
+    def _detect_exchange_pattern(self, transactions):
+        if len(transactions) < 10:
+            return False
         
-        if symbol_lower in self.contract_cache:
-            return self.contract_cache[symbol_lower]
+        unique_senders = set()
+        unique_receivers = set()
         
-        for key, address in self.contracts_db.items():
-            if symbol_lower in key.lower():
-                self.contract_cache[symbol_lower] = address
-                print(f"✅ تم العثور على عنوان العقد لـ {symbol} في قاعدة البيانات: {address}")
-                return address
+        for tx in transactions[-20:]:
+            if 'from' in tx:
+                unique_senders.add(tx['from'])
+            if 'to' in tx:
+                unique_receivers.add(tx['to'])
         
-        coingecko_address = await self._find_contract_via_coingecko(base_symbol)
-        if coingecko_address:
-            self.contract_cache[symbol_lower] = coingecko_address
-            self.contracts_db[symbol_lower] = coingecko_address
-            if self.r2_service:
-                await self._save_contracts_to_r2()
-            return coingecko_address
+        if len(unique_senders) > 15 and len(unique_receivers) < 5:
+            return True
         
-        print(f"⚠️ لم يتم العثور على عنوان عقد لـ {symbol} في أي مصدر")
-        return None
+        return False
 
-    async def _find_contract_via_coingecko(self, symbol):
+    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):
         try:
-            search_url = f"https://api.coingecko.com/api/v3/search?query={symbol}"
-            async with httpx.AsyncClient(timeout=15) as client:
-                response = await client.get(search_url)
-                if response.status_code != 200:
-                    return None
-                
-                data = response.json()
-                coins = data.get('coins', [])
-                
-                if not coins:
-                    return None
-                
-                best_coin = coins[0]
-                coin_id = best_coin.get('id')
+            if not isinstance(address, str):
+                address = str(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'])
+        except Exception as e:
+            print(f"❌ خطأ في التحقق من عنوان التبادل: {e}")
+            return False
+
+    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)
+            
+            if self._is_exchange_address(to_address):
+                if token_symbol not in self.netflow_data[network]:
+                    self._initialize_token_metrics(network, token_symbol)
                 
-                if not coin_id:
-                    return None
+                self.netflow_data[network][token_symbol]['inflow'].append(value_usd)
+                self.netflow_data[network][token_symbol]['timestamps'].append(datetime.now())
                 
-                detail_url = f"https://api.coingecko.com/api/v3/coins/{coin_id}"
-                detail_response = await client.get(detail_url)
-                if detail_response.status_code != 200:
-                    return None
+            if self._is_exchange_address(from_address):
+                if token_symbol not in self.netflow_data[network]:
+                    self._initialize_token_metrics(network, token_symbol)
                 
-                detail_data = detail_response.json()
-                platforms = detail_data.get('platforms', {})
+                self.netflow_data[network][token_symbol]['outflow'].append(value_usd)
+                self.netflow_data[network][token_symbol]['timestamps'].append(datetime.now())
                 
-                for platform in ['ethereum', 'binance-smart-chain', 'polygon-pos']:
-                    if platform in platforms and platforms[platform]:
-                        address = platforms[platform]
-                        if address and len(address) == 42:
-                            print(f"✅ تم العثور على عنوان {symbol} على {platform}: {address}")
-                            self.symbol_networks[symbol] = platform
-                            return address
+            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
                 
-                return None
+                self.netflow_data[network][token_symbol]['netflow'].append(current_netflow)
                 
         except Exception as e:
-            print(f"❌ فشل البحث عن عقد {symbol} عبر CoinGecko: {e}")
-            return None
+            print(f"❌ خطأ في تحديث مقاييس صافي التدفق: {e}")
 
-    async def _save_contracts_to_r2(self):
+    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):
         try:
-            key = "contracts_database.json"
-            data_json = json.dumps(self.contracts_db, indent=2).encode('utf-8')
-            self.r2_service.s3_client.put_object(
-                Bucket="trading", Key=key, Body=data_json, ContentType="application/json"
-            )
-            print(f"✅ تم حفظ {len(self.contracts_db)} عقد في R2")
+            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"❌ فشل حفظ العقود في R2: {e}")
+            print(f"❌ خطأ في حساب Z-score: {e}")
+            return 0
 
-    async def get_symbol_specific_whale_data(self, symbol, contract_address=None):
+    def _generate_netflow_signal(self, network, token_symbol):
         try:
-            print(f"🔍 جلب بيانات الحيتان لـ {symbol}...")
-            base_symbol = symbol.split("/")[0] if '/' in symbol else symbol
+            if token_symbol not in self.netflow_data[network]:
+                return None
             
-            if not contract_address:
-                contract_address = await self._find_contract_address_enhanced(base_symbol)
+            data = self.netflow_data[network][token_symbol]
+            netflow_values = list(data['netflow'])
             
-            if not contract_address:
-                print(f"⚠️ لم يتم العثور على عنوان عقد لـ {symbol}")
-                return await self._scan_networks_for_symbol(symbol, base_symbol)
+            if len(netflow_values) < 12:
+                return None
             
-            network = self.symbol_networks.get(base_symbol, 'ethereum')
-            print(f"🔍 البحث في شبكة {network} للرمز {symbol}")
+            recent_inflow = sum(list(data['inflow'])[-12:])
+            recent_outflow = sum(list(data['outflow'])[-12:])
+            recent_netflow = recent_inflow - recent_outflow
             
-            api_data = await self._get_combined_api_data(contract_address, network)
+            zscore = self._calculate_netflow_zscore(network, token_symbol)
             
-            if api_data:
-                enriched_data = await self._enrich_api_data_with_timing(api_data)
-                result = self._analyze_symbol_specific_data(enriched_data, symbol)
-                print(f"✅ تم تحليل بيانات الحيتان لـ {symbol}: {result.get('transfer_count', 0)} تحويل")
-                return result
-            else:
-                print(f"⚠️ لا توجد بيانات API لـ {symbol}")
-                return await self._scan_networks_for_symbol(symbol, base_symbol)
-                
-        except Exception as e:
-            print(f"❌ فشل جلب بيانات الحيتان لـ {symbol}: {e}")
-            return {
-                'data_available': False,
-                'description': f'غير متوفر - خطأ في جلب بيانات الحيتان',
-                'total_volume': 0,
-                'transfer_count': 0,
-                'source': 'error'
+            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()
             }
-
-    async def _get_combined_api_data(self, contract_address, network='ethereum'):
-        tasks = []
-        
-        if self.moralis_key and self._is_valid_moralis_key():
-            tasks.append(self._get_moralis_token_data(contract_address, network))
-        
-        if self.etherscan_key and network == 'ethereum':
-            tasks.append(self._get_etherscan_token_data_v2(contract_address))
-        
-        if not tasks:
-            return await self._get_rpc_token_data(contract_address, network)
             
-        results = await asyncio.gather(*tasks, return_exceptions=True)
-        
-        all_transfers = []
-        for res in results:
-            if isinstance(res, list):
-                all_transfers.extend(res)
-        
-        if not all_transfers:
-            return await self._get_rpc_token_data(contract_address, network)
-                
-        print(f"✅ تم جمع {len(all_transfers)} تحويل من APIs")
-        return all_transfers
-
-    def _is_valid_moralis_key(self):
-        if not self.moralis_key:
-            return False
-        return len(self.moralis_key) >= 20
+            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 _get_rpc_token_data(self, contract_address, network='ethereum'):
+    async def _scan_single_evm_network(self, network):
+        whale_alerts = []
+        trading_signals = []
+        
         try:
-            print(f"🔍 استخدام RPC لجلب بيانات العقد {contract_address} على شبكة {network}")
-            
-            endpoint = self._get_next_rpc_endpoint(network)
-            if not endpoint:
-                return []
+            if not self.data_manager:
+                print(f"⚠️ DataManager غير متوفر لمسح شبكة {network}")
+                return [], []
                 
-            transfers = []
+            price_usd = await self.data_manager.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: 
+                print(f"⚠️ فشل الحصول على أحدث كتلة لـ {network}")
+                return [], []
             
-            payload = {"jsonrpc": "2.0", "method": "eth_blockNumber", "params": [], "id": 1}
-            async with httpx.AsyncClient(timeout=15.0) as client:
-                response = await client.post(endpoint, json=payload)
-                if response.status_code != 200:
-                    return []
-                
-                result = response.json().get('result')
-                if not result:
-                    return []
-                
-                latest_block = int(result, 16)
+            latest_block = int(latest_block_hex, 16)
+            blocks_to_scan = 15
+            scanned_blocks = 0
+            whale_transactions_found = 0
             
-            for block_offset in range(50):
+            for block_offset in range(blocks_to_scan):
                 block_number = latest_block - block_offset
                 if block_number < 0:
                     break
                     
-                payload = {"jsonrpc": "2.0", "method": "eth_getBlockByNumber", "params": [hex(block_number), True], "id": 1}
-                async with httpx.AsyncClient(timeout=15.0) as client:
-                    response = await client.post(endpoint, json=payload)
-                    if response.status_code != 200:
-                        continue
+                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'
+                            })
+                            whale_transactions_found += 1
+                            
+                if block_offset % 3 == 0:
+                    await asyncio.sleep(0.1)
                     
-                    block_data = response.json().get('result')
-                    if not block_data:
-                        continue
+            signal = self._generate_netflow_signal(network, 'NATIVE')
+            if signal:
+                trading_signals.append(signal)
+
+            print(f"✅ تم مسح {scanned_blocks} كتلة في {network} - تم العثور على {whale_transactions_found} معاملة حوت")
+            return whale_alerts, trading_signals
                     
-                    for tx in block_data.get('transactions', []):
-                        if tx.get('to', '').lower() == contract_address.lower() and tx.get('input', '0x') != '0x':
-                            transfers.append({
-                                'hash': tx.get('hash'),
-                                'from': tx.get('from'),
-                                'to': tx.get('to'),
-                                'value': str(int(tx.get('value', '0x0'), 16)),
-                                'timeStamp': str(int(block_data.get('timestamp', '0x0'), 16)),
-                                'blockNumber': str(block_number)
-                            })
-            
-            print(f"✅ تم جمع {len(transfers)} تحويل من RPC")
-            return transfers
-            
         except Exception as e:
-            print(f"❌ فشل جلب بيانات RPC: {e}")
-            return []
+            print(f"❌ خطأ في مسح شبكة {network}: {e}")
+            return [], []
+
+    async def get_general_whale_activity(self):
+        try:
+            print("🔍 بدء مسح نشاط الحيتان العام...")
+            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 i, res in enumerate(results):
+                if isinstance(res, tuple) and len(res) == 2:
+                    alerts, signals = res
+                    all_alerts.extend(alerts)
+                    all_signals.extend(signals)
+                    successful_networks += 1
+                    print(f"✅ شبكة {networks_to_scan[i]} تمت معالجتها بنجاح")
+                else:
+                    print(f"❌ فشل معالجة شبكة {networks_to_scan[i]}: {res}")
+
+            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.get('flow_direction') == 'TO_EXCHANGE')
+            exchange_outflow = sum(alert['value_usd'] for alert in all_alerts 
+                                 if alert.get('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:
+                result = {
+                    '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'
+                    }
+                }
+                print("ℹ️ لم يتم اكتشاف أي نشاط حيتان كبير")
+                return result
+            
+            latest_alert = all_alerts[0] if all_alerts else None
+            latest_time_info = f"آخر نشاط منذ {latest_alert['minutes_ago']:.1f} دقيقة" if latest_alert else ""
+            
+            # تحديد flow_direction بشكل آمن
+            flow_direction = 'BALANCED'
+            if net_exchange_flow < 0:
+                flow_direction = 'TO_EXCHANGES'
+            elif net_exchange_flow > 0:
+                flow_direction = 'FROM_EXCHANGES'
+            
+            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}"
+
+            result = {
+                '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': flow_direction,
+                    '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
+            }
+            
+            print(f"✅ اكتمل مسح نشاط الحيتان: {alert_count} معاملة، ${total_volume:,.0f} حجم إجمالي")
+            return result
+            
+        except Exception as e:
+            print(f"❌ فشل مراقبة الحيتان العامة: {e}")
+            import traceback
+            traceback.print_exc()
+            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 _call_rpc_async(self, network, method, params=[]):
+        max_retries = 3
+        
+        for attempt in range(max_retries):
+            endpoint = self._get_next_rpc_endpoint(network)
+            if not endpoint:
+                print(f"❌ لا توجد نقاط نهاية متاحة لـ {network}")
+                return None
+                
+            try:
+                if 'infura' in endpoint and self.infura_key and network == 'ethereum':
+                    self._update_api_usage_stats('infura')
+                    
+                    if await self._api_rate_limit_delay('infura'):
+                        continue
+                
+                payload = {"jsonrpc": "2.0", "method": method, "params": params, "id": 1}
+                
+                timeout = 25.0 if method == 'eth_getBlockByNumber' else 12.0
+                
+                async with httpx.AsyncClient(timeout=timeout) as client:
+                    response = await client.post(endpoint, json=payload)
+                    
+                    if response.status_code == 401:
+                        print(f"❌ خطأ في المصادقة لنقطة النهاية {endpoint}")
+                        self._remove_rpc_endpoint(network, endpoint)
+                        continue
+                    elif response.status_code == 429:
+                        print(f"⏰ تجاوز حد المعدل لنقطة النهاية {endpoint}")
+                        await asyncio.sleep(2 * (attempt + 1))
+                        continue
+                        
+                    response.raise_for_status()
+                    result = response.json().get('result')
+                    
+                    self.rpc_failures[network] = 0
+                    return result
+                    
+            except httpx.HTTPStatusError as e:
+                if e.response.status_code == 429:
+                    self.rpc_failures[network] += 1
+                    await asyncio.sleep(3 * (attempt + 1))
+                    continue
+                elif e.response.status_code == 401:
+                    self.rpc_failures[network] += 1
+                    self._remove_rpc_endpoint(network, endpoint)
+                    continue
+                else:
+                    self.rpc_failures[network] += 1
+                    print(f"❌ خطأ HTTP في RPC {network}: {e}")
+                    
+            except Exception as e:
+                self.rpc_failures[network] += 1
+                print(f"❌ خطأ عام في RPC {network}: {e}")
+                
+            if attempt < max_retries - 1:
+                await asyncio.sleep(1 * (attempt + 1))
+        
+        print(f"❌ فشل جميع محاولات RPC لـ {network}")
+        return None
+
+    def _get_next_rpc_endpoint(self, network):
+        if network not in self.rpc_endpoints:
+            return None
+            
+        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
+
+    def _remove_rpc_endpoint(self, network, endpoint):
+        if network in self.rpc_endpoints and endpoint in self.rpc_endpoints[network]:
+            self.rpc_endpoints[network].remove(endpoint)
+            print(f"⚠️ تمت إزالة نقطة RPC {endpoint} من {network} بسبب الفشل")
+            
+            if self.current_rpc_index[network] >= len(self.rpc_endpoints[network]):
+                self.current_rpc_index[network] = 0
+
+    def _update_api_usage_stats(self, api_name):
+        now = datetime.now()
+        current_date = now.date()
+        
+        if api_name not in self.api_usage_stats:
+            self.api_usage_stats[api_name] = {
+                'requests_today': 0,
+                'requests_per_second': 0,
+                'last_request_time': time.time(),
+                'last_reset': current_date
+            }
+        
+        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
+
+    async def _api_rate_limit_delay(self, api_name):
+        if api_name not in self.api_usage_stats:
+            return False
+            
+        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)
+            
+            if stats['requests_today'] > 95000:
+                print(f"🚨 تجاوز الحد اليومي لـ {api_name}")
+                return True
+        
+        elif api_name == 'infura':
+            if stats['requests_per_second'] > 90:
+                delay = 0.1 * (stats['requests_per_second'] - 90)
+                print(f"⏰ تأخير {delay:.2f} ثانية لتجنب حد المعدل لـ {api_name}")
+                await asyncio.sleep(delay)
+            
+            if stats['requests_today'] > 99000:
+                print(f"🚨 تجاوز الحد اليومي لـ {api_name}")
+                return True
+        
+        elif api_name == 'moralis':
+            if stats['requests_per_second'] > 4:
+                delay = 0.2 * (stats['requests_per_second'] - 4)
+                print(f"⏰ تأخير {delay:.2f} ثانية لتجنب حد المعدل لـ {api_name}")
+                await asyncio.sleep(delay)
+            
+            if stats['requests_today'] > 95000:
+                print(f"🚨 تجاوز الحد اليومي لـ {api_name}")
+                return True
+        
+        return False
+
+    async def _find_contract_address_enhanced(self, symbol):
+        """بحث محسن عن عنوان العقد باستخدام مصادر متعددة"""
+        base_symbol = symbol.split("/")[0] if '/' in symbol else symbol
+        symbol_lower = base_symbol.lower()
+        
+        # البحث في الكاش أولاً
+        if symbol_lower in self.contract_cache:
+            return self.contract_cache[symbol_lower]
+        
+        # البحث في قاعدة البيانات المحلية
+        for key, address in self.contracts_db.items():
+            if symbol_lower in key.lower():
+                self.contract_cache[symbol_lower] = address
+                print(f"✅ تم العثور على عنوان العقد لـ {symbol} في قاعدة البيانات: {address}")
+                return address
+        
+        # البحث عبر CoinGecko
+        coingecko_address = await self._find_contract_via_coingecko(base_symbol)
+        if coingecko_address:
+            self.contract_cache[symbol_lower] = coingecko_address
+            # حفظ في قاعدة البيانات للمستقبل
+            self.contracts_db[symbol_lower] = coingecko_address
+            if self.r2_service:
+                await self._save_contracts_to_r2()
+            return coingecko_address
+        
+        print(f"⚠️ لم يتم العثور على عنوان عقد لـ {symbol} في أي مصدر")
+        return None
+
+    async def _find_contract_via_coingecko(self, symbol):
+        """البحث عن عنوان العقد عبر CoinGecko API"""
+        try:
+            # البحث عن ID العملة أولاً
+            search_url = f"https://api.coingecko.com/api/v3/search?query={symbol}"
+            async with httpx.AsyncClient(timeout=15) as client:
+                response = await client.get(search_url)
+                if response.status_code != 200:
+                    return None
+                
+                data = response.json()
+                coins = data.get('coins', [])
+                
+                if not coins:
+                    return None
+                
+                # أخذ أفضل نتيجة مطابقة
+                best_coin = coins[0]
+                coin_id = best_coin.get('id')
+                
+                if not coin_id:
+                    return None
+                
+                # جلب تفاصيل العملة
+                detail_url = f"https://api.coingecko.com/api/v3/coins/{coin_id}"
+                detail_response = await client.get(detail_url)
+                if detail_response.status_code != 200:
+                    return None
+                
+                detail_data = detail_response.json()
+                
+                # البحث عن عناوين العقود في المنصات المختلفة
+                platforms = detail_data.get('platforms', {})
+                
+                # إعطاء الأولوية لـ Ethereum ثم BSC ثم Polygon
+                for platform in ['ethereum', 'binance-smart-chain', 'polygon-pos']:
+                    if platform in platforms and platforms[platform]:
+                        address = platforms[platform]
+                        if address and len(address) == 42:  # تأكيد أن العنوان صالح
+                            print(f"✅ تم العثور على عنوان {symbol} على {platform}: {address}")
+                            # تحديد الشبكة المناسبة للرمز
+                            network_map = {
+                                'ethereum': 'ethereum',
+                                'binance-smart-chain': 'bsc', 
+                                'polygon-pos': 'polygon'
+                            }
+                            self.symbol_networks[symbol] = network_map.get(platform, 'ethereum')
+                            return address
+                
+                return None
+                
+        except Exception as e:
+            print(f"❌ فشل البحث عن عقد {symbol} عبر CoinGecko: {e}")
+            return None
+
+    async def _save_contracts_to_r2(self):
+        """حفظ قاعدة بيانات العقود إلى R2"""
+        try:
+            key = "contracts_database.json"
+            data_json = json.dumps(self.contracts_db, indent=2).encode('utf-8')
+            self.r2_service.s3_client.put_object(
+                Bucket="trading", Key=key, Body=data_json, ContentType="application/json"
+            )
+            print(f"✅ تم حفظ {len(self.contracts_db)} عقد في R2")
+        except Exception as e:
+            print(f"❌ فشل حفظ العقود في R2: {e}")
+
+    async def get_symbol_specific_whale_data(self, symbol, contract_address=None):
+        try:
+            print(f"🔍 جلب بيانات الحيتان لـ {symbol}...")
+            base_symbol = symbol.split("/")[0] if '/' in symbol else symbol
+            
+            # البحث عن عنوان العقد إذا لم يتم توفيره
+            if not contract_address:
+                contract_address = await self._find_contract_address_enhanced(base_symbol)
+            
+            if not contract_address:
+                print(f"⚠️ لم يتم العثور على عنوان عقد لـ {symbol}")
+                return await self._scan_networks_for_symbol(symbol, base_symbol)
+            
+            # تحديد الشبكة المناسبة للبحث
+            network = self.symbol_networks.get(base_symbol, 'ethereum')
+            print(f"🔍 البحث في شبكة {network} للرمز {symbol}")
+            
+            api_data = await self._get_combined_api_data(contract_address, network)
+            
+            if api_data:
+                enriched_data = await self._enrich_api_data_with_timing(api_data)
+                result = self._analyze_symbol_specific_data(enriched_data, symbol)
+                print(f"✅ تم تحليل بيانات الحيتان لـ {symbol}: {result.get('transfer_count', 0)} تحويل")
+                return result
+            else:
+                print(f"⚠️ لا توجد بيانات API لـ {symbol}")
+                return await self._scan_networks_for_symbol(symbol, base_symbol)
+                
+        except Exception as e:
+            print(f"❌ فشل جلب بيانات الحيتان لـ {symbol}: {e}")
+            return {
+                'data_available': False,
+                'description': f'غير متوفر - خطأ في جلب بيانات الحيتان',
+                'total_volume': 0,
+                'transfer_count': 0,
+                'source': 'error'
+            }
+
+    async def _get_combined_api_data(self, contract_address, network='ethereum'):
+        tasks = []
+        
+        # استخدام APIs المتاحة فقط
+        if self.moralis_key and self._is_valid_moralis_key():
+            tasks.append(self._get_moralis_token_data(contract_address, network))
+        
+        if self.etherscan_key and network == 'ethereum':
+            tasks.append(self._get_etherscan_token_data_v2(contract_address))
+        
+        if not tasks:
+            print("⚠️ لا توجد مفاتيح API متاحة لجلب بيانات الرموز")
+            return await self._get_rpc_token_data(contract_address, network)
+            
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        
+        all_transfers = []
+        for res in results:
+            if isinstance(res, list):
+                all_transfers.extend(res)
+        
+        if not all_transfers:
+            print("⚠️ فشل جميع APIs، استخدام RPC كبديل")
+            return await self._get_rpc_token_data(contract_address, network)
+                
+        print(f"✅ تم جمع {len(all_transfers)} تحويل من APIs")
+        return all_transfers
+
+    def _is_valid_moralis_key(self):
+        """التحقق من أن مفتاح Moralis صالح"""
+        if not self.moralis_key:
+            return False
+        return len(self.moralis_key) >= 20
+
+    async def _get_rpc_token_data(self, contract_address, network='ethereum'):
+        try:
+            print(f"🔍 استخدام RPC لجلب بيانات العقد {contract_address} على شبكة {network}")
+            
+            endpoint = self._get_next_rpc_endpoint(network)
+            if not endpoint:
+                print(f"❌ لا توجد نقاط RPC متاحة لـ {network}")
+                return []
+                
+            transfers = []
+            
+            payload = {"jsonrpc": "2.0", "method": "eth_blockNumber", "params": [], "id": 1}
+            async with httpx.AsyncClient(timeout=15.0) as client:
+                response = await client.post(endpoint, json=payload)
+                if response.status_code != 200:
+                    return []
+                
+                result = response.json().get('result')
+                if not result:
+                    return []
+                
+                latest_block = int(result, 16)
+            
+            # مسح آخر 50 كتلة
+            for block_offset in range(50):
+                block_number = latest_block - block_offset
+                if block_number < 0:
+                    break
+                    
+                payload = {"jsonrpc": "2.0", "method": "eth_getBlockByNumber", "params": [hex(block_number), True], "id": 1}
+                async with httpx.AsyncClient(timeout=15.0) as client:
+                    response = await client.post(endpoint, json=payload)
+                    if response.status_code != 200:
+                        continue
+                    
+                    block_data = response.json().get('result')
+                    if not block_data:
+                        continue
+                    
+                    for tx in block_data.get('transactions', []):
+                        if tx.get('to', '').lower() == contract_address.lower() and tx.get('input', '0x') != '0x':
+                            transfers.append({
+                                'hash': tx.get('hash'),
+                                'from': tx.get('from'),
+                                'to': tx.get('to'),
+                                'value': str(int(tx.get('value', '0x0'), 16)),
+                                'timeStamp': str(int(block_data.get('timestamp', '0x0'), 16)),
+                                'blockNumber': str(block_number)
+                            })
+            
+            print(f"✅ تم جمع {len(transfers)} تحويل من RPC")
+            return transfers
+            
+        except Exception as e:
+            print(f"❌ فشل جلب بيانات RPC: {e}")
+            return []
 
     async def _get_etherscan_token_data_v2(self, contract_address):
         if not self.etherscan_key:
+            print("⚠️ مفتاح Etherscan غير متوفر")
             return []
             
         try:
@@ -443,11 +1083,14 @@ class EnhancedWhaleMonitor:
                 response = await client.get(base_url, params=params)
                 
                 if response.status_code == 429:
+                    print("⏰ تجاوز حد المعدل في Etherscan")
                     await asyncio.sleep(2)
                     return []
                 elif response.status_code == 401:
+                    print("❌ خطأ في مصادقة Etherscan - المفتاح غير صالح")
                     return []
                 elif response.status_code >= 500:
+                    print(f"❌ خطأ في خادم Etherscan: {response.status_code}")
                     return []
                 
                 response.raise_for_status()
@@ -458,13 +1101,20 @@ class EnhancedWhaleMonitor:
                     print(f"✅ تم جلب {len(result)} تحويل من Etherscan")
                     return result
                 else:
+                    error_msg = data.get('result', data.get('message', 'Unknown error'))
+                    print(f"⚠️ استجابة غير متوقعة من Etherscan: {error_msg}")
                     return []
                     
+        except httpx.HTTPStatusError as e:
+            print(f"❌ خطأ HTTP في Etherscan: {e}")
+            return []
         except Exception as e:
+            print(f"❌ خطأ عام في Etherscan: {e}")
             return []
 
     async def _get_moralis_token_data(self, contract_address, network='ethereum'):
         if not self.moralis_key or not self._is_valid_moralis_key():
+            print("⚠️ مفتاح Moralis غير متوفر أو غير صالح")
             return []
             
         try:
@@ -481,6 +1131,7 @@ class EnhancedWhaleMonitor:
             
             chain_id = chains.get(network)
             if not chain_id:
+                print(f"⚠️ شبكة {network} غير مدعومة في Moralis")
                 return []
             
             all_transfers = []
@@ -504,18 +1155,23 @@ class EnhancedWhaleMonitor:
                         all_transfers.extend(result)
                         print(f"✅ تم جلب {len(result)} تحويل من Moralis ({network})")
                     elif response.status_code == 401:
+                        print(f"❌ خطأ في مصادقة Moralis - المفتاح غير صالح")
                         return []
                     elif response.status_code == 404:
+                        print(f"⚠️ لم يتم العثور على بيانات للعقد {contract_address} على {network}")
                         return []
                     else:
+                        print(f"⚠️ استجابة غير ناجحة من Moralis لـ {network}: {response.status_code}")
                         return []
                         
-            except Exception:
+            except Exception as chain_error:
+                print(f"❌ خطأ في Moralis لـ {network}: {chain_error}")
                 return []
             
             return all_transfers
                 
         except Exception as e:
+            print(f"❌ خطأ عام في Moralis: {e}")
             return []
 
     async def _enrich_api_data_with_timing(self, api_data):
@@ -546,375 +1202,142 @@ class EnhancedWhaleMonitor:
                 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:
-                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))
-                if value > 1e15:
-                    value = value / 1e18
-                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
-            
-            if transfer_count > 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
-            else:
-                time_range_hours = 0
-            
-            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'] if transfer_count > 0 else None,
-                '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 _scan_networks_for_symbol(self, symbol, base_symbol):
-        networks_to_scan = ['ethereum', 'bsc', 'polygon']
-        
-        for network in networks_to_scan:
-            try:
-                if self.data_manager:
-                    native_price = await self.data_manager.get_native_coin_price(network)
-                    if native_price:
-                        print(f"✅ تم اكتشاف {symbol} على شبكة {network}")
-                        return {
-                            'data_available': True,
-                            'description': f'تم اكتشاف {symbol} على شبكة {network}',
-                            'network': network,
-                            'native_coin_price': native_price,
-                            'source': 'network_scan'
-                        }
-            except Exception as e:
-                continue
-        
-        return {
-            'data_available': False,
-            'description': f'غير متوفر - لم يتم العثور على {symbol} على أي شبكة',
-            'source': 'not_found'
-        }
-
-    async def _call_rpc_async(self, network, method, params=[]):
-        max_retries = 3
-        
-        for attempt in range(max_retries):
-            endpoint = self._get_next_rpc_endpoint(network)
-            if not endpoint:
-                return None
-                
-            try:
-                payload = {"jsonrpc": "2.0", "method": method, "params": params, "id": 1}
-                timeout = 25.0 if method == 'eth_getBlockByNumber' else 12.0
-                
-                async with httpx.AsyncClient(timeout=timeout) as client:
-                    response = await client.post(endpoint, json=payload)
-                    
-                    if response.status_code in [401, 429]:
-                        continue
-                        
-                    response.raise_for_status()
-                    result = response.json().get('result')
-                    
-                    self.rpc_failures[network] = 0
-                    return result
-                    
-            except Exception as e:
-                self.rpc_failures[network] += 1
-                
-            if attempt < max_retries - 1:
-                await asyncio.sleep(1 * (attempt + 1))
-        
-        return None
-
-    def _get_next_rpc_endpoint(self, network):
-        if network not in self.rpc_endpoints:
-            return None
-            
-        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
-
-    def _update_api_usage_stats(self, api_name):
-        now = datetime.now()
-        current_date = now.date()
-        
-        if api_name not in self.api_usage_stats:
-            self.api_usage_stats[api_name] = {
-                'requests_today': 0,
-                'requests_per_second': 0,
-                'last_request_time': time.time(),
-                'last_reset': current_date
-            }
-        
-        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
-
-    async def _api_rate_limit_delay(self, api_name):
-        if api_name not in self.api_usage_stats:
-            return False
-            
-        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)
-                await asyncio.sleep(delay)
-            
-            if stats['requests_today'] > 95000:
-                return True
-        
-        elif api_name == 'infura':
-            if stats['requests_per_second'] > 90:
-                delay = 0.1 * (stats['requests_per_second'] - 90)
-                await asyncio.sleep(delay)
-            
-            if stats['requests_today'] > 99000:
-                return True
-        
-        elif api_name == 'moralis':
-            if stats['requests_per_second'] > 4:
-                delay = 0.2 * (stats['requests_per_second'] - 4)
-                await asyncio.sleep(delay)
-            
-            if stats['requests_today'] > 95000:
-                return True
-        
-        return False
-
-    async def get_general_whale_activity(self):
-        try:
-            print("🔍 بدء مسح نشاط الحيتان العام...")
-            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 i, res in enumerate(results):
-                if isinstance(res, tuple) and len(res) == 2:
-                    alerts, signals = res
-                    all_alerts.extend(alerts)
-                    all_signals.extend(signals)
-                    successful_networks += 1
-                else:
-                    continue
+                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
 
-            all_alerts.sort(key=lambda x: x['timestamp'], reverse=True)
+    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 = []
             
-            total_volume = sum(alert['value_usd'] for alert in all_alerts)
-            alert_count = len(all_alerts)
+            for transfer in enriched_data:
+                value = float(transfer.get('value', 0))
+                if value > 1e15:  # تحويل من wei إلى ether
+                    value = value / 1e18
+                volumes.append(value)
+                
+                if value > 10000:  # تحويل كبير
+                    large_transfers.append(transfer)
             
-            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
+            total_volume = sum(volumes)
+            transfer_count = len(volumes)
+            avg_volume = total_volume / transfer_count if transfer_count > 0 else 0
             
-            if not all_alerts:
-                result = {
-                    'data_available': False,
-                    'description': 'غير متوفر - لم يتم اكتشاف نشاط حيتان كبير',
-                    'critical_alert': False, 
-                    'sentiment': 'UNKNOWN',
-                    'total_volume_usd': 0, 
-                    'transaction_count': 0,
-                    'networks_scanned': successful_networks,
-                    'trading_signals': all_signals,
-                    'netflow_analysis': {
-                        'inflow_to_exchanges': 0,
-                        'outflow_from_exchanges': 0,
-                        'net_flow': 0,
-                        'flow_direction': 'BALANCED'
-                    }
-                }
-                return result
+            if transfer_count > 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
+            else:
+                time_range_hours = 0
             
-            if net_exchange_flow < -1000000:
-                sentiment = 'BEARISH'
-            elif net_exchange_flow < -500000:
-                sentiment = 'SLIGHTLY_BEARISH'
-            elif net_exchange_flow > 1000000:
-                sentiment = 'BULLISH'
-            elif net_exchange_flow > 500000:
-                sentiment = 'SLIGHTLY_BULLISH'
+            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:
-                sentiment = 'NEUTRAL'
-                
-            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
-            )
-
-            result = {
-                'data_available': True, 
-                'description': f"تم اكتشاف {alert_count} معاملة حوت بإجمالي ${total_volume:,.0f}",
-                'critical_alert': critical_alert, 
-                'sentiment': sentiment,
-                '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'
-                },
-                'recent_alerts': all_alerts[:10],
-                'trading_signals': all_signals,
-                'networks_scanned': successful_networks
-            }
+                activity_level = 'LOW'
+                description = f"نشاط حيتان منخفض لـ {symbol}: {len(large_transfers)} تحويل كبير"
             
-            return result
+            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'] if transfer_count > 0 else None,
+                'time_range_hours': time_range_hours,
+                'source': 'api_combined',
+                'recent_large_transfers': large_transfers[:5]
+            }
             
         except Exception as e:
-            print(f"❌ فشل مراقبة الحيتان العامة: {e}")
+            print(f"❌ خطأ في تحليل بيانات {symbol}: {e}")
             return {
                 'data_available': False,
-                'description': f'غير متوفر - فشل في مراقبة الحيتان',
-                'critical_alert': False, 
-                'sentiment': 'UNKNOWN',
-                'total_volume_usd': 0, 
-                'transaction_count': 0,
-                'trading_signals': []
+                'description': f'غير متوفر - خطأ في تحليل البيانات',
+                'total_volume': 0,
+                'transfer_count': 0,
+                'source': 'error'
             }
 
-    async def _scan_single_evm_network(self, network):
-        whale_alerts = []
-        trading_signals = []
+    async def _scan_networks_for_symbol(self, symbol, base_symbol):
+        networks_to_scan = ['ethereum', 'bsc', 'polygon']
         
-        try:
-            if not self.data_manager:
-                return [], []
-                
-            price_usd = await self.data_manager.get_native_coin_price(network)
-            if price_usd is None:
-                return [], []
+        for network in networks_to_scan:
+            try:
+                if self.data_manager:
+                    native_price = await self.data_manager.get_native_coin_price(network)
+                    if native_price:
+                        print(f"✅ تم اكتشاف {symbol} على شبكة {network} - سعر {network.upper()}: ${native_price:.2f}")
+                        return {
+                            'data_available': True,
+                            'description': f'تم اكتشاف {symbol} على شبكة {network}',
+                            'network': network,
+                            'native_coin_price': native_price,
+                            'source': 'network_scan'
+                        }
+            except Exception as e:
+                print(f"⚠️ فشل مسح شبكة {network} لـ {symbol}: {e}")
+                continue
+        
+        print(f"❌ لم يت�� العثور على {symbol} على أي شبكة")
+        return {
+            'data_available': False,
+            'description': f'غير متوفر - لم يتم العثور على {symbol} على أي شبكة',
+            'source': 'not_found'
+        }
 
-            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
-            
-            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
+    def get_api_usage_stats(self):
+        stats = {}
+        
+        for api_name, api_stats in self.api_usage_stats.items():
+            if api_name == 'etherscan':
+                daily_limit = 100000
+                per_second_limit = 5
+            elif api_name == 'infura':
+                daily_limit = 100000
+                per_second_limit = 100
+            elif api_name == 'moralis':
+                daily_limit = 100000
+                per_second_limit = 5
+            else:
+                continue
                 
-                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', '')
-                            
-                            whale_alerts.append({
-                                'network': network, 
-                                'value_usd': value_usd,
-                                'from': from_address,
-                                'to': to_address,
-                                'hash': tx.get('hash', ''),
-                                'block_number': block_number,
-                                'timestamp': int(block_data.get('timestamp', '0x0'), 16)
-                            })
-                            
-                await asyncio.sleep(0.1)
-                    
-            return whale_alerts, trading_signals
-                    
-        except Exception as e:
-            return [], []
+            stats[api_name] = {
+                'requests_today': api_stats['requests_today'],
+                'requests_per_second': api_stats['requests_per_second'],
+                'daily_limit_remaining': daily_limit - api_stats['requests_today'],
+                'usage_percentage': (api_stats['requests_today'] / daily_limit) * 100,
+                'per_second_usage_percentage': (api_stats['requests_per_second'] / per_second_limit) * 100,
+                'last_reset': api_stats['last_reset'].isoformat(),
+                'api_available': getattr(self, f'{api_name}_key') is not None
+            }
+        
+        return stats
 
     def _calculate_whale_activity_score(self, whale_data):
         if not whale_data.get('data_available', False):
@@ -957,53 +1380,87 @@ class EnhancedWhaleMonitor:
                 signal.update({
                     'action': 'STRONG_BUY',
                     'confidence': min(0.9, whale_score),
-                    'reason': f'نشاط حيتان قوي: {transfer_count} تحويل بإجمالي ${total_volume:,.0f}'
+                    'reason': f'نشاط حيتان قوي: {transfer_count} تحويل بإجمالي ${total_volume:,.0f}',
+                    'critical_alert': total_volume > 1000000
                 })
             elif whale_score > 0.2 and total_volume > 100000:
                 signal.update({
                     'action': 'BUY',
                     'confidence': min(0.7, whale_score),
-                    'reason': f'نشاط حيتان متوسط: {transfer_count} تحويل بإجمالي ${total_volume:,.0f}'
+                    'reason': f'نشاط حيتان متوسط: {transfer_count} تحويل بإجمالي ${total_volume:,.0f}',
+                    'critical_alert': False
                 })
             else:
                 signal.update({
                     'action': 'HOLD',
                     'confidence': 0.5,
-                    'reason': f'نشاط حيتان طبيعي: {transfer_count} تحويل'
+                    'reason': f'نشاط حيتان طبيعي: {transfer_count} تحويل',
+                    'critical_alert': False
                 })
             
             return signal
             
         except Exception as e:
+            print(f"❌ خطأ في توليد إشارة الحيتان: {e}")
             return None
 
-    def get_api_usage_stats(self):
-        stats = {}
+    async def track_pattern_outcome(self, symbol, pattern_analysis, success, profit_percent):
+        if not pattern_analysis:
+            return
         
-        for api_name, api_stats in self.api_usage_stats.items():
-            if api_name == 'etherscan':
-                daily_limit = 100000
-                per_second_limit = 5
-            elif api_name == 'infura':
-                daily_limit = 100000
-                per_second_limit = 100
-            elif api_name == 'moralis':
-                daily_limit = 100000
-                per_second_limit = 5
-            else:
-                continue
-                
-            stats[api_name] = {
-                'requests_today': api_stats['requests_today'],
-                'requests_per_second': api_stats['requests_per_second'],
-                'daily_limit_remaining': daily_limit - api_stats['requests_today'],
-                'usage_percentage': (api_stats['requests_today'] / daily_limit) * 100,
-                'api_available': getattr(self, f'{api_name}_key') is not None
-            }
+        pattern_name = pattern_analysis.get('pattern_detected')
+        confidence = pattern_analysis.get('pattern_confidence', 0)
         
-        return stats
+        if pattern_name not in ['no_clear_pattern', 'insufficient_data']:
+            if pattern_name not in self.pattern_performance:
+                self.pattern_performance[pattern_name] = {
+                    'total_trades': 0,
+                    'successful_trades': 0,
+                    'total_profit': 0,
+                    'total_confidence': 0,
+                    'last_updated': datetime.now().isoformat()
+                }
+            
+            stats = self.pattern_performance[pattern_name]
+            stats['total_trades'] += 1
+            stats['total_confidence'] += confidence
+            stats['last_updated'] = datetime.now().isoformat()
+            
+            if success:
+                stats['successful_trades'] += 1
+                stats['total_profit'] += profit_percent
+
+            if stats['total_trades'] > 0:
+                self.pattern_success_rates[pattern_name] = {
+                    'success_rate': stats['successful_trades'] / stats['total_trades'],
+                    'avg_profit': stats['total_profit'] / stats['total_trades'],
+                    'total_trades': stats['total_trades'],
+                    'last_updated': datetime.now().isoformat()
+                }
+            
+            if stats['total_trades'] % 10 == 0:
+                await self._save_pattern_performance()
+
+            print(f"✅ تم تحديث أداء النمط {pattern_name}: {stats['successful_trades']}/{stats['total_trades']} نجاح")
+
+    def get_pattern_reliability(self, pattern_name):
+        if pattern_name in self.pattern_success_rates:
+            return self.pattern_success_rates[pattern_name]['success_rate']
+        return 0.5
+
+    async def save_all_pattern_data(self):
+        await self._save_pattern_performance()
+
+    def get_pattern_performance_summary(self):
+        return {
+            'pattern_performance': self.pattern_performance,
+            'pattern_success_rates': self.pattern_success_rates,
+            'total_patterns_tracked': len(self.pattern_performance),
+            'last_updated': datetime.now().isoformat()
+        }
 
     async def cleanup(self):
         await self.http_client.aclose()
+        print("✅ تم تنظيف موارد EnhancedWhaleMonitor")
 
 print("✅ EnhancedWhaleMonitor loaded - Real-time whale activity monitoring ready")