Update whale_monitor/rpc_manager.py

whale_monitor/rpc_manager.py

@@ -1,419 +1,451 @@
 # whale_monitor/rpc_manager.py
-# (V2.1 - إضافة دعم Solscan API)
-# هذا هو "الوكيل الذكي" لإدارة اتصالات RPC والمستكشفات (APIs)
-# يدير منظمات الطلبات (Rate Limiters) والإحصائيات
+# (V3.2 - GEM-Architect: Full Enterprise Edition)
+# يتضمن: Web3 Engine + Raw RPC Fallback + CSV Injection + Strict API Handling
 
 import asyncio
 import httpx
 import time
-import ssl
-import json
 import os
 import csv
-from collections import deque, defaultdict
+import json
 import random
-from typing import Dict, Any, Optional, List
+import traceback
+from collections import defaultdict, deque
+from typing import Dict, Any, Optional, List, Union
 
-# استيراد الإعدادات الثابتة
-from .config import DEFAULT_NETWORK_CONFIGS, COINGECKO_BASE_URL
+# Web3 Imports
+from web3 import AsyncWeb3
+from web3.providers import AsyncHTTPProvider
+from web3.middleware import async_geth_poa_middleware
 
-# إعدادات الوكيل الذكي
-RPC_HEALTH_CHECK_WINDOW = 10  # تتبع آخر 10 طلبات
-RPC_ERROR_THRESHOLD = 3       # عدد الأخطاء المتتالية لإيقاف مؤقت
-RPC_CIRCUIT_BREAKER_DURATION = 300 # 5 دقائق إيقاف مؤقت
+# Local Imports
+from .config import DEFAULT_NETWORK_CONFIGS, COINGECKO_BASE_URL
 
-# (إضافة ثابت لفرض تأخير بين طلبات CoinGecko)
-COINGECKO_REQUEST_DELAY = 2.0  # 2.0 ثانية (يساوي 30 طلب/دقيقة كحد أقصى)
+# --- Constants & Limits ---
+# التأكد من عدم الحظر من قبل API العامة
+RPC_HEALTH_CHECK_WINDOW = 15
+RPC_ERROR_THRESHOLD = 5
+RPC_CIRCUIT_BREAKER_DURATION = 300  # 5 Minutes
+COINGECKO_REQUEST_DELAY = 1.6       # Safety margin for free tier
+MORALIS_RATE_LIMIT = 1.0            # 1 req/sec
+SOLSCAN_RATE_LIMIT = 0.5            # 2 req/sec
 
-# (تحديد المسار الحالي لملف rpc_manager.py)
+# Paths
 _CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))
-# (تحديد مسار ملف CSV داخل نفس المجلد)
 CUSTOM_RPC_CSV_FILE = os.path.join(_CURRENT_DIR, 'rpc_endpoints (1).csv')
 
 class AdaptiveRpcManager:
     """
-    (محدث V2.1)
-    مدير RPC و API ذكي:
-    1. يدير صحة نقاط RPC العامة (Public).
-    2. يدير منظمات الطلبات (Rate Limiters) للمفاتيح الخاصة (Infura, Moralis, Scanners, Solscan).
-    3. يتتبع إحصائيات الجلسة (Session Stats) لجميع الطلبات.
+    مدير الاتصالات المركزي (Central Connection Manager).
+    يدير:
+    1. نقاط Web3 للاتصال المباشر بالعقود (EVM).
+    2. طلبات HTTP RPC الخام (Raw JSON-RPC) كاحتياطي.
+    3. واجهات API الخارجية (CoinGecko, Solscan, Moralis, Scanners).
+    4. تحميل ودمج نقاط اتصال مخصصة من CSV.
     """
+
     def __init__(self, http_client: httpx.AsyncClient):
+        print("🔄 [RPCManager V3.2] Initializing Enterprise Connection Engine...")
         self.http_client = http_client
         
-        # 1. تحميل المفاتيح الخاصة من متغيرات البيئة
+        # 1. Load Secure Keys
         self.api_keys = {
             "infura": os.getenv("INFURA_KEY"),
             "moralis": os.getenv("MORALIS_KEY"),
             "etherscan": os.getenv("ETHERSCAN_KEY"),
             "bscscan": os.getenv("BSCSCAN_KEY"),
             "polygonscan": os.getenv("POLYGONSCAN_KEY"),
-            # 🔴 --- START OF CHANGE (V2.1) --- 🔴
-            "solscan": os.getenv("SOLSCAN_KEY"), # (إضافة مفتاح Solscan)
-            # 🔴 --- END OF CHANGE --- 🔴
+            "solscan": os.getenv("SOLSCAN_KEY"),
         }
-        print("✅ [RPCManager V2.1] تم تحميل المفاتيح الخاصة من البيئة.")
-
-        # 2. تهيئة منظمات الطلبات (Semaphores)
-        
-        # لـ Infura (500 credits/sec) - سنستخدم 450 كحد أمان
-        self.infura_semaphore = asyncio.Semaphore(450)
         
-        # لـ Moralis (40k/day ~ 0.46/sec) - سنستخدم 1 لضمان طلب واحد في كل مرة
-        self.moralis_semaphore = asyncio.Semaphore(1)
-        
-        # لـ Etherscan, BscScan, PolygonScan (الحد المشترك 5/sec)
-        self.scanner_semaphore = asyncio.Semaphore(5)
-
-        # 🔴 --- START OF CHANGE (V2.1) --- 🔴
-        # لـ Solscan (1000 reqs/60 sec ~ 16.6/sec) - سنستخدم 15 كحد أمان
-        self.solscan_semaphore = asyncio.Semaphore(15)
-        # 🔴 --- END OF CHANGE --- 🔴
-        
-        # لـ CoinGecko (عام، سنكون حذرين)
-        self.coingecko_semaphore = asyncio.Semaphore(1)
-        
-        # لـ مجمع RPC العام (Public Pool) (لحمايتهم من الضغط)
-        self.public_rpc_semaphore = asyncio.Semaphore(10)
+        # 2. Rate Limiting Semaphores (Concurreny Control)
+        self.semaphores = {
+            'coingecko': asyncio.Semaphore(1),       # Strict Serial
+            'solscan': asyncio.Semaphore(5),         # Parallel allowed
+            'moralis': asyncio.Semaphore(2),         # Limited parallel
+            'scanners': asyncio.Semaphore(5),        # Shared limit for Etherscan clones
+            'infura': asyncio.Semaphore(20),         # High throughput
+            'public_rpc': asyncio.Semaphore(10),     # Protected
+        }
 
-        self.last_coingecko_call = 0.0
-        self.last_moralis_call = 0.0
-        
-        # 3. تهيئة إحصائيات الجلسة
+        # 3. Timing & Stats Trackers
+        self.last_calls = defaultdict(float)
         self.session_stats = defaultdict(int)
         
-        # 4. تهيئة إعدادات الشبكة ونقاط RPC
-        self.network_configs = self._initialize_network_configs(DEFAULT_NETWORK_CONFIGS)
-        
-        # 5. نظام تتبع الصحة (فقط لنقاط RPC العامة)
+        # 4. Health Monitoring System
         self.endpoint_health = defaultdict(lambda: defaultdict(lambda: {
             "latency": deque(maxlen=RPC_HEALTH_CHECK_WINDOW),
-            "consecutive_errors": 0, "total_errors": 0, "last_error_time": None,
-            "circuit_open": False,
+            "errors": 0,
+            "last_error": 0.0,
+            "circuit_open": False
         }))
+
+        # 5. Load Configurations & Custom CSV
+        self.network_configs = self._initialize_full_network_configs()
         
-        print("✅ [RPCManager V2.1] مدير RPC/API الذكي (V2.1) مهيأ.")
-        
+        # 6. Web3 Engine Cache
+        self.web3_instances = {}
+
+        print(f"✅ [RPCManager V3.2] System Ready. Tracking {len(self.network_configs)} networks.")
+
+    # ==============================================================================
+    # 🛠️ Initialization & Config Loading (Full Logic)
+    # ==============================================================================
+
     def _load_rpc_from_csv(self, csv_file_path: str) -> Dict[str, List[str]]:
-        """
-        (جديد V2)
-        قراءة ملف rpc_endpoints (1).csv ودمج النقاط.
-        يتوقع الملف أن يحتوي على عمودين: 'network' و 'url'
-        """
+        """قراءة ملف CSV للنقاط الخاصة ودمجها."""
         custom_rpcs = defaultdict(list)
         if not os.path.exists(csv_file_path):
-            print(f"⚠️ [RPCManager V2] ملف CSV المخصص '{csv_file_path}' غير موجود. سيتم تخطيه.")
+            print(f"⚠️ [RPCManager] CSV file missing at: {csv_file_path}")
             return custom_rpcs
             
         try:
-            with open(csv_file_path, mode='r', encoding='utf-8') as f:
+            with open(csv_file_path, mode='r', encoding='utf-8-sig') as f: # utf-8-sig handles BOM
                 reader = csv.DictReader(f)
+                count = 0
                 for row in reader:
-                    network = row.get('network')
-                    url = row.get('url')
-                    if network and url and url.startswith('http'):
-                        custom_rpcs[network].append(url)
-            print(f"✅ [RPCManager V2] تم تحميل {sum(len(v) for v in custom_rpcs.values())} نقطة RPC مخصصة من {csv_file_path}")
+                    # التنظيف والتحقق
+                    net = row.get('network', '').strip().lower()
+                    url = row.get('url', '').strip()
+                    
+                    if net and url and url.startswith(('http://', 'https://')):
+                        custom_rpcs[net].append(url)
+                        count += 1
+            
+            print(f"   📂 [CSV Load] Successfully loaded {count} custom endpoints.")
             return custom_rpcs
         except Exception as e:
-            print(f"❌ [RPCManager V2] فشل في قراءة ملف CSV '{csv_file_path}': {e}")
+            print(f"❌ [CSV Load] Critical Error parsing CSV: {e}")
             return defaultdict(list)
 
-    def _initialize_network_configs(self, configs):
-        """
-        (محدث V2.1)
-        يقوم بدمج CSV، وحقن مفاتيح API، وإعداد الشبكات.
-        """
-        initialized_configs = {}
-        
-        # 1. تحميل نقاط CSV المخصصة
+    def _initialize_full_network_configs(self) -> Dict[str, Any]:
+        """بناء تكوين الشبكة الكامل بدمج الافتراضيات + المفاتيح + CSV"""
+        configs = DEFAULT_NETWORK_CONFIGS.copy()
         custom_rpcs = self._load_rpc_from_csv(CUSTOM_RPC_CSV_FILE)
-        
+        infura_key = self.api_keys.get('infura')
+
+        final_configs = {}
+
         for network, config in configs.items():
+            # Deep Copy لتجنب تعديل الافتراضيات
             new_config = config.copy()
+            current_endpoints = new_config.get('rpc_endpoints', [])
             
-            # 2. حقن مفاتيح Infura
-            new_config['rpc_endpoints'] = self._inject_api_keys(
-                config['rpc_endpoints'], 
-                self.api_keys.get('infura')
-            )
+            # 1. معالجة Infura Keys
+            processed_endpoints = []
+            for ep in current_endpoints:
+                if "<INFURA_KEY>" in ep:
+                    if infura_key:
+                        processed_endpoints.append(ep.replace("<INFURA_KEY>", infura_key))
+                    # else: skip infura endpoint if no key
+                else:
+                    processed_endpoints.append(ep)
             
-            # 3. دمج نقاط CSV
+            # 2. إضافة نقاط CSV (في المقدمة للأولوية)
             if network in custom_rpcs:
-                new_config['rpc_endpoints'].extend(custom_rpcs[network])
-                print(f"   ... دمج {len(custom_rpcs[network])} نقاط مخصصة لشبكة {network}")
+                csv_points = custom_rpcs[network]
+                print(f"   ➕ [Config] Injecting {len(csv_points)} custom RPCs for {network}")
+                processed_endpoints = csv_points + processed_endpoints
+            
+            # 3. إزالة التكرار والحفاظ على الترتيب
+            unique_endpoints = []
+            seen = set()
+            for ep in processed_endpoints:
+                if ep not in seen:
+                    unique_endpoints.append(ep)
+                    seen.add(ep)
+            
+            # 4. خلط عشوائي جزئي (للنقاط العامة فقط) لضمان توزيع الحمل
+            # ملاحظة: نحافظ على أول نقطة إذا كانت من CSV غالباً
+            if len(unique_endpoints) > 1:
+                first = unique_endpoints[0]
+                rest = unique_endpoints[1:]
+                random.shuffle(rest)
+                unique_endpoints = [first] + rest
 
-            # 4. خلط القائمة النهائية (لضمان التوزيع)
-            random.shuffle(new_config['rpc_endpoints'])
+            new_config['rpc_endpoints'] = unique_endpoints
             
-            # 5. حقن مفاتيح المستكشف (Explorer)
+            # 5. حقن مفاتيح المستكشفات (Explorers)
             if config.get('explorer'):
