Разработка торгового бота для опционной торговли

Разработка торгового бота для опционной торговли

Криптоопционы — наиболее сложный и наименее изученный рынок в крипто. Deribit остаётся основной платформой для BTC и ETH опционов. Автоматизированная торговля опционами требует понимания Greeks (Delta, Gamma, Theta, Vega) и специальной инфраструктуры для управления опционными позициями.

Опционные Greeks и их значение для бота

Delta (Δ) — чувствительность цены опциона к изменению цены базового актива. Delta = 0.5 означает: при росте BTC на $100, цена опциона растёт на $50.

Gamma (Γ) — скорость изменения Delta. Высокая Gamma = Delta меняется быстро = риск для маркет-мейкера.

Theta (Θ) — временной распад. Каждый день опцион теряет часть стоимости (для покупателя — это убыток, для продавца — доход).

Vega (V) — чувствительность к изменению implied volatility (IV). Рост IV = рост цены опциона.

Подключение к Deribit API

import websockets
import json
import asyncio
from decimal import Decimal

class DeribitClient:
    WS_URL = "wss://www.deribit.com/ws/api/v2"

    def __init__(self, client_id: str, client_secret: str):
        self.client_id = client_id
        self.client_secret = client_secret
        self.ws = None
        self.request_id = 0

    async def connect(self):
        self.ws = await websockets.connect(self.WS_URL)
        await self.authenticate()

    async def authenticate(self):
        await self.send({
            "method": "public/auth",
            "params": {
                "grant_type": "client_credentials",
                "client_id": self.client_id,
                "client_secret": self.client_secret,
            }
        })

    async def send(self, message: dict) -> dict:
        self.request_id += 1
        message['id'] = self.request_id
        message['jsonrpc'] = '2.0'

        await self.ws.send(json.dumps(message))
        response = json.loads(await self.ws.recv())
        return response.get('result', {})

    async def get_instruments(self, currency: str = 'BTC', kind: str = 'option') -> list:
        return await self.send({
            "method": "public/get_instruments",
            "params": {"currency": currency, "kind": kind, "expired": False}
        })

    async def get_order_book(self, instrument: str) -> dict:
        return await self.send({
            "method": "public/get_order_book",
            "params": {"instrument_name": instrument, "depth": 5}
        })

    async def place_order(self, instrument: str, amount: float, order_type: str = 'market', price: float = None) -> dict:
        params = {
            "instrument_name": instrument,
            "amount": amount,
            "type": order_type,
        }
        if price:
            params["price"] = price

        return await self.send({
            "method": "private/buy" if 'C' in instrument.split('-')[-1] or True else "private/sell",
            "params": params
        })

    async def get_portfolio_greeks(self) -> dict:
        """Суммарные Greeks по всему портфелю"""
        return await self.send({
            "method": "private/get_account_summary",
            "params": {"currency": "BTC", "extended": True}
        })

Стратегия: Theta Decay (продажа опционов)

class ThetaDecayStrategy:
    """
    Зарабатываем на временном распаде, продавая опционы вне денег (OTM).
    Стратегия: Cash-Secured Put + Covered Call = Iron Condor упрощённо.
    """
    TARGET_DELTA = 0.15      # продаём опционы с Delta ~0.15 (15% вероятность исполнения)
    TARGET_DTE = 7           # дней до истечения
    PROFIT_TARGET = 0.50     # закрываем при 50% прибыли
    MAX_LOSS = 2.0           # закрываем при 200% убытка от premium

    async def find_entry_options(self, client: DeribitClient, currency: str = 'BTC') -> dict:
        """Находим подходящие опционы для продажи"""
        instruments = await client.get_instruments(currency, 'option')
        current_price = await self.get_spot_price(client, currency)

        candidates = {'calls': [], 'puts': []}

        for inst in instruments:
            name = inst['instrument_name']
            # Парсим: BTC-24JAN25-50000-C
            parts = name.split('-')
            expiry_str, strike, option_type = parts[1], float(parts[2]), parts[3]

            # Фильтр по DTE
            dte = self.calculate_dte(expiry_str)
            if dte < self.TARGET_DTE - 1 or dte > self.TARGET_DTE + 1:
                continue

            # Получаем Greeks
            book = await client.get_order_book(name)
            if not book.get('greeks'):
                continue

            delta = abs(float(book['greeks']['delta']))

            # Ищем опционы с нужной Delta
            if abs(delta - self.TARGET_DELTA) < 0.03:
                info = {
                    'name': name,
                    'strike': strike,
                    'dte': dte,
                    'delta': delta,
                    'bid': float(book['bids'][0][0]) if book['bids'] else 0,
                    'mid': (float(book['bids'][0][0]) + float(book['asks'][0][0])) / 2 if book['bids'] and book['asks'] else 0,
                    'iv': float(book['mark_iv']),
                }

                if option_type == 'C':
                    candidates['calls'].append(info)
                else:
                    candidates['puts'].append(info)

        # Выбираем лучший put (ниже рынка) и call (выше рынка)
        best_put = max(candidates['puts'], key=lambda x: x['mid']) if candidates['puts'] else None
        best_call = max(candidates['calls'], key=lambda x: x['mid']) if candidates['calls'] else None

        return {'put': best_put, 'call': best_call}

Delta-Neutral Hedging

Для нейтрализации направленного риска при продаже опционов:

class DeltaHedger:
    HEDGE_THRESHOLD = 0.05  # перехеджируем при изменении delta на > 5%

    async def hedge_portfolio(self, client: DeribitClient):
        """Поддерживаем Delta-neutral портфель"""
        portfolio = await client.get_portfolio_greeks()
        total_delta = float(portfolio.get('delta', 0))

        if abs(total_delta) > self.HEDGE_THRESHOLD:
            # Хеджируем через perpetual futures
            hedge_side = 'sell' if total_delta > 0 else 'buy'
            hedge_size = abs(total_delta)

            logger.info(f"Delta hedge: {hedge_side} {hedge_size:.4f} BTC perpetual")

            await client.send({
                "method": f"private/{hedge_side}",
                "params": {
                    "instrument_name": "BTC-PERPETUAL",
                    "amount": int(hedge_size * 10),  # Deribit использует $10 контракты
                    "type": "market",
                }
            })

Управление рисками

Опционные стратегии продавца имеют ассиметричный профиль риска: ограниченная прибыль (premium), потенциально неограниченный убыток (для голых calls). Управление рисками критично:

• Position sizing: не более 5% капитала на одну сделку
• Max portfolio vega: ограничиваем суммарный Vega risk
• IV regime filter: не продаём опционы при аномально низкой IV (дешевые premium = плохой risk/reward)
• Black Swan protection: держим небольшой портфель OTM puts как страховку от краш-событий

Опционный бот — высший уровень сложности. Он требует понимания не только алготрейдинга, но и опционного ценообразования (Black-Scholes, vol surface), управления Greeks и специфики крипто-опционного рынка.