489 lines
17 KiB
Python
489 lines
17 KiB
Python
"""
|
|
Binance exchange connector implementation.
|
|
"""
|
|
|
|
import json
|
|
from typing import Dict, List, Optional, Any
|
|
from datetime import datetime, timezone
|
|
|
|
from ..models.core import OrderBookSnapshot, TradeEvent, PriceLevel
|
|
from ..utils.logging import get_logger, set_correlation_id
|
|
from ..utils.exceptions import ValidationError
|
|
from ..utils.validation import validate_symbol, validate_price, validate_volume
|
|
from .base_connector import BaseExchangeConnector
|
|
|
|
logger = get_logger(__name__)
|
|
|
|
|
|
class BinanceConnector(BaseExchangeConnector):
|
|
"""
|
|
Binance WebSocket connector implementation.
|
|
|
|
Supports:
|
|
- Order book depth streams
|
|
- Trade streams
|
|
- Symbol normalization
|
|
- Real-time data processing
|
|
"""
|
|
|
|
# Binance WebSocket URLs
|
|
WEBSOCKET_URL = "wss://stream.binance.com:9443/ws"
|
|
API_URL = "https://api.binance.com/api/v3"
|
|
|
|
def __init__(self):
|
|
"""Initialize Binance connector"""
|
|
super().__init__("binance", self.WEBSOCKET_URL)
|
|
|
|
# Binance-specific message handlers
|
|
self.message_handlers.update({
|
|
'depthUpdate': self._handle_orderbook_update,
|
|
'trade': self._handle_trade_update,
|
|
'error': self._handle_error_message
|
|
})
|
|
|
|
# Stream management
|
|
self.active_streams: List[str] = []
|
|
self.stream_id = 1
|
|
|
|
logger.info("Binance connector initialized")
|
|
|
|
def _get_message_type(self, data: Dict) -> str:
|
|
"""
|
|
Determine message type from Binance message data.
|
|
|
|
Args:
|
|
data: Parsed message data
|
|
|
|
Returns:
|
|
str: Message type identifier
|
|
"""
|
|
# Binance uses 'e' field for event type
|
|
if 'e' in data:
|
|
return data['e']
|
|
|
|
# Handle error messages
|
|
if 'error' in data:
|
|
return 'error'
|
|
|
|
# Handle subscription confirmations
|
|
if 'result' in data and 'id' in data:
|
|
return 'subscription_response'
|
|
|
|
return 'unknown'
|
|
|
|
def normalize_symbol(self, symbol: str) -> str:
|
|
"""
|
|
Normalize symbol to Binance format.
|
|
|
|
Args:
|
|
symbol: Standard symbol format (e.g., 'BTCUSDT')
|
|
|
|
Returns:
|
|
str: Binance symbol format (e.g., 'BTCUSDT')
|
|
"""
|
|
# Binance uses uppercase symbols without separators
|
|
normalized = symbol.upper().replace('-', '').replace('/', '')
|
|
|
|
# Validate symbol format
|
|
if not validate_symbol(normalized):
|
|
raise ValidationError(f"Invalid symbol format: {symbol}", "INVALID_SYMBOL")
|
|
|
|
return normalized
|
|
|
|
async def subscribe_orderbook(self, symbol: str) -> None:
|
|
"""
|
|
Subscribe to order book depth updates for a symbol.
|
|
|
|
Args:
|
|
symbol: Trading symbol (e.g., 'BTCUSDT')
|
|
"""
|
|
try:
|
|
set_correlation_id()
|
|
normalized_symbol = self.normalize_symbol(symbol)
|
|
stream_name = f"{normalized_symbol.lower()}@depth@100ms"
|
|
|
|
# Create subscription message
|
|
subscription_msg = {
|
|
"method": "SUBSCRIBE",
|
|
"params": [stream_name],
|
|
"id": self.stream_id
|
|
}
|
|
|
|
# Send subscription
|
|
success = await self._send_message(subscription_msg)
|
|
if success:
|
|
# Track subscription
|
|
if symbol not in self.subscriptions:
|
|
self.subscriptions[symbol] = []
|
|
if 'orderbook' not in self.subscriptions[symbol]:
|
|
self.subscriptions[symbol].append('orderbook')
|
|
|
|
self.active_streams.append(stream_name)
|
|
self.stream_id += 1
|
|
|
|
logger.info(f"Subscribed to order book for {symbol} on Binance")
|
|
else:
|
|
logger.error(f"Failed to subscribe to order book for {symbol} on Binance")
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error subscribing to order book for {symbol}: {e}")
|
|
raise
|
|
|
|
async def subscribe_trades(self, symbol: str) -> None:
|
|
"""
|
|
Subscribe to trade updates for a symbol.
|
|
|
|
Args:
|
|
symbol: Trading symbol (e.g., 'BTCUSDT')
|
|
"""
|
|
try:
|
|
set_correlation_id()
|
|
normalized_symbol = self.normalize_symbol(symbol)
|
|
stream_name = f"{normalized_symbol.lower()}@trade"
|
|
|
|
# Create subscription message
|
|
subscription_msg = {
|
|
"method": "SUBSCRIBE",
|
|
"params": [stream_name],
|
|
"id": self.stream_id
|
|
}
|
|
|
|
# Send subscription
|
|
success = await self._send_message(subscription_msg)
|
|
if success:
|
|
# Track subscription
|
|
if symbol not in self.subscriptions:
|
|
self.subscriptions[symbol] = []
|
|
if 'trades' not in self.subscriptions[symbol]:
|
|
self.subscriptions[symbol].append('trades')
|
|
|
|
self.active_streams.append(stream_name)
|
|
self.stream_id += 1
|
|
|
|
logger.info(f"Subscribed to trades for {symbol} on Binance")
|
|
else:
|
|
logger.error(f"Failed to subscribe to trades for {symbol} on Binance")
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error subscribing to trades for {symbol}: {e}")
|
|
raise
|
|
|
|
async def unsubscribe_orderbook(self, symbol: str) -> None:
|
|
"""
|
|
Unsubscribe from order book updates for a symbol.
|
|
|
|
Args:
|
|
symbol: Trading symbol (e.g., 'BTCUSDT')
|
|
"""
|
|
try:
|
|
normalized_symbol = self.normalize_symbol(symbol)
|
|
stream_name = f"{normalized_symbol.lower()}@depth@100ms"
|
|
|
|
# Create unsubscription message
|
|
unsubscription_msg = {
|
|
"method": "UNSUBSCRIBE",
|
|
"params": [stream_name],
|
|
"id": self.stream_id
|
|
}
|
|
|
|
# Send unsubscription
|
|
success = await self._send_message(unsubscription_msg)
|
|
if success:
|
|
# Remove from tracking
|
|
if symbol in self.subscriptions and 'orderbook' in self.subscriptions[symbol]:
|
|
self.subscriptions[symbol].remove('orderbook')
|
|
if not self.subscriptions[symbol]:
|
|
del self.subscriptions[symbol]
|
|
|
|
if stream_name in self.active_streams:
|
|
self.active_streams.remove(stream_name)
|
|
|
|
self.stream_id += 1
|
|
logger.info(f"Unsubscribed from order book for {symbol} on Binance")
|
|
else:
|
|
logger.error(f"Failed to unsubscribe from order book for {symbol} on Binance")
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error unsubscribing from order book for {symbol}: {e}")
|
|
raise
|
|
|
|
async def unsubscribe_trades(self, symbol: str) -> None:
|
|
"""
|
|
Unsubscribe from trade updates for a symbol.
|
|
|
|
Args:
|
|
symbol: Trading symbol (e.g., 'BTCUSDT')
|
|
"""
|
|
try:
|
|
normalized_symbol = self.normalize_symbol(symbol)
|
|
stream_name = f"{normalized_symbol.lower()}@trade"
|
|
|
|
# Create unsubscription message
|
|
unsubscription_msg = {
|
|
"method": "UNSUBSCRIBE",
|
|
"params": [stream_name],
|
|
"id": self.stream_id
|
|
}
|
|
|
|
# Send unsubscription
|
|
success = await self._send_message(unsubscription_msg)
|
|
if success:
|
|
# Remove from tracking
|
|
if symbol in self.subscriptions and 'trades' in self.subscriptions[symbol]:
|
|
self.subscriptions[symbol].remove('trades')
|
|
if not self.subscriptions[symbol]:
|
|
del self.subscriptions[symbol]
|
|
|
|
if stream_name in self.active_streams:
|
|
self.active_streams.remove(stream_name)
|
|
|
|
self.stream_id += 1
|
|
logger.info(f"Unsubscribed from trades for {symbol} on Binance")
|
|
else:
|
|
logger.error(f"Failed to unsubscribe from trades for {symbol} on Binance")
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error unsubscribing from trades for {symbol}: {e}")
|
|
raise
|
|
|
|
async def get_symbols(self) -> List[str]:
|
|
"""
|
|
Get list of available trading symbols from Binance.
|
|
|
|
Returns:
|
|
List[str]: List of available symbols
|
|
"""
|
|
try:
|
|
import aiohttp
|
|
|
|
async with aiohttp.ClientSession() as session:
|
|
async with session.get(f"{self.API_URL}/exchangeInfo") as response:
|
|
if response.status == 200:
|
|
data = await response.json()
|
|
symbols = [
|
|
symbol_info['symbol']
|
|
for symbol_info in data.get('symbols', [])
|
|
if symbol_info.get('status') == 'TRADING'
|
|
]
|
|
logger.info(f"Retrieved {len(symbols)} symbols from Binance")
|
|
return symbols
|
|
else:
|
|
logger.error(f"Failed to get symbols from Binance: HTTP {response.status}")
|
|
return []
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error getting symbols from Binance: {e}")
|
|
return []
|
|
|
|
async def get_orderbook_snapshot(self, symbol: str, depth: int = 20) -> Optional[OrderBookSnapshot]:
|
|
"""
|
|
Get current order book snapshot from Binance REST API.
|
|
|
|
Args:
|
|
symbol: Trading symbol
|
|
depth: Number of price levels to retrieve
|
|
|
|
Returns:
|
|
OrderBookSnapshot: Current order book or None if unavailable
|
|
"""
|
|
try:
|
|
import aiohttp
|
|
|
|
normalized_symbol = self.normalize_symbol(symbol)
|
|
|
|
# Binance supports depths: 5, 10, 20, 50, 100, 500, 1000, 5000
|
|
valid_depths = [5, 10, 20, 50, 100, 500, 1000, 5000]
|
|
api_depth = min(valid_depths, key=lambda x: abs(x - depth))
|
|
|
|
url = f"{self.API_URL}/depth"
|
|
params = {
|
|
'symbol': normalized_symbol,
|
|
'limit': api_depth
|
|
}
|
|
|
|
async with aiohttp.ClientSession() as session:
|
|
async with session.get(url, params=params) as response:
|
|
if response.status == 200:
|
|
data = await response.json()
|
|
return self._parse_orderbook_snapshot(data, symbol)
|
|
else:
|
|
logger.error(f"Failed to get order book for {symbol}: HTTP {response.status}")
|
|
return None
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error getting order book snapshot for {symbol}: {e}")
|
|
return None
|
|
|
|
def _parse_orderbook_snapshot(self, data: Dict, symbol: str) -> OrderBookSnapshot:
|
|
"""
|
|
Parse Binance order book data into OrderBookSnapshot.
|
|
|
|
Args:
|
|
data: Raw Binance order book data
|
|
symbol: Trading symbol
|
|
|
|
Returns:
|
|
OrderBookSnapshot: Parsed order book
|
|
"""
|
|
try:
|
|
# Parse bids and asks
|
|
bids = []
|
|
for bid_data in data.get('bids', []):
|
|
price = float(bid_data[0])
|
|
size = float(bid_data[1])
|
|
|
|
if validate_price(price) and validate_volume(size):
|
|
bids.append(PriceLevel(price=price, size=size))
|
|
|
|
asks = []
|
|
for ask_data in data.get('asks', []):
|
|
price = float(ask_data[0])
|
|
size = float(ask_data[1])
|
|
|
|
if validate_price(price) and validate_volume(size):
|
|
asks.append(PriceLevel(price=price, size=size))
|
|
|
|
# Create order book snapshot
|
|
orderbook = OrderBookSnapshot(
|
|
symbol=symbol,
|
|
exchange=self.exchange_name,
|
|
timestamp=datetime.now(timezone.utc),
|
|
bids=bids,
|
|
asks=asks,
|
|
sequence_id=data.get('lastUpdateId')
|
|
)
|
|
|
|
return orderbook
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error parsing order book snapshot: {e}")
|
|
raise ValidationError(f"Invalid order book data: {e}", "PARSE_ERROR")
|
|
|
|
async def _handle_orderbook_update(self, data: Dict) -> None:
|
|
"""
|
|
Handle order book depth update from Binance.
|
|
|
|
Args:
|
|
data: Order book update data
|
|
"""
|
|
try:
|
|
set_correlation_id()
|
|
|
|
# Extract symbol from stream name
|
|
stream = data.get('s', '').upper()
|
|
if not stream:
|
|
logger.warning("Order book update missing symbol")
|
|
return
|
|
|
|
# Parse bids and asks
|
|
bids = []
|
|
for bid_data in data.get('b', []):
|
|
price = float(bid_data[0])
|
|
size = float(bid_data[1])
|
|
|
|
if validate_price(price) and validate_volume(size):
|
|
bids.append(PriceLevel(price=price, size=size))
|
|
|
|
asks = []
|
|
for ask_data in data.get('a', []):
|
|
price = float(ask_data[0])
|
|
size = float(ask_data[1])
|
|
|
|
if validate_price(price) and validate_volume(size):
|
|
asks.append(PriceLevel(price=price, size=size))
|
|
|
|
# Create order book snapshot
|
|
orderbook = OrderBookSnapshot(
|
|
symbol=stream,
|
|
exchange=self.exchange_name,
|
|
timestamp=datetime.fromtimestamp(data.get('E', 0) / 1000, tz=timezone.utc),
|
|
bids=bids,
|
|
asks=asks,
|
|
sequence_id=data.get('u') # Final update ID
|
|
)
|
|
|
|
# Notify callbacks
|
|
self._notify_data_callbacks(orderbook)
|
|
|
|
logger.debug(f"Processed order book update for {stream}")
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error handling order book update: {e}")
|
|
|
|
async def _handle_trade_update(self, data: Dict) -> None:
|
|
"""
|
|
Handle trade update from Binance.
|
|
|
|
Args:
|
|
data: Trade update data
|
|
"""
|
|
try:
|
|
set_correlation_id()
|
|
|
|
# Extract trade data
|
|
symbol = data.get('s', '').upper()
|
|
if not symbol:
|
|
logger.warning("Trade update missing symbol")
|
|
return
|
|
|
|
price = float(data.get('p', 0))
|
|
size = float(data.get('q', 0))
|
|
|
|
# Validate data
|
|
if not validate_price(price) or not validate_volume(size):
|
|
logger.warning(f"Invalid trade data: price={price}, size={size}")
|
|
return
|
|
|
|
# Determine side (Binance uses 'm' field - true if buyer is market maker)
|
|
is_buyer_maker = data.get('m', False)
|
|
side = 'sell' if is_buyer_maker else 'buy'
|
|
|
|
# Create trade event
|
|
trade = TradeEvent(
|
|
symbol=symbol,
|
|
exchange=self.exchange_name,
|
|
timestamp=datetime.fromtimestamp(data.get('T', 0) / 1000, tz=timezone.utc),
|
|
price=price,
|
|
size=size,
|
|
side=side,
|
|
trade_id=str(data.get('t', ''))
|
|
)
|
|
|
|
# Notify callbacks
|
|
self._notify_data_callbacks(trade)
|
|
|
|
logger.debug(f"Processed trade for {symbol}: {side} {size} @ {price}")
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error handling trade update: {e}")
|
|
|
|
async def _handle_error_message(self, data: Dict) -> None:
|
|
"""
|
|
Handle error message from Binance.
|
|
|
|
Args:
|
|
data: Error message data
|
|
"""
|
|
error_code = data.get('code', 'unknown')
|
|
error_msg = data.get('msg', 'Unknown error')
|
|
|
|
logger.error(f"Binance error {error_code}: {error_msg}")
|
|
|
|
# Handle specific error codes
|
|
if error_code == -1121: # Invalid symbol
|
|
logger.error("Invalid symbol error - check symbol format")
|
|
elif error_code == -1130: # Invalid listen key
|
|
logger.error("Invalid listen key - may need to reconnect")
|
|
|
|
def get_binance_stats(self) -> Dict[str, Any]:
|
|
"""Get Binance-specific statistics"""
|
|
base_stats = self.get_stats()
|
|
|
|
binance_stats = {
|
|
'active_streams': len(self.active_streams),
|
|
'stream_list': self.active_streams.copy(),
|
|
'next_stream_id': self.stream_id
|
|
}
|
|
|
|
base_stats.update(binance_stats)
|
|
return base_stats |