Update whale_monitor/core.py

whale_monitor/core.py

@@ -1,6 +1,6 @@
 # whale_monitor/core.py
-# (V3.2 - GEM-Architect: Enterprise Edition - Full Logic Restored)
-# يتضمن: Web3 Engine, Solscan Fixes, Complex Analysis Windows, R2 Learning, & Robust Fallbacks.
+# (V3.3 - GEM-Architect: Enterprise Edition - Smart Web3 Limits)
+# يتضمن: Web3 Engine, Smart Retry for Limits, Solscan Fixes, & Full Logic.
 
 import os
 import asyncio
@@ -12,7 +12,7 @@ from datetime import datetime, timedelta, timezone
 from collections import defaultdict, deque
 import logging
 import ssl
-from typing import List, Dict, Any, Optional
+from typing import List, Dict, Any
 
 # Web3 Integration
 from web3 import AsyncWeb3
@@ -32,17 +32,14 @@ logging.getLogger("web3").setLevel(logging.WARNING)
 
 class EnhancedWhaleMonitor:
     def __init__(self, contracts_db=None, r2_service=None):
-        print("🔄 [WhaleMonitor V3.2] Initializing Enterprise Engine...")
+        print("🔄 [WhaleMonitor V3.3] Initializing Enterprise Engine...")
         
-        # 1. الخدمات الخارجية
         self.r2_service = r2_service
-        self.data_manager = None # سيتم تعيينه لاحقاً
-        self.rpc_manager: AdaptiveRpcManager = None # سيتم حقنه
+        self.data_manager = None 
+        self.rpc_manager: AdaptiveRpcManager = None
 
-        # 2. إعدادات الحدود
         self.whale_threshold_usd = DEFAULT_WHALE_THRESHOLD_USD
         
-        # 3. قواعد البيانات الداخلية و Caches
         self.contracts_db = {}
         self._initialize_contracts_db(contracts_db or {})
         
@@ -53,14 +50,12 @@ class EnhancedWhaleMonitor:
         self.token_price_cache = {}
         self.token_decimals_cache = {}
 
-        # 4. تحميل العقود من R2 (إن وجد)
         if self.r2_service:
             asyncio.create_task(self._load_contracts_from_r2())
         
-        print("✅ [WhaleMonitor V3.2] System Ready (Waiting for RPC Manager injection).")
+        print("✅ [WhaleMonitor V3.3] System Ready.")
 
     def set_rpc_manager(self, rpc_manager: AdaptiveRpcManager):
-        """حقن مدير الاتصالات المركزي"""
         self.rpc_manager = rpc_manager
         print("✅ [WhaleMonitor] RPC Manager Linked.")
 
@@ -69,7 +64,6 @@ class EnhancedWhaleMonitor:
     # ==============================================================================
     
     def _initialize_contracts_db(self, initial_contracts):
-        print("🔄 [WhaleMonitor] Initializing contracts DB...")
         for symbol, contract_data in initial_contracts.items():
             symbol_lower = symbol.lower()
             if isinstance(contract_data, dict) and 'address' in contract_data and 'network' in contract_data:
@@ -79,89 +73,57 @@ class EnhancedWhaleMonitor:
                     'address': contract_data,
                     'network': self._detect_network_from_address(contract_data)
                 }
-        print(f"✅ [WhaleMonitor] Loaded {len(self.contracts_db)} contracts.")
 
     def _detect_network_from_address(self, address):
         if not isinstance(address, str): return 'ethereum'
         address_lower = address.lower()
-        # Basic Heuristics
         if address_lower.startswith('0x') and len(address_lower) == 42:
-             return 'ethereum' # Default to EVM
-        # Solana Check (Base58 assumption)
+             return 'ethereum'
         if len(address) > 30 and not address.startswith('0x'):
              return 'solana'
         return 'ethereum'
 
     def _initialize_comprehensive_exchange_addresses(self):
-        """تهيئة قاعدة بيانات العناوين المعروفة لتصنيف التدفقات"""
-        count = 0
         for category, addresses in DEFAULT_EXCHANGE_ADDRESSES.items():
             for address in addresses:
                 if not isinstance(address, str): continue
                 addr_lower = address.lower()
                 self.address_labels[addr_lower] = category
                 self.address_categories['exchange'].add(addr_lower)
