Die Welt der Kryptowährungs-Optionen stellt Market Maker vor komplexe Herausforderungen: volatile Basiswerte, komplizierte Greeks-Berechnungen und die Notwendigkeit, in Echtzeit präzise Hedge-Ratios zu berechnen. In diesem Artikel analysiere ich detailliert, wie moderne Algorithmen diese Probleme lösen und wie Sie Ihre Hedge-Strategien mit Produktionscode optimieren.
Grundlagen: Die fünf Greeks im Krypto-Kontext
Bevor wir uns in die Implementierung stürzen, müssen wir die Kernkonzepte verstehen. Die Greeks messen die Sensitivität einer Option gegenüber verschiedenen Marktfaktoren.
Delta (Δ) – Die Richtungssensitivität
Delta zeigt, wie stark sich der Optionspreis ändert, wenn sich der Basispreis um eine Einheit bewegt. Für Bitcoin-Optionen mit einer Volatilität von 60-80% annualized ergeben sich typische Delta-Werte zwischen -1 und +1.
#!/usr/bin/env python3
"""
Delta-Berechnung für Krypto-Optionen mit Black-Scholes-Modell
Produktionsreifer Code für Market Maker Hedging
"""
import numpy as np
from scipy.stats import norm
from dataclasses import dataclass
from typing import Optional
import time
@dataclass
class OptionParams:
"""Parametrierung einer Krypto-Option"""
S: float # Spot-Preis (z.B. BTC in USD)
K: float # Strike-Preis
T: float # Zeit bis Verfall (in Jahren)
r: float # Risikofreier Zinssatz (annualisiert)
sigma: float # Implizite Volatilität (annualisiert)
is_call: bool # True = Call, False = Put
q: float = 0.0 # Dividendenrendite (bei Krypto typisch 0)
class GreeksCalculator:
"""Berechnet alle relevanten Greeks für Optionen"""
def __init__(self, params: OptionParams):
self.params = params
self._precompute()
def _precompute(self):
"""Vorberechnung der internen Variablen für Performance"""
p = self.params
self.sqrt_T = np.sqrt(p.T)
self.d1 = (np.log(p.S / p.K) + (p.r - p.q + 0.5 * p.sigma**2) * p.T) / (p.sigma * self.sqrt_T)
self.d2 = self.d1 - self.sigma * self.sqrt_T
# Normale Verteilungswerte cachen
self.nd1 = norm.pdf(self.d1)
self.Nd1 = norm.cdf(self.d1)
self.Nd2 = norm.cdf(self.d2)
# Vorzeichen für Put-Optionen
self.sign = 1 if self.params.is_call else -1
def delta(self) -> float:
"""
Berechnet Delta: Sensitivity gegenüber Spot-Preisänderung
Returns:
Delta-Wert zwischen -1 und +1
"""
if self.params.is_call:
return self.Nd1
else:
return self.Nd1 - 1
def gamma(self) -> float:
"""
Berechnet Gamma: Sensitivity von Delta gegenüber Spot
Returns:
Gamma-Wert (immer positiv für beide Optionstypen)
"""
return self.nd1 / (self.params.S * self.params.sigma * self.sqrt_T)
def theta(self) -> float:
"""
Berechnet Theta: Zeitverfall pro Tag
Returns:
Theta in USD pro Tag (negativ = Wertverlust über Zeit)
"""
p = self.params
term1 = -(p.S * self.nd1 * p.sigma) / (2 * self.sqrt_T)
if p.is_call:
term2 = p.r * p.K * np.exp(-p.r * p.T)
return (term1 - term2) / 365
else:
term2 = p.r * p.K * np.exp(-p.r * p.T)
return (term1 + term2) / 365
def vega(self) -> float:
"""
Berechnet Vega: Sensitivity gegenüber Volatilitätsänderung
Returns:
Vega in USD pro 1% Volatilitätsänderung
"""
return self.params.S * self.nd1 * np.sqrt(self.params.T) / 100
def rho(self) -> float:
"""
Berechnet Rho: Sensitivity gegenüber Zinsänderung
Returns:
Rho in USD pro 1% Zinsänderung
"""
p = self.params
if p.is_call:
return p.K * p.T * np.exp(-p.r * p.T) * norm.cdf(self.d2) / 100
else:
return -p.K * p.T * np.exp(-p.r * p.T) * norm.cdf(-self.d2) / 100
def demo_delta_hedge():
"""Demonstriert Delta-Hedging für BTC-Optionen"""
# Szenario: BTC bei $45.000, Strike $46.000 Call, 30 Tage bis Verfall
params = OptionParams(
S=45000, # BTC Spot
K=46000, # Strike
T=30/365, # 30 Tage
r=0.05, # 5% risikofreier Zins
sigma=0.70, # 70% implizite Volatilität
is_call=True
)
calc = GreeksCalculator(params)
print("=" * 60)
print("DELTA-HEDGE ANALYSE FÜR BTC-OPTIONEN")
print("=" * 60)
print(f"Spot: ${params.S:,.2f}")
print(f"Strike: ${params.K:,.2f}")
print(f"IV: {params.sigma*100:.1f}%")
print(f"Laufzeit: {params.T*365:.0f} Tage")
print("-" * 60)
print(f"Delta: {calc.delta():.4f}")
print(f"Gamma: {calc.gamma():.6f}")
print(f"Theta: ${calc.theta():.4f}/Tag")
print(f"Vega: ${calc.vega():.4f}/%IV")
print("-" * 60)
# Hedge-Berechnung
delta = calc.delta()
contracts = 100 # 100 Optionen
btc_per_contract = 0.1 # Jeder Kontrakt = 0.1 BTC
# Anzahl BTC für Delta-Hedge
btc_to_sell = delta * contracts * btc_per_contract
print(f"\nDelta-Hedge:")
print(f"Verkauf von {btc_to_sell:.4f} BTC für Delta-Neutralität")
print(f"Bei Delta-Änderung um 0.01: {calc.gamma() * 0.01 * contracts * btc_per_contract:.4f} BTC anpassen")
if __name__ == "__main__":
demo_delta_hedge()
Real-Time Greeks-Berechnung mit HolySheep AI
In Produktionsumgebungen müssen Greeks in Echtzeit für tausende Optionsreihen