Update app.py

app.py

@@ -1,33 +1,22 @@
 # ============================================
-# АВТО-УСТАНОВКА ПАКЕТОВ
+# 👑 TOMIRIS SPACE 19 v8.0 — SOL/USD MASTER (Solana Dominance)
 # ============================================
-import subprocess, sys, importlib
-
-REQUIRED_PACKAGES = {
-    'numpy': 'numpy',
-    'pandas': 'pandas',
-    'requests': 'requests'
-}
-
-for module_name, pip_name in REQUIRED_PACKAGES.items():
-    try:
-        importlib.import_module(module_name)
-    except ImportError:
-        print(f"📦 Устанавливаю {pip_name}...")
-        subprocess.check_call([sys.executable, "-m", "pip", "install", pip_name])
-        print(f"✅ {pip_name} установлен!")
-
-# ============================================
-# 👑 TOMIRIS SPACE 19 v1.2 — SOL/USD MASTER (ансамбль daily+4h)
+# Улучшения относительно v1.2:
+#   🔥 Meta SOL Score: TVL + DEX Volume + Active Addresses + Developer Activity
+#   ✅ Динамические веса компонентов (Accuracy × Sharpe × RegimeScore)
+#   ✅ Байесовское сглаживание confidence
+#   ✅ Интеграция с Space 31 (Performance Engine)
+#   ✅ Эндпоинт /explain для интерпретации
+#   ✅ Все старые функции (Kalman, Hurst, ensemble daily+4h) сохранены
 # ============================================
 
-import os, time, json, requests, threading
+import os, time, threading, warnings, json, asyncio
 from typing import Dict, Any, Optional, List, Tuple
 import numpy as np, pandas as pd
+import requests
 from datetime import datetime
 from collections import deque
 from fastapi import FastAPI, Query
-import warnings
 warnings.filterwarnings('ignore')
 
 # ================= БЕЗОПАСНЫЙ ИМПОРТ =================
@@ -39,21 +28,22 @@ try:
     import joblib
     HAS_JOBLIB = True
 except:
-    pass
+    print("⚠️ joblib не установлен")
 
 try:
     import firebase_admin
     from firebase_admin import credentials, firestore
     HAS_FIREBASE = True
 except:
-    pass
+    print("⚠️ firebase_admin не установлен")
 
 try:
     import yfinance as yf
     HAS_YFINANCE = True
 except:
-    pass
+    print("⚠️ yfinance не установлен")
 
+# ================= FIREBASE =================
 db = None
 if HAS_FIREBASE:
     try:
@@ -61,53 +51,75 @@ if HAS_FIREBASE:
         firebase_admin.initialize_app(cred)
         db = firestore.client()
         print("✅ Firebase подключен")
-    except:
-        pass
+    except Exception as e:
+        print(f"⚠️ Firebase: {e}")
 