-                
                 if category in ['uniswap', 'pancakeswap', 'sushiswap']:
                     self.address_categories['dex'].add(addr_lower)
                 elif 'wormhole' in category or 'bridge' in category:
                      self.address_categories['bridge'].add(addr_lower)
                 else:
                     self.address_categories['cex'].add(addr_lower)
-                count += 1
-        print(f"✅ [WhaleMonitor] Indexed {count} exchange/bridge addresses.")
 
     async def _load_contracts_from_r2(self):
         if not self.r2_service: return
         try:
             key = "contracts.json"
-            # (محاكاة للكود الأصلي للتعامل مع R2)
             if hasattr(self.r2_service, 's3_client'):
                 response = self.r2_service.s3_client.get_object(Bucket="trading", Key=key)
                 contracts_data = json.loads(response['Body'].read())
-                # Merge logic...
                 for s, d in contracts_data.items():
                     if s.lower() not in self.contracts_db:
                         self.contracts_db[s.lower()] = d
-                print(f"✅ [WhaleMonitor] Synced contracts from R2.")
-        except Exception as e:
-            print(f"⚠️ [WhaleMonitor] R2 Sync skipped: {e}")
-
-    async def _save_contracts_to_r2(self):
-        if not self.r2_service: return
-        try:
-            key = "contracts.json"
-            # Logic to save...
-            pass 
         except Exception: pass
 
     # ==============================================================================
-    # 🧠 Core Analysis Logic (The "Brain")
+    # 🧠 Core Analysis Logic
     # ==============================================================================
 
     async def get_symbol_whale_activity(self, symbol: str, known_price: float = 0.0) -> Dict[str, Any]:
-        """
-        الوظيفة الرئيسية (Enterprise Logic):
-        1. التحقق من العملة.
-        2. جلب العقد والكسور العشرية.
-        3. جلب البيانات (Gather 1).
-        4. التحليل عبر نوافذ متعددة (Analyze N).
-        5. تسجيل النتائج للتعلم (R2).
-        """
         try:
-            start_time = time.time()
             if not self.rpc_manager:
                 return self._create_error_response(symbol, "RPC Manager Not Injected")
 
-            # 1. Reset Stats
             self.rpc_manager.reset_session_stats()
             
-            # 2. Native Check
             base_symbol = symbol.split("/")[0].upper() if '/' in symbol else symbol.upper()
             if base_symbol in NATIVE_COINS:
                 return self._create_native_coin_response(symbol)
             
-            # 3. Contract & Network
             contract_info = await self._find_contract_address_enhanced(symbol)
             if not contract_info or not contract_info.get('address'):
                 return self._create_no_contract_response(symbol)
@@ -169,10 +131,8 @@ class EnhancedWhaleMonitor:
             contract_address = contract_info['address']
             network = contract_info['network']
             
-            # 4. Price & Decimals (CRITICAL FIX: Use known_price if available)
             current_price = known_price
             if current_price <= 0:
-                print(f"⚠️ [Whale] Price missing for {symbol}. Attempting fallback fetch...")
                 current_price = await self._get_token_price(symbol)
             
             if current_price <= 0:
@@ -182,8 +142,7 @@ class EnhancedWhaleMonitor:
             if decimals is None:
                 return self._create_error_response(symbol, f"Decimals missing on {network}")
 
