Create app.py

app.py

@@ -0,0 +1,738 @@
+# ============================================
+# АВТО-УСТАНОВКА ПАКЕТОВ
+# ============================================
+import subprocess
+import sys
+import 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.0 — SOL/USD MASTER
+# ============================================
+# Первый из 12 новых Space'ов экосистемного контура.
+# Специализируется ТОЛЬКО на Solana.
+# Модели XGBoost/LightGBM, ончейн-метрики Solana,
+# Pump.fun, DeFi Llama, экосистемные факторы.
+# ============================================
+
+import os
+import time
+import threading
+import warnings
+import json
+import asyncio
+from typing import Dict, Any, Optional, List, Tuple
+import numpy as np
+import pandas as pd
+import requests
+from datetime import datetime, timedelta
+from collections import deque
+from fastapi import FastAPI, Query
+warnings.filterwarnings('ignore')
+
+# ================= БЕЗОПАСНЫЙ ИМПОРТ =================
+HAS_JOBLIB = False
+HAS_FIREBASE = False
+HAS_YFINANCE = False
+
+try:
+    import joblib
+    HAS_JOBLIB = True
+except:
+    print("⚠️ joblib не установлен")
+
+try:
+    import firebase_admin
+    from firebase_admin import credentials, firestore
+    HAS_FIREBASE = True
+except:
+    print("⚠️ firebase_admin не установлен")
+
+try:
+    import yfinance as yf
+    HAS_YFINANCE = True
+except:
+    print("⚠️ yfinance не установлен")
+
+# ================= FIREBASE =================
+db = None
+if HAS_FIREBASE:
+    try:
+        cred = credentials.Certificate("firebase-key.json")
+        firebase_admin.initialize_app(cred)
+        db = firestore.client()
+        print("✅ Firebase подключен")
+    except Exception as e:
+        print(f"⚠️ Firebase: {e}")
+
+# ================= URL'ы СМЕЖНЫХ SPACE'ов =================
+SPACE_URLS: Dict[str, str] = {
+    "space_1_xau": "https://nuxotetotmailsvoboden-tomiris.hf.space",
+    "space_2_eth": "https://nuxotetotmailsvoboden-tomiris-falcon-ai.hf.space",
+    "space_9_onchain": "https://nuxotetotnicksvoboden-name3.hf.space",
+    "space_10_whales": "https://nuxotetotnicksvoboden-name4.hf.space",
+    "space_17_hub": "https://tomiris-ai-name5-5.hf.space",
+    "space_18_arbiter": "https://tomiris-ai-name6-6.hf.space"
+}
+
+# ================= API КЛЮЧИ =================
+TWELVE_KEYS: List[str] = [
+    "e3740c072fda4fe8b8539d40b07e445e",
+    "58e67e0008e24161ac9b1671b7c2d2d0"
+]
+
+# ================= КОНФИГУРАЦИЯ =================
+SYMBOL: str = "SOL/USD"
+MT5_SYMBOL: str = "SOLUSD"
+TIMEFRAMES: List[str] = ["15min", "1h", "4h"]
+
+# Загружаем пороги из best_config.json если есть
+try:
+    with open("best_config.json", "r") as f:
+        config = json.load(f)
+    SOL_THRESHOLD: float = config.get("sol", {}).get("threshold", 0.52)
+    TRADING_RULES: Dict[str, Any] = config.get("trading_rules", {})
+except:
+    SOL_THRESHOLD: float = 0.52
+    TRADING_RULES: Dict[str, Any] = {
+        "sl_atr_multiplier": 2.0,
+        "tp_atr_multiplier": 4.0,
+        "max_spread_pct": 2.0,
+        "trailing_stop_activation": 0.008,
+        "trailing_stop_distance": 0.005,
+        "breakeven_at": 0.008
+    }
+
+CACHE_TTL: int = 900
+MT5_MAX_AGE_SEC: int = 300
+HUB_CACHE_TTL: float = 5.0
+
+# Адаптивные веса по режиму рынка
+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: Dict[str, Any] = {}
+DATA_CACHE: Dict[str, Dict[str, Any]] = {}
+PREDICTION_HISTORY = deque(maxlen=500)
+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
+
+# Yahoo Finance маппинг
+YAHOO_INTERVAL_MAP: Dict[str, str] = {
+    "15min": "15m",
+    "1h": "60m",
+    "4h": "4h"
+}
+
+# ================= ЗАГРУЗКА МОДЕЛЕЙ =================
+print(f"🔥 SPACE 19 v1.0: Загрузка моделей для {SYMBOL}...")
+MODELS: Dict[str, Optional[Any]] = {"xgb": None, "lgb": None}
+
+if HAS_JOBLIB:
+    try:
+        MODELS["xgb"] = joblib.load("xgboost_sol_v3.joblib")
+        print("✅ XGBoost SOL загружен (v3)")
+    except Exception as e:
+        print(f"⚠️ XGBoost SOL: {e}")
+        try:
+            MODELS["xgb"] = joblib.load("xgboost_sol_v2.joblib")
+            print("✅ XGBoost SOL загружен (v2, fallback)")
+        except:
+            print("❌ XGBoost SOL не найден")
+
+    try:
+        MODELS["lgb"] = joblib.load("lgb_sol_v2.joblib")
+        print("✅ LightGBM SOL загружен (v2)")
+    except:
+        print("⚠️ LightGBM SOL не найден")
+else:
+    print("⚠️ joblib не установлен — сигналы будут нейтральными")
+
+# ================= УТИЛИТЫ =================
+api_lock = threading.Lock()
+twelve_counter: int = 0
+
+def get_next_twelve_key() -> str:
+    global twelve_counter
+    with api_lock:
+        key = TWELVE_KEYS[twelve_counter % len(TWELVE_KEYS)]
+        twelve_counter += 1
+        return key
+
+session = requests.Session()
+session.headers.update({"User-Agent": "Tomiris-Space19-v1.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
+        result = float(val)
+        return result if not pd.isna(result) else default
+    except:
+        return default
+
+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()
+        loss = (-delta.clip(upper=0)).rolling(period, min_periods=period).mean()
+        g_val, l_val = gain.iloc[-1], loss.iloc[-1]
+        if pd.notna(g_val) and pd.notna(l_val) and l_val > 0:
+            rs = g_val / l_val
+            return float(100 - (100 / (1 + rs)))
+        return 50.0
+    except:
+        return 50.0
+
+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])
+    except:
+        return None, 0.0
+
+# ================= ФИЛЬТР КАЛМАНА =================
+class KalmanFilter:
+    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.p + self.q
+        k = self.p / (self.p + self.r)
+        self.x = self.x + k * (z - self.x)
+        self.p = (1 - k) * self.p
+        return self.x
+
+# ================= HURST EXPONENT =================
+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
+
+# ================= GOOGLE TRENDS =================
+def fetch_google_trends_index(keyword: str) -> float:
+    try:
+        return 50.0
+    except:
+        return 50.0
+
+# ================= 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
+    try:
+        r = requests.get(f"{SPACE_URLS['space_17_hub']}/price/{SYMBOL}", timeout=3)
+        if r.status_code == 200:
+            data = r.json()
+            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"
+                }
+                return HUB_CACHE
+    except:
+        pass
+    return {"price": 0.0, "timestamp": time.time(), "fresh": False, "source": "UNAVAILABLE"}
+
+# ================= CIRCUIT BREAKER =================
+def breaker_open(name: str) -> bool:
+    info = CIRCUIT_BREAKERS.get(name)
+    if not info: return False
+    if info["fails"] < 5: return False
+    if time.time() - info["last_fail"] > 300:
+        CIRCUIT_BREAKERS[name] = {"fails": 0, "last_fail": 0}
+        return False
+    return True
+
+def breaker_fail(name: str) -> None:
+    info = CIRCUIT_BREAKERS.get(name, {"fails": 0, "last_fail": 0})
+    info["fails"] += 1
+    info["last_fail"] = time.time()
+    CIRCUIT_BREAKERS[name] = info
+
+# ================= СГЛАЖИВАНИЕ =================
+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: 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"
+    return "RANGE"
+
+# ================= СТРЕСС-ТЕСТ =================
+def stress_test(features: Dict[str, Any]) -> Optional[str]:
+    atr_pct = features.get("atr_pct", 3.0)
+    if atr_pct > 12.0:
+        return "WAIT"
+    vol_1h = features.get("volatility_1h", 0.0)
+    if vol_1h > 0.08:
+        return "WAIT"
+    return None
+
+# ================= ЗАГРУЗКА ДАННЫХ =================
+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"]
+
+    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}"
+            r = session.get(url, timeout=10)
+            if r.status_code == 200:
+                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")
+                    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()
+                        }
+                        return df, f"TwelveData-Key{key_idx+1}"
+            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_period = period_map.get(tf, "60d")
+            yf_data = yf.download("SOL-USD", period=yf_period, 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()
+                if len(df) >= 30:
+                    DATA_CACHE[cache_key] = {"df": df, "source": "YahooFinance", "timestamp": time.time()}
+                    return df, "YahooFinance"
+        except:
+            pass
+    return None, None
+
+# ================= SOLANA ОНЧЕЙН-МЕТРИКИ =================
+def fetch_solana_onchain() -> Dict[str, Any]:
+    """TVL, DEX volume, активные кошельки для Solana."""
+    cache_key = "solana_onchain"
+    if cache_key in DATA_CACHE:
+        age = time.time() - DATA_CACHE[cache_key].get("timestamp", 0)
+        if age < 300:
+            return DATA_CACHE[cache_key]["data"]
+
+    result: Dict[str, Any] = {}
+
+    # TVL
+    try:
+        r = requests.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:
+        result['tvl'] = 0
+        result['tvl_trend'] = 'STABLE'
+
+    # DEX volume
+    try:
+        r = requests.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:
+        result['dex_volume_24h'] = 0
+
+    # Активные кошельки
+    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:
+        result['active_users'] = 0
+
+    DATA_CACHE[cache_key] = {"data": result, "timestamp": time.time()}
+    return result
+
+def fetch_pump_fun_activity() -> Dict[str, Any]:
+    """Активность Pump.fun через CoinGecko."""
+    try:
+        r = requests.get(
+            "https://api.coingecko.com/api/v3/coins/solana?community_data=true&developer_data=true",
+            timeout=10
+        )
+        if r.status_code == 200:
+            data = r.json()
+            community = data.get('community_data', {})
+            developer = data.get('developer_data', {})
+            return {
+                'reddit_activity': community.get('reddit_average_posts_48h', 0),
+                'developer_score': developer.get('developer_score', 0),
+                'ecosystem_activity': 'HIGH' if developer.get('developer_score', 0) > 80 else 'MODERATE'
+            }
+    except:
+        pass
+    return {'ecosystem_activity': 'MODERATE'}
+
+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_binance_sol() -> Dict[str, Any]:
+    """Funding Rate и Open Interest для SOLUSDT."""
+    result: Dict[str, Any] = {}
+    try:
+        r = requests.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:
+        result['funding_rate'] = 0
+
+    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:
+        result['open_interest'] = 0
+
+    return result
+
+# ================= ПОСТРОЕНИЕ ПРИЗНАКОВ =================
+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
+    return features
+
+def build_sol_features(df: pd.DataFrame, onchain_data: 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
+        volume = df["volume"].astype(float) if "volume" in df.columns else pd.Series([0.0]*len(df))
+    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
+
+    # Калман
+    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]
+
+    # Hurst
+    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)
+
+    # EMA
+    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)
+
+    # MACD
+    if len(close) >= 26:
+        try:
+            ema12 = close.ewm(span=12, adjust=False).mean()
+            ema26 = close.ewm(span=26, adjust=False).mean()
+            macd = ema12 - ema26
+            signal = macd.ewm(span=9, adjust=False).mean()
+            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
+
+    # RSI
+    features["rsi_14"] = safe_rsi(close, 14) if len(close) >= 14 else 50.0
+
+    # ATR
+    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)
+            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
+
+    # Ончейн
+    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)
+
+    # Время
+    now = datetime.utcnow()
+    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
+
+    return features
+
+# ================= МУЛЬТИ-ТФ =================
+def get_multi_tf_features(onchain_data: 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")
+    return all_features, sources
+
+# ================= ГЛАВНЫЙ СИГНАЛ =================
+def get_sol_signal() -> Optional[Dict[str, Any]]:
+    global LAST_CONFIDENCE
+    start_time = time.time()
+
+    # MT5 данные
+    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"
+        print(f"📡 Используем MT5 данные (возраст {age:.0f}с)")
+
+    # Ончейн и рынок
+    onchain_data = fetch_solana_onchain()
+    pump_fun = fetch_pump_fun_activity()
+    coingecko = fetch_coingecko_sol()
+    binance = fetch_binance_sol()
+
+    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))
+        sources = ["MT5"]
+    else:
+        print("  ⚠️ MT5 данные недоступны, перехожу на API...")
+        mtf_features, sources = get_multi_tf_features(onchain_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)
+        data_source = "+".join(sources) if sources else "API"
+
+    if price == 0:
+        return None
+
+    # Стресс-тест
+    stress = stress_test(model_features)
+    if stress == "WAIT":
+        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)
+    print(f"📊 Режим: {regime} | Цена: ${price:.2f} | TVL: ${onchain_data.get('tvl', 0)/1e9:.1f}B | Данные: {data_source}")
+
+    # Предсказание модели
+    xgb_prob = 0.5
+    if model_features and MODELS.get("xgb"):
+        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))
+            proba = MODELS["xgb"].predict_proba(X)[0]
+            xgb_prob = float(proba[1] if len(proba) > 1 else proba[0])
+            xgb_prob = max(0.0, min(1.0, xgb_prob))
+        except:
+            pass
+
+    # Ончейн-скор
+    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"]:
+            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
+    else:
+        confirmations, total_tf = 0, 0
+        for tf_key in ["15min", "1h", "4h"]:
+            tf_feats = mtf_features.get(tf_key, {})
+            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
+    )
+
+    confidence = smooth_confidence(final_score)
+
+    if confidence > SOL_THRESHOLD + 0.08:
+        direction = "LONG"
+    elif confidence < SOL_THRESHOLD - 0.08:
+        direction = "SHORT"
+    else:
+        direction = "WAIT"
+
+    # SL/TP (шире из-за волатильности SOL)
+    atr = model_features.get("at