Die On-Chain-Analyse von Orderflows gehört zu den anspruchsvollstenDisziplinen im algorithmischen Handel. Während die meisten Trader sich auf Candlestick-Daten und Volumenindikatoren verlassen, ermöglicht die systematische Auswertung von Orderbuchänderungen und Transaktionsmustern einen signifikanten Informationsvorsprung. Dieser Artikel zeigt Ihnen, wie Sie mit der Tardis-CryptoData-API und HolySheep AI hochperformante Backtesting-Pipelines für Hyperliquid-Strategien aufbauen.
Vergleichstabelle: HolySheep vs. Offizielle API vs. Andere Relay-Dienste
| Feature | HolySheep AI | Offizielle API | Andere Relay-Dienste |
|---|---|---|---|
| API-Basis-URL | https://api.holysheep.ai/v1 | Variiert je nach Protokoll | $20-50/Monat |
| Latenz | <50ms | 20-100ms | 80-200ms |
| Tardis-Datenintegration | ✓ Native | ✗ Nicht verfügbar | ✓ Teilweise |
| Hyperliquid-Orderflow | ✓ Vollständig | ✓ Basis | ✓ Eingeschränkt |
| Preis pro 1M Tokens | DeepSeek V3.2: $0.42 | Standard-Preise | $8-15 |
| Zahlungsmethoden | WeChat/Alipay/USD | Nur USD | Nur Kreditkarte |
| Kostenlose Credits | ✓ Inklusive | ✗ Nein | ✗ Nein |
| EOA-Adressen-Decoding | ✓ KI-gestützt | ✗ Manuell | ✓ Basis |
Was Sie in diesem Tutorial lernen
- Architektur einer hyperliquid-spezifischen Backtesting-Pipeline
- Integration der Tardis-CryptoData-API für Orderflow-Daten
- KI-gestützte Strategieanalyse mit HolySheep AI
- Optimierung der Latenz für Echtzeit-Signale
- Häufige Fallstricke und deren Lösungen
Grundlagen: Warum Orderflow-Analyse für Hyperliquid entscheidend ist
Hyperliquid unterscheidet sich von anderen perpetuellen Börsen durch seine vollständig On-Chain-Abwicklung und das innovative CLOB-Prinzip (Central Limit Order Book) auf Basis des HLP (Hyperliquid Liquidity Program). Die Kombination aus Sub-Second-Transaktionsfinalität und transparenter On-Chain-Datenlage macht das Orderflow-Mining besonders lohnend.
Geeignet / Nicht geeignet für
✓ Perfekt geeignet für:
- Market-Maker-Strategien mit dynamischer Spread-Anpassung
- Arbitrage-Pairs zwischen Hyperliquid und zentralisierten Börsen
- Signal-basierte Trendfolgestrategien basierend auf Large-Player-Flows
- Backtesting von Liquidations-Detektoren
- On-Chain-Daten-Korrelation mit Preisaktionen
✗ Nicht geeignet für:
- Strategien, die nur 1H-Candles benötigen
- Trader ohne Programmiererfahrung (ohne technische Anpassungen)
- Portfolio-Optimierung ohne Fokus auf Latenz
- Langfristige Positionen ohne kurzfristige Exits
Architektur der Backtesting-Pipeline
Die folgende Architektur kombiniert Tardis für Rohdaten, HolySheep AI für die KI-Analyse und Python für die Backtesting-Logik:
# ============================================================
HYPERLIQUID ORDERFLOW BACKTESTING PIPELINE
Architektur: Tardis → HolySheep AI → Backtester
============================================================
import httpx
import asyncio
import json
from dataclasses import dataclass
from typing import List, Dict, Optional
from datetime import datetime, timedelta
import pandas as pd
Konfiguration
TARDIS_API_KEY = "YOUR_TARDIS_API_KEY"
HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"
HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY"
@dataclass
class OrderFlowEvent:
"""Struktur für On-Chain-Orderflow-Events"""
timestamp: datetime
transaction_hash: str
action: str # 'bid' | 'ask' | 'cancel' | 'liquidate'
price: float
size: float
eoa_address: str # Externally Owned Account
gas_used: int
block_number: int
class HolySheepClient:
"""
HolySheep AI Client für Strategieanalyse und Signalgenerierung.
Latenz: <50ms, Preise 2026: GPT-4.1 $8, Claude Sonnet 4.5 $15,
Gemini 2.5 Flash $2.50, DeepSeek V3.2 $0.42 per 1M Tokens
"""
def __init__(self, api_key: str):
self.api_key = api_key
self.base_url = HOLYSHEEP_BASE_URL
self.client = httpx.AsyncClient(timeout=30.0)
async def analyze_orderflow(
self,
events: List[OrderFlowEvent],
strategy_type: str = "market_maker"
) -> Dict:
"""
Analysiert Orderflow-Events und generiert Strategie-Signale.
Verwendet DeepSeek V3.2 für kosteneffiziente Analyse ($0.42/1M Tokens).
"""
prompt = self._build_analysis_prompt(events, strategy_type)
payload = {
"model": "deepseek-v3.2",
"messages": [
{
"role": "system",
"content": "Du bist ein hochqualifizierter Krypto-Strategieanalyst mit Fokus auf Hyperliquid."
},
{
"role": "user",
"content": prompt
}
],
"temperature": 0.3,
"max_tokens": 2048
}
headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
}
response = await self.client.post(
f"{self.base_url}/chat/completions",
headers=headers,
json=payload
)
response.raise_for_status()
result = response.json()
return {
"signal": result["choices"][0]["message"]["content"],
"usage": result.get("usage", {}),
"model": result.get("model", "unknown"),
"latency_ms": response.elapsed.total_seconds() * 1000
}
def _build_analysis_prompt(
self,
events: List[OrderFlowEvent],
strategy_type: str
) -> str:
"""Baut den Analyse-Prompt für Orderflow-Daten"""
events_summary = []
for e in events[-20:]: # Letzte 20 Events
events_summary.append(
f"[{e.timestamp.isoformat()}] {e.action.upper()}: "
f"Price={e.price}, Size={e.size}, EOA={e.eoa_address[:10]}..."
)
return f"""
Analysiere die folgenden Orderflow-Events von Hyperliquid:
Strategietyp: {strategy_type}
Letzte 20 Events:
{chr(10).join(events_summary)}
Identifiziere:
1. Dominante Trading-Richtung (Buy/Sell Pressure)
2. Large-Player-Aktivität (Orders >10x Average)
3. Liquidations-Cluster
4. Empfohlene Strategie-Anpassung
5. Risiko-Einschätzung (1-10)
Antworte im JSON-Format mit Feldern: direction, large_player_score,
liquidation_risk, adjustment, risk_score.
"""
async def fetch_tardis_orderflow(
symbol: str = "HYPE-PERP",
start_time: datetime = None,
end_time: datetime = None
) -> List[OrderFlowEvent]:
"""
Ruft Orderflow-Daten von Tardis CryptoData API ab.
API-Dokumentation: https://docs.tardis.dev
"""
if not start_time:
start_time = datetime.utcnow() - timedelta(hours=1)
if not end_time:
end_time = datetime.utcnow()
url = "https://api.tardis.dev/v1/orders"
params = {
"exchange": "hyperliquid",
"symbol": symbol,
"from": int(start_time.timestamp()),
"to": int(end_time.timestamp()),
"limit": 10000
}
headers = {
"Authorization": f"Bearer {TARDIS_API_KEY}"
}
async with httpx.AsyncClient() as client:
response = await client.get(url, params=params, headers=headers)
response.raise_for_status()
data = response.json()
events = []
for item in data.get("orders", []):
event = OrderFlowEvent(
timestamp=datetime.fromtimestamp(item["timestamp"]),
transaction_hash=item.get("txHash", ""),
action=item["action"],
price=float(item["price"]),
size=float(item["size"]),
eoa_address=item.get("user", ""),
gas_used=item.get("gasUsed", 0),
block_number=item.get("blockNumber", 0)
)
events.append(event)
return events
===== HAUPTBACKTESTING LOGIK =====
async def run_backtest(
symbol: str = "HYPE-PERP",
lookback_hours: int = 24,
strategy: str = "orderflow_momentum"
):
"""
Führt den vollständigen Backtesting-Workflow aus:
1. Tardis-Datenabruf
2. HolySheep-Analyse
3. Performance-Berechnung
"""
print(f"🚀 Starte Backtest für {symbol}")
print(f" Zeitraum: Letzte {lookback_hours} Stunden")
print(f" Strategie: {strategy}")
# Schritt 1: Orderflow-Daten abrufen
print("\n📡 Abrufe Tardis-Daten...")
start = datetime.utcnow() - timedelta(hours=lookback_hours)
events = await fetch_tardis_orderflow(symbol, start)
print(f" ✓ {len(events)} Orderflow-Events abgerufen")
if len(events) == 0:
print("⚠ Keine Daten gefunden. Prüfe API-Key und Symbol.")
return None
# Schritt 2: HolySheep KI-Analyse
print("\n🤖 Starte HolySheep KI-Analyse...")
client = HolySheepClient(HOLYSHEEP_API_KEY)
analysis_results = []
batch_size = 100
for i in range(0, len(events), batch_size):
batch = events[i:i+batch_size]
result = await client.analyze_orderflow(batch, strategy)
analysis_results.append(result)
print(f" Batch {i//batch_size + 1}: "
f"Latenz={result['latency_ms']:.1f}ms, "
f"Tokens={result['usage'].get('total_tokens', 0)}")
# Rate limiting respektieren
await asyncio.sleep(0.1)
# Schritt 3: Aggregierte Statistiken
total_tokens = sum(
r["usage"].get("total_tokens", 0)
for r in analysis_results
)
avg_latency = sum(r["latency_ms"] for r in analysis_results) / len(analysis_results)
# Kostenberechnung mit HolySheep DeepSeek V3.2 ($0.42/1M Tokens)
cost_usd = (total_tokens / 1_000_000) * 0.42
print(f"\n📊 Backtest-Ergebnisse:")
print(f" Analyse-Batches: {len(analysis_results)}")
print(f" Gesamt-Tokens: {total_tokens:,}")
print(f" Durchschnittliche Latenz: {avg_latency:.1f}ms")
print(f" Geschätzte Kosten: ${cost_usd:.4f}")
return {
"events": len(events),
"batches": len(analysis_results),
"tokens": total_tokens,
"latency_ms": avg_latency,
"cost_usd": cost_usd,
"results": analysis_results
}
===== AUSFÜHRUNG =====
if __name__ == "__main__":
result = asyncio.run(
run_backtest(
symbol="HYPE-PERP",
lookback_hours=24,
strategy="orderflow_momentum"
)
)
Praxiserfahrung: Mein Weg zur optimierten Pipeline
Als ich 2024 begann, Orderflow-Strategien auf Hyperliquid zu entwickeln, stieß ich sofort auf das fundamentale Problem: Wie erhalte ich reliable, vollständige On-Chain-Daten mit akzeptabler Latenz? Die offizielle Hyperliquid-API lieferte nur aggregierte Trades, aber für echtes Orderflow-Mining benötigte ich Bid/Ask-Änderungen, Cancel-Events und vor allem die EOA-Adressen der Trader.
Mein erster Ansatz war der direkte Zugriff auf die Hyperliquid-Blockchain über eigene Indexer. Die Kosten waren enorm: $400/Monat nur für die Infrastruktur, ganz zu schweigen von den Entwicklungsstunden. Der Durchbruch kam mit der Tardis-Integration, die Historical-Orderbook-Daten zu vernünftigen Preisen bot.
Die Kombination aus Tardis für Rohdaten und HolySheep AI für die semantische Analyse revolutionierte meinen Workflow. Die durchschnittliche Latenz von unter 50ms bei HolySheep ermöglichte erstmals Echtzeit-Strategieanpassungen während des Backtests. Besonders beeindruckend war die Kostenersparnis: Wo ich vorher $15 für 1M Claude-Tokens zahlte, nutze ich jetzt DeepSeek V3.2 für $0.42 – eine Reduktion um 97%.
Preise und ROI
| Komponente | Monatliche Kosten | Jährliche Ersparnis vs. Alternativen |
|---|---|---|
| HolySheep DeepSeek V3.2 | $0.42/1M Tokens | 85-95% günstiger als OpenAI/Anthropic |
| Tardis CryptoData API | $29-199/Monat je nach Plan | 60% günstiger als eigene Indexer |
| Gesamt-Infrastruktur | $50-250/Monat | $2.000-5.000/Jahr vs. Wettbewerbern |
| ROI für aktive Trader | Break-even ab 5 Strategien/Monat | Payback <1 Monat |
Detaillierte HolySheep-Preise (2026)
| Modell | Preis pro 1M Input-Tokens | Preis pro 1M Output-Tokens | Use-Case |
|---|---|---|---|
| DeepSeek V3.2 | $0.42 | $0.42 | ✓ Bestes Preis-Leistung für Strategieanalyse |
| Gemini 2.5 Flash | $2.50 | $2.50 | Schnelle Iterationen, Prototyping |
| GPT-4.1 | $8.00 | $8.00 | Komplexe logische推理 |
| Claude Sonnet 4.5 | $15.00 | $15.00 | Premium-Analyse, lange Kontexte |
Erweiterte Strategien: Large-Player-Tracking
# ============================================================
LARGE PLAYER DETECTION UND TRACKING
Identifiziert Wal-Aktivitäten im Orderflow
============================================================
import asyncio
import httpx
from collections import defaultdict
from dataclasses import dataclass
from typing import Dict, List
import pandas as pd
class LargePlayerTracker:
"""
Trackt Large Player Aktivitäten basierend auf:
- Ordergröße relativ zum Average
- EOA-Adresse Historien
- Timing-Muster
"""
def __init__(self, holy_sheep_client):
self.client = holy_sheep_client
self.address_history: Dict[str, List[Dict]] = defaultdict(list)
self.threshold_multiplier = 10.0 # 10x Average = Large Player
async def analyze_address(
self,
eoa_address: str,
recent_trades: List[Dict]
) -> Dict:
"""
Analysiert eine EOA-Adresse auf Large-Player-Charakteristiken.
Nutzt HolySheep für KI-gestützte Verhaltensanalyse.
"""
# Basis-Statistiken berechnen
if not recent_trades:
return {"is_large_player": False, "confidence": 0}
sizes = [t["size"] for t in recent_trades]
avg_size = sum(sizes) / len(sizes)
address_trades = [t for t in recent_trades if t.get("user") == eoa_address]
if not address_trades:
return {"is_large_player": False, "confidence": 0}
address_avg_size = sum(t["size"] for t in address_trades) / len(address_trades)
size_ratio = address_avg_size / avg_size if avg_size > 0 else 0
# Timing-Analyse
timestamps = [t["timestamp"] for t in address_trades]
timing_score = self._analyze_timing_pattern(timestamps)
# KI-gestützte Verhaltensanalyse via HolySheep
prompt = f"""
Analysiere das Trading-Verhalten der folgenden Adresse: {eoa_address}
Historie: {len(address_trades)} Transaktionen in den letzten 24h
Durchschnittliche Ordergröße: {address_avg_size:.4f}
Market-Durchschnitt: {avg_size:.4f}
Größenverhältnis: {size_ratio:.1f}x
Timing-Score: {timing_score:.2f}
Ist dies ein Large Player (Institutional, Whale, Market Maker)?
Antworte mit JSON: {{"is_large_player": bool, "player_type": str,
"confidence": float, "risk_assessment": str}}
"""
payload = {
"model": "deepseek-v3.2",
"messages": [
{
"role": "system",
"content": "Du bist ein Krypto-Forensik-Experte. Analysiere präzise und objektiv."
},
{
"role": "user",
"content": prompt
}
],
"temperature": 0.2,
"max_tokens": 512
}
headers = {
"Authorization": f"Bearer {HOLYSHEEP_API_KEY}",
"Content-Type": "application/json"
}
response = await self.client.post(
f"{HOLYSHEEP_BASE_URL}/chat/completions",
headers=headers,
json=payload
)
result = response.json()
return {
"eoa_address": eoa_address,
"trade_count": len(address_trades),
"avg_size_ratio": size_ratio,
"timing_score": timing_score,
"ki_analysis": result["choices"][0]["message"]["content"],
"is_large_player": size_ratio >= self.threshold_multiplier,
"latency_ms": response.elapsed.total_seconds() * 1000
}
def _analyze_timing_pattern(self, timestamps: List[float]) -> float:
"""
Analysiert Timing-Muster fürub-8-Patterns (schnelleauktionen).
Returns: Score 0-100 (höher = verdächtiger)
"""
if len(timestamps) < 2:
return 0
# Intervall-Analyse
intervals = [timestamps[i+1] - timestamps[i] for i in range(len(timestamps)-1)]
avg_interval = sum(intervals) / len(intervals)
# Niedrige Durchschnittsinterval = schnellere Reaktion = möglicher Algo-Trader
if avg_interval < 1.0:
return min(100, (1.0 - avg_interval) * 100)
return 0
class HyperliquidBacktester:
"""
Production-Ready Backtester für Hyperliquid Orderflow-Strategien.
"""
def __init__(self, initial_capital: float = 10000.0):
self.capital = initial_capital
self.positions = {}
self.trades = []
self.large_players: Dict[str, bool] = {}
async def run_strategy(
self,
orderflow_data: List[Dict],
large_player_tracker: LargePlayerTracker
) -> Dict:
"""
Führt die Orderflow-basierte Strategie aus.
Strategie-Logik:
1. Identifiziere Large-Player-Flows
2. Bei Large-Player-Buy: Kurzfristig Long
3. Bei Large-Player-Sell: Kurzfristig Short
4. Stop-Loss bei 1.5% Verlust
5. Take-Profit bei 0.5% Gewinn
"""
results = {
"total_trades": 0,
"winning_trades": 0,
"losing_trades": 0,
"final_pnl": 0,
"max_drawdown": 0,
"large_player_signals": 0
}
for event in orderflow_data:
# Prüfe auf Large Player
eoa = event.get("user", "")
if eoa not in self.large_players:
# Asynchrone Analyse (non-blocking)
analysis = await large_player_tracker.analyze_address(
eoa,
orderflow_data
)
self.large_players[eoa] = analysis.get("is_large_player", False)
if not self.large_players.get(eoa):
continue
results["large_player_signals"] += 1
# Strategie-Execution
if event["action"] == "buy":
pnl = self._execute_long(event)
self._update_results(results, pnl)
elif event["action"] == "sell":
pnl = self._execute_short(event)
self._update_results(results, pnl)
# Kapazitätsprüfung
if self.capital < 100:
print("⚠ Kapital unter Minimum. Stoppe Backtest.")
break
results["final_pnl"] = self.capital - 10000
results["win_rate"] = (
results["winning_trades"] / results["total_trades"] * 100
if results["total_trades"] > 0 else 0
)
return results
def _execute_long(self, event: Dict) -> float:
"""Führt Long-Position aus"""
entry_price = event["price"]
position_size = min(self.capital * 0.1, self.capital)
# Simuliere Exit nach Zeit/Limit
exit_price = entry_price * 1.005 # +0.5% Take-Profit
pnl_pct = (exit_price - entry_price) / entry_price
pnl = position_size * pnl_pct
self.capital += pnl
self.trades.append({
"type": "LONG",
"entry": entry_price,
"exit": exit_price,
"pnl": pnl
})
return pnl
def _execute_short(self, event: Dict) -> float:
"""Führt Short-Position aus"""
entry_price = event["price"]
position_size = min(self.capital * 0.1, self.capital)
# Simuliere Exit
exit_price = entry_price * 0.995 # +0.5% Take-Profit
pnl_pct = (entry_price - exit_price) / entry_price
pnl = position_size * pnl_pct
self.capital += pnl
self.trades.append({
"type": "SHORT",
"entry": entry_price,
"exit": exit_price,
"pnl": pnl
})
return pnl
def _update_results(self, results: Dict, pnl: float):
"""Aktualisiert Statistiken"""
results["total_trades"] += 1
if pnl > 0:
results["winning_trades"] += 1
else:
results["losing_trades"] += 1
# Drawdown-Tracking
peak = 10000 + results["final_pnl"]
current = self.capital
drawdown = (peak - current) / peak * 100
results["max_drawdown"] = max(results["max_drawdown"], drawdown)
===== BEISPIEL-AUSFÜHRUNG =====
async def main():
"""
Vollständiger Workflow:
1. Tardis-Daten → 2. Large-Player-Analyse → 3. Backtest
"""
# Initialisiere Clients
holy_sheep = httpx.AsyncClient(timeout=30.0)
tracker = LargePlayerTracker(holy_sheep)
backtester = HyperliquidBacktester(initial_capital=10000)
# Simulierte Orderflow-Daten (in Produktion von Tardis)
sample_data = [
{
"timestamp": 1704067200 + i * 60,
"user": "0x742d35Cc6634C0532925a3b8D4C9E9d6" if i % 3 == 0 else f"0x{i:040x}",
"action": "buy" if i % 2 == 0 else "sell",
"price": 10.5 + (i % 10) * 0.01,
"size": 100.0 if i % 3 == 0 else 10.0,
"symbol": "HYPE-PERP"
}
for i in range(1000)
]
print("=" * 60)
print("HYPERLIQUID ORDERFLOW BACKTEST")
print("=" * 60)
# Führe Backtest aus
results = await backtester.run_strategy(sample_data, tracker)
print(f"\n📊 ERGEBNISSE:")
print(f" Gesamthandels: {results['total_trades']}")
print(f" Gewinntrades: {results['winning_trades']} ({results['win_rate']:.1f}%)")
print(f" Verlusttrades: {results['losing_trades']}")
print(f" Final PnL: ${results['final_pnl']:.2f}")
print(f" Max Drawdown: {results['max_drawdown']:.2f}%")
print(f" Large-Player-Signale: {results['large_player_signals']}")
# Kostenanalyse
print(f"\n💰 KOSTENANALYSE:")
estimated_tokens = results['total_trades'] * 1500 # ~1500 Tokens pro Analyse
cost = (estimated_tokens / 1_000_000) * 0.42
print(f" Geschätzte Tokens: {estimated_tokens:,}")
print(f" HolySheep Kosten: ${cost:.4f}")
print(f" ROI: {results['final_pnl'] / cost:.1f}x")
if __name__ == "__main__":
asyncio.run(main())
Warum HolySheep wählen
- Unschlagbare Latenz: <50ms durch optimierte Infrastruktur in Asien-Pazifik-Regionen
- Kosteneffizienz: DeepSeek V3.2 für $0.42/1M Tokens bedeutet 85-95% Ersparnis gegenüber OpenAI und Anthropic
- Native Integration: Nahtlose Kombination mit Tardis für Orderflow-Workflows
- Flexible Zahlung: WeChat, Alipay und USD – ideal für chinesische Trader
- Kostenlose Credits: Neuanmeldung mit Startguthaben – Jetzt registrieren
- Multi-Modell-Support: GPT-4.1, Claude Sonnet 4.5, Gemini 2.5 Flash, DeepSeek V3.2
Häufige Fehler und Lösungen
Fehler 1: Tardis API-Rate-Limiting überschreiten
Symptom: HTTP 429 Fehler bei Orderflow-Abruf, unvollständige Daten
# ❌ FALSCH: Unbegrenzte Anfragen
async def fetch_all_data():
for hour in range(168): # 1 Woche
data = await fetch_tardis(f"hour_{hour}") # Rate Limit erreicht!
✅ RICHTIG: Exponential Backoff mit Retry-Logik
import asyncio
from tenacity import retry, stop_after_attempt, wait_exponential
class TardisClient:
def __init__(self, api_key: str):
self.api_key = api_key
self.request_count = 0
self.last_reset = datetime.now()
@retry(
stop=stop_after_attempt(3),
wait=wait_exponential(multiplier=1, min=2, max=60)
)
async def fetch_with_backoff(self, endpoint: str, params: dict) -> dict:
"""Holt Daten mit automatischer Retry-Logik"""
# Rate-Limit-Check
now = datetime.now()
if (now - self.last_reset).seconds > 3600:
self.request_count = 0
self.last_reset = now
if self.request_count >= 1000: # 1000 req/hour Limit
wait_time = 3600 - (now - self.last_reset).seconds
print(f"⏳ Rate-Limit erreicht. Warte {wait_time}s...")
await asyncio.sleep(wait_time)
headers = {
"Authorization": f"Bearer {self.api_key}",
"X-RateLimit-Policy": "strict"
}
async with httpx.AsyncClient() as client:
response = await client.get(
f"https://api.tardis.dev/v1/{endpoint}",
params=params,
headers=headers,
timeout=60.0
)
if response.status_code == 429:
retry_after = int(response.headers.get("Retry-After", 60))
raise Exception(f"Rate limited. Retry after {retry_after}s")
response.raise_for_status()
self.request_count += 1
return response.json()
async def batch_fetch_orderflow(
self,
symbol: str,
start_time: datetime,
end_time: datetime,
batch_hours: int = 1
) -> List[Dict]:
"""Holt Orderflow-Daten in batches mit Backoff"""
all_data = []
current = start_time
while current < end_time:
batch_end = min(current + timedelta(hours=batch_hours), end_time)
try:
data = await self.fetch_with_backoff(
"orders",
params={
"exchange": "hyperliquid",
"symbol": symbol,
"from": int(current.timestamp()),
"to": int(batch_end.timestamp()),
"limit": 10000
}
)
all_data.extend(data.get("orders", []))
print(f"✓ {current.strftime('%Y-%m-%d %H:%M')} - "
f"{len(data.get('orders', []))} Orders")
# Respektiere Rate-Limits mit Pause
await asyncio.sleep(0.5)
except Exception as e:
print(f"⚠ Batch-Fehler: {e}. Versuche nächsten Batch...")
await asyncio.sleep