Update app.py

app.py

@@ -19,15 +19,14 @@ for module_name, pip_name in REQUIRED_PACKAGES.items():
         print(f"✅ {pip_name} установлен!")
 
 # ============================================
-# 👑 TOMIRIS SPACE 23 v1.0 — ON-CHAIN ANOMALY DETECTOR
+# 👑 TOMIRIS SPACE 24 v1.0 — ECOSYSTEM AGGREGATOR
 # ============================================
-# Детектирует аномалии на блокчейне:
-# Китовые транзакции, приток/отток на биржи, скачки газа,
-# нетипичная активность, сливы/пампы.
+# Агрегирует сигналы от Space 19-23 и выдаёт единый
+# экосистемный вердикт для XAU/USD, ETH/USD, SOL/USD.
 # ============================================
 
 from fastapi import FastAPI, Query
-from typing import Optional, Dict, Any, List
+from typing import Dict, Any, List, Optional, Tuple
 import time
 import requests
 import threading
@@ -38,284 +37,211 @@ import warnings
 warnings.filterwarnings('ignore')
 
 # ================= КОНФИГУРАЦИЯ =================
-TRACKED_SYMBOLS: List[str] = ["ETH/USD", "SOL/USD"]
+SYMBOLS: List[str] = ["XAU/USD", "ETH/USD", "SOL/USD"]
+
+# URL'ы экосистемных Space'ов (19-23)
+ECOSYSTEM_SPACES: Dict[str, Dict[str, Any]] = {
+    "space_19_sol": {
+        "url": "https://tomiris-ecosystem-sol-master.hf.space",
+        "weight": 0.25,
+        "symbols": ["SOL/USD"],
+        "description": "SOL Master"
+    },
+    "space_20_l2_defi": {
+        "url": "https://tomiris-ecosystem-l2-defi.hf.space",
+        "weight": 0.25,
+        "symbols": ["ETH/USD"],
+        "description": "L2 & DeFi Pulse"
+    },
+    "space_21_gold_macro": {
+        "url": "https://tomiris-ecosystem-gold-macro.hf.space",
+        "weight": 0.25,
+        "symbols": ["XAU/USD"],
+        "description": "Gold Macro & Flow"
+    },
+    "space_22_sentiment": {
+        "url": "https://tomiris-ecosystem-sentiment.hf.space",
+        "weight": 0.15,
+        "symbols": ["XAU/USD", "ETH/USD", "SOL/USD"],
+        "description": "Cross-Asset Sentiment"
+    },
+    "space_23_anomaly": {
+        "url": "https://tomiris-ecosystem-anomaly.hf.space",
+        "weight": 0.10,
+        "symbols": ["ETH/USD", "SOL/USD"],
+        "description": "On-Chain Anomaly"
+    }
+}
 
 SPACE_18_ARBITER: str = "https://tomiris-ai-name6-6.hf.space"
 
-# API ключи
-ETHERSCAN_KEYS: List[str] = [
-    "TZGVD58I2HZ9G4BBD548KX11E4JFH4J5GX",
-    "NMK1GC2S8RKVQZ6YKV7CIVZGGAKS1XYWSI"
-]
-
 CACHE: Dict[str, Dict[str, Any]] = {}
 CACHE_TIMES: Dict[str, float] = {}
 FEATURES_STORE: Dict[str, Dict[str, Any]] = {}
 MT5_MAX_AGE_SEC: int = 300
-ANOMALY_HISTORY: deque = deque(maxlen=200)
-
-etherscan_counter: int = 0
-api_lock = threading.Lock()
-
-def get_next_etherscan_key() -> str:
-    global etherscan_counter
-    with api_lock:
-        key = ETHERSCAN_KEYS[etherscan_counter % len(ETHERSCAN_KEYS)]
-        etherscan_counter += 1
-        return key
 
 def send_to_arbiter(signal_data: Dict[str, Any]) -> None:
     try:
         requests.post(
             f"{SPACE_18_ARBITER}/log_signal",
-            json={'space': 'space_23_anomaly', 'symbol': 'ETH/USD', 'signal': signal_data.get('signal', {})},
+            json={'space': 'space_24_ecosystem', 'symbol': 'ALL', 'signal': signal_data.get('signal', {})},
             timeout=5
         )
     except:
         pass
 
