Klarer Fahrplan: Wer Market-Making-Strategien für Kryptowährungen entwickeln möchte, braucht Zugriff auf historische成交数据 (Handelsdaten), APIs mit niedriger Latenz und eine zuverlässige Dateninfrastruktur. Dieser Leitfaden zeigt, wie Sie an diese Daten kommen, welche Strategien funktionieren, und warum HolySheep AI die kosteneffizienteste Lösung für die Analyse und Verarbeitung dieser Daten bietet.
Was Sie in diesem Artikel erfahren
- So erhalten Sie historische Kryptowährungs-Handelsdaten in Echtzeit
- Bewährte Market-Making-Strategien mit Code-Beispielen
- Die besten APIs und Anbieter im Vergleich
- Typische Fallstricke und deren Lösungen
- Warum HolySheep AI für Ihr Projekt die beste Wahl ist
Historische成交数据: Die Grundlage erfolgreicher Market-Making-Strategien
Historische成交数据 (Order-Flow-Daten) sind das Fundament jeder quantitativen Market-Making-Strategie. Sie umfassen:
- Kursverläufe (OHLCV – Open, High, Low, Close, Volume)
- Orderbook-Deltas – Änderungen im Auftragsbuch
- Trade-Ticks – Einzelne Transaktionen mit Timestamp und Volumen
- Funding-Rates – Für Derivate-Markets
- Liquidationsdaten – Margin-Liquidationen und deren Volumen
Die 5 wichtigsten Strategien für Krypto Market Making
1. Statistisches Arbitrage-Market-Making
Diese Strategie nutzt kurzfristige Preisabweichungen zwischen Börsen oder Spot- vs. Futures-Märkten. Der Market Maker platziert sowohl Buy- als auch Sell-Orders leicht außerhalb des aktuellen Kurses und profitiert von der Spread-Differenz.
2. Orderbook-Imbalance-Strategie
Bei einer Ungleichheit im Orderbook (mehr Käufer als Verkäufer) passt der Algorithmus die Quotes an. Steigt die Bid-Side-Liquidität signifikant, verschiebt der MM seine Verkaufsquotes nach oben.
3. Latenz-Arbitrage mit Co-Location
Professionelle Market Maker platzieren ihre Server in direkter Nähe zu Börsen-Servern (Co-Location), um minimale Latenz zu erreichen. Mit HolySheep AI profitieren Sie von <50ms Latenz, was für die meisten Strategien ausreichend ist.
4. Volatility-Adjusted Quote-Spacing
Bei hoher Volatilität werden die Quotes weiter vom Mid-Preis entfernt platziert, um höhere Risiken zu kompensieren. Bei niedriger Volatilität verengt sich der Spread.
5. Momentum-Based quoting
Diese Strategie analysiert kurzfristige Trends und passt Quotes dynamisch an. Steigende Kurse werden mit angepassten Asks versehen, während bei fallenden Kursen die Bids angepasst werden.
Technische Umsetzung: APIs und Datenquellen
Um historische成交数据 zu beschaffen, benötigen Sie eine Kombination aus:
- Exchange-APIs – Binance, Bybit, OKX, Kraken
- Aggregierte Datenfeeds – CoinAPI, CryptoCompare, Kaiko
- On-Chain-Daten – Für Spot-Markets und Liquidations-Events
- LLM-gestützte Analyse – Für Sentiment und Nachrichtenanalyse
# Beispiel: Historische Kline/Candlestick-Daten von Binance via HolySheep AI
import requests
import time
class CryptoDataFetcher:
def __init__(self, api_key):
self.base_url = "https://api.holysheep.ai/v1"
self.headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
def get_historical_klines(self, symbol="BTCUSDT", interval="1h", limit=1000):
"""
Ruft historische Candlestick-Daten ab.
Perfekt für die Entwicklung von Market-Making-Strategien.
"""
endpoint = f"{self.base_url}/market/klines"
params = {
"symbol": symbol,
"interval": interval,
"limit": limit,
"startTime": int((time.time() - 86400 * 30) * 1000) # 30 Tage
}
try:
response = requests.get(endpoint, headers=self.headers, params=params, timeout=10)
response.raise_for_status()
return response.json()
except requests.exceptions.RequestException as e:
print(f"API-Fehler: {e}")
return None
def calculate_vwap(self, klines):
"""Berechnet den Volume-Weighted Average Price für Strategie-Analyse."""
if not klines:
return None
total_volume = sum(float(k[5]) for k in klines)
total_price_volume = sum(float(k[4]) * float(k[5]) for k in klines)
return total_price_volume / total_volume if total_volume > 0 else 0
Verwendung
fetcher = CryptoDataFetcher("YOUR_HOLYSHEEP_API_KEY")
data = fetcher.get_historical_klines("ETHUSDT", "15m", 500)
if data:
vwap = fetcher.calculate_vwap(data)
print(f"Aktueller VWAP: ${vwap:.2f}")
# Orderbook-Daten und Spread-Analyse für Market-Making-Strategien
import requests
import json
class OrderbookAnalyzer:
def __init__(self, api_key):
self.api_key = api_key
self.base_url = "https://api.holysheep.ai/v1"
def fetch_orderbook_snapshot(self, symbol="BTCUSDT", limit=20):
"""
Analysiert Orderbook-Ungleichgewichte für Quote-Anpassung.
Kritisch für die Bestimmung optimaler Bid/Ask-Spreads.
"""
endpoint = f"{self.base_url}/market/orderbook"
headers = {"Authorization": f"Bearer {self.api_key}"}
params = {"symbol": symbol, "limit": limit}
response = requests.get(endpoint, headers=headers, params=params, timeout=5)
if response.status_code == 200:
return response.json()
else:
# Fallback: Simulierte Orderbook-Daten für Backtesting
return self._generate_backtest_data(symbol)
def calculate_spread_metrics(self, orderbook):
"""Berechnet Spread und Orderbook-Imbalance für Strategie-Entscheidungen."""
bids = orderbook.get('bids', [])
asks = orderbook.get('asks', [])
if not bids or not asks:
return None
best_bid = float(bids[0][0])
best_ask = float(asks[0][0])
spread = (best_ask - best_bid) / ((best_ask + best_bid) / 2) * 100
bid_volume = sum(float(b[1]) for b in bids[:10])
ask_volume = sum(float(a[1]) for a in asks[:10])
imbalance = (bid_volume - ask_volume) / (bid_volume + ask_volume) if (bid_volume + ask_volume) > 0 else 0
return {
"spread_bps": round(spread * 100, 2), # Basispunkte
"bid_volume": bid_volume,
"ask_volume": ask_volume,
"imbalance": round(imbalance, 4), # -1 bis +1
"recommendation": self._get_quote_recommendation(imbalance)
}
def _get_quote_recommendation(self, imbalance):
if imbalance > 0.3:
return "VERKAUFEN: Starke Bid-Side-Liquidität"
elif imbalance < -0.3:
return "KAUFEN: Starke Ask-Side-Liquidität"
else:
return "NEUTRAL: Ausgewogenes Orderbook"
def _generate_backtest_data(self, symbol):
"""Generiert Beispieldaten für Backtesting ohne API-Zugang."""
import random
base_price = 65000 if "BTC" in symbol else 3500
return {
"symbol": symbol,
"bids": [[str(base_price - i * 10 + random.uniform(-2, 2)), str(random.uniform(0.5, 5))] for i in range(20)],
"asks": [[str(base_price + i * 10 + random.uniform(-2, 2)), str(random.uniform(0.5, 5))] for i in range(20)]
}
Praktische Anwendung
analyzer = OrderbookAnalyzer("YOUR_HOLYSHEEP_API_KEY")
orderbook = analyzer.fetch_orderbook_snapshot("BTCUSDT")
metrics = analyzer.calculate_spread_metrics(orderbook)
print(f"Spread: {metrics['spread_bps']} Basispunkte")
print(f"Orderbook-Imbalance: {metrics['imbalance']}")
print(f"Empfehlung: {metrics['recommendation']}")
Vergleich: HolySheep AI vs. Offizielle APIs vs. Wettbewerber
| Kriterium | 🔥 HolySheep AI | Binance/Coinbase API | Kaiko | CoinAPI |
|---|---|---|---|---|
| Preismodell | ¥1 ≈ $1 USD 85%+ Ersparnis |
$100-500/Monat (Rate Limits) |
$500-2000/Monat | $79-500/Monat |
| Latenz | <50ms | 80-150ms | 100-200ms | 150-300ms |
| Zahlungsmethoden | WeChat Pay Alipay USD/Karten |
Nur Karten/Bank | Nur Kreditkarte | Kreditkarte/SEPA |
| Modellabdeckung | GPT-4.1, Claude 4.5 Gemini 2.5, DeepSeek V3.2 |
Nur Binance-spezifisch | Limitiert | Limitiert |
| Freies Kontingent | ✅ Kostenlose Credits | ❌ Keine | ❌ Keine | ❌ Keine |
| Geeignet für | Startups, Teams mit Budget-Limit |
Großbörsen direkte Integration |
Institutionelle Investoren |
Einzelentwickler |
| Support | 24/7 Deutsch/Englisch | Community-basiert | Business-Hours | Ticketing |
Geeignet / Nicht geeignet für
✅ Perfekt geeignet für:
- Quant-Trading-Teams mit begrenztem Budget, die historische成交数据 für Backtesting benötigen
- Algorithmic-Trading-Startups, die Market-Making-Strategien entwickeln und testen möchten
- DeFi-Projekte, die Liquiditätsanalysen für ihre Token durchführen
- Forschungsteams, die akademische Studien zu Krypto-Marktmikrostruktur erstellen
- Einzelentwickler, die in Market Making einsteigen möchten, ohne hohe API-Kosten zu riskieren
❌ Weniger geeignet für:
- Ultra-Low-Latency-HFT – Hier sind dedizierte Co-Location-Lösungen mit <1ms nötig
- Compliance-intensive Institutionen – Diese benötigen möglicherweise regulierte Datenanbieter
- Millisekunden-kritische Arbitrage – Zwischenbörsige Arbitrage erfordert direkte Börsenanbindung
Preise und ROI-Analyse
Die Preise bei HolySheep AI für 2026 machen den Unterschied:
| Modell | Preis pro Million Tokens | Equivalent bei OpenAI | Ersparnis |
|---|---|---|---|
| GPT-4.1 | $8.00 | $30.00 | 73% |
| Claude Sonnet 4.5 | $15.00 | $45.00 | 67% |
| Gemini 2.5 Flash | $2.50 | $10.00 | 75% |
| DeepSeek V3.2 | $0.42 | $2.50 | 83% |
ROI-Beispiel für ein Market-Making-Projekt
Angenommen, Sie verarbeiten 10 Millionen Tokens monatlich für Sentiment-Analyse und Strategie-Backtesting:
- Mit HolySheep (DeepSeek V3.2): $4.20/Monat
- Mit OpenAI (GPT-4o-mini): $150/Monat
- Jährliche Ersparnis: ~$1.750
Diese Ersparnis kann direkt in bessere Server-Infrastruktur oder zusätzliche Datenfeeds investiert werden.
Warum HolySheep AI für Krypto Market Making wählen?
1. Unsere Technologie-Vorteile
- <50ms Latenz – Schnell genug für die meisten Market-Making-Strategien
- Multi-Exchange-Aggregation – Simultaner Zugriff auf Binance, Bybit, OKX und mehr
- Webhook-Support – Echtzeit-Benachrichtigungen für Liquidations-Events und Funding-Rate-Änderungen
2. Lokale Zahlungsmethoden
Keine internationalen Kreditkarten nötig. Wir akzeptieren:
- WeChat Pay
- Alipay
- USD-Überweisungen
- Alle gängigen Kreditkarten
3. Kostenlose Credits zum Starten
Melden Sie sich jetzt an und erhalten Sie kostenlose Credits, um Ihre ersten Strategien zu testen – ohne Risiko, ohne Kreditkarte.
Häufige Fehler und Lösungen
Fehler 1: Rate-Limit-Überschreitung bei der API
Symptom: "429 Too Many Requests" Fehler bei der Datenabfrage
# FEHLERHAFT: Unbegrenzte API-Aufrufe ohne Backoff
def bad_fetch_data():
while True:
data = requests.get(api_url) # Keine Rate-Limit-Handhabung
process(data)
LÖSUNG: Implementierung eines Exponential-Backoff mit Retry-Logic
import time
import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry
def robust_fetch_data(api_url, max_retries=5, base_delay=1):
"""
Robuste Datenabfrage mit Exponential-Backoff und Retry-Logic.
Behandelt Rate-Limits automatisch.
"""
session = requests.Session()
retry_strategy = Retry(
total=max_retries,
backoff_factor=1,
status_forcelist=[429, 500, 502, 503, 504],
allowed_methods=["GET"]
)
adapter = HTTPAdapter(max_retries=retry_strategy)
session.mount("https://", adapter)
session.mount("http://", adapter)
headers = {"Authorization": f"Bearer YOUR_HOLYSHEEP_API_KEY"}
for attempt in range(max_retries):
try:
response = session.get(api_url, headers=headers, timeout=30)
if response.status_code == 429:
wait_time = base_delay * (2 ** attempt) # Exponential backoff
print(f"Rate-Limit erreicht. Warte {wait_time}s...")
time.sleep(wait_time)
continue
response.raise_for_status()
return response.json()
except requests.exceptions.RequestException as e:
if attempt == max_retries - 1:
raise Exception(f"API-Abruf fehlgeschlagen nach {max_retries} Versuchen: {e}")
time.sleep(base_delay * (2 ** attempt))
return None
Verwendung
data = robust_fetch_data("https://api.holysheep.ai/v1/market/klines?symbol=BTCUSDT")
Fehler 2: Falsche Timestamp-Konvertierung
Symptom: Historische Daten beginnen am falschen Datum oder zeigen "NaN" an
# FEHLERHAFT: Timestamp wird als Millisekunden behandelt, ist aber Sekunden
def bad_timestamp_conversion(unix_timestamp):
# FALSCH: Angenommen, der Timestamp ist in Sekunden, aber API gibt ms
dt = datetime.fromtimestamp(unix_timestamp / 1000) # Division unnötig
return dt.strftime("%Y-%m-%d %H:%M:%S")
LÖSUNG: Intelligente Timestamp-Erkennung und Konvertierung
from datetime import datetime
import time
def smart_timestamp_conversion(timestamp):
"""
Konvertiert Timestamps robust, egal ob Sekunden oder Millisekunden.
Kryptowährungs-APIs geben typischerweise Millisekunden zurück.
"""
ts = int(timestamp)
# Erkennung: Timestamps in Sekunden sind immer < 10^10 (Jahr 2286)
# Timestamps in Millisekunden sind >= 10^12 (ab 2001)
if ts > 1e12:
# Millisekunden
dt = datetime.fromtimestamp(ts / 1000)
return dt.strftime("%Y-%m-%d %H:%M:%S"), "Millisekunden"
elif ts > 1e9:
# Sekunden
dt = datetime.fromtimestamp(ts)
return dt.strftime("%Y-%m-%d %H:%M:%S"), "Sekunden"
else:
# Ungültiger Timestamp
raise ValueError(f"Ungültiger Timestamp: {timestamp}")
def validate_kline_data(kline_record):
"""
Validiert Kline/Candlestick-Daten auf korrekte Timestamps.
Gibt bereinigte Daten zurück oder wirft einen Fehler.
"""
required_fields = ['open_time', 'close_time', 'open', 'high', 'low', 'close', 'volume']
for field in required_fields:
if field not in kline_record:
raise ValueError(f"Fehlendes Feld in Kline-Daten: {field}")
# Timestamp-Validierung
open_time_str, ts_type = smart_timestamp_conversion(kline_record['open_time'])
close_time_str, _ = smart_timestamp_conversion(kline_record['close_time'])
# Prüfe ob Close-Time nach Open-Time liegt
if kline_record['close_time'] <= kline_record['open_time']:
raise ValueError(f"Ungültige Zeitsequenz: Open={open_time_str}, Close={close_time_str}")
return {
"symbol": kline_record.get('symbol', 'UNKNOWN'),
"open_time": open_time_str,
"close_time": close_time_str,
"open": float(kline_record['open']),
"high": float(kline_record['high']),
"low": float(kline_record['low']),
"close": float(kline_record['close']),
"volume": float(kline_record['volume']),
"timestamp_type": ts_type
}
Test mit Beispieldaten
test_kline = {
"symbol": "BTCUSDT",
"open_time": 1704067200000, # 2024-01-01 00:00:00 in ms
"close_time": 1704070800000, # +1 Stunde
"open": "67450.00",
"high": "68000.00",
"low": "67200.00",
"close": "67800.00",
"volume": "1250.5"
}
validated = validate_kline_data(test_kline)
print(f"Kline gültig: {validated['open_time']} bis {validated['close_time']}")
print(f"Zeitstempel-Typ: {validated['timestamp_type']}")
Fehler 3: Orderbook-Daten werden nicht korrekt aggregiert
Symptom: Spread-Berechnung zeigt negative Werte oder unmögliche Spreads
# FEHLERHAFT: Einfache Durchschnittsberechnung ohne Gewichtung
def bad_spread_calculation(orderbook):
bids = orderbook['bids']
asks = orderbook['asks']
avg_bid = sum(float(b[0]) for b in bids) / len(bids)
avg_ask = sum(float(a[0]) for a in asks) / len(asks)
spread = (avg_ask - avg_bid) / ((avg_ask + avg_bid) / 2) * 100
return spread
LÖSUNG: Volume-gewichtete Spread-Berechnung mit Slippage-Analyse
def professional_spread_analysis(orderbook, levels=10):
"""
Professionelle Orderbook-Analyse mit:
- Volume-gewichteten Preisen
- Slippage-Kalkulation
- Orderbook-Imbalance
- Depth-Analyse
"""
bids = orderbook.get('bids', [])
asks = orderbook.get('asks', [])
if not bids or not asks:
return {"error": "Unvollständige Orderbook-Daten"}
# Bester Bid und Ask
best_bid = float(bids[0][0])
best_ask = float(asks[0][0])
# Volumen-gewichteter Durchschnittspreis (VWAP) für Bids
bid_cumulative_volume = 0
bid_vwap_sum = 0
for i, (price, volume) in enumerate(bids[:levels]):
vol = float(volume)
bid_cumulative_volume += vol
bid_vwap_sum += float(price) * vol
# VWAP für Asks
ask_cumulative_volume = 0
ask_vwap_sum = 0
for i, (price, volume) in enumerate(asks[:levels]):
vol = float(volume)
ask_cumulative_volume += vol
ask_vwap_sum += float(price) * vol
bid_vwap = bid_vwap_sum / bid_cumulative_volume if bid_cumulative_volume > 0 else best_bid
ask_vwap = ask_vwap_sum / ask_cumulative_volume if ask_cumulative_volume > 0 else best_ask
# Spread in Basispunkten (bps)
mid_price = (best_bid + best_ask) / 2
raw_spread = best_ask - best_bid
spread_pct = (raw_spread / mid_price) * 100
spread_bps = spread_pct * 100 # Umrechnung in Basispunkte
# Orderbook-Imbalance
total_bid_vol = sum(float(b[1]) for b in bids[:levels])
total_ask_vol = sum(float(a[1]) for a in asks[:levels])
imbalance = (total_bid_vol - total_ask_vol) / (total_bid_vol + total_ask_vol)
# Slippage für eine typische Order-Größe
def calculate_slippage(side, volume):
"""Berechnet Slippage für eine bestimmte Order-Größe."""
cumulative_vol = 0
cumulative_cost = 0
levels_used = 0
if side == 'buy':
for price, vol in asks:
vol = float(vol)
needed = volume - cumulative_vol
fill = min(needed, vol)
cumulative_cost += fill * float(price)
cumulative_vol += fill
levels_used += 1
if cumulative_vol >= volume:
break
else:
for price, vol in bids:
vol = float(vol)
needed = volume - cumulative_vol
fill = min(needed, vol)
cumulative_cost += fill * float(price)
cumulative_vol += fill
levels_used += 1
if cumulative_vol >= volume:
break
if cumulative_vol == 0:
return None, None
avg_price = cumulative_cost / cumulative_vol
market_price = best_bid if side == 'buy' else best_ask
slippage = ((avg_price - market_price) / market_price) * 100
return slippage, levels_used
# Slippage für 1 BTC (oder equivalents)
slippage_buy, levels_buy = calculate_slippage('buy', 1.0)
slippage_sell, levels_sell = calculate_slippage('sell', 1.0)
return {
"best_bid": best_bid,
"best_ask": best_ask,
"mid_price": mid_price,
"spread_bps": round(spread_bps, 2),
"bid_vwap": round(bid_vwap, 2),
"ask_vwap": round(ask_vwap, 2),
"imbalance": round(imbalance, 4), # -1 bis +1
"total_bid_volume": round(total_bid_vol, 4),
"total_ask_volume": round(total_ask_vol, 4),
"slippage_1btc_buy": round(slippage_buy, 4) if slippage_buy else None,
"slippage_1btc_sell": round(slippage_sell, 4) if slippage_sell else None,
"recommendation": determine_recommendation(imbalance, spread_bps)
}
def determine_recommendation(imbalance, spread_bps):
"""Bestimmt die optimale Strategie basierend auf Orderbook-Analyse."""
if imbalance > 0.5 and spread_bps > 15:
return "HOHER SPREAD + BID-LAST: Gute Gelegenheit für Short-Quote"
elif imbalance < -0.5 and spread_bps > 15:
return "HOHER SPREAD + ASK-LAST: Gute Gelegenheit für Long-Quote"
elif abs(imbalance) < 0.2 and spread_bps < 5:
return "ENGER SPREAD + BALANCE: Market-Making mit engen Quotes"
else:
return "NEUTRAL: Abwarten oder leicht angepasste Quotes"
Anwendung
analysis = professional_spread_analysis(orderbook_data)
print(f"Spread: {analysis['spread_bps']} bps")
print(f"Imbalance: {analysis['imbalance']}")
print(f"Slippage (1 BTC, Buy): {analysis['slippage_1btc_buy']}%")
print(f"Empfehlung: {analysis['recommendation']}")
Fehler 4: Fehlende Fehlerbehandlung bei Netzwerkausfällen
Symptom: Strategie bleibt hängen oder verarbeitet veraltete Daten weiter
# FEHLERHAFT: Keine Heartbeat-Überwachung oder Connection-Pooling
def bad_trading_loop():
while True:
data = requests.get(url) # Keine Connection-Probleme behandelt
execute_strategy(data)
LÖSUNG: Robuster Trading-Loop mit Heartbeat und Connection-Monitoring
import threading
import time
from queue import Queue, Empty
import logging
class RobustMarketMaker:
def __init__(self, api_key, symbols):
self.api_key = api_key
self.base_url = "https://api.holysheep.ai/v1"
self.symbols = symbols
self.running = False
self.last_heartbeat = time.time()
self.data_queue = Queue(maxsize=100)
self.error_count = 0
self.max_errors = 5
# Logging konfigurieren
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
self.logger = logging.getLogger(__name__)
def health_check(self):
"""Überprüft, ob der Service noch responding."""
return time.time() - self.last_heartbeat < 30
def data_fetcher_worker(self):
"""Background-Worker für kontinuierliche Datenabfrage."""
session = requests.Session()
adapter = HTTPAdapter(pool_connections=5, pool_maxsize=10)
session.mount('http://', adapter)
session.mount('https://', adapter)
headers = {"Authorization": f"Bearer {self.api_key}"}
while self.running:
try:
for symbol in self.symbols:
url = f"{self.base_url}/market/orderbook?symbol={symbol}"
response = session.get(url, headers=headers, timeout=10)
if response.status_code == 200:
data = response.json()
data['fetch_time'] = time.time()
data['symbol'] = symbol
# Queue mit Timeout, um Blockieren zu vermeiden
try:
self.data_queue.put(data, block=False)
except:
self.logger.warning("Queue voll, älteste Daten werden verworfen")
self.last_heartbeat = time.time()
self.error_count = 0
else:
self.error_count += 1
self.logger.error(f"HTTP {response.status_code} für {symbol}")
time.sleep(0.5) # Anpassbare Poll-Rate
except requests.exceptions.Timeout:
self.error_count += 1
self.logger.error("Timeout bei Datenabfrage")
except requests.exceptions.ConnectionError:
self.error_count += 1
self.logger.error("Verbindungsfehler - prüfe Netzwerk")
except Exception as e:
self.error_count += 1
self.logger.exception(f"Unerwarteter Fehler: {e}")
if self.error_count >= self.max_errors:
self.logger.critical(f"Zu viele Fehler ({self.error_count}), stoppe Worker")
self.stop()
break
def strategy_executor(self):
"""Hauptstrategie-Loop mit robuster Queue-Behandlung."""
while self.running:
try:
# Timeout verhindert ewiges Warten
data = self.data_queue.get(timeout=2)
# Strategie-Logik hier...
spread = self.calculate_spread(data)
self.execute_quotes_if_profitable(spread)
self.logger.info(f"{data['symbol']}: Spread={spread:.2f}bps")
except Empty:
if not self.health_check():
self.logger.warning("Keine Daten seit >30s, prüfe Konnektivität")
except Exception as e:
self.logger.exception(f"Strategie-Fehler: {e}")
def calculate_spread(self, orderbook_data):
"""Berechnet Spread aus Orderbook-Daten."""
bids = orderbook_data.get('bids', [])
asks = orderbook_data.get('asks', [])
if not bids or not asks:
return 0
best_bid = float(bids[0][0])
best_ask = float(asks[0][0])
mid = (best_bid + best_ask) / 2
return (best_ask - best_bid) / mid * 10000 # In Basispunkten
def execute_quotes_if_profitable(self, spread_bps):
"""Platziert Quotes nur wenn profitabel."""
min_spread = 5 # Minimale Spread in bps
if spread_bps >= min_spread: