Upload backend/services/binance_dns_connector.py with huggingface_hub

backend/services/binance_dns_connector.py

@@ -1,448 +1,438 @@
 #!/usr/bin/env python3
 """
-Binance DNS Connector with Multi-Endpoint Failover
-Handles Binance API connections with automatic DNS-based failover across multiple mirror endpoints
+Binance + KuCoin DNS connector for Hugging Face / US-restricted egress.
+
+HTTP 451 on api.binance.com* is IP geo-block — NOT fixed by mirror hostnames alone.
+Strategy (in order):
+  1. data-api.binance.vision  (official public market data — works from US/HF)
+  2. data.binance.com
+  3. Standard api.binance.com mirrors
+  4. DoH direct-IP + Host header
+  5. KuCoin equivalent endpoints
+  6. Optional EXCHANGE_EGRESS_PROXY env (non-US proxy URL)
 """
 
-import httpx
-from typing import Optional, Dict, Any, List
+from __future__ import annotations
+
 import asyncio
 import logging
-from datetime import datetime
+import os
 import time
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+import httpx
+
+from backend.services.exchange_dns_resolver import ExchangeDNSResolver
 
 logger = logging.getLogger(__name__)
 
+# Official public market-data host first (bypasses US 451 on trading API)
+BINANCE_GLOBAL_ENDPOINTS = [
+    "https://data-api.binance.vision",
+    "https://data.binance.com",
+    "https://api.binance.com",
+    "https://api1.binance.com",
+    "https://api2.binance.com",
+    "https://api3.binance.com",
+    "https://api4.binance.com",
+]
+
+BINANCE_US_ENDPOINTS = ["https://api.binance.us"]
+
+KUCOIN_ENDPOINTS = [
+    "https://api.kucoin.com",
+    "https://api-futures.kucoin.com",
+]
+
+KUCOIN_INTERVAL_MAP = {
+    "1m": "1min",
+    "3m": "3min",
+    "5m": "5min",
+    "15m": "15min",
+    "30m": "30min",
+    "1h": "1hour",
+    "2h": "2hour",
+    "4h": "4hour",
+    "6h": "6hour",
+    "8h": "8hour",
+    "12h": "12hour",
+    "1d": "1day",
+    "1w": "1week",
+}
+
+
+def _binance_to_kucoin_symbol(symbol: str) -> str:
+    sym = symbol.upper().replace("/", "").replace("-", "")
+    for quote in ("USDT", "USDC", "BUSD", "USD"):
+        if sym.endswith(quote) and len(sym) > len(quote):
+            return f"{sym[:-len(quote)]}-{quote}"
+    return sym
+
+
+def _egress_proxy() -> Optional[str]:
+    return (os.getenv("EXCHANGE_EGRESS_PROXY") or os.getenv("BINANCE_PROXY_URL") or "").strip() or None
+
 
 class BinanceDNSConnector:
-    """
-    Binance API connector with DNS-based failover support
-    
-    Features:
-    - Multiple DNS endpoints for Binance global distribution
-    - Automatic failover on connection errors
-    - Health tracking per endpoint
-    - Round-robin with health-based selection
-    - Exponential backoff for failed endpoints
-    """
-    
-    # Multiple DNS entries for Binance (global distribution)
-    BINANCE_GLOBAL_ENDPOINTS = [
-        "https://api.binance.com",      # Primary (Global)
-        "https://api1.binance.com",     # Mirror 1
-        "https://api2.binance.com",     # Mirror 2
-        "https://api3.binance.com",     # Mirror 3
-        "https://api4.binance.com",     # Mirror 4 (if available)
-    ]
-    
-    BINANCE_US_ENDPOINTS = [
-        "https://api.binance.us",       # US users
-    ]
-    
-    def __init__(self, use_us: bool = False, timeout: float = 10.0):
-        """
-        Initialize Binance DNS connector
-        
-        Args:
-            use_us: If True, use Binance US endpoints
-            timeout: Request timeout in seconds
-        """
-        self.endpoints = self.BINANCE_US_ENDPOINTS if use_us else self.BINANCE_GLOBAL_ENDPOINTS
+    """Binance market-data connector with Vision-first routing and KuCoin fallback."""
+
+    def __init__(self, use_us: bool = False, timeout: float = 12.0) -> None:
+        self.endpoints = BINANCE_US_ENDPOINTS if use_us else list(BINANCE_GLOBAL_ENDPOINTS)
+        custom = (os.getenv("BINANCE_PREFERRED_HOST") or "").strip()
+        if custom and custom not in self.endpoints:
+            self.endpoints.insert(0, custom.rstrip("/"))
         self.timeout = timeout
         self.use_us = use_us
-        
-        # Health tracking for each endpoint
+        self._doh = ExchangeDNSResolver()
         self.endpoint_health: Dict[str, Dict[str, Any]] = {
-            endpoint: {
+            ep: {
                 "available": True,
                 "consecutive_failures": 0,
+                "geo_blocked": False,
                 "last_success": None,
                 "last_failure": None,
                 "total_requests": 0,
                 "successful_requests": 0,
                 "failed_requests": 0,
                 "avg_response_time": 0.0,
-                "backoff_until": 0.0
+                "backoff_until": 0.0,
             }
-            for endpoint in self.endpoints
+            for ep in self.endpoints
         }
-        
-        self.current_endpoint_index = 0
-        
-        logger.info(f"🌐 Binance DNS Connector initialized: {len(self.endpoints)} endpoints available")
-    
+        logger.info("Binance DNS Connector: %s endpoints (vision-first)", len(self.endpoints))
+
     def _get_next_healthy_endpoint(self) -> Optional[str]:
-        """
-        Get next healthy endpoint using intelligent selection
-        
-        Strategy:
-        1. Filter endpoints not in backoff
-        2. Prefer endpoints with recent success
-        3. Round-robin among healthy endpoints
-        
-        Returns:
-            Next healthy endpoint URL or None if all down
-        """
         now = time.time()
-        
-        # Get available endpoints (not in backoff)
         available = [
-            endpoint for endpoint in self.endpoints
-            if self.endpoint_health[endpoint]["backoff_until"] <= now
+            ep for ep in self.endpoints
+            if self.endpoint_health[ep]["backoff_until"] <= now
         ]
-        
         if not available:
-            # All endpoints in backoff - return least recently failed
-            logger.warning("🚨 All Binance endpoints in backoff! Using least recently failed.")
-            return min(
-                self.endpoints,
-                key=lambda e: self.endpoint_health[e]["backoff_until"]
-            )
-        
-        # Sort by success rate and recent activity
-        def score_endpoint(endpoint: str) -> float:
-            health = self.endpoint_health[endpoint]
-            total = health["total_requests"]
-            
-            if total == 0:
-                return 0  # New endpoint - high priority
-            
-            success_rate = health["successful_requests"] / total
-            score = (1 - success_rate) * 100  # Lower is better
-            
-            # Add penalty for consecutive failures
-            score += health["consecutive_failures"] * 10
-            
-            return score
-        
-        # Get best endpoint
-        best_endpoint = min(available, key=score_endpoint)
-        
-        return best_endpoint
-    
-    def _record_success(self, endpoint: str, response_time: float):
-        """Record successful request"""
-        health = self.endpoint_health[endpoint]
-        health["consecutive_failures"] = 0
-        health["last_success"] = datetime.now().isoformat()
-        health["total_requests"] += 1
-        health["successful_requests"] += 1
-        health["backoff_until"] = 0.0
-        
-        # Update average response time
-        if health["avg_response_time"] == 0:
-            health["avg_response_time"] = response_time
+            return min(self.endpoints, key=lambda e: self.endpoint_health[e]["backoff_until"])
+
+        def score(ep: str) -> float:
+            h = self.endpoint_health[ep]
+            if h.get("geo_blocked"):
+                return 1000.0
+            total = h["total_requests"] or 1
+            fail_rate = h["failed_requests"] / total
+            return fail_rate * 100 + h["consecutive_failures"] * 5
+
+        return min(available, key=score)
+
+    def _record_success(self, endpoint: str, response_time: float) -> None:
+        h = self.endpoint_health[endpoint]
+        h["consecutive_failures"] = 0
+        h["geo_blocked"] = False
+        h["last_success"] = datetime.now().isoformat()
+        h["total_requests"] += 1
+        h["successful_requests"] += 1
+        h["backoff_until"] = 0.0
+        if h["avg_response_time"] == 0:
+            h["avg_response_time"] = response_time
+        else:
+            h["avg_response_time"] = 0.7 * h["avg_response_time"] + 0.3 * response_time
+
+    def _record_failure(self, endpoint: str, error: str, geo: bool = False) -> None:
+        h = self.endpoint_health[endpoint]
+        h["consecutive_failures"] += 1
+        h["last_failure"] = datetime.now().isoformat()
+        h["total_requests"] += 1
+        h["failed_requests"] += 1
+        if geo or "451" in error:
+            h["geo_blocked"] = True
+            h["backoff_until"] = time.time() + 30
         else:
-            # Exponential moving average
-            health["avg_response_time"] = 0.7 * health["avg_response_time"] + 0.3 * response_time
-    
-    def _record_failure(self, endpoint: str, error: str):
-        """Record failed request with exponential backoff"""
-        health = self.endpoint_health[endpoint]
-        health["consecutive_failures"] += 1
-        health["last_failure"] = datetime.now().isoformat()
-        health["total_requests"] += 1
-        health["failed_requests"] += 1
-        
-        # Exponential backoff: 2^failures seconds (max 300s = 5 min)
-        backoff_duration = min(2 ** health["consecutive_failures"], 300)
-        health["backoff_until"] = time.time() + backoff_duration
-        
-        logger.warning(
-            f"❌ Binance endpoint failed: {endpoint} - {error} "
-            f"(failures: {health['consecutive_failures']}, backoff: {backoff_duration}s)"
-        )
-    
+            backoff = min(2 ** h["consecutive_failures"], 120)
+            h["backoff_until"] = time.time() + backoff
+        logger.warning("Binance endpoint failed: %s - %s", endpoint, error)
+
+    async def _http_get(
+        self,
+        base_url: str,
+        path: str,
+        params: Optional[Dict] = None,
+    ) -> Optional[httpx.Response]:
+        proxy = _egress_proxy()
+        client_kwargs: Dict[str, Any] = {"timeout": self.timeout, "follow_redirects": True}
+        if proxy:
+            client_kwargs["proxy"] = proxy
+        async with httpx.AsyncClient(**client_kwargs) as client:
+            return await client.get(f"{base_url}{path}", params=params)
+
+    async def _try_kucoin(self, path: str, params: Optional[Dict]) -> Optional[Any]:
+        """Map common Binance public paths to KuCoin."""
+        params = dict(params or {})
+        base = KUCOIN_ENDPOINTS[0]
+
+        if path == "/api/v3/ticker/price":
+            symbol = params.get("symbol", "BTCUSDT")
+            ksym = _binance_to_kucoin_symbol(str(symbol))
+            resp = await self._http_get(base, "/api/v1/market/stats", {"symbol": ksym})
+            if resp and resp.status_code == 200:
+                body = resp.json()
+                if body.get("code") == "200000":
+                    data = body.get("data") or {}
+                    return {"symbol": symbol, "price": data.get("last", data.get("buy", "0"))}
+            return None
+
+        if path == "/api/v3/klines":
+            symbol = params.get("symbol", "BTCUSDT")
+            interval = params.get("interval", "1h")
+            limit = int(params.get("limit", 100))
+            ksym = _binance_to_kucoin_symbol(str(symbol))
+            ktype = KUCOIN_INTERVAL_MAP.get(interval, "1hour")
+            resp = await self._http_get(
+                base,
+                "/api/v1/market/candles",
+                {"symbol": ksym, "type": ktype},
+            )
+            if resp and resp.status_code == 200:
+                body = resp.json()
+                if body.get("code") == "200000":
+                    rows = (body.get("data") or [])[-limit:]
+                    # KuCoin: [time, open, close, high, low, volume, turnover]
+                    return [
+                        [int(r[0]), r[1], r[3], r[4], r[2], r[5], 0, 0, 0, 0, 0, 0]
+                        for r in rows
+                    ]
+            return None
+
+        if path == "/api/v3/ticker/24hr":
+            symbol = params.get("symbol", "BTCUSDT")
+            ksym = _binance_to_kucoin_symbol(str(symbol))
+            resp = await self._http_get(base, "/api/v1/market/stats", {"symbol": ksym})
+            if resp and resp.status_code == 200:
+                body = resp.json()
+                if body.get("code") == "200000":
+                    d = body.get("data") or {}
+                    return {
+                        "symbol": symbol,
+                        "lastPrice": d.get("last"),
+                        "priceChangePercent": str(float(d.get("changeRate", 0)) * 100),
+                        "highPrice": d.get("high"),
+                        "lowPrice": d.get("low"),
+                        "volume": d.get("vol"),
+                    }
+            return None
+
+        return None
+
     async def get(
         self,
         path: str,
         params: Optional[Dict] = None,
-        max_retries: int = None
-    ) -> Optional[Dict[str, Any]]:
-        """
-        Make GET request with automatic DNS failover
-        
-        Args:
-            path: API endpoint path (e.g., "/api/v3/ticker/price")
-            params: Query parameters
-            max_retries: Maximum retry attempts (default: number of endpoints)
-        
-        Returns:
-            JSON response or None if all endpoints failed
-        """
+        max_retries: Optional[int] = None,
+    ) -> Optional[Any]:
         if max_retries is None:
-            max_retries = len(self.endpoints)
-        
-        last_error = None
-        
+            max_retries = len(self.endpoints) + 2
+
+        last_error = "unknown"
+
         for attempt in range(max_retries):
             endpoint = self._get_next_healthy_endpoint()
-            
             if not endpoint:
-                logger.error("🚨 No Binance endpoints available!")
                 break
-            
-            url = f"{endpoint}{path}"
-            start_time = time.time()
-            
+
+            start = time.time()
             try:
-                async with httpx.AsyncClient(timeout=self.timeout) as client:
-                    response = await client.get(url, params=params)
-                    response.raise_for_status()
-                    
-                    response_time = time.time() - start_time
-                    self._record_success(endpoint, response_time)
-                    
+                resp = await self._http_get(endpoint, path, params)
+                if resp is None:
+                    last_error = "no response"
+                    self._record_failure(endpoint, last_error)
+                    continue
+
+                if resp.status_code == 200:
+                    self._record_success(endpoint, time.time() - start)
                     logger.info(
-                        f"✅ Binance {path} - {endpoint} - {response_time*1000:.0f}ms"
+                        "Binance %s via %s (%.0fms)",
+                        path,
+                        endpoint.replace("https://", ""),
+                        (time.time() - start) * 1000,
                     )