-                explorer_key_name = config['explorer'].get('api_key_name')
-                if explorer_key_name and explorer_key_name in self.api_keys:
-                    new_config['explorer']['api_key'] = self.api_keys[explorer_key_name]
-                else:
-                    new_config['explorer']['api_key'] = None # مفتاح غير متوفر
+                key_name = config['explorer'].get('api_key_name')
+                if key_name and key_name in self.api_keys:
+                    new_config['explorer']['api_key'] = self.api_keys[key_name]
+            
+            final_configs[network] = new_config
             
-            initialized_configs[network] = new_config
-        return initialized_configs
+        return final_configs
 
-    def _inject_api_keys(self, endpoints: list, infura_key: str):
+    # ==============================================================================
+    # ⚡ Web3 Engine (High Performance)
+    # ==============================================================================
+
+    def get_web3(self, network: str) -> Optional[AsyncWeb3]:
         """
-        يستبدل <INFURA_KEY> بالمفتاح الفعلي.
+        إرجاع مثيل Web3 حيوي للشبكة.
+        يستخدم Cache، وإذا فشل يقوم بتدوير النقاط.
         """
-        if not infura_key:
-            # إزالة النقاط التي تعتمد على مفتاح غير متوفر
-            return [ep for ep in endpoints if "<INFURA_KEY>" not in ep]
-        
-        return [ep.replace("<INFURA_KEY>", infura_key) for ep in endpoints]
-
-    # --- (دوال مساعدة للحصول على الإعدادات) ---
-    
-    def get_network_configs(self):
-        return self.network_configs
-
-    def get_explorer_config(self, network: str):
-        config = self.network_configs.get(network, {})
-        return config.get('explorer')
-
-    def get_api_key(self, key_name: str) -> Optional[str]:
-        """(جديد V2) جلب مفتاح API بأمان"""
-        return self.api_keys.get(key_name)
-
-    # --- (دوال إدارة الإحصائيات V2) ---
-    
-    def reset_session_stats(self):
-        """(جديد V2) تصفير عدادات الإحصائيات للجلسة الجديدة"""
-        self.session_stats = defaultdict(int)
-        print("📊 [RPCManager V2.1] تم تصفير عدادات إحصائيات الجلسة.")
+        config = self.network_configs.get(network)
+        if not config or config.get('type') != 'evm':
+            return None
+            
+        # التحقق من الكاش
+        if network in self.web3_instances:
+            # هنا يمكن إضافة فحص صحة الاتصال (isConnected) إذا لزم الأمر
+            return self.web3_instances[network]
+            
+        endpoints = config['rpc_endpoints']
+        if not endpoints:
+            print(f"❌ [Web3] No endpoints available for {network}")
+            return None
 
-    def get_session_stats(self) -> Dict[str, int]:
-        """(جديد V2) إرجاع نسخة من الإحصائيات الحالية"""
-        return self.session_stats.copy()
+        # محاولة الاتصال (نختار أفضل نقطة متاحة)
+        # في بيئة الإنتاج، نفضل النقطة الأولى (التي قد تكون Private Node من CSV)
+        endpoint = endpoints[0]
+        
+        try:
+            provider = AsyncHTTPProvider(endpoint, request_kwargs={'timeout': 20.0})
+            w3 = AsyncWeb3(provider)
+            
+            # إضافة Middleware للشبكات التي تحتاج POA (مثل BSC, Polygon)
+            if network in ['bsc', 'polygon', 'avalanche', 'fantom']:
+                w3.middleware_onion.inject(async_geth_poa_middleware, layer=0)
+            
+            self.web3_instances[network] = w3
+            print(f"   🔌 [Web3] Connected to {network} via {endpoint.split('//')[-1][:20]}...")
+            return w3
+        except Exception as e:
+            print(f"❌ [Web3] Failed to initialize {network}: {e}")
+            return None
 
-    # --- (دوال الصحة لـ Public RPCs - لا تغيير) ---
+    # ==============================================================================
+    # 🌐 Raw HTTP RPC (Legacy & Fallback Support)
+    # ==============================================================================
 
-    def _get_healthy_public_endpoints(self, network: str):
+    async def post_rpc(self, network: str, payload: dict, timeout: float = 20.0) -> Optional[Dict]:
         """
-        (معدل V2)
-        يرتب نقاط RPC العامة (فقط) بناءً على الصحة.
+        إرسال طلب JSON-RPC خام عبر HTTP.
+        ضروري للوظائف التي لا تغطيها Web3 أو عند فشل Web3.
+        يدعم نظام Circuit Breaker والصحة.
         """
-        if network not in self.network_configs: return []
+        config = self.network_configs.get(network)
+        if not config: return None
+        
+        endpoints = config['rpc_endpoints']
+        valid_endpoints = self._get_healthy_endpoints(network, endpoints)
+        
+        if not valid_endpoints:
+            print(f"❌ [Raw RPC] No healthy endpoints for {network}")
+            return None
             
-        endpoints = self.network_configs[network]['rpc_endpoints']
-        healthy_endpoints = []
-        current_time = time.time()
+        # المحاولة مع أفضل 3 نقاط
+        for endpoint in valid_endpoints[:3]:
+            ep_name = endpoint.split('//')[-1]
+            
+            # تحديد Semaphore المناسب
+            semaphore = self.semaphores['infura'] if 'infura.io' in endpoint else self.semaphores['public_rpc']
+            
+            async with semaphore:
+                start_time = time.time()
+                try:
+                    response = await self.http_client.post(endpoint, json=payload, timeout=timeout)
+                    response.raise_for_status()
+                    data = response.json()
+                    
+                    # تحديث الصحة
+                    latency = time.time() - start_time
+                    self._update_health(network, endpoint, True, latency)
+                    self.session_stats['rpc_raw_success'] += 1
+                    
+                    return data
+                    
+                except Exception as e:
+                    self._update_health(network, endpoint, False, 0.0)
+                    self.session_stats['rpc_raw_fail'] += 1
+                    # print(f"⚠️ [Raw RPC] Fail {ep_name}: {str(e)}") # سجل صامت لتفادي الإزعاج
+                    continue
+        
+        return None
+
+    def _get_healthy_endpoints(self, network: str, endpoints: List[str]) -> List[str]:
+        """تصفية وترتيب النقاط بناءً على الصحة والأخطاء السابقة"""
+        now = time.time()
+        healthy = []
         
         for ep in endpoints:
-            # (تخطي Infura، هذا المجمع للعام فقط)
-            if "infura.io" in ep:
-                continue
-                
-            health = self.endpoint_health[network][ep]
-            if health['circuit_open']:
-                if current_time - health['last_error_time'] > RPC_CIRCUIT_BREAKER_DURATION:
-                    health['circuit_open'] = False; health['consecutive_errors'] = 0
+            stats = self.endpoint_health[network][ep]
+            
+            # التحقق من قاطع الدائرة (Circuit Breaker)
+            if stats['circuit_open']:
+                if now - stats['last_error'] > RPC_CIRCUIT_BREAKER_DURATION:
+                    stats['circuit_open'] = False
+                    stats['errors'] = 0
                 else:
-                    continue # ��لنقطة لا تزال معطلة مؤقتاً
+                    continue # تجاوز هذه النقطة
             
-            avg_latency = sum(health['latency']) / len(health['latency']) if health['latency'] else float('inf')
-            healthy_endpoints.append((ep, avg_latency, health['consecutive_errors']))
-
-        healthy_endpoints.sort(key=lambda x: (x[2], x[1]))
-        
-        # (فصل السليم تماماً عن غير السليم)
-        healthy_list = [ep[0] for ep in healthy_endpoints if ep[2] == 0]
-        random.shuffle(healthy_list) # خلط السليم للتوزيع
-        unhealthy_list = [ep[0] for ep in healthy_endpoints if ep[2] > 0]
-        
-        return healthy_list + unhealthy_list
+            # حساب متوسط التأخير (Latency Score)
+            avg_lat = sum(stats['latency']) / len(stats['latency']) if stats['latency'] else 1.0
+            healthy.append((ep, avg_lat))
+            
+        # الترتيب حسب الأسرع
+        healthy.sort(key=lambda x: x[1])
+        return [h[0] for h in healthy]
 
     def _update_health(self, network: str, endpoint: str, success: bool, latency: float):
-        """(لا تغيير) تحديث إحصائيات صحة نقطة RPC العامة."""
-        health = self.endpoint_health[network][endpoint]
+        stats = self.endpoint_health[network][endpoint]
         if success:
-            health['latency'].append(latency)
-            health['consecutive_errors'] = 0
-            health['circuit_open'] = False
+            stats['latency'].append(latency)
+            stats['errors'] = 0
+            stats['circuit_open'] = False
         else:
-            health['consecutive_errors'] += 1; health['total_errors'] += 1
-            health['last_error_time'] = time.time()
-            if health['consecutive_errors'] >= RPC_ERROR_THRESHOLD:
-                health['circuit_open'] = True
-                print(f"🚨 [RPCManager V2.1] قاطع الدائرة مفعل (عام)! إيقاف مؤقت لـ: {endpoint.split('//')[-1]}")
+            stats['errors'] += 1
+            stats['last_error'] = time.time()
+            if stats['errors'] >= RPC_ERROR_THRESHOLD:
+                stats['circuit_open'] = True
+                print(f"🚨 [RPC Breaker] Endpoint suspended: {endpoint.split('//')[-1]}")
 