-            # 5. Data Gathering (Gather 1 - Deep Scan)
-            # نطلب 24 ساعة للتحليل الكامل، لكن يمكن تقليلها لـ 4 ساعات للقنص
+            # [CONFIG] Scan window
             scan_hours = 4 
             all_transfers = await self._get_targeted_transfer_data(
                 contract_address, network, hours=scan_hours, price=current_price, decimals=decimals
@@ -194,10 +153,7 @@ class EnhancedWhaleMonitor:
 
             print(f"📊 [WhaleMonitor] Analyzed {symbol}: {len(all_transfers)} transfers found ({scan_hours}h).")
 
-            # 6. Multi-Window Analysis (Analyze N)
-            # هذا هو المنطق المعقد الذي طلبته (تحليل النوافذ)
             analysis_windows = [
-                {'name': '30m', 'minutes': 30},
                 {'name': '1h', 'minutes': 60},
                 {'name': '4h', 'minutes': 240},
                 {'name': '24h', 'minutes': 1440}
@@ -211,31 +167,25 @@ class EnhancedWhaleMonitor:
                 window_name = window['name']
                 cutoff_ts = timestamp_cutoff_base - (window['minutes'] * 60)
                 
-                # تصفية التحويلات لهذه النافذة
                 window_transfers = [
                     t for t in all_transfers 
                     if float(t.get('timeStamp', 0)) >= cutoff_ts
                 ]
                 
-                # التحليل العميق
                 analysis_result = self._analyze_transfer_list(
                     symbol=symbol,
                     transfers=window_transfers,
-                    daily_volume_usd=0 # يمكن جلبه إذا توفر
+                    daily_volume_usd=0 
                 )
                 multi_window_analysis[window_name] = analysis_result
 
-            # 7. Learning Record (R2)
-            # تسجيل البيانات لاستخدامها لاحقاً في تدريب النماذج
             if self.r2_service:
                 asyncio.create_task(self._save_learning_record(
                     symbol, current_price, multi_window_analysis, self.rpc_manager.get_session_stats()
                 ))
 
-            # 8. Final Response Construction
-            # نستخدم نافذة 1h للقرار اللحظي، و 24h للسياق العام
             short_term = multi_window_analysis.get('1h', {})
-            long_term = multi_window_analysis.get('4h', {}) # أو 24h
+            long_term = multi_window_analysis.get('4h', {})
             
             signal = self._generate_enhanced_trading_signal(short_term)
             llm_summary = self._create_enhanced_llm_summary(signal, short_term)
@@ -249,48 +199,41 @@ class EnhancedWhaleMonitor:
                     'whale_count_1h': short_term.get('whale_transfers_count', 0),
                     'net_flow_1h': short_term.get('net_flow_usd', 0)
                 },
-                'exchange_flows': short_term,      # النموذج يحتاج هذا
-                'accumulation_analysis_24h': long_term, # النموذج يحتاج هذا
+                'exchange_flows': short_term,      
+                'accumulation_analysis_24h': long_term, 
                 'trading_signal': signal,
                 'llm_friendly_summary': llm_summary
             }
 
         except Exception as e:
-            print(f"❌ [WhaleMonitor] Critical Error {symbol}: {e}")
+            # print(f"❌ [WhaleMonitor] Critical Error {symbol}: {e}")
             traceback.print_exc()
             return self._create_error_response(symbol, str(e))
 
     # ==============================================================================
-    # 🕵️‍♂️ Data Fetching & Web3 Logic (Robust & Fixed)
+    # 🕵️‍♂️ Data Fetching & Web3 Logic (Smart Limits)
     # ==============================================================================
 
     async def _get_targeted_transfer_data(self, contract_address: str, network: str, hours: int, price: float, decimals: int) -> List[Dict]:
-        """
-        المحرك الرئيسي لجلب البيانات.
-        يستخدم الآن Web3 بشكل أساسي للشبكات المدعومة (EVM)، و Solscan لـ Solana.
-        مع الاحتفاظ بالـ Fallbacks.
-        """
         all_transfers = []
         
-        # A. Solana Logic (Solscan API)
+        # A. Solana Logic
         if network == 'solana':
-            print(f"   🌊 [Solana] Fetching via Solscan...")
             try:
-                # [FIXED] استخدام المسار الصحيح /v2.0/token/transfer
                 transfers = await self._get_solscan_token_data(contract_address, hours, price)
                 if transfers: return transfers
             except Exception as e:
                 print(f"   ⚠️ [Solana] Solscan failed: {e}")
-            return [] # No Web3 fallback for Solana yet
+            return []
 
-        # B. EVM Logic (Web3 -> Moralis -> Scanners)
-        # 1. Web3 Direct (Fastest & Most Reliable for recent blocks)
+        # B. EVM Logic
+        # 1. Web3 Direct (with Smart Retry)
         try:
             print(f"   ⚡ [Web3] Scanning {network} logs...")
             web3_transfers = await self._get_web3_transfers(contract_address, network, hours, price, decimals)
             if web3_transfers:
                 print(f"     ✅ [Web3] Found {len(web3_transfers)} transfers.")
