Update app.py

app.py

@@ -19,11 +19,11 @@ for module_name, pip_name in REQUIRED_PACKAGES.items():
         print(f"✅ {pip_name} установлен!")
 
 # ============================================
-# 👑 TOMIRIS SPACE 22 v1.0 — CROSS-ASSET SENTIMENT ENGINE
+# 👑 TOMIRIS SPACE 23 v1.0 — ON-CHAIN ANOMALY DETECTOR
 # ============================================
-# Мониторит настроения рынка: Reddit, Google Trends, мемы,
-# панические атаки, эйфорию. Работает для XAU, ETH, SOL.
-# Контриан-индикатор: когда толпа паникует — покупаем.
+# Детектирует аномалии на блокчейне:
+# Китовые транзакции, приток/отток на биржи, скачки газа,
+# нетипичная активность, сливы/пампы.
 # ============================================
 
 from fastapi import FastAPI, Query
@@ -34,367 +34,343 @@ import threading
 import numpy as np
 from datetime import datetime
 from collections import deque
-import xml.etree.ElementTree as ET
 import warnings
 warnings.filterwarnings('ignore')
 
 # ================= КОНФИГУРАЦИЯ =================
-SYMBOLS: List[str] = ["XAU/USD", "ETH/USD", "SOL/USD"]
+TRACKED_SYMBOLS: List[str] = ["ETH/USD", "SOL/USD"]
 
 SPACE_18_ARBITER: str = "https://tomiris-ai-name6-6.hf.space"
 
-# Категории ключевых слов
-FEAR_KEYWORDS: Dict[str, List[str]] = {
-    "XAU/USD": ["gold crash", "gold selloff", "gold bubble", "xau short"],
-    "ETH/USD": ["ethereum crash", "eth sell", "defi hack", "eth dump"],
-    "SOL/USD": ["solana crash", "sol dump", "solana outage", "sol hack"]
-}
-
-GREED_KEYWORDS: Dict[str, List[str]] = {
-    "XAU/USD": ["gold moon", "gold to the moon", "buy gold now", "xau long"],
-    "ETH/USD": ["ethereum moon", "eth to the moon", "eth pump", "buy eth"],
-    "SOL/USD": ["solana moon", "sol to the moon", "sol pump", "buy sol"]
-}
-
-MEME_KEYWORDS: List[str] = ["meme coin", "pump", "dump", "wagmi", "ngmi", "to the moon", "wen lambo"]
+# 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
-MEME_HISTORY: deque = deque(maxlen=100)
+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_22_sentiment', 'symbol': 'XAU/USD', 'signal': signal_data.get('signals', {}).get('XAU/USD', {})},
+            json={'space': 'space_23_anomaly', 'symbol': 'ETH/USD', 'signal': signal_data.get('signal', {})},
             timeout=5
         )
     except:
         pass
 
-# ================= REDDIT СКАНЕР =================
-def fetch_reddit_sentiment(symbol: str) -> Dict[str, Any]:
-    """Сканирует Reddit на упоминания."""
-    cache_key = f"reddit_{symbol.replace('/', '_')}"
-    if cache_key in CACHE and time.time() - CACHE_TIMES.get(cache_key, 0) < 600:
+# ================= ETHERSCAN =================
+def fetch_gas_oracle() -> Dict[str, Any]:
+    cache_key = "gas_oracle"
+    if cache_key in CACHE and time.time() - CACHE_TIMES.get(cache_key, 0) < 60:
         return CACHE[cache_key]
 
     try:
-        query = symbol.replace("/USD", "").lower()
-        if "xau" in query:
-            query = "gold"
+        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
+            }
+            CACHE[cache_key] = data
+            CACHE_TIMES[cache_key] = time.time()
+            return data
+    except:
+        pass
+    return {'avg_gas': 45, 'gas_level': 'NORMAL', 'is_anomaly': False}
 
-        headers = {'User-Agent': 'Mozilla/5.0 (compatible; TomirisSentiment/1.0)'}
-        url = f"https://www.reddit.com/r/CryptoCurrency+wallstreetbets+investing/search.json?q={query}&sort=new&limit=20"
-        r = requests.get(url, headers=headers, timeout=10)
+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]
 
-        if r.status_code == 200:
-            posts = r.json().get('data', {}).get('children', [])
-            fear_count = 0
-            greed_count = 0
-            total_sentiment = 0.0
-
-            for post in posts:
-                data = post.get('data', {})
-                title = data.get('title', '').lower()
-                text = data.get('selftext', '')[:200].lower()
-                full_text = title + ' ' + text
-                ups = data.get('ups', 0)
-                comments = data.get('num_comments', 0)
-                viral_score = ups + comments * 2
-
-                for kw in FEAR_KEYWORDS.get(symbol, []):
-                    if kw in full_text:
-                        fear_count += 1
-                        total_sentiment -= viral_score
-                for kw in GREED_KEYWORDS.get(symbol, []):
-                    if kw in full_text:
-                        greed_count += 1
-                        total_sentiment += viral_score
-                for kw in MEME_KEYWORDS:
-                    if kw in full_text:
-                        MEME_HISTORY.append({"keyword": kw, "symbol": symbol, "timestamp": time.time()})
-
-            total = fear_count + greed_count
-            fear_ratio = fear_count / total if total > 0 else 0.5
-
-            if fear_ratio > 0.65:
-                sentiment = "FEAR"
-                signal = "BULLISH"  # Покупаем на страхе
-            elif fear_ratio > 0.50:
-                sentiment = "SLIGHT_FEAR"
-                signal = "SLIGHTLY_BULLISH"
-            elif fear_ratio < 0.35:
-                sentiment = "GREED"
-                signal = "BEARISH"  # Продаём на жадности
-            elif fear_ratio < 0.50:
-                sentiment = "SLIGHT_GREED"
-                signal = "SLIGHTLY_BEARISH"
-            else:
-                sentiment = "NEUTRAL"
-                signal = "NEUTRAL"
+    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 = {
-                'sentiment': sentiment,
-                'fear_ratio': round(fear_ratio, 4),
-                'fear_count': fear_count,
-                'greed_count': greed_count,
-                'total_posts': len(posts),
-                'market_signal': signal,
-                'source': 'Reddit'
+                '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
 
-    return {'sentiment': 'NEUTRAL', 'fear_ratio': 0.5, 'market_signal': 'NEUTRAL', 'source': 'Reddit'}
+    return {'large_transactions': [], 'count': 0, 'is_anomaly': False, 'signal': 'NORMAL'}
 
-# ================= GOOGLE TRENDS =================
-def fetch_google_trends(symbol: str) -> Dict[str, Any]:
-    """Оценка трендов через Google News RSS."""
-    cache_key = f"trends_{symbol.replace('/', '_')}"
-    if cache_key in CACHE and time.time() - CACHE_TIMES.get(cache_key, 0) < 900:
+# ================= 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]
 
     try:
-        query = symbol.replace("/USD", "").lower()
-        if "xau" in query:
-            query = "gold price"
+        binance_symbol = "ETHUSDT" if symbol == "ETH" else "SOLUSDT"
 
-        url = f"https://news.google.com/rss/search?q={query}&hl=en-US&ceid=US:en"
-        r = requests.get(url, timeout=10)
+        # Оцениваем через 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:
-            root = ET.fromstring(r.content)
-            items = root.findall("./channel/item")
-            mention_count = len(items)
-
-            if mention_count > 30:
-                level = "EXTREME"
-            elif mention_count > 20:
-                level = "HIGH"
-            elif mention_count > 10:
-                level = "MODERATE"
-            else:
-                level = "LOW"
-
-            # Высокий интерес = жадность для крипты, страх для золота
-            if "xau" in symbol.lower():
-                signal = "BULLISH" if level in ["HIGH", "EXTREME"] else "NEUTRAL"
-            else:
-                signal = "BEARISH" if level == "EXTREME" else "BULLISH" if level == "LOW" else "NEUTRAL"
+            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 = {
-                'mention_count': mention_count,
-                'level': level,
-                'market_signal': signal,
-                'source': 'Google Trends'
+                '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
+
+    return {'signal': 'BALANCED', 'is_anomaly': False}
+
+# ================= АКТИВНЫЕ АДРЕСА (через 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]
+
+    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
 
-    return {'mention_count': 0, 'level': 'LOW', 'market_signal': 'NEUTRAL', 'source': 'Google Trends'}
-
-# ================= МЕМ-ДЕТЕКТОР =================
-def analyze_meme_activity() -> Dict[str, Any]:
-    """Анализ мемной активности."""
-    if not MEME_HISTORY:
-        return {'meme_level': 'LOW', 'market_signal': 'NEUTRAL'}
-
-    recent_memes = [m for m in MEME_HISTORY if time.time() - m.get('timestamp', 0) < 3600]
-    meme_count = len(recent_memes)
-
-    if meme_count > 20:
-        level = "EXTREME"
-        signal = "BEARISH"  # Слишком много мемов = эйфория
-    elif meme_count > 10:
-        level = "HIGH"
-        signal = "SLIGHTLY_BEARISH"
-    elif meme_count > 5:
-        level = "MODERATE"
-        signal = "NEUTRAL"
+    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"
     else:
-        level = "LOW"
+        level = "NORMAL"
         signal = "NEUTRAL"
 
+    if anomalies:
+        ANOMALY_HISTORY.append({
+            "timestamp": datetime.utcnow().isoformat(),
+            "symbol": symbol,
+            "anomalies": anomalies,
+            "score": anomaly_score
+        })
+
     return {
-        'meme_level': level,
-        'recent_memes': meme_count,
-        'market_signal': signal,
-        'source': 'Meme Detector'
+        "anomaly_score": anomaly_score,
+        "anomaly_level": level,
+        "signal": signal,
+        "anomalies": anomalies,
+        "metrics": {
+            "gas": gas,
+            "large_transactions": large_tx,
+            "exchange_flows": flows,
+            "active_addresses": active
+        }
     }
 
 # ================= АНАЛИЗ ИЗ MT5 =================
 def analyze_from_mt5(mt5_features: Dict[str, Any]) -> Optional[Dict[str, Any]]:
     try:
-        score = 50.0
-        now = datetime.utcnow()
-        hour = now.hour
-
-        if 13 <= hour < 22:
-            score -= 5
-        elif hour < 8:
-            score += 5
-
-        rsi = mt5_features.get('H1_rsi', 50)
-        if isinstance(rsi, (int, float)):
-            if rsi > 70:
-                score -= 15
-            elif rsi < 30:
-                score += 15
-
-        atr = mt5_features.get('H1_atr_pct', 1)
-        if isinstance(atr, (int, float)) and atr > 2:
-            score -= 10
-
-        score = max(0, min(100, score))
-
-        if score > 60:
-            sentiment = "FEAR"
-            direction = "LONG"
-        elif score < 40:
-            sentiment = "GREED"
-            direction = "SHORT"
+        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"
         else:
-            sentiment = "NEUTRAL"
-            direction = "WAIT"
+            signal = "NEUTRAL"
 
         return {
-            "sentiment": sentiment,
-            "direction": direction,
-            "confidence": round(abs(score - 50) / 50, 4),
-            "sentiment_score": score,
+            "anomaly_score": score,
+            "signal": signal,
+            "anomalies": anomalies,
             "source": "MT5"
         }
     except:
         return None
 
-# ================= ГЛАВНЫЙ АНАЛИЗ =================
-def analyze_sentiment(symbol: str) -> Dict[str, Any]:
-    reddit = fetch_reddit_sentiment(symbol)
-    trends = fetch_google_trends(symbol)
-    meme = analyze_meme_activity()
-
-    signals = []
-    score = 50.0
-
-    # Reddit
-    if reddit.get('market_signal') == 'BULLISH':
-        signals.append({"source": "Reddit", "signal": "BULLISH", "reason": f"Страх ({reddit.get('fear_ratio', 0):.2f})"})
-        score += 15
-    elif reddit.get('market_signal') == 'BEARISH':
-        signals.append({"source": "Reddit", "signal": "BEARISH", "reason": "Жадность"})
-        score -= 15
-
-    # Google Trends
-    if trends.get('market_signal') == 'BULLISH':
-        signals.append({"source": "Trends", "signal": "BULLISH", "reason": f"Интерес: {trends.get('level')}"})
-        score += 10
-    elif trends.get('market_signal') == 'BEARISH':
-        signals.append({"source": "Trends", "signal": "BEARISH", "reason": f"Хайп: {trends.get('level')}"})
-        score -= 10
-
-    # Meme
-    if meme.get('market_signal') == 'BEARISH':
-        signals.append({"source": "Meme", "signal": "BEARISH", "reason": f"Мемов: {meme.get('meme_level')}"})
-        score -= 10
-    elif meme.get('market_signal') == 'SLIGHTLY_BEARISH':
-        signals.append({"source": "Meme", "signal": "CAUTION", "reason": "Много мемов"})
-        score -= 5
-
-    score = max(0, min(100, score))
-
-    if score > 60:
-        direction = "LONG"
-        confidence = score / 100
-    elif score < 40:
-        direction = "SHORT"
-        confidence = (100 - score) / 100
-    else:
-        direction = "WAIT"
-        confidence = 0.0
-
-    return {
-        "sentiment_score": score,
-        "direction": direction,
-        "confidence": round(confidence, 4),
-        "signals": signals,
-        "metrics": {
-            "reddit": reddit,
-            "google_trends": trends,
-            "meme_activity": meme
-        }
-    }
-
 # ================= ГЛАВНЫЙ СИГНАЛ =================
-def get_sentiment_signal() -> Dict[str, Any]:
+def get_anomaly_signal(symbol: str = "ETH/USD") -> Dict[str, Any]:
     start = time.time()
 
     # Проверка MT5
-    for symbol in SYMBOLS:
-        if symbol in FEATURES_STORE:
-            fs = FEATURES_STORE[symbol]
-            age = time.time() - fs.get("timestamp", 0)
-            if age < MT5_MAX_AGE_SEC:
-                mt5_features = fs.get("features", {})
-                if mt5_features:
-                    mt5_result = analyze_from_mt5(mt5_features)
-                    if mt5_result and mt5_result["confidence"] > 0.3:
-                        result = {
-                            "space": "space_22_sentiment",
-                            "timestamp": int(time.time()),
-                            "signals": {
-                                s: {"direction": mt5_result["direction"], "confidence": mt5_result["confidence"]}
-                                for s in SYMBOLS
-                            },
-                            "sentiment": mt5_result["sentiment"],
-                            "data_source": "MT5",
-                            "meta": {"latency_ms": int((time.time() - start) * 1000)}
-                        }
-                        send_to_arbiter(result)
-                        print(f"💬 SENTIMENT: {mt5_result['sentiment']} | {mt5_result['direction']} (MT5)")
-                        return result
-
-    # Fallback: полный анализ
-    signals_dict = {}
-    for symbol in SYMBOLS:
-        analysis = analyze_sentiment(symbol)
-        signals_dict[symbol] = {
-            "direction": analysis['direction'],
-            "confidence": analysis['confidence'],
-            "sentiment_score": analysis['sentiment_score']
-        }
-
+    if symbol in FEATURES_STORE:
+        fs = FEATURES_STORE[symbol]
+        age = time.time() - fs.get("timestamp", 0)
+        if age < MT5_MAX_AGE_SEC:
+            mt5_features = fs.get("features", {})
+            if mt5_features:
+                mt5_result = analyze_from_mt5(mt5_features)
+                if mt5_result and mt5_result["anomaly_score"] > 0:
+                    result = {
+                        "space": "space_23_anomaly",
+                        "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"]
+                        },
+                        "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)")
+                    return result
+
+    # Fallback
+    analysis = detect_anomalies(symbol)
     latency = int((time.time() - start) * 1000)
 
-    # Агрегируем (все три актива)
-    xau = signals_dict.get("XAU/USD", {})
-    eth = signals_dict.get("ETH/USD", {})
-    sol = signals_dict.get("SOL/USD", {})
+    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_22_sentiment",
+        "space": "space_23_anomaly",
         "timestamp": int(time.time()),
-        "signals": signals_dict,
-        "sentiment_analysis": {
-            "gold": analyze_sentiment("XAU/USD"),
-            "eth": analyze_sentiment("ETH/USD"),
-            "sol": analyze_sentiment("SOL/USD")
+        "symbol": symbol,
+        "signal": {
+            "direction": direction,
+            "confidence": round(confidence, 4)
+        },
+        "anomaly_analysis": {
+            "score": analysis['anomaly_score'],
+            "level": analysis['anomaly_level'],
+            "anomalies": analysis['anomalies'],
+            "metrics": analysis['metrics']
         },
-        "data_source": "SOCIAL",
+        "data_source": "ONCHAIN",
         "meta": {"latency_ms": latency}
     }
 
     send_to_arbiter(result)
-    print(f"💬 SENTIMENT v1: XAU={xau.get('direction')} | ETH={eth.get('direction')} | SOL={sol.get('direction')}")
+    if analysis['anomalies']:
+        print(f"🔍 ANOMALY {symbol}: {analysis['anomaly_level']} | Score={analysis['anomaly_score']} | {len(analysis['anomalies'])} аномалий")
     return result
 
 # ================= KEEP-ALIVE =================