-    # --- (دوال الاتصال الأساسية V2.1 - محدثة بالكامل) ---
+    # ==============================================================================
+    # 🌍 External APIs (CoinGecko, Solscan, Moralis)
+    # ==============================================================================
 
-    async def post_rpc(self, network: str, payload: dict, timeout: float = 20.0):
+    async def get_coingecko_api(self, path: str, params: dict, retries: int = 1) -> Optional[Dict]:
         """
-        (محدث V2)
-        إرسال طلب POST (JSON-RPC)
-        سيحاول مع Infura أولاً (إذا كان متاحاً)، ثم يلجأ إلى المجمع العام.
+        التعامل الدقيق مع CoinGecko لتفادي 404 و 429.
         """
+        full_url = f"{COINGECKO_BASE_URL}{path}"
         
-        # 1. محاولة Infura أولاً (الأولوية)
-        infura_key = self.api_keys.get('infura')
-        infura_endpoint = next((ep for ep in self.network_configs.get(network, {}).get('rpc_endpoints', []) if "infura.io" in ep), None)
-        
-        if infura_key and infura_endpoint:
-            start_time = time.time()
-            try:
-                async with self.infura_semaphore:
-                    response = await self.http_client.post(infura_endpoint, json=payload, timeout=timeout)
-                    response.raise_for_status()
-                
-                self.session_stats['infura_success'] += 1
-                latency = time.time() - start_time
-                print(f"✅ [RPC Infura] {network} - {latency:.2f}s")
-                return response.json()
+        async with self.semaphores['coingecko']:
+            # Throttling
+            now = time.time()
+            diff = now - self.last_calls['coingecko']
+            if diff < COINGECKO_REQUEST_DELAY:
+                wait_time = COINGECKO_REQUEST_DELAY - diff
+                await asyncio.sleep(wait_time)
             
-            except Exception as e:
-                self.session_stats['infura_fail'] += 1
-                print(f"⚠️ [RPC Infura] فشل {network}: {type(e).__name__}. اللجوء إلى المجمع العام...")
+            for attempt in range(retries + 1):
+                try:
+                    self.session_stats['coingecko_total'] += 1
+                    response = await self.http_client.get(full_url, params=params)
+                    self.last_calls['coingecko'] = time.time()
+                    
+                    if response.status_code == 200:
+                        self.session_stats['coingecko_success'] += 1
+                        return response.json()
+                    
+                    elif response.status_code == 429: # Rate Limit
+                        wait = 10.0 * (attempt + 1)
+                        print(f"⚠️ [CoinGecko] Rate Limit (429). Waiting {wait}s...")
+                        await asyncio.sleep(wait)
+                        continue
+                        
+                    elif response.status_code == 404:
+                        # 404 تعني العملة غير موجودة أو المسار خطأ
+                        # لا نعتبرها خطأ اتصال، بل استجابة فارغة
+                        return None
+                        
+                    else:
+                        response.raise_for_status()
+                        
+                except Exception as e:
+                    self.session_stats['coingecko_fail'] += 1
+                    print(f"❌ [CoinGecko] Error: {e}")
+                    return None
+            return None
 
-        # 2. اللجوء إلى المجمع العام (Public Pool)
-        endpoints = self._get_healthy_public_endpoints(network)
-        if not endpoints:
-            print(f"❌ [RPCManager V2.1] لا توجد نقاط RPC عامة متاحة لشبكة {network}")
+    async def get_solscan_api(self, path: str, params: dict) -> Optional[Dict]:
+        """جلب بيانات Solscan مع التحقق من المفتاح"""
+        key = self.api_keys.get('solscan')
+        if not key:
+            # print("⚠️ [Solscan] Key missing. Request skipped.")
             return None
             
-        for endpoint in endpoints[:3]: # محاولة أفضل 3
-            start_time = time.time()
-            ep_name = endpoint.split('//')[-1].split('/')[0]
-            try:
-                async with self.public_rpc_semaphore:
-                    response = await self.http_client.post(endpoint, json=payload, timeout=timeout)
-                    response.raise_for_status()
+        base_url = "https://pro-api.solscan.io"
+        full_url = f"{base_url}{path}"
+        headers = {"token": key, "accept": "application/json"}
+        
+        async with self.semaphores['solscan']:
+            # Solscan Throttling
+            now = time.time()
+            if now - self.last_calls['solscan'] < SOLSCAN_RATE_LIMIT:
+                await asyncio.sleep(SOLSCAN_RATE_LIMIT)
                 
