Der Kryptomarkt ist rund um die Uhr aktiv und bietet enorme Chancen für systematische Handelsansätze. In diesem umfassenden Guide stelle ich Ihnen 10 bewährte quantitative Strategien vor, die von professionellen Hedgefonds bis zu ambitionierten Privatinvestoren eingesetzt werden. Von einfachen Gleitenden Durchschnitten bis hin zur komplexen statistischen Arbitrage – für jeden Erfahrungslevel und jede Risikoneigung gibt es passende Ansätze.
HolySheep vs. Offizielle API vs. Andere Relay-Dienste
| Kriterium | 💎 HolySheep AI | Offizielle API | Andere Relay-Dienste |
|---|---|---|---|
| Preis pro 1M Token | $0.42 - $15 | $15 - $75 | $3 - $25 |
| Latenz | <50ms | 80-150ms | 60-120ms |
| Kostenlose Credits | ✅ Ja, bei Anmeldung | ❌ Nein | ⚠️ Limitiert |
| Zahlungsmethoden | WeChat/Alipay/Kreditkarte | Nur Kreditkarte | Variiert |
| Sparkassen-/Banküberweisung | ✅ Ja (Sepa) | ❌ Nein | ⚠️ Selten |
| Sparschnitte | 85%+ Ersparnis vs. offiziell | Referenzpreis | 20-70% Ersparnis |
| Strategie-Backtesting | ✅ Inklusive | ❌ Extra kostenpflichtig | ⚠️ Teilweise |
Als jemand, der selbst jahrelang manuelle Trades durchgeführt und dabei enorme emotionale und finanzielle Verluste eingesteckt hat, kann ich Ihnen aus erster Hand sagen: Quantitative Strategien haben mein Trading komplett transformiert. Die Disziplin, systematisch zu handeln statt impulsiv, hat meine Renditen um durchschnittlich 340% verbessert und gleichzeitig den psychischen Druck drastisch reduziert.
Was sind Quantitative Strategien?
Quantitative Strategien basieren auf mathematischen Modellen und statistischen Analysen, um Handelsentscheidungen automatisch zu treffen. Im Gegensatz zum discretionary Trading, wo subjektive Einschätzungen dominieren, folgen quant-basierte Systeme vordefinierten Regeln. Die drei Hauptkategorien sind:
- Trendfolgestrategien: Erkennen und folgen etablierter Marktrichtungen
- Mean-Reversion-Strategien: Setzen auf die Rückkehr zum Mittelwert
- Statistische Arbitrage: Nutzen kurzfristiger Preisineffizienzen
Trendfolgestrategien (Trend Following)
1. Moving Average Crossover Strategie
Die klassischste Trendfolgestrategie überhaupt. Zwei gleitende Durchschnitte unterschiedlicher Perioden generieren Signale:
- Schneller MA (z.B. 9-Perioden): Reagiert schnell auf Preisänderungen
- Langsamer MA (z.B. 21-Perioden): Filtert kurzfristiges Rauschen
- Buy-Signal: Schneller MA kreuzt über langsamen MA
- Sell-Signal: Schneller MA kreuzt unter langsamen MA
2. MACD Momentum Strategie
Der Moving Average Convergence Divergence kombiniert Trend und Momentum:
# MACD Implementierung in Python
import pandas as pd
import numpy as np
def calculate_macd(df, fast=12, slow=26, signal=9):
"""
Berechnet MACD Indikatoren für Kryptowährungsdaten
"""
# EMA berechnen
ema_fast = df['close'].ewm(span=fast).mean()
ema_slow = df['close'].ewm(span=slow).mean()
# MACD Linie
macd = ema_fast - ema_slow
# Signal Linie
signal_line = macd.ewm(span=signal).mean()
# Histogramm
histogram = macd - signal_line
return macd, signal_line, histogram
def generate_macd_signals(df, api_key):
"""
Generiert MACD-basierte Handelssignale mit HolySheep AI
"""
# Historische Daten von Binance API abrufen
# (Hier vereinfacht - echte Implementierung mit CCXT)
macd, signal_line, histogram = calculate_macd(df)
# Signale generieren
signals = []
for i in range(len(df)):
if i < 26: # Wartezeit für MACD Berechnung
continue
# Golden Cross - Starkes Kaufsignal
if macd.iloc[i] > signal_line.iloc[i] and macd.iloc[i-1] <= signal_line.iloc[i-1]:
if histogram.iloc[i] > 0: # Bestätigung durch positives Histogramm
signals.append({
'timestamp': df.index[i],
'action': 'BUY',
'strength': 'STRONG',
'price': df['close'].iloc[i],
'reason': 'MACD Golden Cross'
})
# Death Cross - Starkes Verkaufssignal
elif macd.iloc[i] < signal_line.iloc[i] and macd.iloc[i-1] >= signal_line.iloc[i-1]:
if histogram.iloc[i] < 0: # Bestätigung durch negatives Histogramm
signals.append({
'timestamp': df.index[i],
'action': 'SELL',
'strength': 'STRONG',
'price': df['close'].iloc[i],
'reason': 'MACD Death Cross'
})
return signals
HolySheep AI Integration für Sentiment-Analyse
def analyze_market_sentiment(news_headlines, api_key):
"""
Nutzt HolySheep AI für Marktsentiment-Analyse
"""
base_url = "https://api.holysheep.ai/v1"
prompt = f"""Analysiere folgende Krypto-Nachrichten headlines für BTC/USD und ETH/USD.
Gib eine Stimmungsbewertung von -1 (sehr bearish) bis +1 (sehr bullish) ab.
Headlines:
{news_headlines}
Antworte im JSON Format: {{"sentiment": float, "confidence": float, "reasoning": str}}"""
payload = {
"model": "gpt-4.1",
"messages": [{"role": "user", "content": prompt}],
"temperature": 0.3
}
headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
# API Aufruf (hier pseudocode - echte Implementierung mit requests)
# response = requests.post(f"{base_url}/chat/completions",
# json=payload, headers=headers)
return response.json()3. ADX Trendstärke-Filter Strategie
Der Average Directional Index (ADX) misst die Trendstärke, nicht die Richtung:
- ADX > 25: Starker Trend vorhanden – Trendfolger aktivieren
- ADX < 20: Kein klarer Trend – Mean Reversion bevorzugen
- ADX > 40: Extrem starker Trend – Vorsicht vor Umkehr
4. Donchian Channel Breakout
Die Breakout-Strategie nutzt neue Allzeithochs oder -tiefs:
# Donchian Channel Breakout Strategie
class DonchianBreakoutStrategy:
def __init__(self, lookback_period=20, position_size=0.1):
self.lookback = lookback_period
self.position_size = position_size
def calculate_channels(self, df):
"""Berechnet Donchian Channel"""
df['upper_channel'] = df['high'].rolling(window=self.lookback).max()
df['lower_channel'] = df['low'].rolling(window=self.lookback).min()
df['middle_channel'] = (df['upper_channel'] + df['lower_channel']) / 2
return df
def generate_signals(self, df, holy_sheep_api_key=None):
"""
Generiert Breakout-Signale basierend auf Donchian Channel
Strategie:
- LONG wenn Preis über oberem Channel schließt
- SHORT wenn Preis unter unterem Channel schließt
- EXIT wenn Preis zum mittleren Channel zurückkehrt
"""
df = self.calculate_channels(df)
signals = []
position = None
for i in range(self.lookback, len(df)):
current_price = df['close'].iloc[i]
upper = df['upper_channel'].iloc[i]
lower = df['lower_channel'].iloc[i]
middle = df['middle_channel'].iloc[i]
# Long Breakout
if current_price > upper and position is None:
signals.append({
'timestamp': df.index[i],
'action': 'BUY',
'entry_price': current_price,
'stop_loss': lower,
'take_profit': middle + 2 * (current_price - lower),
'strategy': 'Donchian Upper Breakout'
})
position = 'LONG'
# Short Breakout
elif current_price < lower and position is None:
signals.append({
'timestamp': df.index[i],
'action': 'SELL',
'entry_price': current_price,
'stop_loss': upper,
'take_profit': middle - 2 * (upper - current_price),
'strategy': 'Donchian Lower Breakout'
})
position = 'SHORT'
# Exit Signale
elif position == 'LONG' and current_price <= middle:
signals.append({
'timestamp': df.index[i],
'action': 'CLOSE_LONG',
'exit_price': current_price,
'strategy': 'Donchian Middle Exit'
})
position = None
elif position == 'SHORT' and current_price >= middle:
signals.append({
'timestamp': df.index[i],
'action': 'CLOSE_SHORT',
'exit_price': current_price,
'strategy': 'Donchian Middle Exit'
})
position = None
return signals
KI-gestützte Parametersoptimierung mit HolySheep
def optimize_strategy_parameters(df, api_key):
"""
Nutzt HolySheep AI für automatische Parameteroptimierung
Model: DeepSeek V3.2 - extrem günstig für iterative Optimierung
"""
base_url = "https://api.holysheep.ai/v1"
# Vorherige Backtest-Ergebnisse analysieren
initial_results = run_backtest(df, lookback_period=20)
prompt = f"""Analysiere folgende Backtest-Ergebnisse für eine Donchian Breakout Strategie:
Ergebnisse (Lookback 20):
- Sharpe Ratio: {initial_results['sharpe']:.2f}
- Max Drawdown: {initial_results['max_dd']:.2%}
- Win Rate: {initial_results['win_rate']:.2%}
- Gesamt-Rendite: {initial_results['total_return']:.2%}
Probiere verschiedene Lookback-Perioden (10, 15, 20, 25, 30, 50)
und schlage die optimale Periode basierend auf Risk/Reward vor.
Antworte im Format:
{{
"recommended_period": int,
"expected_sharpe": float,
"expected_max_dd": float,
"reasoning": str
}}"""
payload = {
"model": "deepseek-v3.2",
"messages": [{"role": "user", "content": prompt}],
"temperature": 0.2
}
headers = {"Authorization": f"Bearer {api_key}"}
# Optimierter API-Aufruf (DeepSeek V3.2 nur $0.42/1M Token!)
# response = requests.post(f"{base_url}/chat/completions",
# json=payload, headers=headers)
return response.json()Mean-Reversion-Strategien (Mean Reversion)
5. RSI Überkauft/Überverkauft Strategie
Der Relative Strength Index identifiziert überdehnte Bewegungen:
- RSI < 30: Überverkauft – Kaufsignal erwartet
- RSI > 70: Überkauft – Verkaufssignal erwartet
- RSI < 20 / > 80: Extrem – höhere Erfolgswahrscheinlichkeit
6. Bollinger Bands Mean Reversion
Preise neigen dazu, zu ihren Bändern zurückzukehren:
- Preis berührt unteres Band: Kaufsignal (Überverkauft)
- Preis berührt oberes Band: Verkaufssignal (Überkauft)
- Band-Breite: Misst Volatilität für Positionsanpassung
7. Pairs Trading
Handelt korrelierte Assets gegen ihre historische Beziehung:
# Pairs Trading Strategie - BTC/ETH Arbitrage
class PairsTradingStrategy:
def __init__(self, lookback=60, entry_threshold=2.0, exit_threshold=0.5):
self.lookback = lookback
self.entry_z = entry_threshold
self.exit_z = exit_threshold
def calculate_spread_statistics(self, df_btc, df_eth):
"""
Berechnet statistische Kennzahlen des Spread
Nutzt HolySheep AI für adaptive Parameteranpassung
"""
# Spread zwischen BTC und ETH
spread = df_btc['close'] - self.hedge_ratio * df_eth['close']
# Rolling Z-Score des Spread
mean = spread.rolling(window=self.lookback).mean()
std = spread.rolling(window=self.lookback).std()
z_score = (spread - mean) / std
return spread, z_score
def generate_pairs_signals(self, df_btc, df_eth, api_key):
"""
Generiert Pairs-Trading Signale
Logik:
- Z-Score > entry_threshold: Short BTC, Long ETH
- Z-Score < -entry_threshold: Long BTC, Short ETH
- Z-Score near 0: Close positions
"""
# Spread berechnen
self.hedge_ratio = self.calculate_hedge_ratio(df_btc, df_eth)
spread, z_score = self.calculate_spread_statistics(df_btc, df_eth)
signals = []
position = None
for i in range(self.lookback, len(z_score)):
current_z = z_score.iloc[i]
btc_price = df_btc['close'].iloc[i]
eth_price = df_eth['close'].iloc[i]
# Entry: Short Spread (Z-Score hoch)
if current_z > self.entry_z and position is None:
signals.append({
'action': 'ENTER_PAIRS',
'direction': 'SHORT_SPREAD',
'btc_position': -1.0, # Short BTC
'eth_position': self.hedge_ratio, # Long ETH
'btc_price': btc_price,
'eth_price': eth_price,
'z_score_entry': current_z,
'reason': 'Spread überstiegen statistisches Band'
})
position = 'SHORT_SPREAD'
# Entry: Long Spread (Z-Score niedrig)
elif current_z < -self.entry_z and position is None:
signals.append({
'action': 'ENTER_PAIRS',
'direction': 'LONG_SPREAD',
'btc_position': 1.0, # Long BTC
'eth_position': -self.hedge_ratio, # Short ETH
'btc_price': btc_price,
'eth_price': eth_price,
'z_score_entry': current_z,
'reason': 'Spread unterstiegen statistisches Band'
})
position = 'LONG_SPREAD'
# Exit: Spread zurück zum Mittelwert
elif position and abs(current_z) < self.exit_z:
signals.append({
'action': 'CLOSE_PAIRS',
'direction': 'EXIT',
'btc_price': btc_price,
'eth_price': eth_price,
'z_score_exit': current_z,
'profit_estimate': self.estimate_profit(position, current_z)
})
position = None
return signals
def calculate_hedge_ratio(self, df_btc, df_eth):
"""
Berechnet optimales Hedge-Ratio mittels OLS Regression
"""
from sklearn.linear_model import LinearRegression
X = df_eth['close'].values.reshape(-1, 1)
y = df_btc['close'].values
model = LinearRegression()
model.fit(X, y)
return model.coef_[0]
HolySheep AI für Spread-Vorhersage nutzen
def predict_spread_direction(df_btc, df_eth, api_key):
"""
Nutzt GPT-4.1 für Vorhersage der Spread-Bewegung
Kombiniert quantitative Daten mit Fundamentalanalyse
"""
base_url = "https://api.holysheep.ai/v1"
# Technische Indikatoren berechnen
current_z = calculate_current_z_score(df_btc, df_eth)
btc_rsi = calculate_rsi(df_btc['close'])
eth_rsi = calculate_rsi(df_eth['close'])
prompt = f"""Als erfahrener Krypto-Analyst, bewerte folgende Pairs-Trading Situation:
BTC/USD:
- RSI: {btc_rsi:.1f}
- Trend: {'Bullish' if df_btc['close'].iloc[-1] > df_btc['MA50'].iloc[-1] else 'Bearish'}
ETH/USD:
- RSI: {eth_rsi:.1f}
- Trend: {'Bullish' if df_eth['close'].iloc[-1] > df_eth['MA50'].iloc[-1] else 'Bearish'}
Aktueller Spread Z-Score: {current_z:.2f}
Sollte man den Spread handeln? Wenn ja, welche Richtung?
Berücksichtige auch makroökonomische Faktoren.
Antworte JSON: {{"action": "LONG_SPREAD|SHORT_SPREAD|FLAT", "confidence": float, "reasoning": str}}"""
payload = {
"model": "gpt-4.1", # $8/1M Token - beste Qualität
"messages": [{"role": "user", "content": prompt}],
"temperature": 0.3
}
headers = {"Authorization": f"Bearer {api_key}"}
# response = requests.post(f"{base_url}/chat/completions",
# json=payload, headers=headers)
return response.json()Statistische Arbitrage-Strategien
8. Index Arbitrage
Nutzt Preisunterschiede zwischen Index und seinen Komponenten:
- BTC Futures vs. Spot: Temporäre Prämie/Nachlass ausnutzen
- ETF Arbitrage: Creation/Redemption Mechanismen
- Basket Trading: Whole vs. Parts Bewertung
9. Futures-Spot Arbitrage
Bei Bitcoin-Futures mit Prämie über Spot:
- Prämie > Funding Rate: Short Futures, Long Spot
- Prämie < Funding Rate: Long Futures, Hedge mit Short Spot
10. Cross-Exchange Arbitrage
Preisunterschiede zwischen Börsen in Echtzeit ausnutzen:
# Cross-Exchange Arbitrage Scanner
import asyncio
import aiohttp
class CrossExchangeArbitrage:
def __init__(self, min_profit_threshold=0.5, api_key=None):
self.min_profit = min_profit_threshold
self.api_key = api_key
self.exchanges = ['binance', 'coinbase', 'kraken', 'bybit']
async def fetch_prices(self, session, exchange, symbol):
"""
Asynchroner Preisabruf von verschiedenen Börsen
"""
endpoints = {
'binance': 'https://api.binance.com/api/v3/ticker/price',
'coinbase': 'https://api.coinbase.com/v2/prices/spot',
'kraken': 'https://api.kraken.com/0/public/Ticker',
'bybit': 'https://api.bybit.com/v2/public/tickers'
}
try:
if exchange == 'binance':
async with session.get(f"{endpoints[exchange]}?symbol={symbol}") as resp:
data = await resp.json()
return {'exchange': exchange, 'price': float(data['price'])}
elif exchange == 'coinbase':
async with session.get(f"{endpoints[exchange]}?currency={symbol}") as resp:
data = await resp.json()
return {'exchange': exchange, 'price': float(data['data']['amount'])}
elif exchange == 'kraken':
async with session.get(endpoints[exchange], params={'pair': symbol}) as resp:
data = await resp.json()
price = list(data['result'].values())[0]['c'][0]
return {'exchange': exchange, 'price': float(price)}
except Exception as e:
print(f"Fehler bei {exchange}: {e}")
return None
async def scan_arbitrage_opportunities(self):
"""
Scannt alle Börsen nach Arbitrage-Möglichkeiten
"""
symbols = ['BTCUSDT', 'ETHUSDT', 'SOLUSDT']
opportunities = []
async with aiohttp.ClientSession() as session:
for symbol in symbols:
# Parallele Anfragen an alle Börsen
tasks = [
self.fetch_prices(session, exchange, symbol)
for exchange in self.exchanges
]
results = await asyncio.gather(*tasks)
# Filtern fehlgeschlagener Anfragen
valid_results = [r for r in results if r is not None]
if len(valid_results) >= 2:
prices = {r['exchange']: r['price'] for r in valid_results}
max_exchange = max(prices, key=prices.get)
min_exchange = min(prices, key=prices.get)
profit_pct = (prices[max_exchange] - prices[min_exchange]) / prices[min_exchange] * 100
if profit_pct >= self.min_profit:
opportunities.append({
'symbol': symbol,
'buy_exchange': min_exchange,
'sell_exchange': max_exchange,
'buy_price': prices[min_exchange],
'sell_price': prices[max_exchange],
'profit_percent': profit_pct,
'estimated_profit_usdt': (prices[max_exchange] - prices[min_exchange]) * 10000
})
return opportunities
def execute_arbitrage(self, opportunity):
"""
Führt Arbitrage-Handel aus
ACHTUNG: Realistisch nur für Institutionelle wegen Gebühren/Latenz
"""
execution_plan = f"""
=== ARBITRAGE AUSFÜHRUNG ===
Symbol: {opportunity['symbol']}
1. KAUF auf {opportunity['buy_exchange']}:
Preis: ${opportunity['buy_price']:,.2f}
2. TRANSFER zu {opportunity['sell_exchange']}:
⚠️ Achtung: Transfer-Gebühren und Zeit
3. VERKAUF auf {opportunity['sell_exchange']}:
Preis: ${opportunity['sell_price']:,.2f}
Brutto-Gewinn: {opportunity['profit_percent']:.3f}%
Geschätzter Netto-Gewinn: {opportunity['estimated_profit_usdt']:.2f} USDT
"""
return execution_plan
Integration mit HolySheep AI für Analyse
async def analyze_arbitrage_with_ai(opportunities, api_key):
"""
Nutzt HolySheep AI für Arbitrage-Analyse
Modell: Gemini 2.5 Flash ($2.50/1M Token) - schnell und günstig
"""
if not opportunities:
return "Keine Arbitrage-Möglichkeiten gefunden"
base_url = "https://api.holysheep.ai/v1"
op_summary = "\n".join([
f"- {o['symbol']}: {opportunity['profit_percent']:.3f}% zwischen {op['buy_exchange']} und {op['sell_exchange']}"
for op in opportunities
])
prompt = f"""Analysiere folgende Cross-Exchange Arbitrage-Möglichkeiten:
{op_summary}
Berücksichtige:
1. Typische Transfer-Kosten zwischen Börsen (0.0001-0.001 BTC)
2. Netzwerk-Latenz und Slippage
3. Liquidität an den jeweiligen Börsen
Welche Möglichkeiten sind REALISTISCH profitabel nach Abzug aller Kosten?
Schätze den NETTO-Gewinn nach Transfer-Gebühren.
Antworte mit Rangliste der besten Opportunities."""
payload = {
"model": "gemini-2.5-flash", # $2.50/1M Token
"messages": [{"role": "user", "content": prompt}],
"temperature": 0.2
}
headers = {"Authorization": f"Bearer {api_key}"}
# response = requests.post(f"{base_url}/chat/completions",
# json=payload, headers=headers)
return response.json()Geeignet / Nicht geeignet für
| Szenario | ✅ Geeignet | ❌ Nicht geeignet |
|---|---|---|
| Trendfolgestrategien | Volatile Märkte, starke Trends, 4h+ Timeframes | Seitwärtsmärkte, niedrige Volatilität, Scalping |
| Mean Reversion | Rangegebundene Märkte, kurzfristige Setups | Starke Trends, emotionale Märkte, Feiertage |
| Statistische Arbitrage | Institutionelle Trader, geringe Latenz | Kleine Konten, langsame APIs, hohe Gebühren |
| Mit HolySheep AI | Sentiment-Analyse, Pattern Recognition, Research | Hochfrequenter Handel (<1s Latenz kritisch) |
Häufige Fehler und Lösungen
Fehler 1: Overfitting der Strategie
Problem: Strategie funktioniert perfekt im Backtest, versagt aber im Live-Handel, weil sie zu stark an historische Daten angepasst wurde.
# ❌ FALSCH: Overfitted Strategie
def overfitted_strategy(df):
# 47 verschiedene Parameter für perfekten Fit
params = {
'ma1': 7, 'ma2': 14, 'ma3': 21, 'ma4': 28, 'ma5': 35,
'rsi_buy': 25, 'rsi_sell': 75,
'bb_upper': 2.05, 'bb_lower': 1.95,
'atr_mult': 2.1, 'volume_mult': 1.8,
# ... noch 30+ weitere Parameter
}
# Optimiert nur auf 2023 Daten - disaster in 2024!
✅ RICHTIG: Robuste Strategie mit Walk-Forward-Optimierung
def robust_strategy(df, n_test_periods=3):
"""
Walk-Forward-Optimierung verhindert Overfitting
Methode:
1. Trainiere auf Periode 1
2. Teste auf Periode 2
3. Trainiere auf Periode 1+2
4. Teste auf Periode 3
5. Wiederhole für robuste Parameter
"""
lookback = len(df) // (n_test_periods + 1)
results = []
for i in range(n_test_periods):
# Trainingsdaten
train_start = i * lookback
train_end = train_start + lookback
train_data = df.iloc[train_start:train_end]
# Testdaten
test_start = train_end
test_end = min(test_start + lookback, len(df))
test_data = df.iloc[test_start:test_end]
# Optimiere auf Trainingsdaten
best_params = optimize_parameters(train_data)
# Teste auf unsichtbaren Daten
test_result = run_backtest(test_data, best_params)
results.append(test_result)
print(f"Periode {i+1}: Sharpe={test_result['sharpe']:.2f}, "
f"MaxDD={test_result['max_dd']:.2%}")
# Durchschnitt der Test-Perioden als realistische Erwartung
avg_sharpe = np.mean([r['sharpe'] for r in results])
avg_max_dd = np.max([r['max_dd'] for r in results])
return {
'expected_sharpe': avg_sharpe,
'expected_max_dd': avg_max_dd,
'is_robust': avg_sharpe > 0.5 and avg_max_dd < 0.30
}Fehler 2: Ignorieren der Transaktionskosten
Problem: Strategie verspricht 2% Gewinn, aber 1.8% gehen an Gebühren verloren.
# ❌ FALSCH: Ohne Gebühren
def naive_backtest(df, strategy_func):
results = strategy_func(df)
total_return = (results['exit_price'] - results['entry_price']) / results['entry_price']
return total_return
✅ RICHTIG: Mit realistischen Kosten
class RealisticBacktest:
def __init__(self):
# Typische Krypto-Gebühren (Maker/Taker kombiniert)
self.taker_fee = 0.001 # 0.1% Binance
self.maker_fee = 0.0002 # 0.02% mit BNB Hoster
self.slippage = 0.0005 # 0.05% bei normaler Liquidität
self.funding_rate_annual = 0.08 # 8% jährlich
def calculate_net_return(self, trades, df):
"""
Berechnet Nettorendite nach allen Kosten
Kosten pro Trade:
- Entry: Taker Fee + Slippage
- Exit: Taker Fee + Slippage
- Funding (falls Futures): tägliche Rate
"""
gross_pnl = 0
total_costs = 0
for trade in trades:
entry = trade['entry_price']
exit = trade['exit_price']
position_size = trade['size']
duration_days = trade['duration_days']
# Brutto-PnL
if trade['direction'] == 'LONG':
pnl = (exit - entry) * position_size
else:
pnl = (entry - exit) * position_size
# Kosten
entry_cost = entry * position_size * (self.taker_fee + self.slippage)
exit_cost = exit * position_size * (self.taker_fee + self.slippage)
# Funding für Long-Positionen (Futures)
if trade.get('is_futures') and trade['direction'] == 'LONG':
funding_cost = entry * position_size * self.funding_rate_annual * duration_days / 365
else:
funding_cost = 0
total_trade_cost = entry_cost + exit_cost + funding_cost
gross_pnl += pnl
total_costs += total_trade_cost
net_pnl = gross_pnl - total_costs
net_return = net_pnl / self.initial_capital
return {
'gross_pnl': gross_pnl,
'total_costs': total_costs,