Create app.py

app.py

@@ -0,0 +1,446 @@
+# ============================================
+# АВТО-УСТАНОВКА ПАКЕТОВ
+# ============================================
+import subprocess
+import sys
+import importlib
+
+REQUIRED_PACKAGES = {
+    'numpy': 'numpy',
+    '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 23 v1.0 — ON-CHAIN ANOMALY DETECTOR
+# ============================================
+# Детектирует аномалии на блокчейне:
+# Китовые транзакции, приток/отток на биржи, скачки газа,
+# нетипичная активность, сливы/пампы.
+# ============================================
+
+from fastapi import FastAPI, Query
+from typing import Optional, Dict, Any, List
+import time
+import requests
+import threading
+import numpy as np
+from datetime import datetime
+from collections import deque
+import warnings
+warnings.filterwarnings('ignore')
+
+# ================= КОНФИГУРАЦИЯ =================
+TRACKED_SYMBOLS: List[str] = ["ETH/USD", "SOL/USD"]
+
+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', {})},
+            timeout=5
+        )
+    except:
+        pass
+
+# ================= 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:
+        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}
+
+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]
+
+    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
+
+    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]
+
+    try:
+        binance_symbol = "ETHUSDT" if symbol == "ETH" else "SOLUSDT"
+
+        # Оцениваем через 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
+
+    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 {'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 = "NORMAL"
+        signal = "NEUTRAL"
+
+    if anomalies:
+        ANOMALY_HISTORY.append({
+            "timestamp": datetime.utcnow().isoformat(),
+            "symbol": symbol,
+            "anomalies": anomalies,
+            "score": anomaly_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
+        }
+    }
+
+# ================= АНАЛИЗ ИЗ 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"
+        else:
+            signal = "NEUTRAL"
+
+        return {
+            "anomaly_score": score,
+            "signal": signal,
+            "anomalies": anomalies,
+            "source": "MT5"
+        }
+    except:
+        return None
+
+# ================= ГЛАВНЫЙ СИГНАЛ =================
+def get_anomaly_signal(symbol: str = "ETH/USD") -> Dict[str, Any]:
+    start = time.time()
+
+    # Проверка MT5
+    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)
+
+    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",
+        "timestamp": int(time.time()),
+        "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": "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'])} аномалий")
+    return result
+
+# ================= KEEP-ALIVE =================
+def keep_alive():
+    while True:
+        time.sleep(840)
+        try:
+            requests.get("http://localhost:7860/health", timeout=5)
+        except:
+            pass
+
+threading.Thread(target=keep_alive, daemon=True).start()
+
+# ================= FASTAPI =================
+app = FastAPI(title="TOMIRIS SPACE 23 v1.0 — ON-CHAIN ANOMALY DETECTOR")
+
+@app.get("/health")
+@app.head("/health")
+async def health():
+    return {
+        "space": "Space 23 - On-Chain Anomaly Detector v1.0",
+        "status": "operational",
+        "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("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:
+        return {"error": f"Unsupported: {symbol}"}
+    return detect_anomalies(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("/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", "ETH/USD")
+    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(f"🚀 SPACE 23 v1.0 — ON-CHAIN ANOMALY DETECTOR ЗАПУЩЕН!")
+print(f"🔍 Детектор: Gas Spike | Whale TX | Exchange Flows | Active Addresses")
+print(f"✅ Готов к бою!")