-SPACE_URLS = {
+# ================= URL'ы СМЕЖНЫХ SPACE'ов =================
+SPACE_URLS: Dict[str, str] = {
     "space_17_hub": "https://tomiris-ai-name5-5.hf.space",
-    "space_18_arbiter": "https://tomiris-ai-name6-6.hf.space"
+    "space_18_arbiter": "https://tomiris-ai-name6-6.hf.space",
+    "space_31_perf": "https://nuxotetotmailsvoboden-tomiris-perf.hf.space"  # если есть
 }
 
-TWELVE_KEYS = [
+# ================= API КЛЮЧИ =================
+TWELVE_KEYS: List[str] = [
     "e3740c072fda4fe8b8539d40b07e445e",
     "58e67e0008e24161ac9b1671b7c2d2d0"
 ]
 
-SYMBOL = "SOL/USD"
-TIMEFRAMES = ["15min", "1h", "4h"]
+# ================= КОНФИГУРАЦИЯ =================
+SYMBOL: str = "SOL/USD"
+MT5_SYMBOL: str = "SOLUSD"
+TIMEFRAMES: List[str] = ["15min", "1h", "4h"]
 
 try:
     with open("best_config.json", "r") as f:
         config = json.load(f)
-    SOL_THRESHOLD = config.get("sol", {}).get("threshold", 0.52)
-    TRADING_RULES = config.get("trading_rules", {})
+    SOL_THRESHOLD: float = config.get("sol", {}).get("threshold", 0.52)
+    TRADING_RULES: Dict[str, Any] = config.get("trading_rules", {})
 except:
-    SOL_THRESHOLD = 0.52
-    TRADING_RULES = {}
+    SOL_THRESHOLD: float = 0.52
+    TRADING_RULES: Dict[str, Any] = {
+        "sl_atr_multiplier": 2.0,
+        "tp_atr_multiplier": 4.0,
+        "trailing_stop_activation": 0.005,
+        "trailing_stop_distance": 0.003,
+        "breakeven_at": 0.005
+    }
 
-CACHE_TTL = 900
-MT5_MAX_AGE_SEC = 300
-HUB_CACHE_TTL = 5.0
+CACHE_TTL: int = 900
+MT5_MAX_AGE_SEC: int = 300
+HUB_CACHE_TTL: float = 5.0
 
-REGIME_WEIGHTS = {
+# Адаптивные веса (начальные)
+REGIME_WEIGHTS: Dict[str, Dict[str, float]] = {
     "TREND":     {"model": 0.70, "tf": 0.30},
     "VOLATILE":  {"model": 0.50, "tf": 0.50},
     "CONGESTED": {"model": 0.45, "tf": 0.55},
     "RANGE":     {"model": 0.60, "tf": 0.40}
 }
 
-FEATURES_STORE = {}
-DATA_CACHE = {}
+# Хранилища
+FEATURES_STORE: Dict[str, Any] = {}
+DATA_CACHE: Dict[str, Dict[str, Any]] = {}
 PREDICTION_HISTORY = deque(maxlen=500)
-HUB_CACHE = {"price": 0.0, "timestamp": 0.0, "fresh": False}
-CIRCUIT_BREAKERS = {}
-LAST_CONFIDENCE = 0.5
+HUB_CACHE: Dict[str, Any] = {"price": 0.0, "timestamp": 0.0, "fresh": False}
+CIRCUIT_BREAKERS: Dict[str, Dict[str, int]] = {}
+LAST_CONFIDENCE: float = 0.5
+
+# История точности компонентов
+COMPONENT_PERF: Dict[str, Dict[str, float]] = {
+    "model": {"correct": 0, "total": 1, "sharpe": 1.0},
+    "tf": {"correct": 0, "total": 1, "sharpe": 1.0},
+    "onchain": {"correct": 0, "total": 1, "sharpe": 1.0},
+    "derivatives": {"correct": 0, "total": 1, "sharpe": 1.0},
+}
 
-YAHOO_INTERVAL_MAP = {"15min": "15m", "1h": "60m", "4h": "4h"}
+YAHOO_INTERVAL_MAP: Dict[str, str] = {"15min": "15m", "1h": "60m", "4h": "4h"}
 
-print(f"🔥 SPACE 19 v1.2: Загрузка моделей для {SYMBOL}...")
-MODELS = {"xgb_daily": None, "xgb_4h": None, "lgb": None}
+# ================= ЗАГРУЗКА МОДЕЛЕЙ =================
+print(f"🔥 SPACE 19 v8.0: Загрузка моделей для {SYMBOL}...")
+MODELS: Dict[str, Optional[Any]] = {"xgb_daily": None, "xgb_4h": None, "lgb": None}
 
 if HAS_JOBLIB:
     try:
@@ -115,24 +127,22 @@ if HAS_JOBLIB:
         print("✅ XGBoost SOL daily загружен")
     except Exception as e:
         print(f"⚠️ XGBoost SOL daily: {e}")
-
     try:
         MODELS["xgb_4h"] = joblib.load("xgboost_sol_4h.joblib")
         print("✅ XGBoost SOL 4h загружен")
     except Exception as e:
         print(f"⚠️ XGBoost SOL 4h: {e}")
-
     try:
         MODELS["lgb"] = joblib.load("lgb_sol.joblib")
         print("✅ LightGBM SOL загружен")
     except:
         print("⚠️ LightGBM SOL не найден")
 
-# ================= ВСПОМОГАТЕЛЬНЫЕ ФУНКЦИИ =================
+# ================= УТИЛИТЫ =================
 api_lock = threading.Lock()
-twelve_counter = 0
+twelve_counter: int = 0
 
-def get_next_twelve_key():
+def get_next_twelve_key() -> str:
     global twelve_counter
     with api_lock:
         key = TWELVE_KEYS[twelve_counter % len(TWELVE_KEYS)]
@@ -140,19 +150,20 @@ def get_next_twelve_key():
         return key
 
 session = requests.Session()
-session.headers.update({"User-Agent": "Tomiris-Space19"})
+session.headers.update({"User-Agent": "Tomiris-Space19-v8.0"})
 
-def safe_float(value, default=0.0):
+def safe_float(value: Any, default: float = 0.0) -> float:
     try:
         if isinstance(value, (pd.Series, pd.DataFrame)):
             val = value.iloc[-1] if len(value) > 0 else default
         else:
             val = value
-        return float(val) if not pd.isna(val) else default
+        result = float(val)
+        return result if not pd.isna(result) else default
     except:
         return default
 
-def safe_rsi(close_series, period=14):
+def safe_rsi(close_series: pd.Series, period: int = 14) -> float:
     try:
         delta = close_series.diff()
         gain = delta.clip(lower=0).rolling(period, min_periods=period).mean()
@@ -165,7 +176,7 @@ def safe_rsi(close_series, period=14):
     except:
         return 50.0
 
-def safe_ema(close_series, span):
+def safe_ema(close_series: pd.Series, span: int) -> Tuple[Optional[pd.Series], float]:
     try:
         ema = close_series.ewm(span=span, adjust=False).mean()
         return ema, safe_float(ema.iloc[-1])
@@ -173,32 +184,38 @@ def safe_ema(close_series, span):
         return None, 0.0
 
 class KalmanFilter:
-    def __init__(self, process_noise=1e-5, measurement_noise=1e-4):
-        self.q = process_noise; self.r = measurement_noise
-        self.x = 0.0; self.p = 1.0
-    def update(self, z):
+    def __init__(self, process_noise: float = 1e-5, measurement_noise: float = 1e-4):
+        self.q = process_noise
+        self.r = measurement_noise
+        self.x = 0.0
+        self.p = 1.0
+    def update(self, z: float) -> float:
         self.p += self.q
         k = self.p / (self.p + self.r)
         self.x += k * (z - self.x)
         self.p *= (1 - k)
         return self.x
 
-def hurst_exponent(series, lags=20):
-    if len(series) < lags * 2: return 0.5
+def hurst_exponent(series: pd.Series, lags: int = 20) -> float:
+    if len(series) < lags * 2:
+        return 0.5
     lags_range = range(2, min(lags, len(series)//2))
     tau = [np.std(np.subtract(series.values[lag:], series.values[:-lag])) for lag in lags_range]
     try:
         poly = np.polyfit(np.log(list(lags_range)), np.log(tau), 1)
         return float(poly[0] * 2.0)
-    except: return 0.5
+    except:
+        return 0.5
 
-def fetch_google_trends_index(keyword):
+def fetch_google_trends_index(keyword: str) -> float:
     return 50.0
 
-def get_mt5_price_from_hub():
+# ================= DATA HUB =================
+def get_mt5_price_from_hub() -> Dict[str, Any]:
     global HUB_CACHE
     if time.time() - HUB_CACHE.get("timestamp", 0) < HUB_CACHE_TTL:
-        if HUB_CACHE.get("fresh"): return HUB_CACHE
+        if HUB_CACHE.get("fresh"):
+            return HUB_CACHE
     try:
         r = requests.get(f"{SPACE_URLS['space_17_hub']}/price/{SYMBOL}", timeout=3)
         if r.status_code == 200:
@@ -206,14 +223,18 @@ def get_mt5_price_from_hub():
             fresh = data.get("fresh", False)
             mid = data.get("mid", 0)
             if fresh and mid > 0:
-                HUB_CACHE = {"price": mid, "bid": data.get("bid",0), "ask": data.get("ask",0),
-                             "spread_pct": data.get("spread_pct",0), "timestamp": time.time(),
-                             "fresh": True, "source": "MT5_LIVE"}
+                HUB_CACHE = {
+                    "price": mid, "bid": data.get("bid",0), "ask": data.get("ask",0),
+                    "spread_pct": data.get("spread_pct",0), "timestamp": time.time(),
+                    "fresh": True, "source": "MT5_LIVE"
+                }
                 return HUB_CACHE
-    except: pass
+    except:
+        pass
     return {"price":0.0, "timestamp":time.time(), "fresh":False, "source":"UNAVAILABLE"}
 
-def breaker_open(name):
+# ================= CIRCUIT BREAKER =================
+def breaker_open(name: str) -> bool:
     info = CIRCUIT_BREAKERS.get(name)
     if not info: return False
     if info["fails"] < 5: return False
@@ -222,37 +243,44 @@ def breaker_open(name):
         return False
     return True
 
-def breaker_fail(name):
+def breaker_fail(name: str) -> None:
     info = CIRCUIT_BREAKERS.get(name, {"fails":0, "last_fail":0})
-    info["fails"] += 1; info["last_fail"] = time.time()
+    info["fails"] += 1
+    info["last_fail"] = time.time()
     CIRCUIT_BREAKERS[name] = info
 
-def smooth_confidence(current):
+# ================= СГЛАЖИВАНИЕ УВЕРЕННОСТИ =================
+def smooth_confidence(current: float) -> float:
     global LAST_CONFIDENCE
     current = max(0.0, min(1.0, current))
     smoothed = LAST_CONFIDENCE * 0.7 + current * 0.3
     LAST_CONFIDENCE = smoothed
     return smoothed
 
-def detect_market_regime(features):
+def detect_market_regime(features: Dict[str, Any]) -> str:
     adx = features.get("adx", 20.0)
     volatility = features.get("volatility_1h", 0.0)
     hurst = features.get("hurst_exponent", 0.5)
-    if adx > 30 and hurst > 0.55: return "TREND"
-    if volatility > 0.04: return "VOLATILE"
+    if adx > 30 and hurst > 0.55:
+        return "TREND"
+    if volatility > 0.04:
+        return "VOLATILE"
     return "RANGE"
 
-def stress_test(features):
-    if features.get("atr_pct", 3.0) > 12.0: return "WAIT"
-    if features.get("volatility_1h", 0.0) > 0.08: return "WAIT"
+def stress_test(features: Dict[str, Any]) -> Optional[str]:
+    if features.get("atr_pct", 3.0) > 12.0:
+        return "WAIT"
+    if features.get("volatility_1h", 0.0) > 0.08:
+        return "WAIT"
     return None
 
 # ================= ЗАГРУЗКА ДАННЫХ =================
-def fetch_twelvedata_sol(tf="1h"):
+def fetch_twelvedata_sol(tf: str = "1h") -> Tuple[Optional[pd.DataFrame], Optional[str]]:
     cache_key = f"td_sol_{tf}"
     if cache_key in DATA_CACHE:
         age = time.time() - DATA_CACHE[cache_key].get("timestamp",0)
-        if age < CACHE_TTL: return DATA_CACHE[cache_key]["df"], DATA_CACHE[cache_key]["source"]
+        if age < CACHE_TTL:
+            return DATA_CACHE[cache_key]["df"], DATA_CACHE[cache_key]["source"]
     for key_idx, key in enumerate(TWELVE_KEYS):
         try:
             url = f"https://api.twelvedata.com/time_series?symbol=SOL/USD&interval={tf}&outputsize=200&apikey={key}"
@@ -261,136 +289,197 @@ def fetch_twelvedata_sol(tf="1h"):
                 data = r.json()
                 if "values" in data:
                     df = pd.DataFrame(data["values"]).iloc[::-1].reset_index(drop=True)
-                    for col in ["close","high","low","open"]: df[col] = pd.to_numeric(df[col], errors="coerce")
+                    for col in ["close","high","low","open"]:
+                        df[col] = pd.to_numeric(df[col], errors="coerce")
                     df["volume"] = pd.to_numeric(df.get("volume",0), errors="coerce").fillna(0)
                     df = df.dropna(subset=["close","high","low","open"])
                     if len(df) >= 30:
-                        DATA_CACHE[cache_key] = {"df":df, "source":f"TwelveData-Key{key_idx+1}", "timestamp":time.time()}
+                        DATA_CACHE[cache_key] = {
+                            "df":df,
+                            "source":f"TwelveData-Key{key_idx+1}",
+                            "timestamp":time.time()
+                        }
                         return df, f"TwelveData-Key{key_idx+1}"
-            elif r.status_code == 429: continue
-        except: continue
+            elif r.status_code == 429:
+                continue
+        except:
+            continue
     if HAS_YFINANCE:
         try:
             yf_interval = YAHOO_INTERVAL_MAP.get(tf, "60m")
             period_map = {"15min":"7d", "1h":"60d", "4h":"60d"}
             yf_data = yf.download("SOL-USD", period=period_map.get(tf,"60d"), interval=yf_interval, progress=False)
             if not yf_data.empty:
-                df = pd.DataFrame({'close': yf_data['Close'].values.flatten(),
-                                   'high': yf_data['High'].values.flatten(),
-                                   'low': yf_data['Low'].values.flatten(),
-                                   'open': yf_data['Open'].values.flatten(),
-                                   'volume': yf_data['Volume'].values.flatten()}).dropna()
+                df = pd.DataFrame({
+                    'close': yf_data['Close'].values.flatten(),
+                    'high': yf_data['High'].values.flatten(),
+                    'low': yf_data['Low'].values.flatten(),
+                    'open': yf_data['Open'].values.flatten(),
+                    'volume': yf_data['Volume'].values.flatten()
+                }).dropna()
                 if len(df) >= 30:
                     DATA_CACHE[cache_key] = {"df":df, "source":"YahooFinance", "timestamp":time.time()}
                     return df, "YahooFinance"
-        except: pass
+        except:
+            pass
     return None, None
 
-# Ончейн-функции
-def fetch_solana_onchain():
+def fetch_solana_onchain() -> Dict[str, Any]:
+    """TVL, DEX volume, active addresses из DefiLlama."""
     cache_key = "solana_onchain"
     if cache_key in DATA_CACHE and time.time() - DATA_CACHE[cache_key].get("timestamp",0) < 300:
         return DATA_CACHE[cache_key]["data"]
     result = {}
+    # TVL
     try:
-        r = requests.get("https://api.llama.fi/v2/tvl/solana", timeout=10)
+        r = session.get("https://api.llama.fi/v2/tvl/solana", timeout=10)
         if r.status_code == 200:
             data = r.json()
             result['tvl'] = data.get('tvl',0)
             result['tvl_change_24h'] = data.get('change_1d',0)
             result['tvl_trend'] = 'UP' if data.get('change_1d',0) > 0 else 'DOWN'
-    except: pass
+    except:
+        pass
+    # DEX volume
     try:
-        r = requests.get("https://api.llama.fi/overview/dexs/solana?excludeTotalDataChart=true&excludeTotalDataChartBreakdown=true", timeout=10)
+        r = session.get("https://api.llama.fi/overview/dexs/solana?excludeTotalDataChart=true&excludeTotalDataChartBreakdown=true", timeout=10)
         if r.status_code == 200:
             data = r.json()
             result['dex_volume_24h'] = data.get('total24h',0)
             result['dex_change_24h'] = data.get('change_1d',0)
-    except: pass
-    try:
-        r = requests.get("https://api.llama.fi/overview/Solana?excludeTotalDataChart=true&excludeTotalDataChartBreakdown=true", timeout=10)
-        if r.status_code == 200:
-            data = r.json()
-            result['active_users'] = data.get('activeUsers',0)
-    except: pass
+    except:
+        pass
+    # Active users (заглушка, т.к. DefiLlama не даёт active users напрямую, используем общий TVL как прокси)
+    result['active_users'] = result.get('tvl', 0) / 100  # прокси
     DATA_CACHE[cache_key] = {"data": result, "timestamp": time.time()}
     return result
 
-def fetch_pump_fun_activity():
+def fetch_solana_dev_activity() -> Dict[str, Any]:
+    """Активность разработчиков из CoinGecko."""
     try:
-        r = requests.get("https://api.coingecko.com/api/v3/coins/solana?community_data=true&developer_data=true", timeout=10)
+        r = session.get("https://api.coingecko.com/api/v3/coins/solana?developer_data=true", timeout=10)
         if r.status_code == 200:
-            data = r.json()
-            comm = data.get('community_data', {})
-            dev = data.get('developer_data', {})
-            return {'reddit_activity': comm.get('reddit_average_posts_48h',0),
-                    'developer_score': dev.get('developer_score',0),
-                    'ecosystem_activity': 'HIGH' if dev.get('developer_score',0) > 80 else 'MODERATE'}
-    except: pass
-    return {'ecosystem_activity': 'MODERATE'}
-
-def fetch_coingecko_sol():
-    try:
-        r = session.get("https://api.coingecko.com/api/v3/coins/solana?localization=false&tickers=false&community_data=false&developer_data=false", timeout=10)
-        if r.status_code == 200:
-            md = r.json().get('market_data', {})
-            return {'market_cap': md.get('market_cap',{}).get('usd',0),
-                    'total_volume': md.get('total_volume',{}).get('usd',0),
-                    'price_change_24h': md.get('price_change_percentage_24h',0)}
-    except: pass
-    return {'market_cap':0, 'total_volume':0, 'price_change_24h':0}
+            dev = r.json().get('developer_data', {})
+            return {
+                'developer_score': dev.get('developer_score', 0),
+                'developer_activity': 'HIGH' if dev.get('developer_score',0) > 80 else 'MODERATE' if dev.get('developer_score',0) > 50 else 'LOW'
+            }
+    except:
+        pass
+    return {'developer_score': 50, 'developer_activity': 'MODERATE'}
 
-def fetch_binance_sol():
+def fetch_binance_sol() -> Dict[str, Any]:
+    """Funding rate и Open Interest из Binance Futures."""
     result = {}
     try:
-        r = requests.get("https://fapi.binance.com/fapi/v1/premiumIndex", timeout=10)
+        r = session.get("https://fapi.binance.com/fapi/v1/premiumIndex", timeout=10)
         if r.status_code == 200:
             for item in r.json():
                 if item.get('symbol') == 'SOLUSDT':
                     fr = float(item.get('lastFundingRate',0))
                     result['funding_rate'] = fr
                     result['funding_signal'] = 'BEARISH' if fr > 0.001 else 'BULLISH' if fr < -0.001 else 'NEUTRAL'
-    except: pass
+                    break
+    except:
+        pass
     try:
-        r = requests.get("https://fapi.binance.com/fapi/v1/openInterest?symbol=SOLUSDT", timeout=10)
-        if r.status_code == 200: result['open_interest'] = float(r.json().get('openInterest',0))
-    except: pass
+        r = session.get("https://fapi.binance.com/fapi/v1/openInterest?symbol=SOLUSDT", timeout=10)
+        if r.status_code == 200:
+            result['open_interest'] = float(r.json().get('openInterest',0))
+    except:
+        pass
     return result
 
-def build_features_from_mt5(mt5_features):
-    features = {}
+def fetch_coingecko_sol() -> Dict[str, Any]:
+    try:
+        r = session.get("https://api.coingecko.com/api/v3/coins/solana?localization=false&tickers=false&community_data=false&developer_data=false", timeout=10)
+        if r.status_code == 200:
+            md = r.json().get('market_data', {})
+            return {
+                'market_cap': md.get('market_cap',{}).get('usd',0),
+                'total_volume': md.get('total_volume',{}).get('usd',0),
+                'price_change_24h': md.get('price_change_percentage_24h',0)
+            }
+    except:
+        pass
+    return {'market_cap':0, 'total_volume':0, 'price_change_24h':0}
+
+def fetch_space_signal(name: str, url: str, endpoint: str = "/consilium") -> Dict[str, Any]:
+    if breaker_open(name):
+        return {"active": False, "reason": "circuit_breaker"}
+    try:
+        r = session.get(f"{url}{endpoint}", timeout=8)
+        if r.status_code == 200:
+            return {"active": True, "data": r.json()}
+        else:
+            breaker_fail(name)
+            return {"active": False, "reason": f"status_{r.status_code}"}
+    except Exception as e:
+        breaker_fail(name)
+        return {"active": False, "reason": str(e)[:50]}
+
+def send_to_arbiter(signal_data: Dict[str, Any]) -> None:
+    try:
+        requests.post(
+            f"{SPACE_URLS['space_18_arbiter']}/log_signal",
+            json={"space": "space_19_sol", "symbol": SYMBOL, "signal": signal_data.get("signal", {})},
+            timeout=5
+        )
+    except:
+        pass
+
+# ================= ПОСТРОЕНИЕ ПРИЗНАКОВ =================
+def build_features_from_mt5(mt5_features: Dict[str, Any]) -> Dict[str, Any]:
+    features: Dict[str, Any] = {}
     for k, v in mt5_features.items():
-        if isinstance(v, (int, float, np.floating, np.integer)): features[k] = float(v)
-        elif isinstance(v, np.bool_): features[k] = bool(v)
-        else: features[k] = v
-    while len(features) < 200: features[f"mt5_pad_{len(features)}"] = 0.0
+        if isinstance(v, (int, float, np.floating, np.integer)):
+            features[k] = float(v)
+        elif isinstance(v, np.bool_):
+            features[k] = bool(v)
+        else:
+            features[k] = v
+    while len(features) < 200:
+        features[f"mt5_pad_{len(features)}"] = 0.0
     return features
 
-def build_sol_features(df, onchain_data=None):
-    if df is None or len(df) < 20: return {}
+def build_sol_features(df: pd.DataFrame, onchain_data: Optional[Dict[str, Any]] = None,
+                       dev_data: Optional[Dict[str, Any]] = None,
+                       derivatives: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+    if df is None or len(df) < 20:
+        return {}
+
     try:
-        close = df["close"].astype(float); high = df["high"].astype(float)
-        low = df["low"].astype(float); open_p = df["open"].astype(float) if "open" in df.columns else close
+        close = df["close"].astype(float)
+        high = df["high"].astype(float)
+        low = df["low"].astype(float)
+        open_p = df["open"].astype(float) if "open" in df.columns else close
         volume = df["volume"].astype(float) if "volume" in df.columns else pd.Series([0.0]*len(df))
-    except: return {}
-    features = {}
+    except:
+        return {}
+
+    features: Dict[str, Any] = {}
     features["price"] = safe_float(close.iloc[-1])
     features["return_1h"] = safe_float(close.pct_change(1).iloc[-1])
-    features["return_24h"] = safe_float(close.pct_change(24).iloc[-1]) if len(close)>24 else 0.0
+    features["return_24h"] = safe_float(close.pct_change(24).iloc[-1]) if len(close) > 24 else 0.0
+
     kf = KalmanFilter()
     kalman_close = [kf.update(x) for x in close.values]
     features["kalman_price"] = kalman_close[-1]
     features["kalman_diff"] = close.iloc[-1] - kalman_close[-1]
+
     features["hurst_exponent"] = hurst_exponent(close)
+
     ret = close.pct_change()
-    features["volatility_1h"] = safe_float(ret.rolling(24, min_periods=24).std().iloc[-1]) if len(close)>=24 else 0.0
-    features["high_low_ratio"] = safe_float(((high.iloc[-1]-low.iloc[-1])/(close.iloc[-1]+1e-10))*100)
-    for span in [9,21,50]:
+    features["volatility_1h"] = safe_float(ret.rolling(24, min_periods=24).std().iloc[-1]) if len(close) >= 24 else 0.0
+    features["high_low_ratio"] = safe_float(((high.iloc[-1] - low.iloc[-1]) / (close.iloc[-1] + 1e-10)) * 100)
+
+    for span in [9, 21, 50]:
         if len(close) >= span:
             _, ema_val = safe_ema(close, span)
             if ema_val != 0:
                 features[f"ema_{span}"] = ema_val
-                features[f"price_vs_ema_{span}"] = safe_float(((close.iloc[-1]-ema_val)/ema_val)*100)
+                features[f"price_vs_ema_{span}"] = safe_float(((close.iloc[-1] - ema_val) / ema_val) * 100)
+
     if len(close) >= 26:
         try:
             ema12 = close.ewm(span=12, adjust=False).mean()
@@ -400,210 +489,418 @@ def build_sol_features(df, onchain_data=None):
             features["macd"] = safe_float(macd.iloc[-1])
             features["macd_signal"] = safe_float(signal.iloc[-1])
             features["macd_hist"] = features["macd"] - features["macd_signal"]
-        except: pass
-    features["rsi_14"] = safe_rsi(close, 14) if len(close)>=14 else 50.0
+        except:
+            pass
+
+    features["rsi_14"] = safe_rsi(close, 14) if len(close) >= 14 else 50.0
+
     if len(close) >= 14:
         try:
             prev_close = close.shift(1)
-            tr = pd.DataFrame({"tr1":high-low, "tr2":(high-prev_close).abs(), "tr3":(low-prev_close).abs()}).max(axis=1)
+            tr = pd.DataFrame({
+                "tr1": high - low,
+                "tr2": (high - prev_close).abs(),
+                "tr3": (low - prev_close).abs()
+            }).max(axis=1)
             features["atr_14"] = safe_float(tr.rolling(14, min_periods=14).mean().iloc[-1])
-            features["atr_pct"] = (features["atr_14"]/(close.iloc[-1]+1e-10))*100
-        except: features["atr_14"] = close.iloc[-1]*0.02
+            features["atr_pct"] = (features["atr_14"] / (close.iloc[-1] + 1e-10)) * 100
+        except:
+            features["atr_14"] = close.iloc[-1] * 0.02
+
+    # Ончейн и фундаментальные данные
     if onchain_data:
-        features["tvl"] = onchain_data.get("tvl",0)
-        features["tvl_trend"] = 1 if onchain_data.get("tvl_trend")=="UP" else -1
-        features["dex_volume_24h"] = onchain_data.get("dex_volume_24h",0)
-        features["active_users"] = onchain_data.get("active_users",0)
-    for kw in ["solana","memecoin","pump_fun","firedancer"]: features[f"trends_{kw}"] = fetch_google_trends_index(kw)
+        features["tvl"] = onchain_data.get("tvl", 0)
+        features["tvl_trend"] = 1 if onchain_data.get("tvl_trend") == "UP" else -1
+        features["dex_volume_24h"] = onchain_data.get("dex_volume_24h", 0)
+        features["active_users"] = onchain_data.get("active_users", 0)
+    if dev_data:
+        features["developer_score"] = dev_data.get("developer_score", 50)
+        features["developer_activity"] = dev_data.get("developer_activity", "MODERATE")
+    if derivatives:
+        features["funding_rate"] = derivatives.get("funding_rate", 0)
+        features["open_interest"] = derivatives.get("open_interest", 0)
+        features["funding_bullish"] = 1 if derivatives.get("funding_signal") == "BULLISH" else 0
+        features["funding_bearish"] = 1 if derivatives.get("funding_signal") == "BEARISH" else 0
+
+    for kw in ["solana", "memecoin", "pump_fun", "firedancer"]:
+        features[f"trends_{kw}"] = fetch_google_trends_index(kw)
+
     now = datetime.utcnow()
-    features["is_weekend"] = 1 if now.weekday()>=5 else 0
+    features["is_weekend"] = 1 if now.weekday() >= 5 else 0
     features["hour"] = now.hour
-    while len(features) < 200: features[f"pad_{len(features)}"] = 0.0
+
+    while len(features) < 200:
+        features[f"pad_{len(features)}"] = 0.0
+
     return features
 
-def get_multi_tf_features(onchain_data):
-    all_features, sources = {}, []
+def get_multi_tf_features(onchain_data: Dict[str, Any], dev_data: Dict[str, Any],
+                          derivatives: Dict[str, Any]) -> Tuple[Dict[str, Dict[str, Any]], List[str]]:
+    all_features: Dict[str, Dict[str, Any]] = {}
+    sources: List[str] = []
     for tf in TIMEFRAMES:
         df, source = fetch_twelvedata_sol(tf)
         if df is not None and len(df) >= 30:
-            feats = build_sol_features(df, onchain_data)
-            if feats: all_features[tf] = feats; sources.append(source or "Unknown")
+            feats = build_sol_features(df, onchain_data, dev_data, derivatives)
+            if feats:
+                all_features[tf] = feats
+                sources.append(source or "Unknown")
     return all_features, sources
 
-# ================= ГЛАВНЫЙ СИГНАЛ (ансамбль daily + 4h) =================
-def get_sol_signal():
+# ================= ДИНАМИЧЕСКИЕ ВЕСА =================
+def update_component_perf(component: str, success: bool):
+    c = COMPONENT_PERF[component]
+    c["total"] += 1
+    if success:
+        c["correct"] += 1
+    if success:
+        c["sharpe"] = min(3.0, c["sharpe"] + 0.1)
+    else:
+        c["sharpe"] = max(0.1, c["sharpe"] - 0.1)
+
+def get_dynamic_component_weights(regime: str) -> Dict[str, float]:
+    base = REGIME_WEIGHTS.get(regime, REGIME_WEIGHTS["RANGE"])
+    model_acc = COMPONENT_PERF["model"]["correct"] / max(COMPONENT_PERF["model"]["total"], 1)
+    model_sharpe = COMPONENT_PERF["model"]["sharpe"]
+    model_w = base["model"] * model_acc * model_sharpe
+
+    tf_acc = COMPONENT_PERF["tf"]["correct"] / max(COMPONENT_PERF["tf"]["total"], 1)
+    tf_sharpe = COMPONENT_PERF["tf"]["sharpe"]
+    tf_w = base["tf"] * tf_acc * tf_sharpe
+
+    remaining = 1.0 - (model_w + tf_w)
+    onchain_w = remaining * 0.6
+    deriv_w = remaining * 0.4
+
+    weights = {"model": model_w, "tf": tf_w, "onchain": onchain_w, "derivatives": deriv_w}
+    norm = sum(weights.values())
+    if norm > 0:
+        weights = {k: v/norm for k, v in weights.items()}
+    return weights
+
+# ================= ГЛАВНЫЙ СИГНАЛ (АНСАМБЛЬ С DYNAMIC WEIGHTS) =================
+def get_sol_signal() -> Optional[Dict[str, Any]]:
     global LAST_CONFIDENCE
     start = time.time()
-    mt5_features = None; mt5_price = None; data_source = "UNKNOWN"
+
+    # Дополнительные данные (всегда)
+    onchain_data = fetch_solana_onchain()
+    dev_data = fetch_solana_dev_activity()
+    coingecko = fetch_coingecko_sol()
+    binance_data = fetch_binance_sol()
+
+    # MT5 или API
+    mt5_features: Optional[Dict[str, Any]] = None
+    mt5_price: Optional[float] = None
+    data_source: str = "UNKNOWN"
+
     fs = FEATURES_STORE.get(SYMBOL, {})
     age = time.time() - fs.get("timestamp", 0)
     if age < MT5_MAX_AGE_SEC:
-        mt5_features = fs.get("features", {}); mt5_price = fs.get("price"); data_source = "MT5"
-    onchain_data = fetch_solana_onchain()
-    pump_fun = fetch_pump_fun_activity()
-    coingecko = fetch_coingecko_sol()
-    binance = fetch_binance_sol()
-    mtf_features, sources = {}, []
+        mt5_features = fs.get("features", {})
+        mt5_price = fs.get("price")
+        data_source = "MT5"
+        print(f"📡 Используем MT5 данные (возраст {age:.0f}с)")
+
+    mtf_features: Dict[str, Dict[str, Any]] = {}
+    sources: List[str] = []
+
     if mt5_features and len(mt5_features) >= 50:
         model_features = build_features_from_mt5(mt5_features)
-        model_features["tvl"] = onchain_data.get("tvl",0)
-        model_features["tvl_trend"] = 1 if onchain_data.get("tvl_trend")=="UP" else -1
-        model_features["active_users"] = onchain_data.get("active_users",0)
-        price = mt5_price or model_features.get("H1_price", model_features.get("price",0))
+        # Добавляем доп. данные
+        model_features["tvl"] = onchain_data.get("tvl", 0)
+        model_features["tvl_trend"] = 1 if onchain_data.get("tvl_trend") == "UP" else -1
+        model_features["active_users"] = onchain_data.get("active_users", 0)
+        model_features["developer_score"] = dev_data.get("developer_score", 50)
+        model_features["funding_rate"] = binance_data.get("funding_rate", 0)
+        model_features["open_interest"] = binance_data.get("open_interest", 0)
+        model_features["funding_bullish"] = 1 if binance_data.get("funding_signal") == "BULLISH" else 0
+        model_features["funding_bearish"] = 1 if binance_data.get("funding_signal") == "BEARISH" else 0
+        price = mt5_price or model_features.get("H1_price", model_features.get("price", 0))
         sources = ["MT5"]
     else:
-        mtf_features, sources = get_multi_tf_features(onchain_data)
-        if not mtf_features: return None
+        print("  ⚠️ MT5 данные недоступны, перехожу на API...")
+        mtf_features, sources = get_multi_tf_features(onchain_data, dev_data, binance_data)
+        if not mtf_features:
+            print("❌ Нет данных")
+            return None
         h1_features = mtf_features.get("1h", list(mtf_features.values())[0])
         model_features = h1_features
-        price = h1_features.get("price",0)
+        price = h1_features.get("price", 0)
         data_source = "+".join(sources) if sources else "API"
-    if price == 0: return None
+
+    if price == 0:
+        return None
+
+    # Стресс-тест
     stress = stress_test(model_features)
     if stress == "WAIT":
-        return {"space":"space_19_sol_master","symbol":SYMBOL,"signal":{"direction":"WAIT","confidence":0.0},"reason":"stress_test_black_swan"}
+        print("🛑 СТРЕСС-ТЕСТ: рынок слишком опасен")
+        return {
+            "space": "space_19_sol_master",
+            "symbol": SYMBOL,
+            "signal": {"direction": "WAIT", "confidence": 0.0},
+            "reason": "stress_test_black_swan"
+        }
+
     regime = detect_market_regime(model_features)
-    
-    # ----- АНСАМБЛЬ DAILY + 4H -----
+    print(f"📊 Режим: {regime} | Цена: ${price:.2f} | TVL: ${onchain_data.get('tvl',0)/1e6:.1f}M | Данные: {data_source}")
+
+    # === ПРЕДСКАЗАНИЕ МОДЕЛИ (АНСАМБЛЬ daily + 4h) ===
     xgb_prob = 0.5
+    models_used = 0
     if model_features:
         try:
             fv = list(model_features.values())[:200]
             while len(fv) < 200:
                 fv.append(0.0)
             X = np.nan_to_num(np.array(fv, dtype=np.float64).reshape(1, -1))
+
             probs = []
             if MODELS.get("xgb_daily"):
                 proba = MODELS["xgb_daily"].predict_proba(X)[0]
                 probs.append(float(proba[1] if len(proba) > 1 else proba[0]))
+                models_used += 1
             if MODELS.get("xgb_4h"):
                 proba = MODELS["xgb_4h"].predict_proba(X)[0]
                 probs.append(float(proba[1] if len(proba) > 1 else proba[0]))
-            if probs:
+                models_used += 1
+            if MODELS.get("lgb"):
+                proba = MODELS["lgb"].predict_proba(X)[0]
+                lgb_prob = float(proba[1] if len(proba) > 1 else proba[0])
+                if probs:
+                    xgb_prob = sum(probs)/len(probs) * 0.6 + lgb_prob * 0.4
+                else:
+                    xgb_prob = lgb_prob
+                models_used += 1
+            elif probs:
                 xgb_prob = sum(probs) / len(probs)
-                xgb_prob = max(0.0, min(1.0, xgb_prob))
+            xgb_prob = max(0.0, min(1.0, xgb_prob))
         except Exception as e:
             print(f"  ⚠️ Ошибка предсказания: {e}")
 
-    onchain_score = 0.0
-    if onchain_data.get("tvl_trend")=="UP": onchain_score += 0.1
-    if onchain_data.get("dex_change_24h",0) > 10: onchain_score += 0.05
-    if pump_fun.get("ecosystem_activity")=="HIGH": onchain_score += 0.05
-    if binance.get("funding_signal")=="BULLISH": onchain_score += 0.05
-    elif binance.get("funding_signal")=="BEARISH": onchain_score -= 0.05
-
+    # Мульти-ТФ подтверждение
     if data_source == "MT5":
-        confirmations, total_tf = 0,0
-        for tf_key in ["M15","H1","H4"]:
+        confirmations, total_tf = 0, 0
+        for tf_key in ["M15", "H1", "H4"]:
             ema_key = f"{tf_key}_price_vs_ema_21"
             if ema_key in model_features:
                 total_tf += 1
-                if model_features.get(ema_key,0) > 0: confirmations += 1
-                else: confirmations -= 1
-        tf_score = confirmations / max(total_tf,1)
-        tf_norm = (tf_score + 1)/2
+                if model_features.get(ema_key, 0) > 0:
+                    confirmations += 1
+                else:
+                    confirmations -= 1
+        tf_score = confirmations / max(total_tf, 1)
+        tf_norm = (tf_score + 1) / 2
     else:
-        confirmations, total_tf = 0,0
-        for tf_key in ["15min","1h","4h"]:
+        confirmations, total_tf = 0, 0
+        for tf_key in ["15min", "1h", "4h"]:
             tf_feats = mtf_features.get(tf_key, {})
-            if not tf_feats: continue
+            if not tf_feats:
+                continue
             total_tf += 1
-            ema_score = tf_feats.get("price_vs_ema_21",0)
-            rsi_val = tf_feats.get("rsi_14",50)
-            macd_hist = tf_feats.get("macd_hist",0)
-            if ema_score > 0 and rsi_val > 50 and macd_hist > 0: confirmations += 1
-            elif ema_score < 0 and rsi_val < 50 and macd_hist < 0: confirmations -= 1
-        tf_score = confirmations / max(total_tf,1)
-        tf_norm = (tf_score + 1)/2
-
-    w = REGIME_WEIGHTS.get(regime, REGIME_WEIGHTS["RANGE"])
-    final_score = xgb_prob * w["model"] * 0.50 + tf_norm * w["tf"] * 0.20 + (0.5 + onchain_score) * 0.30
+            ema_score = tf_feats.get("price_vs_ema_21", 0)
+            rsi_val = tf_feats.get("rsi_14", 50)
+            macd_hist = tf_feats.get("macd_hist", 0)
+            if ema_score > 0 and rsi_val > 50 and macd_hist > 0:
+                confirmations += 1
+            elif ema_score < 0 and rsi_val < 50 and macd_hist < 0:
+                confirmations -= 1
+        tf_score = confirmations / max(total_tf, 1)
+        tf_norm = (tf_score + 1) / 2
+
+    # Meta SOL Score: TVL, DEX Volume, Active Addresses, Developer Activity
+    tvl_norm = 0.5
+    if onchain_data.get("tvl", 0) > 0:
+        tvl_norm = min(1.0, max(0.0, 0.5 + onchain_data.get("tvl_change_24h", 0) / 20))
+    dex_norm = 0.5
+    if onchain_data.get("dex_volume_24h", 0) > 0:
+        dex_norm = min(1.0, max(0.0, 0.5 + onchain_data.get("dex_change_24h", 0) / 20))
+    dev_norm = 0.5
+    if dev_data.get("developer_score", 50) > 50:
+        dev_norm = 0.7
+    active_norm = 0.5
+    # Meta Score = среднее
+    meta_sol_score = (tvl_norm + dex_norm + dev_norm + active_norm) / 4
+
+    # Компонент деривативов
+    deriv_norm = 0.5
+    if binance_data.get("funding_signal") == "BULLISH":
+        deriv_norm = 0.7
+    elif binance_data.get("funding_signal") == "BEARISH":
+        deriv_norm = 0.3
+
+    # Динамические веса
+    comp_weights = get_dynamic_component_weights(regime)
+    print(f"  ⚖️ Веса: {comp_weights}")
+
+    final_score = (
+        xgb_prob * comp_weights["model"] +
+        tf_norm * comp_weights["tf"] +
+        meta_sol_score * comp_weights["onchain"] +
+        deriv_norm * comp_weights["derivatives"]
+    )
     confidence = smooth_confidence(final_score)
 
-    if confidence > SOL_THRESHOLD + 0.08: direction = "LONG"
-    elif confidence < SOL_THRESHOLD - 0.08: direction = "SHORT"
-    else: direction = "WAIT"
+    if confidence > SOL_THRESHOLD + 0.08:
+        direction = "LONG"
+    elif confidence < SOL_THRESHOLD - 0.08:
+        direction = "SHORT"
+    else:
+        direction = "WAIT"
 
-    atr = model_features.get("atr_14", price*0.02)
+    # SL/TP
+    atr = model_features.get("atr_14", price * 0.02)
     sl_mult = TRADING_RULES.get("sl_atr_multiplier", 2.0)
     tp_mult = TRADING_RULES.get("tp_atr_multiplier", 4.0)
-    sl_dist = atr * sl_mult; tp_dist = atr * tp_mult
-    sl = round(price - sl_dist, 2) if direction == "LONG" else round(price + sl_dist, 2) if direction == "SHORT" else 0
-    tp = round(price + tp_dist, 2) if direction == "LONG" else round(price - tp_dist, 2) if direction == "SHORT" else 0
+    sl_dist = atr * sl_mult
+    tp_dist = atr * tp_mult
+    if direction == "LONG":
+        sl = round(price - sl_dist, 2)
+        tp = round(price + tp_dist, 2)
+    elif direction == "SHORT":
+        sl = round(price + sl_dist, 2)
+        tp = round(price - tp_dist, 2)
+    else:
+        sl = tp = 0
 
-    PREDICTION_HISTORY.append({"timestamp": datetime.utcnow().isoformat(), "direction": direction, "confidence": confidence, "price": price})
-    if db:
-        try: db.collection("space19_sol_signals").add({"direction":direction,"confidence":confidence,"price":price,"regime":regime,"data_source":data_source,"timestamp": firestore.SERVER_TIMESTAMP})
-        except: pass
+    PREDICTION_HISTORY.append({
+        "timestamp": datetime.utcnow().isoformat(),
+        "direction": direction,
+        "confidence": confidence,
+        "price": price
+    })
 
+    if db:
+        try:
+            db.collection("space19_sol_signals").add({
+                "direction": direction,
+                "confidence": confidence,
+                "price": price,
+                "regime": regime,
+                "data_source": data_source,
+                "timestamp": firestore.SERVER_TIMESTAMP
+            })
+        except:
+            pass
+
+    latency = int((time.time() - start) * 1000)
     result = {
-        "space": "space_19_sol_master", "timestamp": int(time.time()), "symbol": SYMBOL,
-        "signal": {"direction": direction, "confidence": round(confidence, 4)},
+        "space": "space_19_sol_master",
+        "timestamp": int(time.time()),
+        "symbol": SYMBOL,
+        "signal": {
+            "direction": direction,
+            "confidence": round(confidence, 4),
+            "strength": round(confidence * (1 + abs(tf_score)), 4)
+        },
         "analysis": {
-            "xgb_probability": round(xgb_prob,4),
-            "models_used": sum(1 for m in ["xgb_daily","xgb_4h"] if MODELS.get(m) is not None),
-            "multi_tf_score": round(tf_score,4),
-            "onchain_score": round(onchain_score,4),
+            "xgb_probability": round(xgb_prob, 4),
+            "models_used": models_used,
+            "multi_tf_score": round(tf_score, 4),
+            "meta_sol_score": round(meta_sol_score, 4),
             "market_regime": regime,
             "data_source": data_source
         },
-        "onchain": {"tvl": onchain_data.get("tvl",0), "tvl_trend": onchain_data.get("tvl_trend","STABLE"), "active_users": onchain_data.get("active_users",0), "pump_fun": pump_fun, "binance": binance},
-        "risk": {"sl": sl, "tp": tp, "rr": round(tp_dist/(sl_dist+1e-10),2) if direction!="WAIT" else 0},
-        "meta": {"latency_ms": int((time.time()-start)*1000), "model_version": "v1.2 ensemble", "features_used": len(model_features) if model_features else 0}
+        "onchain": {
+            "tvl": onchain_data.get("tvl", 0),
+            "dex_volume_24h": onchain_data.get("dex_volume_24h", 0),
+            "active_users": onchain_data.get("active_users", 0),
+            "developer_score": dev_data.get("developer_score", 50),
+            "funding_rate": binance_data.get("funding_rate", 0)
+        },
+        "risk": {"sl": sl, "tp": tp, "rr": round(tp_dist/(sl_dist+1e-10), 2) if direction != "WAIT" else 0},
+        "meta": {
+            "latency_ms": latency,
+            "model_version": "v8.0_solana_dominance",
+            "features_used": len(model_features) if model_features else 0,
+            "dynamic_weights": comp_weights
+        }
     }
-    try:
-        requests.post(f"{SPACE_URLS['space_18_arbiter']}/log_signal", json={"space":"space_19_sol","symbol":SYMBOL,"signal":result.get("signal",{})}, timeout=5)
-    except: pass
-    print(f"🥉 SOL/USD: {direction} | conf={confidence:.3f} | ensemble={xgb_prob:.3f} | models={result['analysis']['models_used']} | regime={regime}")
+
+    send_to_arbiter(result)
+    print(f"🥉 SOL/USD: {direction} | conf={confidence:.3f} | ensemble={xgb_prob:.3f} | models={models_used} | regime={regime} | latency={latency}ms")
     return result
 
+# ================= KEEP-ALIVE =================
 def keep_alive():
     while True:
         time.sleep(840)
-        try: requests.get("http://localhost:7860/health", timeout=5)
-        except: pass
+        try:
+            requests.get("http://localhost:7860/health", timeout=5)
+        except:
+            pass
 threading.Thread(target=keep_alive, daemon=True).start()
 
-app = FastAPI(title="TOMIRIS SPACE 19 v1.2 — SOL/USD MASTER (Ensemble)")
+# ================= FASTAPI =================
+app = FastAPI(title="TOMIRIS SOL/USD MASTER v8.0 Solana Dominance")
 
 @app.get("/health")
-def health():
-    models_loaded = sum(1 for m in ["xgb_daily","xgb_4h"] if MODELS.get(m) is not None)
+async def health():
+    models_loaded = sum(1 for m in ["xgb_daily","xgb_4h","lgb"] if MODELS.get(m) is not None)
     return {
-        "space": "Space 19 v1.2 Ensemble",
+        "space": "Space 19 v8.0 Solana Dominance",
         "status": "operational",
         "symbol": SYMBOL,
         "models_loaded": models_loaded,
-        "models": {"daily": MODELS["xgb_daily"] is not None, "4h": MODELS["xgb_4h"] is not None}
+        "dynamic_weights": True,
+        "features": ["TVL", "DEX Volume", "Active Addresses", "Developer Activity", "Funding Rate"]
     }
 
 @app.get("/consilium")
-def consilium():
+async def consilium():
     try:
         signal = get_sol_signal()
-        return signal if signal else {"space":"space_19_sol_master","symbol":SYMBOL,"signal":{"direction":"WAIT","confidence":0.0},"error":"no_data"}
+        if signal:
+            return signal
+        return {"space":"space_19_sol_master","symbol":SYMBOL,"signal":{"direction":"WAIT","confidence":0.0},"error":"no_data"}
     except Exception as e:
         return {"space":"space_19_sol_master","symbol":SYMBOL,"signal":{"direction":"WAIT","confidence":0.0},"error": str(e)[:100]}
 
 @app.get("/signal")
-def signal(): return consilium()
+async def signal():
+    return await consilium()
 
 @app.get("/onchain")
-def onchain():
-    return {"solana": fetch_solana_onchain(), "pump_fun": fetch_pump_fun_activity(), "coingecko": fetch_coingecko_sol(), "binance": fetch_binance_sol()}
+async def onchain():
+    return {
+        "solana": fetch_solana_onchain(),
+        "dev_activity": fetch_solana_dev_activity(),
+        "coingecko": fetch_coingecko_sol(),
+        "binance": fetch_binance_sol()
+    }
 
 @app.get("/price")
-def current_price():
+async def current_price():
     hub = get_mt5_price_from_hub()
     return {"symbol": SYMBOL, "price": hub["price"] if hub["fresh"] else HUB_CACHE.get("price",0.0), "source": hub["source"], "fresh": hub["fresh"]}
 
 @app.post("/features")
-def receive_features(data: Dict[str, Any]):
-    symbol = data.get("symbol", "SOL/USD")
-    FEATURES_STORE[symbol] = {"features": data.get("features",{}), "price": data.get("price",0.0), "timestamp": time.time()}
+async def receive_features(data: Dict[str, Any]):
+    symbol = data.get("symbol", SYMBOL)
+    FEATURES_STORE[symbol] = {
+        "features": data.get("features", {}),
+        "price": data.get("price", 0.0),
+        "timestamp": time.time()
+    }
     print(f"📥 MT5 {symbol}: {len(data.get('features',{}))} признаков")
     return {"status": "ok"}
 
-print("🚀 SPACE 19 v1.2 — SOL/USD MASTER ENSEMBLE ЗАПУЩЕН!")
-print("🥉 Обе модели (daily + 4h) работают вместе!")
+@app.get("/metrics")
+async def metrics():
+    return {"symbol": SYMBOL, "predictions_stored": len(PREDICTION_HISTORY), "last_confidence": LAST_CONFIDENCE, "component_performance": COMPONENT_PERF}
+
+@app.get("/explain")
+async def explain():
+    if PREDICTION_HISTORY:
+        last = PREDICTION_HISTORY[-1]
+        return {
+            "last_direction": last["direction"],
+            "confidence": last["confidence"],
+            "note": "Explainability via dynamic weights"
+        }
+    return {"error": "No prediction yet"}
+
+print("🚀 SPACE 19 v8.0 — SOL/USD MASTER (Solana Dominance) ЗАПУЩЕН!")
+print("🥉 Ансамбль daily+4h + Meta SOL Score + Dynamic Weights")
 print("✅ Готов к бою!")