-                latency = time.time() - start_time
-                self._update_health(network, endpoint, success=True, latency=latency)
-                self.session_stats['public_rpc_success'] += 1
-                print(f"✅ [RPC Public] {network} ({ep_name}) - {latency:.2f}s")
-                return response.json()
+            try:
+                self.session_stats['solscan_total'] += 1
+                response = await self.http_client.get(full_url, params=params, headers=headers)
+                self.last_calls['solscan'] = time.time()
                 
+                if response.status_code == 200:
+                    self.session_stats['solscan_success'] += 1
+                    return response.json()
+                else:
+                    print(f"⚠️ [Solscan] Error {response.status_code}: {response.text}")
+                    return None
             except Exception as e:
-                latency = time.time() - start_time
-                self._update_health(network, endpoint, success=False, latency=latency)
-                self.session_stats['public_rpc_fail'] += 1
-                print(f"⚠️ [RPC Public] فشل {network} ({ep_name}): {type(e).__name__}")
-                continue
-
-        print(f"❌ [RPCManager V2.1] فشلت جميع محاولات RPC لشبكة {network}")
-        return None
+                self.session_stats['solscan_fail'] += 1
+                print(f"❌ [Solscan] Exception: {e}")
+                return None
 
-    async def get_scanner_api(self, base_url: str, params: dict, timeout: float = 15.0):
-        """
-        (جديد V2)
-        إجراء طلب GET لواجهات Scanners (Etherscan, BscScan, etc.)
-        يستخدم المنظم المشترك (5/ثانية).
-        """
-        self.session_stats['scanner_total'] += 1
-        try:
-            async with self.scanner_semaphore:
-                response = await self.http_client.get(base_url, params=params, headers=None, timeout=timeout)
-                response.raise_for_status()
-            self.session_stats['scanner_success'] += 1
-            return response.json()
-        except Exception as e:
-            self.session_stats['scanner_fail'] += 1
-            print(f"❌ [Scanner API] فشل الطلب من {base_url.split('//')[-1]}: {e}")
-            return None
-
-    # 🔴 --- START OF CHANGE (V2.1) --- 🔴
-    async def get_solscan_api(self, path: str, params: dict, timeout: float = 15.0):
-        """
-        (جديد V2.1)
-        إجراء طلب GET لـ Solscan Pro API.
-        يستخدم المنظم الخاص به (15/ثانية) ومفتاح API.
-        """
-        solscan_key = self.api_keys.get('solscan')
-        if not solscan_key:
-            print("❌ [Solscan API] لا يوجد مفتاح SOLSCAN_KEY.")
-            self.session_stats['solscan_fail_key'] += 1
-            return None
+    async def get_moralis_api(self, params: dict) -> Optional[Dict]:
+        """جلب بيانات Moralis"""
+        key = self.api_keys.get('moralis')
+        if not key: return None
         
-        base_url = self.network_configs.get('solana', {}).get('explorer', {}).get('api_url', 'https://pro-api.solscan.io')
-        full_url = f"{base_url}{path}"
-        headers = {"accept": "application/json", "token": solscan_key}
-        self.session_stats['solscan_total'] += 1
+        url = "https://deep-index.moralis.io/api/v2.2/erc20/transfers"
+        headers = {"X-API-Key": key, "accept": "application/json"}
         
-        try:
-            async with self.solscan_semaphore:
-                response = await self.http_client.get(full_url, params=params, headers=headers, timeout=timeout)
-                response.raise_for_status()
-            
-            self.session_stats['solscan_success'] += 1
-            return response.json()
-        except Exception as e:
-            self.session_stats['solscan_fail'] += 1
-            print(f"❌ [Solscan API] فشل الطلب من {path}: {e}")
-            return None
-    # 🔴 --- END OF CHANGE --- 🔴
-
-    async def get_moralis_api(self, base_url: str, params: dict, timeout: float = 20.0):
-        """
-        (جديد V2)
-        إجراء طلب GET لـ Moralis API.
-        يستخدم المنظم الخاص به (1/ثانية) ومفتاح API.
-        """
-        moralis_key = self.api_keys.get('moralis')
-        if not moralis_key:
-            print("❌ [Moralis API] لا يوجد مفتاح MORALIS_KEY.")
-            return None
-            
-        headers = {"accept": "application/json", "X-API-Key": moralis_key}
-        self.session_stats['moralis_total'] += 1
-        
-        try:
-            async with self.moralis_semaphore:
-                # (ضمان وجود ثانية واحدة على الأقل بين الطلبات لتوزيع 40k على اليوم)
-                current_time = time.time()
-                if current_time - self.last_moralis_call < 1.0:
-                    await asyncio.sleep(1.0 - (current_time - self.last_moralis_call))
-                self.last_moralis_call = time.time()
+        async with self.semaphores['moralis']:
+            now = time.time()
+            if now - self.last_calls['moralis'] < MORALIS_RATE_LIMIT:
+                await asyncio.sleep(MORALIS_RATE_LIMIT)
                 
