COB data and dash

This commit is contained in:
Dobromir Popov
2025-06-18 16:23:47 +03:00
parent e238ce374b
commit 3cadae60f7
16 changed files with 7539 additions and 19 deletions

View File

@ -0,0 +1,409 @@
# Multi-Exchange Consolidated Order Book (COB) Data Provider
## Overview
This document describes the implementation of a comprehensive multi-exchange Consolidated Order Book (COB) data provider for the gogo2 trading system. The system aggregates real-time order book data from multiple cryptocurrency exchanges to provide enhanced market liquidity analysis and fine-grain volume bucket data.
## BookMap API Analysis
### What is BookMap?
BookMap is a professional trading platform that provides:
- **Multibook**: Consolidated order book data from multiple exchanges
- **Real-time market depth visualization**
- **Order flow analysis tools**
- **Market microstructure analytics**
### BookMap API Capabilities
Based on research, BookMap offers three types of APIs:
1. **L1 (Add-ons API)**: For creating custom indicators and trading strategies within BookMap
2. **L0 (Connect API)**: For creating custom market data connections (requires approval)
3. **Broadcasting API (BrAPI)**: For data sharing between BookMap add-ons
### BookMap Multibook Features
BookMap's Multibook provides:
- **Pre-configured synthetic instruments** combining data from major exchanges:
- **USD Spot**: BTC, ETH, ADA, etc. from Bitstamp, Bitfinex, Coinbase Pro, Kraken
- **USDT Spot**: BTC, ETH, DOGE, etc. from Binance, Huobi, Poloniex
- **USDT Perpetual Futures**: From Binance Futures, Bitget, Bybit, OKEx
- **Consolidated order book visualization**
- **Cross-exchange arbitrage detection**
- **Volume-weighted pricing**
### Limitations for External Use
**Important Finding**: BookMap's APIs are primarily designed for:
- Creating add-ons **within** the BookMap platform
- Extending BookMap's functionality
- **NOT for external data consumption**
The APIs do not provide a simple way to consume Multibook data externally for use in other trading systems.
### Cost and Accessibility
- BookMap Multibook requires **Global Plus subscription**
- External API access requires approval and specific use cases
- Focus is on professional institutional users
## Our Implementation Approach
Given the limitations of accessing BookMap's data externally, we've implemented our own multi-exchange COB provider that replicates and extends BookMap's functionality.
## Architecture
### Core Components
1. **MultiExchangeCOBProvider** (`core/multi_exchange_cob_provider.py`)
- Main aggregation engine
- Real-time WebSocket connections to multiple exchanges
- Order book consolidation logic
- Fine-grain price bucket generation
2. **COBIntegration** (`core/cob_integration.py`)
- Integration layer with existing gogo2 system
- CNN/DQN feature generation
- Dashboard data formatting
- Trading signal generation
### Supported Exchanges
| Exchange | WebSocket URL | Market Share Weight | Symbols Supported |
|----------|---------------|-------------------|-------------------|
| Binance | wss://stream.binance.com:9443/ws/ | 30% | BTC/USDT, ETH/USDT |
| Coinbase Pro | wss://ws-feed.exchange.coinbase.com | 25% | BTC-USD, ETH-USD |
| Kraken | wss://ws.kraken.com | 20% | XBT/USDT, ETH/USDT |
| Huobi | wss://api.huobi.pro/ws | 15% | btcusdt, ethusdt |
| Bitfinex | wss://api-pub.bitfinex.com/ws/2 | 10% | tBTCUST, tETHUST |
## Key Features
### 1. Real-Time Order Book Aggregation
```python
@dataclass
class ConsolidatedOrderBookLevel:
price: float
total_size: float
total_volume_usd: float
total_orders: int
side: str
exchange_breakdown: Dict[str, ExchangeOrderBookLevel]
dominant_exchange: str
liquidity_score: float
timestamp: datetime
```
### 2. Fine-Grain Price Buckets
- **Configurable bucket size** (default: 1 basis point)
- **Volume aggregation** at each price level
- **Exchange attribution** for each bucket
- **Real-time bucket updates** every 100ms
```python
price_buckets = {
'bids': {
bucket_key: {
'price': bucket_price,
'volume_usd': total_volume,
'size': total_size,
'orders': total_orders,
'exchanges': ['binance', 'coinbase']
}
},
'asks': { ... }
}
```
### 3. Market Microstructure Analysis
- **Volume-weighted mid price** calculation
- **Liquidity imbalance** detection
- **Cross-exchange spread** analysis
- **Exchange dominance** metrics
- **Market depth** distribution
### 4. CNN/DQN Integration
#### CNN Features (220 dimensions)
- **Order book levels**: 20 levels × 5 features × 2 sides = 200 features
- **Market microstructure**: 20 additional features
- **Normalized and scaled** for neural network consumption
#### DQN State Features (30 dimensions)
- **Normalized order book state**: 20 features
- **Market state indicators**: 10 features
- **Real-time market regime** detection
### 5. Trading Signal Generation
- **Liquidity imbalance signals**
- **Arbitrage opportunity detection**
- **Liquidity anomaly alerts**
- **Market microstructure pattern recognition**
## Implementation Details
### Data Structures
```python
@dataclass
class COBSnapshot:
symbol: str
timestamp: datetime
consolidated_bids: List[ConsolidatedOrderBookLevel]
consolidated_asks: List[ConsolidatedOrderBookLevel]
exchanges_active: List[str]
volume_weighted_mid: float
total_bid_liquidity: float
total_ask_liquidity: float
spread_bps: float
liquidity_imbalance: float
price_buckets: Dict[str, Dict[str, float]]
```
### Real-Time Processing
1. **WebSocket Connections**: Independent connections to each exchange
2. **Order Book Updates**: Process depth updates at 100ms intervals
3. **Consolidation Engine**: Aggregate order books every 100ms
4. **Bucket Generation**: Create fine-grain volume buckets
5. **Feature Generation**: Compute CNN/DQN features in real-time
6. **Signal Detection**: Analyze patterns and generate trading signals
### Performance Optimizations
- **Asynchronous processing** for all WebSocket connections
- **Lock-based synchronization** for thread-safe data access
- **Deque-based storage** for efficient historical data management
- **Configurable update frequencies** for different components
## Integration with Existing System
### Dashboard Integration
```python
# Add COB data to dashboard
cob_integration.add_dashboard_callback(dashboard.update_cob_data)
# Dashboard receives:
{
'consolidated_bids': [...],
'consolidated_asks': [...],
'price_buckets': {...},
'market_quality': {...},
'recent_signals': [...]
}
```
### AI Model Integration
```python
# CNN feature generation
cob_integration.add_cnn_callback(cnn_model.process_cob_features)
# DQN state updates
cob_integration.add_dqn_callback(dqn_agent.update_cob_state)
```
### Trading System Integration
```python
# Signal-based trading
for signal in cob_integration.get_recent_signals(symbol):
if signal['confidence'] > 0.8:
trading_executor.process_cob_signal(signal)
```
## Usage Examples
### Basic Setup
```python
from core.multi_exchange_cob_provider import MultiExchangeCOBProvider
from core.cob_integration import COBIntegration
# Initialize COB provider
symbols = ['BTC/USDT', 'ETH/USDT']
cob_provider = MultiExchangeCOBProvider(
symbols=symbols,
bucket_size_bps=1.0 # 1 basis point granularity
)
# Integration layer
cob_integration = COBIntegration(symbols=symbols)
# Start streaming
await cob_integration.start()
```
### Accessing Data
```python
# Get consolidated order book
cob_snapshot = cob_integration.get_cob_snapshot('BTC/USDT')
# Get fine-grain price buckets
price_buckets = cob_integration.get_price_buckets('BTC/USDT')
# Get exchange breakdown
exchange_breakdown = cob_integration.get_exchange_breakdown('BTC/USDT')
# Get CNN features
cnn_features = cob_integration.get_cob_features('BTC/USDT')
# Get recent trading signals
signals = cob_integration.get_recent_signals('BTC/USDT', count=10)
```
### Market Analysis
```python
# Market depth analysis
depth_analysis = cob_integration.get_market_depth_analysis('BTC/USDT')
print(f"Active exchanges: {depth_analysis['exchanges_active']}")
print(f"Total liquidity: ${depth_analysis['total_bid_liquidity'] + depth_analysis['total_ask_liquidity']:,.0f}")
print(f"Spread: {depth_analysis['spread_bps']:.2f} bps")
print(f"Liquidity imbalance: {depth_analysis['liquidity_imbalance']:.3f}")
```
## Testing
Use the provided test script to validate functionality:
```bash
python test_multi_exchange_cob.py
```
The test script provides:
- **Basic functionality testing**
- **Feature generation validation**
- **Dashboard integration testing**
- **Signal analysis verification**
- **Performance monitoring**
- **Comprehensive test reporting**
## Advantages Over BookMap
### Our Implementation Benefits
1. **Full Control**: Complete customization of aggregation logic
2. **Cost Effective**: Uses free exchange APIs instead of paid BookMap subscription
3. **Direct Integration**: Seamless integration with existing gogo2 architecture
4. **Extended Features**: Custom signal generation and analysis
5. **Fine-Grain Control**: Configurable bucket sizes and update frequencies
6. **Open Source**: Fully customizable and extensible
### Comparison with BookMap Multibook
| Feature | BookMap Multibook | Our Implementation |
|---------|------------------|-------------------|
| **Data Sources** | Pre-configured instruments | Fully configurable exchanges |
| **Cost** | Global Plus subscription | Free (exchange APIs) |
| **Integration** | BookMap platform only | Direct gogo2 integration |
| **Customization** | Limited | Full control |
| **Bucket Granularity** | Fixed by BookMap | Configurable (1 bps default) |
| **Signal Generation** | BookMap's algorithms | Custom trading signals |
| **AI Integration** | Limited | Native CNN/DQN features |
| **Real-time Updates** | BookMap frequency | 100ms configurable |
## Future Enhancements
### Planned Improvements
1. **Additional Exchanges**: OKX, Bybit, KuCoin integration
2. **Options/Futures Support**: Extend beyond spot markets
3. **Advanced Analytics**: Machine learning-based pattern recognition
4. **Risk Management**: Real-time exposure and risk metrics
5. **Cross-Asset Analysis**: Multi-symbol correlation analysis
6. **Historical Analysis**: COB pattern backtesting
7. **API Rate Optimization**: Intelligent request management
8. **Fault Tolerance**: Exchange failover and redundancy
### Performance Optimizations
1. **WebSocket Pooling**: Shared connections for multiple symbols
2. **Data Compression**: Optimized data structures
3. **Caching Strategies**: Intelligent feature caching
4. **Parallel Processing**: Multi-threaded consolidation
5. **Memory Management**: Optimized historical data storage
## Configuration
### Exchange Configuration
```python
exchange_configs = {
'binance': ExchangeConfig(
exchange_type=ExchangeType.BINANCE,
weight=0.3, # 30% weight in aggregation
websocket_url="wss://stream.binance.com:9443/ws/",
symbols_mapping={'BTC/USDT': 'BTCUSDT'},
rate_limits={'requests_per_minute': 1200}
)
}
```
### Bucket Configuration
```python
# Configure price bucket granularity
bucket_size_bps = 1.0 # 1 basis point per bucket
bucket_update_frequency = 100 # Update every 100ms
```
### Feature Configuration
```python
# CNN feature dimensions
cnn_feature_config = {
'order_book_levels': 20,
'features_per_level': 5,
'microstructure_features': 20,
'total_dimensions': 220
}
```
## Monitoring and Diagnostics
### Performance Metrics
- **Update rates**: COB updates per second
- **Processing latency**: Time from exchange update to consolidation
- **Feature generation time**: CNN/DQN feature computation time
- **Memory usage**: Data structure memory consumption
- **Connection health**: WebSocket connection status
### Logging
Comprehensive logging includes:
- Exchange connection events
- Order book update statistics
- Feature generation metrics
- Signal generation events
- Error handling and recovery
## Conclusion
The Multi-Exchange COB Provider successfully replicates and extends BookMap's Multibook functionality while providing:
1. **Superior Integration** with the gogo2 trading system
2. **Cost Effectiveness** using free exchange APIs
3. **Enhanced Customization** for specific trading requirements
4. **Real-time Performance** optimized for high-frequency trading
5. **Advanced Analytics** with native AI model integration
This implementation provides a robust foundation for multi-exchange order book analysis and represents a significant enhancement to the gogo2 trading platform's market data capabilities.
## Files Created
1. `core/multi_exchange_cob_provider.py` - Main COB aggregation engine
2. `core/cob_integration.py` - Integration layer with gogo2 system
3. `test_multi_exchange_cob.py` - Comprehensive testing framework
4. `MULTI_EXCHANGE_COB_PROVIDER_SUMMARY.md` - This documentation
The system is ready for integration and testing with the existing gogo2 trading infrastructure.