-                return web3_transfers # إذا نجح Web3، نكتفي به للسرعة
+                return web3_transfers 
         except Exception as e:
             print(f"     ⚠️ [Web3] Failed: {e}. Trying fallbacks...")
 
@@ -300,46 +243,57 @@ class EnhancedWhaleMonitor:
             if chain_id:
                 print(f"   🛡️ [Moralis] Fallback scan...")
                 moralis_transfers = await self._get_moralis_token_data(contract_address, chain_id, hours, price, decimals)
-                if moralis_transfers:
-                    return moralis_transfers
+                if moralis_transfers: return moralis_transfers
         except Exception: pass
 
-        # 3. Scanners Fallback (Etherscan etc.)
+        # 3. Scanners Fallback
         try:
             print(f"   🔍 [Scanner] Fallback scan...")
             scanner_transfers = await self._get_scanner_token_data(contract_address, network, hours, price, decimals)
-            if scanner_transfers:
-                return scanner_transfers
+            if scanner_transfers: return scanner_transfers
         except Exception: pass
 
         return []
 
-    # --- Web3 Implementation ---
     async def _get_web3_transfers(self, address: str, network: str, hours: int, price: float, decimals: int):
+        """Web3 Fetcher with Limit Exceeded Handling"""
         w3 = self.rpc_manager.get_web3(network)
         if not w3: raise Exception(f"No Web3 provider for {network}")
         
-        # Calculate blocks
         latest = await w3.eth.block_number
-        # Approx block times
         block_time = 3 if network == 'bsc' else 12 if network == 'ethereum' else 2
+        
+        # محاولة أولية لكامل المدة
         blocks_back = int((hours * 3600) / block_time)
         from_block = max(0, latest - blocks_back)
         
         contract = w3.eth.contract(address=w3.to_checksum_address(address), abi=ERC20_ABI)
         
-        # Fetch Logs (Standard ERC20 Transfer)
-        logs = await w3.eth.get_logs({
-            'fromBlock': from_block,
-            'toBlock': 'latest',
-            'address': w3.to_checksum_address(address),
-            'topics': [TRANSFER_EVENT_SIGNATURE]
-        })
+        try:
+            # المحاولة الأولى
+            logs = await w3.eth.get_logs({
+                'fromBlock': from_block, 'toBlock': 'latest',
+                'address': w3.to_checksum_address(address),
+                'topics': [TRANSFER_EVENT_SIGNATURE]
+            })
+        except Exception as e:
+            # [SMART RETRY] إذا فشل بسبب الحد، قلل المدة للربع (1 ساعة)
+            err_str = str(e).lower()
+            if 'limit' in err_str or 'range' in err_str or 'exceeded' in err_str:
+                print(f"     ⚠️ [Web3] Range too big. Retrying with 1 hour window...")
+                blocks_back = int((1 * 3600) / block_time) # 1 hour
+                from_block = max(0, latest - blocks_back)
+                logs = await w3.eth.get_logs({
+                    'fromBlock': from_block, 'toBlock': 'latest',
+                    'address': w3.to_checksum_address(address),
+                    'topics': [TRANSFER_EVENT_SIGNATURE]
+                })
+            else:
+                raise e # خطأ آخر لا يمكن التعامل معه
         
         transfers = []
         for log in logs:
             try:
-                # Parsing
                 if len(log['topics']) < 3: continue
                 val_hex = log['data'].hex()
                 val_int = int(val_hex, 16)
@@ -347,36 +301,27 @@ class EnhancedWhaleMonitor:
                 amount = val_int / (10 ** decimals)
                 val_usd = amount * price
                 
-                if val_usd < self.whale_threshold_usd: continue # Filter small tx
+                # استخدام حد أدنى 20k للمضاربة السريعة
+                if val_usd < 20000.0: continue 
                 
-                # Extract addresses
                 from_addr = '0x' + log['topics'][1].hex()[-40:]
                 to_addr = '0x' + log['topics'][2].hex()[-40:]
                 