@@ -409,48 +385,54 @@ def keep_alive():
 threading.Thread(target=keep_alive, daemon=True).start()
 
 # ================= FASTAPI =================
-app = FastAPI(title="TOMIRIS SPACE 22 v1.0 — CROSS-ASSET SENTIMENT ENGINE")
+app = FastAPI(title="TOMIRIS SPACE 23 v1.0 — ON-CHAIN ANOMALY DETECTOR")
 
 @app.get("/health")
 @app.head("/health")
 async def health():
     return {
-        "space": "Space 22 - Cross-Asset Sentiment Engine v1.0",
+        "space": "Space 23 - On-Chain Anomaly Detector v1.0",
         "status": "operational",
-        "symbols": SYMBOLS,
-        "sources": ["Reddit", "Google Trends", "Meme Detector"],
-        "meme_history": len(MEME_HISTORY)
+        "symbols": TRACKED_SYMBOLS,
+        "features": ["Gas Spike", "Whale TX", "Exchange Flows", "Active Addresses"],
+        "anomaly_history": len(ANOMALY_HISTORY)
     }
 
 @app.get("/consilium")
-async def consilium(symbol: str = Query("XAU/USD")):
-    return get_sentiment_signal()
+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("/sentiment/{symbol}")
-async def sentiment(symbol: str):
-    if symbol not in SYMBOLS:
+@app.get("/scan/{symbol}")
+async def scan(symbol: str):
+    if symbol not in TRACKED_SYMBOLS:
         return {"error": f"Unsupported: {symbol}"}
-    return analyze_sentiment(symbol)
+    return detect_anomalies(symbol)
 
-@app.get("/meme")
-async def meme():
-    return analyze_meme_activity()
+@app.get("/gas")
+async def gas():
+    return fetch_gas_oracle()
 
-@app.get("/reddit/{symbol}")
-async def reddit(symbol: str):
-    if symbol not in SYMBOLS:
-        return {"error": f"Unsupported: {symbol}"}
-    return fetch_reddit_sentiment(symbol)
+@app.get("/whales")
+async def whales():
+    return fetch_large_transactions()
 
-@app.get("/trends/{symbol}")
-async def trends(symbol: str):
-    if symbol not in SYMBOLS:
-        return {"error": f"Unsupported: {symbol}"}
-    return fetch_google_trends(symbol)
+@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("/history")
+async def history(limit: int = Query(20)):
+    return list(ANOMALY_HISTORY)[-limit:]
 
 @app.post("/features")
 async def receive_features(data: Dict[str, Any]):
-    symbol = data.get("symbol", "XAU/USD")
+    symbol = data.get("symbol", "ETH/USD")
     FEATURES_STORE[symbol] = {
         "features": data.get("features", {}),
         "price": data.get("price", 0.0),
@@ -459,6 +441,6 @@ async def receive_features(data: Dict[str, Any]):
     print(f"📥 MT5 {symbol}: {len(data.get('features', {}))} признаков")
     return {"status": "ok"}
 
-print(f"🚀 SPACE 22 v1.0 — CROSS-ASSET SENTIMENT ENGINE ЗАПУЩЕН!")
-print(f"💬 Сканирую: Reddit | Google Trends | Мемы | для XAU, ETH, SOL")
+print(f"🚀 SPACE 23 v1.0 — ON-CHAIN ANOMALY DETECTOR ЗАПУЩЕН!")
+print(f"🔍 Детектор: Gas Spike | Whale TX | Exchange Flows | Active Addresses")
 print(f"✅ Готов к бою!")