-# ================= ETHERSCAN =================
-def fetch_gas_oracle() -> Dict[str, Any]:
-    cache_key = "gas_oracle"
+# ================= ЗАГРУЗКА СИГНАЛОВ =================
+def fetch_space_signal(space_name: str, url: str, symbol: str) -> Optional[Dict[str, Any]]:
+    cache_key = f"{space_name}_{symbol}"
     if cache_key in CACHE and time.time() - CACHE_TIMES.get(cache_key, 0) < 60:
         return CACHE[cache_key]
 
     try:
-        key = get_next_etherscan_key()
-        r = requests.get(
-            f"https://api.etherscan.io/api?module=gastracker&action=gasoracle&apikey={key}",
-            timeout=10
-        )
-        if r.status_code == 200 and r.json().get('status') == '1':
-            result = r.json()['result']
-            avg = int(result['ProposeGasPrice'])
-            data = {
-                'avg_gas': avg,
-                'gas_level': 'LOW' if avg < 30 else 'NORMAL' if avg < 80 else 'HIGH' if avg < 150 else 'EXTREME',
-                'is_anomaly': avg > 200
-            }
+        r = requests.get(f"{url}/consilium?symbol={symbol}", timeout=10)
+        if r.status_code == 200:
+            data = r.json()
             CACHE[cache_key] = data
             CACHE_TIMES[cache_key] = time.time()
             return data
-    except:
-        pass
-    return {'avg_gas': 45, 'gas_level': 'NORMAL', 'is_anomaly': False}
+    except Exception as e:
+        print(f"⚠️ {space_name}: {e}")
+    return None
 
-def fetch_large_transactions() -> Dict[str, Any]:
-    """Китовые транзакции (>100 ETH) через Etherscan."""
-    cache_key = "large_tx"
-    if cache_key in CACHE and time.time() - CACHE_TIMES.get(cache_key, 0) < 300:
-        return CACHE[cache_key]
+def fetch_all_ecosystem_signals(symbol: str) -> Dict[str, Dict[str, Any]]:
+    signals = {}
+    errors = []
 
-    try:
-        key = get_next_etherscan_key()
-        r = requests.get(
-            f"https://api.etherscan.io/api?module=account&action=txlist&address=0x00000000219ab540356cBB839Cbe05303d7705Fa&page=1&offset=10&sort=desc&apikey={key}",
-            timeout=10
-        )
-        if r.status_code == 200 and r.json().get('status') == '1':
-            txs = r.json()['result']
-            large_txs = []
-            for tx in txs:
-                value_eth = float(tx.get('value', 0)) / 1e18
-                if value_eth > 100:
-                    large_txs.append({
-                        'hash': tx.get('hash', '')[:10],
-                        'value_eth': round(value_eth, 2),
-                        'from': tx.get('from', '')[:10],
-                        'to': tx.get('to', '')[:10]
-                    })
-
-            is_anomaly = len(large_txs) > 3
-
-            result = {
-                'large_transactions': large_txs[:5],
-                'count': len(large_txs),
-                'is_anomaly': is_anomaly,
-                'signal': 'WHALE_ACTIVE' if is_anomaly else 'NORMAL'
-            }
-            CACHE[cache_key] = result
-            CACHE_TIMES[cache_key] = time.time()
-            return result
-    except:
-        pass
+    for space_name, config in ECOSYSTEM_SPACES.items():
+        if symbol not in config['symbols']:
+            continue
 
-    return {'large_transactions': [], 'count': 0, 'is_anomaly': False, 'signal': 'NORMAL'}
-
-# ================= BINANCE ПРИТОКИ/ОТТОКИ =================
-def fetch_exchange_flows(symbol: str = "ETH") -> Dict[str, Any]:
-    """Приток/отток на биржи (упрощённо через Binance данные)."""
-    cache_key = f"exchange_flows_{symbol}"
-    if cache_key in CACHE and time.time() - CACHE_TIMES.get(cache_key, 0) < 300:
-        return CACHE[cache_key]
+        signal = fetch_space_signal(space_name, config['url'], symbol)
+        if signal:
+            signals[space_name] = signal
+        else:
+            errors.append(space_name)
 
-    try:
-        binance_symbol = "ETHUSDT" if symbol == "ETH" else "SOLUSDT"
+    return signals, errors
 