-                # Timestamp (Optimization: Don't fetch block time for every tx if possible, 
-                # but for accuracy we might need to batch fetch or approximate)
-                # Here we simply use current time approx for speed or fetch if critical
-                # For high speed, we mark 'timeStamp' as unknown or fetch block timestamp in batches.
-                # For now, let's assume valid logs are within our window.
-                
                 transfers.append({
                     'hash': log['transactionHash'].hex(),
                     'from': from_addr,
                     'to': to_addr,
                     'value_usd': val_usd,
-                    'timeStamp': time.time(), # Placeholder, real impl needs block time
+                    'timeStamp': time.time(), 
                     'network': network,
                     'source': 'web3'
                 })
             except: continue
         return transfers
 
-    # --- Solscan Implementation (Fixed) ---
     async def _get_solscan_token_data(self, address: str, hours: int, price: float):
-        # [FIXED] Using /v2.0/token/transfer
         params = {"address": address, "limit": 50} 
         data = await self.rpc_manager.get_solscan_api("/v2.0/token/transfer", params)
-        
         if not data or not data.get('data'): return []
         
         transfers = []
@@ -388,10 +333,10 @@ class EnhancedWhaleMonitor:
                 if ts < cutoff: continue
                 
                 amount_raw = int(tx.get('amount', 0))
-                dec = tx.get('decimals', 9) # Default SOL decimals
-                
+                dec = tx.get('decimals', 9)
                 val_usd = (amount_raw / (10**dec)) * price