-                    
-                    return response.json()
-            
-            except httpx.HTTPStatusError as e:
-                last_error = f"HTTP {e.response.status_code}"
-                self._record_failure(endpoint, last_error)
-                
-                # If rate limited, try next endpoint immediately
-                if e.response.status_code == 429:
-                    logger.warning(f"⚠️ Binance rate limit hit on {endpoint}, trying next...")
+                    return resp.json()
+
+                last_error = f"HTTP {resp.status_code}"
+                self._record_failure(endpoint, last_error, geo=(resp.status_code == 451))
+                if resp.status_code == 451:
                     continue
-                
-                # For other HTTP errors, might still retry
-                if attempt < max_retries - 1:
-                    await asyncio.sleep(0.3)
-            
+
             except httpx.TimeoutException:
                 last_error = "Timeout"
                 self._record_failure(endpoint, last_error)
-                
-                if attempt < max_retries - 1:
-                    await asyncio.sleep(0.3)
-            
-            except Exception as e:
-                last_error = str(e)
+            except Exception as exc:
+                last_error = str(exc)
                 self._record_failure(endpoint, last_error)
-                
-                if attempt < max_retries - 1:
-                    await asyncio.sleep(0.3)
-        
-        logger.error(f"❌ All Binance endpoints failed for {path}: {last_error}")
+
+            if attempt < max_retries - 1:
+                await asyncio.sleep(0.15)
+
+        # DoH direct-IP (api.binance.com mirrors only)
+        for endpoint in ("https://api.binance.com", "https://data-api.binance.vision"):
+            resp = await self._doh.fetch_via_doh(endpoint, path, params, timeout=self.timeout)
+            if resp and resp.status_code == 200:
+                logger.info("Binance %s via DoH %s", path, endpoint)
+                return resp.json()
+
+        # KuCoin fallback
+        kucoin_result = await self._try_kucoin(path, params)
+        if kucoin_result is not None:
+            logger.info("Binance path %s served via KuCoin fallback", path)
+            return kucoin_result
+
+        logger.error("All Binance/KuCoin routes failed for %s: %s", path, last_error)
         return None