-        # Оцениваем через large trades на Binance
-        r = requests.get(f"https://fapi.binance.com/fapi/v1/trades?symbol={binance_symbol}&limit=50", timeout=10)
-        if r.status_code == 200:
-            trades = r.json()
-            large_trades = [t for t in trades if float(t.get('qty', 0)) > 100]
-            buy_large = sum(1 for t in large_trades if t.get('isBuyerMaker') == False)
-            sell_large = sum(1 for t in large_trades if t.get('isBuyerMaker') == True)
-
-            net_flow = buy_large - sell_large
-            is_anomaly = abs(net_flow) > 10
-
-            result = {
-                'symbol': symbol,
-                'large_buys': buy_large,
-                'large_sells': sell_large,
-                'net_flow': net_flow,
-                'signal': 'INFLOW' if net_flow > 10 else 'OUTFLOW' if net_flow < -10 else 'BALANCED',
-                'is_anomaly': is_anomaly
-            }
-            CACHE[cache_key] = result
-            CACHE_TIMES[cache_key] = time.time()
-            return result
-    except:
-        pass
+# ================= АГРЕГАЦИЯ =================
+def aggregate_ecosystem(symbol: str) -> Dict[str, Any]:
+    signals, errors = fetch_all_ecosystem_signals(symbol)
 
-    return {'signal': 'BALANCED', 'is_anomaly': False}
+    if not signals:
+        return {
+            "ecosystem_score": 50.0,
+            "direction": "WAIT",
+            "confidence": 0.0,
+            "active_spaces": 0,
+            "error_spaces": len(errors),
+            "signals_detail": {},
+            "votes": {"LONG": 0.0, "SHORT": 0.0}
+        }
 
-# ================= АКТИВНЫЕ АДРЕСА (через DeFiLlama) =================
-def fetch_active_addresses(chain: str = "ethereum") -> Dict[str, Any]:
-    cache_key = f"active_addresses_{chain}"
-    if cache_key in CACHE and time.time() - CACHE_TIMES.get(cache_key, 0) < 600:
-        return CACHE[cache_key]
+    total_weight = 0.0
+    long_votes = 0.0
+    short_votes = 0.0
+    details = {}
+
+    for space_name, data in signals.items():
+        config = ECOSYSTEM_SPACES.get(space_name, {})
+        weight = config.get('weight', 0.1)
+        sig = data.get('signal', {})
+        direction = sig.get('direction', 'WAIT')
+        confidence = sig.get('confidence', 0)
+
+        # Взвешенное голосование
+        if direction == 'LONG':
+            long_votes += weight * confidence
+        elif direction == 'SHORT':
+            short_votes += weight * confidence
+
+        total_weight += weight
+        details[space_name] = {
+            "direction": direction,
+            "confidence": confidence,
+            "weight": weight,
+            "status": "active",
+            "description": config.get('description', '')
+        }
 
-    try:
-        r = requests.get(
-            f"https://api.llama.fi/overview/{chain}?excludeTotalDataChart=true&excludeTotalDataChartBreakdown=true",
-            timeout=10
-        )
-        if r.status_code == 200:
-            data = r.json()
-            active_users = data.get('activeUsers', 0)
-
-            prev = CACHE.get(f"{cache_key}_prev", active_users)
-            change = ((active_users - prev) / prev * 100) if prev > 0 else 0
-            CACHE[f"{cache_key}_prev"] = active_users
-
-            is_anomaly = abs(change) > 20  # Резкий скачок >20% = аномалия
-
-            result = {
-                'chain': chain,
-                'active_users': active_users,
-                'change_pct': round(change, 2),
-                'is_anomaly': is_anomaly,
-                'signal': 'SPIKE_UP' if change > 20 else 'SPIKE_DOWN' if change < -20 else 'NORMAL'
-            }
-            CACHE[cache_key] = result
-            CACHE_TIMES[cache_key] = time.time()
-            return result
-    except:
-        pass
+    for name in errors:
+        config = ECOSYSTEM_SPACES.get(name, {})
+        details[name] = {
+            "direction": "ERROR",
+            "confidence": 0,
+            "weight": config.get('weight', 0),
+            "status": "error",
+            "description": config.get('description', '')
+        }
 
