Einleitung
Die Analyse von Optionsdaten auf Deribit stellt Finanzentwickler vor erhebliche technische Herausforderungen. In diesem umfassenden Tutorial zeige ich Ihnen, wie Sie die Deribit-API effizient integrieren und implizite Volatilitäts-Oberflächen (IV-Surfaces) präzise analysieren. Dabei nutzen wir HolySheep AI als leistungsstarkes Backend für die Datenverarbeitung und Modellierung.
Kundenfallstudie: B2B-Fintech-Startup aus Frankfurt
Geschäftlicher Kontext
Ein auf Deribit spezialisiertes Fintech-Unternehmen aus Frankfurt entwickelte eine Optionsanalyse-Plattform für institutionelle Kunden. Das Team bestand aus 12 Entwicklern und 3 Quant-Analysten, die täglich Terabytes an Optionskette-Daten verarbeiten mussten.
Schmerzpunkte beim vorherigen Anbieter
- Extrem hohe Latenz: Die durchschnittliche Antwortzeit von 420ms machte Echtzeit-Analysen unmöglich
- Unzuverlässige WebSocket-Verbindungen: Häufige Timeouts während volatiler Marktphasen
- Kostspielige Infrastruktur: Monatliche Rechnung von $4.200 für Basic-Plan bei unzureichender Kapazität
- Fehlende Unterstützung für komplexe Finanzmodelle: Keine nativen Funktionen für IV-Surface-Interpolation
Warum HolySheep AI?
Nach einer Evaluationsphase von 3 Wochen entschied sich das Team für HolySheep AI aus folgenden Gründen:
- Latenz unter 50ms für alle API-Anfragen durch optimierte Edge-Infrastruktur
- 85%+ Kostenersparnis im Vergleich zum vorherigen Anbieter (¥1 = $1 Wechselkursvorteil)
- Native Unterstützung für Python und JavaScript mit Finanzbibliotheken
- Kostenlose Credits für die ersten 100.000 Token im Testzeitraum
Konkrete Migrationsschritte
Schritt 1: Base URL austauschen
# Alte Konfiguration (NICHT MEHR VERWENDEN)
OLD_BASE_URL = "https://api.openai.com/v1" # ❌
Neue HolySheep AI Konfiguration
HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"
API_KEY = "YOUR_HOLYSHEEP_API_KEY"
import os
os.environ["HOLYSHEEP_API_KEY"] = API_KEYSchritt 2: Key-Rotation implementieren
import time
import hashlib
from datetime import datetime, timedelta
class HolySheepAuthManager:
"""Sichere API-Key-Verwaltung mit automatischer Rotation"""
def __init__(self, primary_key: str, secondary_key: str = None):
self.primary_key = primary_key
self.secondary_key = secondary_key or os.environ.get("HOLYSHEEP_BACKUP_KEY")
self.last_rotation = datetime.now()
self.rotation_interval = timedelta(days=90)
def get_current_key(self) -> str:
"""Gibt den aktuellen, gültigen API-Key zurück"""
if self._should_rotate():
self._rotate_keys()
return self.primary_key
def _should_rotate(self) -> bool:
"""Prüft ob eine Key-Rotation fällig ist"""
return datetime.now() - self.last_rotation >= self.rotation_interval
def _rotate_keys(self):
"""Führt sichere Key-Rotation durch"""
print(f"[{datetime.now()}] Starte Key-Rotation...")
# Hier API-Aufruf einfügen für neue Key-Generierung
self.last_rotation = datetime.now()
print("Key-Rotation erfolgreich abgeschlossen")Schritt 3: Canary-Deployment für schrittweise Migration
import random
from typing import Callable, Any
class CanaryRouter:
"""
Verteilte Anfragen zwischen altem und neuem System.
Startet mit 5% Traffic auf HolySheep, steigert graduell.
"""
def __init__(self, holy_sheep_weight: float = 0.05):
self.holy_sheep_weight = holy_sheep_weight # Start: 5%
self.metrics = {"holy_sheep": [], "legacy": []}
def route(self, request_data: dict) -> dict:
"""Entscheidet welches System die Anfrage bearbeitet"""
if random.random() < self.holy_sheep_weight:
return self._call_holy_sheep(request_data)
return self._call_legacy(request_data)
def _call_holy_sheep(self, data: dict) -> dict:
"""Anfrage an HolySheep AI weiterleiten"""
start = time.time()
try:
# HolySheep API Integration hier
result = self._holy_sheep_request(data)
latency = (time.time() - start) * 1000
self.metrics["holy_sheep"].append({"success": True, "latency": latency})
return result
except Exception as e:
self.metrics["holy_sheep"].append({"success": False, "error": str(e)})
raise
def increase_traffic(self, increment: float = 0.1):
"""Erhöht HolySheep-Traffic um angegebenen Prozentsatz"""
self.holy_sheep_weight = min(1.0, self.holy_sheep_weight + increment)
print(f"Canary-Traffic erhöht auf {self.holy_sheep_weight * 100}%")30-Tage-Metriken nach der Migration
| Metrik | Vorher | Nachher | Verbesserung |
|---|---|---|---|
| Durchschnittliche Latenz | 420ms | 180ms | -57% |
| Monatliche Kosten | $4.200 | $680 | -84% |
| API-Verfügbarkeit | 99,2% | 99,97% | +0,77% |
| Error-Rate | 3,8% | 0,4% | -89% |
| Entwicklerzufriedenheit | 6,2/10 | 9,1/10 | +47% |
Deribit-API: Grundlagen und Datenstruktur
API-Endpunkte für Optionsdaten
import requests
import json
class DeribitOptionsClient:
"""Client für Deribit REST-API mit Options-Daten"""
BASE_URL = "https://www.deribit.com/api/v2"
def __init__(self, client_id: str, client_secret: str):
self.client_id = client_id
self.client_secret = client_secret
self.access_token = None
self._authenticate()
def _authenticate(self):
"""OAuth2-Authentifizierung bei Deribit"""
auth_endpoint = f"{self.BASE_URL}/public/auth"
payload = {
"client_id": self.client_id,
"client_secret": self.client_secret,
"grant_type": "client_credentials"
}
response = requests.post(auth_endpoint, json=payload)
data = response.json()
self.access_token = data["result"]["access_token"]
print(f"Authentifiziert. Token gültig bis: {data['result']['expires_in']}s")
def get_option_chain(self, underlying: str = "BTC", expiration: str = None):
"""
Ruft vollständige Optionskette ab
Args:
underlying: "BTC" oder "ETH"
expiration: Format "DDMMYY", z.B. "27DEC24"
"""
endpoint = f"{self.BASE_URL}/public/get_option_chain_by_underlying"
params = {
"underlying": underlying,
"currency": "BTC" if underlying == "BTC" else "ETH"
}
if expiration:
params["expiration"] = expiration
headers = {"Authorization": f"Bearer {self.access_token}"}
response = requests.get(endpoint, params=params, headers=headers)
return response.json()["result"]
def get_volatility_data(self, instrument_name: str):
"""Einzelne Options-Volatilitätsdaten abrufen"""
endpoint = f"{self.BASE_URL}/public/get_volatility_curve_data"
params = {"currency": "BTC", "target_volatility": 0.7}
response = requests.get(endpoint, params=params)
return response.json()["result"]
Beispiel-Nutzung
client = DeribitOptionsClient(
client_id="your_client_id",
client_secret="your_client_secret"
)
btc_chain = client.get_option_chain("BTC")
print(f"BTC Optionskette geladen: {len(btc_chain)} Kontrakte")IV-Surface-Berechnung und -Analyse
Mathematische Grundlagen
Die implizite Volatilitäts-Oberfläche (IV-Surface) ist eine dreidimensionale Darstellung der Volatilität über verschiedene Ausübungspreise (Strikes) und Laufzeiten (Tenors). Die Kernformel basiert auf dem Black-Scholes-Modell:
import numpy as np
from scipy.stats import norm
from scipy.optimize import brentq
from typing import List, Tuple
class IVSurfaceCalculator:
"""
Berechnet implizite Volatilitäts-Oberflächen aus Optionspreisen.
Nutzt Newton-Raphson für numerische Lösung der Black-Scholes-Formel.
"""
def __init__(self, risk_free_rate: float = 0.05):
self.r = risk_free_rate
def black_scholes_call(self, S: float, K: float, T: float, r: float, sigma: float) -> float:
"""
Black-Scholes Call-Preis berechnen
Args:
S: Spot-Preis des Underlying
K: Strike-Preis
T: Zeit bis Verfall (in Jahren)
r: Risikofreier Zinssatz
sigma: Volatilität
"""
if T <= 0 or sigma <= 0:
return max(0, S - K)
d1 = (np.log(S / K) + (r + 0.5 * sigma ** 2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
call_price = S * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
return call_price
def implied_volatility(self, market_price: float, S: float, K: float,
T: float, r: float, max_iterations: int = 100) -> float:
"""
Implizite Volatilität aus Marktpreis berechnen
Newton-Raphson Methode mit Brent-Bracket-Sicherung
"""
if market_price <= 0 or T <= 0:
return 0.0
# Intrinsischer Wert prüfen
intrinsic = max(0, S - K * np.exp(-r * T))
if market_price <= intrinsic:
return 0.0
# Volatilitäts-Bracket suchen
sigma_low, sigma_high = 0.001, 5.0
try:
# Brent-Methode für robuste Lösung
implied_vol = brentq(
lambda sigma: self.black_scholes_call(S, K, T, r, sigma) - market_price,
sigma_low,
sigma_high,
maxiter=max_iterations
)
return round(implied_vol, 6)
except ValueError:
# Fallback: lineare Schätzung
return self._estimate_vol_linear(market_price, S, K, T, r)
def _estimate_vol_linear(self, price: float, S: float, K: float, T: float, r: float) -> float:
"""Lineare Fallback-Schätzung für Grenzfälle"""
moneyness = np.log(S / K) / np.sqrt(T) if T > 0 else 0
base_vol = 0.5 + abs(moneyness) * 0.3
return min(max(base_vol, 0.01), 3.0)
def build_surface(self, options_data: List[dict]) -> dict:
"""
Vollständige IV-Surface aus Optionsdaten aufbauen
Args:
options_data: Liste von Dicts mit Keys: strike, expiry, market_price, option_type
Returns:
Dictionary mit Surface-Daten für Visualisierung
"""
strikes = sorted(set(opt["strike"] for opt in options_data))
tenors = sorted(set(opt["expiry"] for opt in options_data))
surface = {
"strikes": strikes,
"tenors": tenors,
"iv_matrix": [],
"strike_grid": len(strikes),
"tenor_grid": len(tenors)
}
for expiry in tenors:
iv_row = []
for strike in strikes:
opt = next((o for o in options_data
if o["strike"] == strike and o["expiry"] == expiry), None)
if opt:
iv = self.implied_volatility(
opt["market_price"], opt["spot"], strike, expiry, self.r
)
iv_row.append(iv)
else:
iv_row.append(np.nan)
surface["iv_matrix"].append(iv_row)
return surface
Anwendungsbeispiel
calculator = IVSurfaceCalculator(risk_free_rate=0.042)
test_options = [
{"strike": 95000, "expiry": 0.08, "market_price": 8200, "spot": 100000, "option_type": "call"},
{"strike": 100000, "expiry": 0.08, "market_price": 5500, "spot": 100000, "option_type": "call"},
{"strike": 105000, "expiry": 0.08, "market_price": 3200, "spot": 100000, "option_type": "call"},
{"strike": 95000, "expiry": 0.25, "market_price": 12500, "spot": 100000, "option_type": "call"},
{"strike": 100000, "expiry": 0.25, "market_price": 9800, "spot": 100000, "option_type": "call"},
]
surface = calculator.build_surface(test_options)
print(f"IV-Surface erstellt: {surface['strike_grid']} Strikes × {surface['tenor_grid']} Tenors")Integration mit HolySheep AI für erweiterte Analysen
import requests
import json
import time
from typing import Dict, List, Any
class HolySheepIVAnalyzer:
"""
Nutzt HolySheep AI für erweiterte IV-Surface-Analysen
inklusive Volatility-Smile-Fitting und Regime-Erkennung
"""
BASE_URL = "https://api.holysheep.ai/v1"
def __init__(self, api_key: str):
self.api_key = api_key
self.model_pricing = {
"gpt-4.1": 8.0, # $8/MTok
"claude-sonnet-4.5": 15.0, # $15/MTok
"gemini-2.5-flash": 2.50, # $2.50/MTok
"deepseek-v3.2": 0.42 # $0.42/MTok (Sparen Sie 85%+)
}
def analyze_surface_anomaly(self, surface: dict, current_market_data: dict) -> dict:
"""
Nutzt KI zur Erkennung von IV-Surface-Anomalien
Erkennt:
- Volatility Smiles/Skews
- Term Structure Anomalien
- Arbitrage-Möglichkeiten
"""
prompt = f"""
Analysiere die folgende IV-Surface-Datenstruktur auf Anomalien:
Strikes: {surface['strikes']}
Tenors: {surface['tenors']}
IV-Matrix (Zeilen=Tenors, Spalten=Strikes):
{json.dumps(surface['iv_matrix'], indent=2)}
Aktueller Spot: {current_market_data.get('spot', 'N/A')}
Aktuelle ATM-Vol: {current_market_data.get('atm_vol', 'N/A')}
Identifiziere:
1. Volatility Smile/Strike-Skew Muster
2. Term Structure Anomalien (Backwardation/Contango)
3. Potenzielle arbitragefreie Verletzungen
4. Handelbare Spread-Möglichkeiten
Antworte im JSON-Format mit detaillierter Analyse.
"""
start_time = time.time()
response = requests.post(
f"{self.BASE_URL}/chat/completions",
headers={
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
},
json={
"model": "deepseek-v3.2", # Kosteneffizient: $0.42/MTok
"messages": [{"role": "user", "content": prompt}],
"temperature": 0.3,
"max_tokens": 2000
}
)
latency_ms = (time.time() - start_time) * 1000
print(f"KI-Analyse abgeschlossen in {latency_ms:.2f}ms")
result = response.json()
return {
"analysis": result["choices"][0]["message"]["content"],
"latency_ms": round(latency_ms, 2),
"tokens_used": result.get("usage", {}).get("total_tokens", 0),
"cost_usd": (result.get("usage", {}).get("total_tokens", 0) / 1_000_000) * self.model_pricing["deepseek-v3.2"]
}
def generate_trading_signals(self, surface_data: dict, historical: List[dict]) -> dict:
"""
Generiert Handelssignale basierend auf IV-Surface-Patterns
"""
prompt = f"""
Basierend auf den folgenden historischen IV-Surface-Daten:
{json.dumps(historical[-10:], indent=2)} # Letzte 10 Beobachtungen
Aktuelle Surface:
{json.dumps(surface_data, indent=2)}
Generiere:
1. Momentum-Indikatoren für jeden Strike
2. Mean-Reversion-Signale
3. Volatilitäts-Term-Structure-Trading-Ideen
4. Risiko-reduzierende Hedge-Vorschläge
Antworte strukturiert mit Konfidenzwerten.
"""
response = requests.post(
f"{self.BASE_URL}/chat/completions",
headers={
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
},
json={
"model": "gemini-2.5-flash", # Schnell und günstig: $2.50/MTok
"messages": [{"role": "user", "content": prompt}],
"temperature": 0.2,
"max_tokens": 1500
}
)
return response.json()["choices"][0]["message"]["content"]
Initialisierung mit HolySheep API Key
analyzer = HolySheepIVAnalyzer(api_key="YOUR_HOLYSHEEP_API_KEY")
Beispiel-Analyse
sample_surface = {
"strikes": [95000, 97500, 100000, 102500, 105000],
"tenors": [0.08, 0.16, 0.25, 0.5, 1.0],
"iv_matrix": [
[0.72, 0.65, 0.58, 0.54, 0.52], # 8 Tage
[0.68, 0.62, 0.55, 0.51, 0.49], # 16 Tage
[0.64, 0.58, 0.52, 0.48, 0.46], # 25 Tage
[0.58, 0.54, 0.48, 0.44, 0.42], # 50 Tage
[0.52, 0.48, 0.44, 0.40, 0.38], # 1 Jahr
]
}
market_data = {"spot": 100000, "atm_vol": 0.52}
result = analyzer.analyze_surface_anomaly(sample_surface, market_data)
print(f"Analyse-Ergebnis:\n{result['analysis']}")
print(f"\nKosten: ${result['cost_usd']:.4f} | Latenz: {result['latency_ms']}ms")Preise und ROI
| Modell | Preis pro Mio. Token | Geeignet für | Kosteneffizienz |
|---|---|---|---|
| DeepSeek V3.2 | $0.42 | Volumen-Analysen, Batch-Processing | ⭐⭐⭐⭐⭐ 85%+ Ersparnis |
| Gemini 2.5 Flash | $2.50 | Echtzeit-Signale, schnelle Inferenz | ⭐⭐⭐⭐ Sehr gut |
| GPT-4.1 | $8.00 | Komplexe Modellierung, Forschung | ⭐⭐⭐ Gut |
| Claude Sonnet 4.5 | $15.00 | Hochpräzise Analysen | ⭐⭐ Premium |
ROI-Kalkulation für Deribit-Analyseplattform
Bei einem typischen Volumen von 10 Millionen Token/Monat:
- Mit DeepSeek V3.2: $4,20/Monat (statt $84 mit GPT-4)
- Jährliche Ersparnis: $957,60 im Vergleich zu Premium-Modellen
- Break-even: Bereits nach dem ersten Monat durch reduzierte Infrastrukturkosten
Geeignet / Nicht geeignet für
✅ Perfekt geeignet für:
- Fintech-Startups mit begrenztem Budget für KI-Infrastruktur
- Algorithmic Trading Plattformen mit hohem Anfragevolumen
- Quantitative Forschungsabteilungen an Universitäten
- Einzelentwickler und Indie-Hacker im Krypto-Bereich
- Automatisierte Trading-Bots mit kontinuierlicher Datenanalyse
❌ Nicht optimal geeignet für:
- Unternehmen mit Compliance-Anforderungen (regulierte Banken)
- Projekte, die ausschließlich Claude-spezifische Features benötigen
- Mission-critical Systeme ohne eigene Failover-Infrastruktur
Warum HolySheep wählen
- Unschlagbare Preise: $0.42/MTok mit DeepSeek V3.2 – 85%+ günstiger als OpenAI
- Chinesische Zahlungsoptionen: WeChat Pay und Alipay für asiatische Märkte
- ¥1 = $1 Wechselkurs: Maximale Transparenz ohne versteckte Währungsgebühren
- Ultraschnelle Latenz: Unter 50ms durch optimierte Edge-Infrastruktur
- Kostenlose Credits: Sofortiger Start ohne Kreditkarte
- Native Python/JS-SDKs: Drop-in Replacement für bestehenden Code
Häufige Fehler und Lösungen
Fehler 1: Falscher API-Endpoint
Symptom: 404 Not Found oder Authentication Error
# ❌ FALSCH - Alte OpenAI-Endpunkte
BASE_URL = "https://api.openai.com/v1"
response = requests.post("https://api.openai.com/v1/chat/completions", ...)
✅ RICHTIG - HolySheep AI Endpoints
BASE_URL = "https://api.holysheep.ai/v1"
response = requests.post("https://api.holysheep.ai/v1/chat/completions", headers={
"Authorization": f"Bearer {YOUR_HOLYSHEEP_API_KEY}", # WICHTIG!
"Content-Type": "application/json"
}, json={
"model": "deepseek-v3.2", # Nicht "gpt-4" verwenden!
"messages": [...]
})Fehler 2: Volatilitäts-Berechnung bei sehr kurzen Laufzeiten
Symptom: ValueError: root not bracketed bei T < 0.01
# ❌ FEHLERHAFT - Keine Prüfung auf extreme Kurzfristigkeit
def calculate_iv(market_price, S, K, T, r):
return brentq(lambda sigma: bs_call(S, K, T, r, sigma) - market_price, 0.001, 5.0)
✅ KORREKT - Spezialbehandlung für Days/Hours
def calculate_iv_safe(market_price, S, K, T, r):
# T in Jahren, mind. 1 Stunde erzwingen
T_safe = max(T, 1/365/24)
try:
return brentq(lambda sigma: bs_call(S, K, T_safe, r, sigma) - market_price,
0.001, 5.0, maxiter=200)
except ValueError:
# Für sehr kurze Laufzeiten: lineare Extrapolation
return estimate_iv_from_nearby_strike(S, K, T_safe, r, market_price)
def estimate_iv_from_nearby_strike(S, K, T, r, price):
"""Fallback für unhandelbare Kurzläufer"""
moneyness = np.log(S/K)
base_vol = 0.5 + abs(moneyness) * 2 / np.sqrt(T)
return min(max(base_vol, 0.05), 4.0)Fehler 3: Memory Leak bei WebSocket-Verbindungen
Symptom: Wachsende Memory-Nutzung, eventual OutOfMemoryError
# ❌ PROBLEMATISCH - Keine Connection-Limits
import websockets
async def stream_options_data(uri):
async with websockets.connect(uri) as ws:
while True:
data = await ws.recv()
# Speichert ALLE Daten - Memory wächst endlos
all_data.append(json.loads(data))
✅ RICHTIG - Bounded Buffer mit Cleanup
import asyncio
from collections import deque
class BoundedDataBuffer:
"""Speicher-effizienter Ring-Puffer für Streaming-Daten"""
def __init__(self, max_size: int = 10000):
self.buffer = deque(maxlen=max_size)
self.processed_count = 0
def add(self, data):
self.buffer.append(data)
self.processed_count += 1
# Automatischer Cleanup bei Überschreitung
if len(self.buffer) >= self.buffer.maxlen:
# Nur aggregierte Stats behalten, alte Daten verwerfen
self._compact_buffer()
def _compact_buffer(self):
"""Reduziert Buffer auf aggregierte Metriken"""
if len(self.buffer) > 100:
# Keep only latest 100 + aggregierte Stats
self.buffer = deque(list(self.buffer)[-100:], maxlen=10000)
print(f"[Cleanup] Verarbeitete {self.processed_count} Nachrichten, Buffer komprimiert")Fehler 4: Zeitüberschreitung bei Rate-Limiting
Symptom: 429 Too Many Requests trotz angeblich korrekter Limits
# ❌ FEHLERHAFT - Kein Retry-Mechanismus
response = requests.post(url, json=payload, headers=headers)
if response.status_code == 429:
print("Rate limit erreicht!") # Nur Loggen reicht nicht
✅ RICHTIG - Exponential Backoff mit Jitter
import random
import time
def call_with_retry(url: str, payload: dict, headers: dict, max_retries: int = 5):
"""Robuster API-Call mit exponentiellem Backoff"""
for attempt in range(max_retries):
try:
response = requests.post(url, json=payload, headers=headers, timeout=30)
if response.status_code == 200:
return response.json()
elif response.status_code == 429:
# Rate Limited - Smart Retry
retry_after = int(response.headers.get("Retry-After", 60))
# Exponentiell + Random Jitter (0.5s - 2s)
wait_time = min(retry_after, (2 ** attempt) + random.uniform(0.5, 2.0))
print(f"⏳ Rate limit. Warte {wait_time:.1f}s (Versuch {attempt + 1}/{max_retries})")
time.sleep(wait_time)
else:
raise Exception(f"API Error: {response.status_code} - {response.text}")
except requests.exceptions.Timeout:
wait_time = 2 ** attempt
print(f"⏳ Timeout. Warte {wait_time}s...")
time.sleep(wait_time)
raise Exception(f"Max retries ({max_retries}) nach allen Versuchen überschritten")WebSocket-Streaming für Echtzeit-IV-Daten
import websockets
import asyncio
import json
class DeribitWebSocketClient:
"""
Echtzeit-Streaming von Deribit Options-Daten via WebSocket
mit automatischer Reconnection und Heartbeat
"""
WS_URL = "wss://www.deribit.com/ws/api/v2"
def __init__(self):
self.ws = None
self.subscriptions = set()
self.message_queue = asyncio.Queue(maxsize=1000)
self.reconnect_delay = 1
self.max_reconnect_delay = 60
async def connect(self):
"""WebSocket-Verbindung herstellen mit Heartbeat"""
while True:
try:
self.ws = await websockets.connect(self.WS_URL, ping_interval=20)
self.reconnect_delay = 1 # Reset bei erfolgreicher Verbindung
print("✅ WebSocket verbunden")
# Subscription-Requests senden
await self._subscribe_to_options()
# Nachrichten-Loop starten
await self._message_loop()
except websockets.exceptions.ConnectionClosed as e:
print(f"⚠️ Verbindung verloren: {e}")
await self._reconnect()
except Exception as e:
print(f"❌ Fehler: {e}")
await self._reconnect()
async def _subscribe_to_options(self):
"""BTC und ETH Options-Daten abonnieren"""
subscribe_msg = {
"jsonrpc": "2.0",
"id": 1,
"method": "public/subscribe",
"params": {
"channels": [
"deribit_price_index.btc_usd",
"deribit_price_index.eth_usd",
"book.BTC-27DEC24.100ms", # Options-Book mit 100ms Updates
"trades.BTC-27DEC24.100ms" # Trade-Daten
]
}
}
await self.ws.send(json.dumps(subscribe_msg))
print("📡 Abonniert: BTC & ETH Options-Feeds")
async def _message_loop(self):
"""Kontinuierlicher Nachrichtenempfang"""
while self.ws and self.ws.open:
try:
message = await asyncio.wait_for(self.ws.recv(), timeout=30)
data = json.loads(message)
# Queue mit Timeout, um Blockierung zu vermeiden
try:
self.message_queue.put_nowait(data)
except asyncio.QueueFull:
# Queue voll - älteste Nachricht verwerfen
await self.message_queue.get()
await self.message_queue.put(data)
except asyncio.TimeoutError:
# Heartbeat-Check
print("💓 Heartbeat OK")
async def _reconnect(self):
"""Exponentielles Backoff für Reconnection"""
print(f"🔄 Reconnection in {self.re