-    
+
     async def post(
         self,
         path: str,
         data: Optional[Dict] = None,
         params: Optional[Dict] = None,
-        max_retries: int = None
-    ) -> Optional[Dict[str, Any]]:
-        """
-        Make POST request with automatic DNS failover
-        
-        Args:
-            path: API endpoint path
-            data: Request body data
-            params: Query parameters
-            max_retries: Maximum retry attempts
-        
-        Returns:
-            JSON response or None if all endpoints failed
-        """
+        max_retries: Optional[int] = None,
+    ) -> Optional[Any]:
         if max_retries is None:
             max_retries = len(self.endpoints)
-        
-        last_error = None
-        
+
+        last_error = "unknown"
         for attempt in range(max_retries):
             endpoint = self._get_next_healthy_endpoint()
-            
             if not endpoint:
-                logger.error("🚨 No Binance endpoints available!")
                 break
-            
-            url = f"{endpoint}{path}"
-            start_time = time.time()
-            
             try:
-                async with httpx.AsyncClient(timeout=self.timeout) as client:
-                    response = await client.post(url, json=data, params=params)
-                    response.raise_for_status()
-                    
-                    response_time = time.time() - start_time
-                    self._record_success(endpoint, response_time)
-                    
-                    logger.info(
-                        f"✅ Binance POST {path} - {endpoint} - {response_time*1000:.0f}ms"
-                    )
-                    
-                    return response.json()
-            
-            except Exception as e:
-                last_error = str(e)
+                proxy = _egress_proxy()
+                kwargs: Dict[str, Any] = {"timeout": self.timeout}
+                if proxy:
+                    kwargs["proxy"] = proxy
+                async with httpx.AsyncClient(**kwargs) as client:
+                    resp = await client.post(f"{endpoint}{path}", json=data, params=params)
+                    if resp.status_code == 200:
+                        return resp.json()
+                    last_error = f"HTTP {resp.status_code}"
+                    self._record_failure(endpoint, last_error, geo=(resp.status_code == 451))
+            except Exception as exc:
+                last_error = str(exc)
                 self._record_failure(endpoint, last_error)
-                
-                if attempt < max_retries - 1:
-                    await asyncio.sleep(0.3)
-        
-        logger.error(f"❌ All Binance endpoints failed for POST {path}: {last_error}")
+        logger.error("All Binance POST routes failed for %s: %s", path, last_error)
         return None
-    
+
     def get_health_status(self) -> Dict[str, Any]:
-        """
-        Get health status of all Binance endpoints
-        
-        Returns:
-            Dict with health information for each endpoint
-        """
         now = time.time()
-        
         return {
-            "connector_type": "Binance US" if self.use_us else "Binance Global",
+            "connector_type": "Binance US" if self.use_us else "Binance Global (vision-first)",
+            "vision_primary": "https://data-api.binance.vision",
+            "kucoin_fallback": KUCOIN_ENDPOINTS[0],
+            "doh_enabled": True,
+            "egress_proxy_configured": bool(_egress_proxy()),
             "total_endpoints": len(self.endpoints),
             "endpoints": [
                 {
-                    "url": endpoint,
-                    "available": health["backoff_until"] <= now,
-                    "consecutive_failures": health["consecutive_failures"],
+                    "url": ep,
+                    "available": h["backoff_until"] <= now,
+                    "geo_blocked": h.get("geo_blocked", False),
+                    "consecutive_failures": h["consecutive_failures"],
                     "success_rate": (
-                        100 * health["successful_requests"] / health["total_requests"]
-                        if health["total_requests"] > 0 else 0
+                        100 * h["successful_requests"] / h["total_requests"]
+                        if h["total_requests"] else 0
                     ),
-                    "total_requests": health["total_requests"],
-                    "avg_response_time_ms": health["avg_response_time"] * 1000,
-                    "last_success": health["last_success"],
-                    "last_failure": health["last_failure"],
-                    "backoff_until": (
-                        datetime.fromtimestamp(health["backoff_until"]).isoformat()
-                        if health["backoff_until"] > now else None
-                    )
+                    "total_requests": h["total_requests"],
+                    "avg_response_time_ms": h["avg_response_time"] * 1000,
+                    "last_success": h["last_success"],
+                    "last_failure": h["last_failure"],
                 }
-                for endpoint, health in self.endpoint_health.items()
-            ]
+                for ep, h in self.endpoint_health.items()
+            ],
         }
-    
-    def reset_health(self, endpoint: Optional[str] = None):
-        """
-        Reset health tracking for endpoint(s)
-        
-        Args:
-            endpoint: Specific endpoint to reset, or None to reset all
-        """
-        if endpoint:
-            if endpoint in self.endpoint_health:
-                self.endpoint_health[endpoint]["consecutive_failures"] = 0
-                self.endpoint_health[endpoint]["backoff_until"] = 0.0
-                logger.info(f"🔄 Reset health for {endpoint}")
-        else:
-            for ep in self.endpoint_health:
-                self.endpoint_health[ep]["consecutive_failures"] = 0
-                self.endpoint_health[ep]["backoff_until"] = 0.0
-            logger.info("🔄 Reset health for all endpoints")
 
 
-# ===== GLOBAL INSTANCES =====
+class KuCoinDNSConnector:
+    """KuCoin public API with DoH + optional egress proxy."""
 
-_binance_global_connector: Optional[BinanceDNSConnector] = None
-_binance_us_connector: Optional[BinanceDNSConnector] = None
+    def __init__(self, timeout: float = 12.0) -> None:
+        self.endpoints = list(KUCOIN_ENDPOINTS)
+        self.timeout = timeout
+        self._doh = ExchangeDNSResolver()
+
+    async def get(
+        self,
+        path: str,
+        params: Optional[Dict] = None,
+    ) -> Optional[Any]:
+        for base in self.endpoints:
+            try:
+                resp = await self._http_get(base, path, params)
+                if resp and resp.status_code == 200:
+                    body = resp.json()
+                    if body.get("code") == "200000":
+                        return body.get("data")
+            except Exception as exc:
+                logger.debug("KuCoin %s failed: %s", base, exc)
+
+        hostname = "api.kucoin.com"
+        ip = await self._doh.resolve(hostname)
+        if ip:
+            try:
+                proxy = _egress_proxy()
+                kwargs: Dict[str, Any] = {
+                    "timeout": self.timeout,
+                    "verify": False,
+                    "headers": {"Host": hostname},
+                }
+                if proxy:
+                    kwargs["proxy"] = proxy
+                async with httpx.AsyncClient(**kwargs) as client:
+                    resp = await client.get(f"https://{ip}{path}", params=params)
+                    if resp.status_code == 200:
+                        body = resp.json()
+                        if body.get("code") == "200000":
+                            return body.get("data")
+            except Exception as exc:
+                logger.debug("KuCoin DoH failed: %s", exc)
+        return None
+
+    async def _http_get(self, base_url: str, path: str, params: Optional[Dict]) -> Optional[httpx.Response]:
+        proxy = _egress_proxy()
+        kwargs: Dict[str, Any] = {"timeout": self.timeout}
+        if proxy:
+            kwargs["proxy"] = proxy
+        async with httpx.AsyncClient(**kwargs) as client:
+            return await client.get(f"{base_url}{path}", params=params)
+
+    def get_health_status(self) -> Dict[str, Any]:
+        return {
+            "connector_type": "KuCoin",
+            "endpoints": self.endpoints,
+            "doh_enabled": True,
+            "egress_proxy_configured": bool(_egress_proxy()),
+        }
+
+
+_binance_global: Optional[BinanceDNSConnector] = None
+_binance_us: Optional[BinanceDNSConnector] = None
+_kucoin: Optional[KuCoinDNSConnector] = None
 
 
 def get_binance_connector(use_us: bool = False) -> BinanceDNSConnector:
-    """
-    Get singleton Binance connector instance
-    
-    Args:
-        use_us: If True, return US connector, else global connector
-    
-    Returns:
-        BinanceDNSConnector instance
-    """
-    global _binance_global_connector, _binance_us_connector
-    
+    global _binance_global, _binance_us
     if use_us:
-        if _binance_us_connector is None:
-            _binance_us_connector = BinanceDNSConnector(use_us=True)
-        return _binance_us_connector
-    else:
-        if _binance_global_connector is None:
-            _binance_global_connector = BinanceDNSConnector(use_us=False)
-        return _binance_global_connector
-
-
-# ===== CONVENIENCE FUNCTIONS =====
-
-async def binance_get(path: str, params: Optional[Dict] = None, use_us: bool = False) -> Optional[Dict]:
-    """
-    Convenience function for Binance GET requests with failover
-    
-    Args:
-        path: API path (e.g., "/api/v3/ticker/price")
-        params: Query parameters
-        use_us: Use Binance US endpoints
-    
-    Returns:
-        JSON response or None
-    """
-    connector = get_binance_connector(use_us=use_us)
-    return await connector.get(path, params=params)
-
-
-async def binance_post(
-    path: str,
-    data: Optional[Dict] = None,
-    params: Optional[Dict] = None,
-    use_us: bool = False
-) -> Optional[Dict]:
-    """
-    Convenience function for Binance POST requests with failover
-    
-    Args:
-        path: API path
-        data: Request body
-        params: Query parameters
-        use_us: Use Binance US endpoints
-    
-    Returns:
-        JSON response or None
-    """
-    connector = get_binance_connector(use_us=use_us)
-    return await connector.post(path, data=data, params=params)
-
-
-# ===== TEST =====
-
-if __name__ == "__main__":
-    async def test():
-        print("=" * 70)
-        print("Testing Binance DNS Connector")
-        print("=" * 70)
-        
-        connector = get_binance_connector(use_us=False)
-        
-        # Test 1: Get BTC price
-        print("\n1. Testing BTC price fetch:")
-        result = await connector.get("/api/v3/ticker/price", params={"symbol": "BTCUSDT"})
-        if result:
-            print(f"   ✅ BTC Price: ${float(result.get('price', 0)):,.2f}")
-        else:
-            print("   ❌ Failed to fetch BTC price")
-        
-        # Test 2: Get multiple prices
-        print("\n2. Testing multiple price fetch:")
-        result = await connector.get("/api/v3/ticker/price")
-        if result:
-            print(f"   ✅ Fetched {len(result)} prices")
-        else:
-            print("   ❌ Failed to fetch prices")
-        
-        # Test 3: Health status
-        print("\n3. Health Status:")
-        health = connector.get_health_status()
-        print(f"   Total endpoints: {health['total_endpoints']}")
-        for ep in health['endpoints']:
-            status = "✅" if ep['available'] else "❌"
-            print(f"   {status} {ep['url']}: {ep['success_rate']:.1f}% success, {ep['total_requests']} requests")
-        
-        print("\n" + "=" * 70)
-        print("Test completed!")
-    
-    asyncio.run(test())
+        if _binance_us is None:
+            _binance_us = BinanceDNSConnector(use_us=True)
+        return _binance_us
+    if _binance_global is None:
+        _binance_global = BinanceDNSConnector(use_us=False)
+    return _binance_global
+
+
+def get_kucoin_connector() -> KuCoinDNSConnector:
+    global _kucoin
+    if _kucoin is None:
+        _kucoin = KuCoinDNSConnector()
+    return _kucoin
+
+
+async def binance_get(path: str, params: Optional[Dict] = None, use_us: bool = False) -> Optional[Any]:
+    return await get_binance_connector(use_us=use_us).get(path, params=params)
+
+
+async def kucoin_get(path: str, params: Optional[Dict] = None) -> Optional[Any]:
+    return await get_kucoin_connector().get(path, params=params)