-    return {'active_users': 0, 'is_anomaly': False, 'signal': 'NORMAL'}
-
-# ================= ОБЩИЙ ДЕТЕКТОР АНОМАЛИЙ =================
-def detect_anomalies(symbol: str) -> Dict[str, Any]:
-    chain = "ethereum" if "ETH" in symbol else "solana"
-    native = "ETH" if "ETH" in symbol else "SOL"
-
-    gas = fetch_gas_oracle() if chain == "ethereum" else {'is_anomaly': False}
-    large_tx = fetch_large_transactions() if chain == "ethereum" else {'is_anomaly': False, 'signal': 'NORMAL'}
-    flows = fetch_exchange_flows(native)
-    active = fetch_active_addresses(chain)
-
-    anomalies = []
-    anomaly_score = 0
-
-    if gas.get('is_anomaly'):
-        anomalies.append({"type": "GAS_SPIKE", "severity": "HIGH", "reason": f"Газ: {gas.get('avg_gas')} gwei"})
-        anomaly_score += 30
-
-    if large_tx.get('is_anomaly'):
-        anomalies.append({"type": "WHALE_MOVEMENT", "severity": "HIGH", "reason": f"Китовых TX: {large_tx.get('count')}"})
-        anomaly_score += 25
-
-    if flows.get('is_anomaly'):
-        direction = flows.get('signal', '')
-        if direction == 'OUTFLOW':
-            anomalies.append({"type": "EXCHANGE_OUTFLOW", "severity": "HIGH", "reason": "Крупный отток с бирж"})
-            anomaly_score += 20
-        elif direction == 'INFLOW':
-            anomalies.append({"type": "EXCHANGE_INFLOW", "severity": "MEDIUM", "reason": "Крупный приток на биржи"})
-            anomaly_score += 15
-
-    if active.get('is_anomaly'):
-        anomalies.append({"type": "ADDRESS_SPIKE", "severity": "MEDIUM", "reason": f"Адреса: {active.get('signal')} ({active.get('change_pct')}%)"})
-        anomaly_score += 15
-
-    anomaly_score = min(100, anomaly_score)
-
-    if anomaly_score >= 60:
-        level = "CRITICAL"
-        signal = "WAIT"  # При критических аномалиях — не торгуем
-    elif anomaly_score >= 30:
-        level = "ELEVATED"
-        signal = "CAUTION"
+    # Определяем направление
+    if long_votes > short_votes * 1.3:
+        direction = "LONG"
+        confidence = min(0.85, long_votes / max(total_weight, 0.1))
+    elif short_votes > long_votes * 1.3:
+        direction = "SHORT"
+        confidence = min(0.85, short_votes / max(total_weight, 0.1))
     else:
-        level = "NORMAL"
-        signal = "NEUTRAL"
+        direction = "WAIT"
+        confidence = max(long_votes, short_votes) / max(total_weight, 0.1)
 
