Deribit WebSocket: Получение Греков Опционов в Реальном Времени с Asyncio

import asyncio
import websockets
import json
import time

class DeribitGreeksClient:
    def __init__(self, instrument_name: str, testnet: bool = True):
        self.instrument_name = instrument_name
        self.url = "wss://test.deribit.com/ws/api/v2" if testnet else "wss://www.deribit.com/ws/api/v2"
        self.websocket = None
        self.reconnect_interval = 5 # seconds

    async def connect(self):
        print(f"Connecting to Deribit WebSocket at {self.url}...")
        try:
            self.websocket = await websockets.connect(self.url)
            print("Connected to Deribit WebSocket.")
            await self.subscribe_to_greeks()
            return True
        except Exception as e:
            print(f"Connection failed: {e}")
            return False

    async def subscribe_to_greeks(self):
        channel = f"options.greeks.{self.instrument_name}.100ms"
        subscribe_request = {
            "jsonrpc": "2.0",
            "id": 1,
            "method": "public/subscribe",
            "params": {
                "channels": [channel]
            }
        }
        await self.websocket.send(json.dumps(subscribe_request))
        print(f"Subscribed to channel: {channel}")

    async def listen_for_messages(self):
        while True:
            try:
                message = await self.websocket.recv()
                data = json.loads(message)
                if data.get("method") == "subscription":
                    channel = data["params"]["channel"]
                    greeks_data = data["params"]["data"]
                    print(f"Received Greeks for {channel}:")
                    print(f"  Delta: {greeks_data.get('delta')}")
                    print(f"  Gamma: {greeks_data.get('gamma')}")
                    print(f"  Vega: {greeks_data.get('vega')}")
                    print(f"  Theta: {greeks_data.get('theta')}")
                    print(f"  Rho: {greeks_data.get('rho')}")
                    print(f"  Implied Volatility: {greeks_data.get('iv')}")
                    print("-" * 30)
                elif data.get("result"):
                    print(f"Subscription response: {data}")
                elif data.get("error"):
                    print(f"Error: {data['error']}")
            except websockets.exceptions.ConnectionClosedOK:
                print("Connection closed gracefully.")
                break
            except websockets.exceptions.ConnectionClosedError as e:
                print(f"Connection closed with error: {e}")
                await self.handle_reconnect()
                break
            except Exception as e:
                print(f"An unexpected error occurred: {e}")
                await self.handle_reconnect()
                break

    async def handle_reconnect(self):
        print(f"Attempting to reconnect in {self.reconnect_interval} seconds...")
        await asyncio.sleep(self.reconnect_interval)
        while not await self.connect():
            print(f"Reconnection failed, retrying in {self.reconnect_interval} seconds...")
            await asyncio.sleep(self.reconnect_interval)
        print("Reconnected successfully.")
        # After reconnecting, the subscription needs to be re-established
        await self.subscribe_to_greeks()
        # Restart listening
        asyncio.create_task(self.listen_for_messages())


async def get_some_instrument_name(testnet: bool = True):
    url = "wss://test.deribit.com/ws/api/v2" if testnet else "wss://www.deribit.com/ws/api/v2"
    try:
        async with websockets.connect(url) as ws:
            request = {
                "jsonrpc": "2.0",
                "id": 7617,
                "method": "public/get_instruments",
                "params": {
                    "currency": "BTC",
                    "kind": "option",
                    "expired": False
                }
            }
            await ws.send(json.dumps(request))
            response = await ws.recv()
            data = json.loads(response)
            if data and data.get("result"):
                # Find an active instrument, preferably with some trading activity
                for instrument in data["result"]:
                    if instrument["is_active"] and instrument["instrument_name"].startswith("BTC-"):
                        return instrument["instrument_name"]
            print("No active BTC option instrument found, using fallback.")
            return "BTC-29DEC23-60000-C" # Fallback, might be expired or inactive
    except Exception as e:
        print(f"Error fetching instrument name: {e}. Using fallback.")
        return "BTC-29DEC23-60000-C" # Fallback

async def main():
    instrument_to_subscribe = await get_some_instrument_name(testnet=True)
    if not instrument_to_subscribe:
        print("Could not fetch a valid instrument name. Exiting.")
        return

    print(f"Using instrument: {instrument_to_subscribe}")
    client = DeribitGreeksClient(instrument_to_subscribe, testnet=True)
    if await client.connect():
        await client.listen_for_messages()

if __name__ == "__main__":
    asyncio.run(main())