-                response = await self.http_client.get(base_url, params=params, headers=headers, timeout=timeout)
-                response.raise_for_status()
+            try:
+                self.session_stats['moralis_total'] += 1
+                response = await self.http_client.get(url, params=params, headers=headers)
+                self.last_calls['moralis'] = time.time()
                 
-            self.session_stats['moralis_success'] += 1
-            return response.json()
-        except Exception as e:
-            self.session_stats['moralis_fail'] += 1
-            print(f"❌ [Moralis API] فشل الطلب: {e}")
-            return None
+                if response.status_code == 200:
+                    self.session_stats['moralis_success'] += 1
+                    return response.json()
+                return None
+            except Exception as e:
+                self.session_stats['moralis_fail'] += 1
+                return None
 
-    async def get_coingecko_api(self, params: dict, headers: dict = None, timeout: float = 15.0):
-        """
-        (معدل V2)
-        إجراء طلب GET لـ CoinGecko (يستخدم الآن إحصائيات ومنظم خاص).
-        """
-        base_url = COINGECKO_BASE_URL
-        self.session_stats['coingecko_total'] += 1
-        try:
-            async with self.coingecko_semaphore:
-                # (تطبيق "الخنق" لـ CoinGecko)
-                current_time = time.time()
-                time_since_last = current_time - self.last_coingecko_call
-                if time_since_last < COINGECKO_REQUEST_DELAY:
-                    wait_time = COINGECKO_REQUEST_DELAY - time_since_last
-                    await asyncio.sleep(wait_time)
-                self.last_coingecko_call = time.time()
-
-                response = await self.http_client.get(base_url, params=params, headers=headers, timeout=timeout)
-                
-                if response.status_code == 429: # Too Many Requests
-                    wait_duration = 15.0
-                    print(f"⚠️ [CoinGecko] خطأ 429 (Rate Limit). الانتظار {wait_duration} ثوان...")
-                    await asyncio.sleep(wait_duration)
-                    self.last_coingecko_call = time.time()
-                    response = await self.http_client.get(base_url, params=params, headers=headers, timeout=timeout)
+    async def get_scanner_api(self, base_url: str, params: dict) -> Optional[Dict]:
+        """Etherscan/BscScan compatible API calls"""
+        async with self.semaphores['scanners']:
+            try:
+                self.session_stats['scanner_total'] += 1
+                response = await self.http_client.get(base_url, params=params, timeout=15.0)
                 
-                response.raise_for_status()
-            
-            self.session_stats['coingecko_success'] += 1
-            return response.json()
-            
-        except Exception as e:
-            self.session_stats['coingecko_fail'] += 1
-            print(f"❌ [CoinGecko] فشل الطلب: {e}")
-            return None
+                if response.status_code == 200:
+                    self.session_stats['scanner_success'] += 1
+                    return response.json()
+                return None
+            except Exception as e:
+                self.session_stats['scanner_fail'] += 1
+                return None
+
+    # ==============================================================================
+    # 📊 Utilities
+    # ==============================================================================
+
+    def reset_session_stats(self):
+        self.session_stats = defaultdict(int)
+
+    def get_session_stats(self):
+        return self.session_stats.copy()
+
+    def get_api_key(self, name: str) -> Optional[str]:
+        return self.api_keys.get(name)
+    
+    def get_explorer_config(self, network: str) -> Optional[Dict]:
+        return self.network_configs.get(network, {}).get('explorer')
+
+    def get_network_configs(self) -> Dict:
+        return self.network_configs
+
+    async def close(self):
+        """Cleanup resources if needed"""
+        # Usually http_client is managed externally, but we can clear caches
+        self.web3_instances.clear()
+        print("🛑 [RPCManager] Shutting down connection engine.")