-    if anomalies:
-        ANOMALY_HISTORY.append({
-            "timestamp": datetime.utcnow().isoformat(),
-            "symbol": symbol,
-            "anomalies": anomalies,
-            "score": anomaly_score
-        })
+    # Экосистемный скор (0-100)
+    ecosystem_score = ((long_votes + short_votes) / max(total_weight, 0.1)) * 50
+    ecosystem_score = min(100, max(0, ecosystem_score))
 
     return {
-        "anomaly_score": anomaly_score,
-        "anomaly_level": level,
-        "signal": signal,
-        "anomalies": anomalies,
-        "metrics": {
-            "gas": gas,
-            "large_transactions": large_tx,
-            "exchange_flows": flows,
-            "active_addresses": active
+        "ecosystem_score": round(ecosystem_score, 2),
+        "direction": direction,
+        "confidence": round(confidence, 4),
+        "active_spaces": len(signals),
+        "error_spaces": len(errors),
+        "signals_detail": details,
+        "votes": {
+            "LONG": round(long_votes, 4),
+            "SHORT": round(short_votes, 4)
         }
     }
 
 # ================= АНАЛИЗ ИЗ MT5 =================
 def analyze_from_mt5(mt5_features: Dict[str, Any]) -> Optional[Dict[str, Any]]:
     try:
-        anomalies = []
-        score = 0
-
-        atr_pct = mt5_features.get('H1_atr_pct', 1)
-        if isinstance(atr_pct, (int, float)) and atr_pct > 3.0:
-            anomalies.append({"type": "VOLATILITY_SPIKE", "severity": "HIGH", "reason": f"ATR {atr_pct}%"})
-            score += 25
-
-        volume = mt5_features.get('H1_volume', 0)
-        if isinstance(volume, (int, float)) and volume > 5000:
-            anomalies.append({"type": "VOLUME_SPIKE", "severity": "MEDIUM", "reason": f"Объём {volume}"})
-            score += 15
-
-        if score >= 30:
-            signal = "WAIT"
-        elif score >= 15:
-            signal = "CAUTION"
+        score = 50.0
+
+        rsi = mt5_features.get('H1_rsi', 50)
+        if isinstance(rsi, (int, float)):
+            if rsi > 70:
+                score -= 10
+            elif rsi < 30:
+                score += 10
+
+        ema = mt5_features.get('H1_price_vs_ema_21', 0)
+        if isinstance(ema, (int, float)):
+            if ema > 1.0:
+                score += 10
+            elif ema < -1.0:
+                score -= 10
+
+        score = max(0, min(100, score))
+
+        if score > 60:
+            direction, confidence = "LONG", score / 100
+        elif score < 40:
+            direction, confidence = "SHORT", (100 - score) / 100
         else:
-            signal = "NEUTRAL"
+            direction, confidence = "WAIT", 0.0
 
         return {
-            "anomaly_score": score,
-            "signal": signal,
-            "anomalies": anomalies,
+            "direction": direction,
+            "confidence": round(confidence, 4),
+            "score": score,
             "source": "MT5"
         }
     except:
         return None
 
 # ================= ГЛАВНЫЙ СИГНАЛ =================
-def get_anomaly_signal(symbol: str = "ETH/USD") -> Dict[str, Any]:
+def get_ecosystem_aggregate(symbol: str = "XAU/USD") -> Dict[str, Any]:
     start = time.time()
 
     # Проверка MT5
@@ -326,51 +252,50 @@ def get_anomaly_signal(symbol: str = "ETH/USD") -> Dict[str, Any]:
             mt5_features = fs.get("features", {})
             if mt5_features:
                 mt5_result = analyze_from_mt5(mt5_features)
-                if mt5_result and mt5_result["anomaly_score"] > 0:
+                if mt5_result:
                     result = {
-                        "space": "space_23_anomaly",
+                        "space": "space_24_ecosystem_aggregator",
                         "timestamp": int(time.time()),
                         "symbol": symbol,
-                        "signal": {"direction": mt5_result["signal"], "confidence": min(0.9, mt5_result["anomaly_score"] / 50)},
-                        "anomaly_analysis": {
-                            "score": mt5_result["anomaly_score"],
-                            "anomalies": mt5_result["anomalies"]
+                        "signal": {
+                            "direction": mt5_result["direction"],
+                            "confidence": mt5_result["confidence"]
+                        },
+                        "ecosystem_analysis": {
+                            "score": mt5_result["score"],
+                            "active_spaces": 0,
+                            "data_source": "MT5"
                         },
-                        "data_source": "MT5",
                         "meta": {"latency_ms": int((time.time() - start) * 1000)}
                     }
                     send_to_arbiter(result)
-                    print(f"🔍 ANOMALY {symbol}: Score={mt5_result['anomaly_score']} (MT5)")
+                    print(f"🌐 ECO AGG: {mt5_result['direction']} | Score={mt5_result['score']} (MT5)")
                     return result
 
-    # Fallback
-    analysis = detect_anomalies(symbol)
+    # Fallback: агрегация экосистемных Space'ов
+    agg = aggregate_ecosystem(symbol)
     latency = int((time.time() - start) * 1000)
 
-    direction = "WAIT" if analysis['anomaly_level'] in ['CRITICAL', 'ELEVATED'] else "NEUTRAL"
-    confidence = analysis['anomaly_score'] / 100 if analysis['anomaly_score'] > 0 else 0.0
-
     result = {
-        "space": "space_23_anomaly",
+        "space": "space_24_ecosystem_aggregator",
         "timestamp": int(time.time()),
         "symbol": symbol,
         "signal": {
-            "direction": direction,
-            "confidence": round(confidence, 4)
+            "direction": agg['direction'],
+            "confidence": agg['confidence']
         },
-        "anomaly_analysis": {
-            "score": analysis['anomaly_score'],
-            "level": analysis['anomaly_level'],
-            "anomalies": analysis['anomalies'],
-            "metrics": analysis['metrics']
+        "ecosystem_analysis": {
+            "score": agg['ecosystem_score'],
+            "active_spaces": agg['active_spaces'],
+            "error_spaces": agg['error_spaces'],
+            "votes": agg['votes'],
+            "details": agg['signals_detail']
         },
-        "data_source": "ONCHAIN",
         "meta": {"latency_ms": latency}
     }
 
     send_to_arbiter(result)
-    if analysis['anomalies']:
-        print(f"🔍 ANOMALY {symbol}: {analysis['anomaly_level']} | Score={analysis['anomaly_score']} | {len(analysis['anomalies'])} аномалий")
+    print(f"🌐 ECO AGG v1: {symbol} | {agg['direction']} | Active={agg['active_spaces']}/{len(ECOSYSTEM_SPACES)}")
     return result
 
 # ================= KEEP-ALIVE =================
@@ -385,54 +310,46 @@ def keep_alive():
 threading.Thread(target=keep_alive, daemon=True).start()
 
 # ================= FASTAPI =================
-app = FastAPI(title="TOMIRIS SPACE 23 v1.0 — ON-CHAIN ANOMALY DETECTOR")
+app = FastAPI(title="TOMIRIS SPACE 24 v1.0 — ECOSYSTEM AGGREGATOR")
 
 @app.get("/health")
 @app.head("/health")
 async def health():
     return {
-        "space": "Space 23 - On-Chain Anomaly Detector v1.0",
+        "space": "Space 24 - Ecosystem Aggregator v1.0",
         "status": "operational",
-        "symbols": TRACKED_SYMBOLS,
-        "features": ["Gas Spike", "Whale TX", "Exchange Flows", "Active Addresses"],
-        "anomaly_history": len(ANOMALY_HISTORY)
+        "symbols": SYMBOLS,
+        "ecosystem_spaces": {k: v['description'] for k, v in ECOSYSTEM_SPACES.items()},
+        "total_spaces": len(ECOSYSTEM_SPACES)
     }
 
 @app.get("/consilium")
-async def consilium(symbol: str = Query("ETH/USD")):
-    if symbol not in TRACKED_SYMBOLS:
-        return {"error": f"Unsupported: {symbol}"}
-    return get_anomaly_signal(symbol)
-
-@app.get("/scan/{symbol}")
-async def scan(symbol: str):
-    if symbol not in TRACKED_SYMBOLS:
+async def consilium(symbol: str = Query("XAU/USD")):
+    if symbol not in SYMBOLS:
         return {"error": f"Unsupported: {symbol}"}
-    return detect_anomalies(symbol)
+    return get_ecosystem_aggregate(symbol)
 
-@app.get("/gas")
-async def gas():
-    return fetch_gas_oracle()
-
-@app.get("/whales")
-async def whales():
-    return fetch_large_transactions()
-
-@app.get("/flows/{symbol}")
-async def flows(symbol: str = "ETH"):
-    return fetch_exchange_flows(symbol)
-
-@app.get("/active/{chain}")
-async def active(chain: str = "ethereum"):
-    return fetch_active_addresses(chain)
+@app.get("/breakdown/{symbol}")
+async def breakdown(symbol: str):
+    """Детальный разбор всех экосистемных Space'ов."""
+    agg = aggregate_ecosystem(symbol)
+    return {
+        "symbol": symbol,
+        "aggregate": agg,
+        "spaces_detail": agg.get('signals_detail', {})
+    }
 
-@app.get("/history")
-async def history(limit: int = Query(20)):
-    return list(ANOMALY_HISTORY)[-limit:]
+@app.get("/all")
+async def all_signals():
+    """Сигналы по всем трём активам."""
+    results = {}
+    for sym in SYMBOLS:
+        results[sym] = aggregate_ecosystem(sym)
+    return results
 
 @app.post("/features")
 async def receive_features(data: Dict[str, Any]):
-    symbol = data.get("symbol", "ETH/USD")
+    symbol = data.get("symbol", "XAU/USD")
     FEATURES_STORE[symbol] = {
         "features": data.get("features", {}),
         "price": data.get("price", 0.0),
@@ -441,6 +358,6 @@ async def receive_features(data: Dict[str, Any]):
     print(f"📥 MT5 {symbol}: {len(data.get('features', {}))} признаков")
     return {"status": "ok"}
 
-print(f"🚀 SPACE 23 v1.0 — ON-CHAIN ANOMALY DETECTOR ЗАПУЩЕН!")
-print(f"🔍 Детектор: Gas Spike | Whale TX | Exchange Flows | Active Addresses")
+print(f"🚀 SPACE 24 v1.0 — ECOSYSTEM AGGREGATOR ЗАПУЩЕН!")
+print(f"🌐 Агрегирует Space 19-23 для XAU, ETH, SOL")
 print(f"✅ Готов к бою!")