-                if val_usd < self.whale_threshold_usd: continue
+                
+                if val_usd < 20000.0: continue
                 
                 transfers.append({
                     'hash': tx.get('signature'),
@@ -405,9 +350,7 @@ class EnhancedWhaleMonitor:
             except: continue
         return transfers
 
-    # --- Moralis Implementation ---
     async def _get_moralis_token_data(self, address, chain, hours, price, decimals):
-        # ... (نفس المنطق السابق مع استخدام rpc_manager.get_moralis_api)
         params = {
             "chain": chain, "contract_address": address, 
             "order": "DESC", "limit": 100
@@ -419,7 +362,7 @@ class EnhancedWhaleMonitor:
         for tx in data['result']:
             try:
                 val = int(tx['value']) / (10**decimals) * price
-                if val < self.whale_threshold_usd: continue
+                if val < 20000.0: continue
                 transfers.append({
                     'hash': tx['transaction_hash'],
                     'from': tx['from_address'],
@@ -431,7 +374,6 @@ class EnhancedWhaleMonitor:
             except: continue
         return transfers
 
-    # --- Scanner Implementation ---
     async def _get_scanner_token_data(self, address, network, hours, price, decimals):
         config = self.rpc_manager.get_explorer_config(network)
         if not config: return []
@@ -448,7 +390,7 @@ class EnhancedWhaleMonitor:
         for tx in data['result']:
             try:
                 val = int(tx['value']) / (10**decimals) * price
-                if val < self.whale_threshold_usd: continue
+                if val < 20000.0: continue
                 transfers.append({
                     'hash': tx['hash'],
                     'from': tx['from'],
@@ -461,25 +403,18 @@ class EnhancedWhaleMonitor:
         return transfers
 
     # ==============================================================================
-    # 🕵️‍♂️ Contract Finding (Fixed 404)
+    # 🕵️‍♂️ Contract Finding & Search
     # ==============================================================================
 
     async def _find_contract_address_enhanced(self, symbol: str):
         base_symbol = symbol.split('/')[0].lower()
-        
-        # 1. Local Cache
-        if base_symbol in self.contracts_db:
-            return self.contracts_db[base_symbol]
+        if base_symbol in self.contracts_db: return self.contracts_db[base_symbol]
             
-        # 2. CoinGecko Search (FIXED: Use /search endpoint)
         print(f"   🔍 Searching CoinGecko for {base_symbol}...")
         try:
-            # [FIXED] استخدام المسار الصحيح /search
             data = await self.rpc_manager.get_coingecko_api('/search', params={'query': base_symbol})
-            
             if not data or not data.get('coins'): return None
             
-            # Find best match
             best_id = None
             for coin in data['coins']:
                 if coin['symbol'].lower() == base_symbol:
@@ -487,7 +422,6 @@ class EnhancedWhaleMonitor:
                     break
             if not best_id: best_id = data['coins'][0]['id']
             
-            # 3. Get Details
             details = await self.rpc_manager.get_coingecko_api(f'/coins/{best_id}', params={
                 "localization": "false", "tickers": "false", "market_data": "false", 
                 "community_data": "false", "developer_data": "false"
@@ -496,29 +430,22 @@ class EnhancedWhaleMonitor:
             if not details or 'platforms' not in details: return None
             
             platforms = details['platforms']
-            priority_nets = ['binance-smart-chain', 'polygon-pos', 'ethereum', 'arbitrum-one', 'optimistic-ethereum', 'solana', 'avalanche']
-            mapping = {'binance-smart-chain': 'bsc', 'polygon-pos': 'polygon', 'ethereum': 'ethereum', 'arbitrum-one': 'arbitrum', 'optimistic-ethereum': 'optimism', 'solana': 'solana', 'avalanche': 'avalanche'}
+            priority_nets = ['binance-smart-chain', 'polygon-pos', 'ethereum', 'solana', 'avalanche']
+            mapping = {'binance-smart-chain': 'bsc', 'polygon-pos': 'polygon', 'ethereum': 'ethereum', 'solana': 'solana', 'avalanche': 'avalanche'}
             
             for net_key in priority_nets:
                 if net_key in platforms and platforms[net_key]:
                     res = {'address': platforms[net_key], 'network': mapping[net_key]}
-                    self.contracts_db[base_symbol] = res # Cache it
-                    if self.r2_service: asyncio.create_task(self._save_contracts_to_r2())
+                    self.contracts_db[base_symbol] = res
                     return res
-                    
-        except Exception as e:
-            print(f"❌ [FindContract] Error: {e}")
-            
+        except Exception: pass
         return None
 
     # ==============================================================================
-    # 📐 Analysis Logic (The Math)
+    # 📐 Analysis Logic
     # ==============================================================================
 
     def _analyze_transfer_list(self, symbol: str, transfers: List[Dict], daily_volume_usd: float) -> Dict[str, Any]:
-        """
-        تحليل القائمة وحساب التدفقات (Logic Preserved)
-        """
         stats = {
             'to_exchanges_usd': 0.0, 'from_exchanges_usd': 0.0,
             'deposit_count': 0, 'withdrawal_count': 0,
@@ -530,8 +457,6 @@ class EnhancedWhaleMonitor:
             stats['whale_transfers_count'] += 1
             stats['total_volume'] += val
             
-            # Classification
-            # Simple Check first, then DB check
             to_addr = tx.get('to', '').lower()
             from_addr = tx.get('from', '').lower()
             
@@ -546,41 +471,25 @@ class EnhancedWhaleMonitor:
                 stats['withdrawal_count'] += 1
                 
         stats['net_flow_usd'] = stats['to_exchanges_usd'] - stats['from_exchanges_usd']
-        
-        # Derived Metrics
-        stats['relative_net_flow'] = 0.0
-        if daily_volume_usd > 0:
-            stats['relative_net_flow'] = (stats['net_flow_usd'] / daily_volume_usd) * 100
-            
         return stats
 
     def _generate_enhanced_trading_signal(self, analysis: Dict) -> Dict:
         net = analysis.get('net_flow_usd', 0)
         whales = analysis.get('whale_transfers_count', 0)
         
-        if whales < 3:
-            return {'action': 'HOLD', 'confidence': 0.1, 'reason': 'Low Activity'}
-            
-        if net > 1_000_000: # High Inflow -> Sell Pressure
-            return {'action': 'SELL', 'confidence': 0.8, 'reason': 'Major Exchange Inflow'}
-        elif net < -1_000_000: # High Outflow -> Buy Pressure
-            return {'action': 'BUY', 'confidence': 0.8, 'reason': 'Major Exchange Outflow'}
-            
+        if whales < 3: return {'action': 'HOLD', 'confidence': 0.1, 'reason': 'Low Activity'}
+        if net > 500_000: return {'action': 'SELL', 'confidence': 0.8, 'reason': 'Exchange Inflow'}
+        elif net < -500_000: return {'action': 'BUY', 'confidence': 0.8, 'reason': 'Exchange Outflow'}
         return {'action': 'WATCH', 'confidence': 0.5, 'reason': 'Mixed Activity'}
 
     def _create_enhanced_llm_summary(self, signal, analysis):
-        return {
-            'summary': f"Whale Activity: {analysis.get('whale_transfers_count')} txs.",
-            'action': signal['action'],
-            'metrics': analysis
-        }
+        return {'summary': f"Whales: {analysis.get('whale_transfers_count')}", 'action': signal['action']}
 
     # ==============================================================================
     # ⚙️ Helpers
     # ==============================================================================
 
     async def _get_token_price(self, symbol):
-        # Fallback only
         try:
             res = await self.rpc_manager.get_coingecko_api('/simple/price', 
                 params={'ids': COINGECKO_SYMBOL_MAPPING.get(symbol.split('/')[0], symbol), 'vs_currencies': 'usd'})
@@ -588,11 +497,9 @@ class EnhancedWhaleMonitor:
         except: return 0.0
 
     async def _get_token_decimals(self, address, network):
-        # Check cache
         key = f"{address}_{network}"
         if key in self.token_decimals_cache: return self.token_decimals_cache[key]
         
-        # Web3 Fetch
         try:
             w3 = self.rpc_manager.get_web3(network)
             if w3:
@@ -602,37 +509,19 @@ class EnhancedWhaleMonitor:
                 return dec
         except: pass
         
-        # Solscan Fetch
-        if network == 'solana':
-            return 9 # Default/Approx
-            
-        return 18 # EVM Default
+        if network == 'solana': return 9
+        return 18
 
     async def _save_learning_record(self, symbol, price, analysis, api_stats):
         if not self.r2_service: return
         try:
-            record = {
-                'id': f"{symbol}_{int(time.time())}",
-                'symbol': symbol,
-                'price': price,
-                'analysis': analysis,
-                'api_stats': api_stats,
-                'timestamp': datetime.now(timezone.utc).isoformat()
-            }
-            # (Assuming R2 Service has this method, or using S3 put directly)
-            if hasattr(self.r2_service, 'save_record'):
-                await self.r2_service.save_record(record)
+            record = {'id': f"{symbol}_{int(time.time())}", 'symbol': symbol, 'price': price, 'analysis': analysis, 'api_stats': api_stats, 'timestamp': datetime.now(timezone.utc).isoformat()}
+            if hasattr(self.r2_service, 'save_record'): await self.r2_service.save_record(record)
         except: pass
 
-    # Error Responses
-    def _create_error_response(self, symbol, err):
-        return {'symbol': symbol, 'data_available': False, 'error': err, 'trading_signal': {}}
-    def _create_native_coin_response(self, symbol):
-        return {'symbol': symbol, 'data_available': False, 'error': 'Native Coin', 'trading_signal': {}}
-    def _create_no_contract_response(self, symbol):
-        return {'symbol': symbol, 'data_available': False, 'error': 'No Contract', 'trading_signal': {}}
-    def _create_no_transfers_response(self, symbol):
-        return {'symbol': symbol, 'data_available': True, 'summary': {'total': 0}, 'trading_signal': {'action': 'HOLD'}}
-
-    async def cleanup(self):
-        print("🛑 [WhaleMonitor] Cleanup.")
+    def _create_error_response(self, symbol, err): return {'symbol': symbol, 'data_available': False, 'error': err, 'trading_signal': {}}
+    def _create_native_coin_response(self, symbol): return {'symbol': symbol, 'data_available': False, 'error': 'Native Coin', 'trading_signal': {}}
+    def _create_no_contract_response(self, symbol): return {'symbol': symbol, 'data_available': False, 'error': 'No Contract', 'trading_signal': {}}
+    def _create_no_transfers_response(self, symbol): return {'symbol': symbol, 'data_available': True, 'summary': {'total': 0}, 'trading_signal': {'action': 'HOLD'}}
+
+    async def cleanup(self): print("🛑 [WhaleMonitor] Cleanup.")