deribit

NN/exchanges/exchange_factory.py

@@ -0,0 +1,153 @@
+"""
+Exchange Factory - Creates exchange interfaces based on configuration
+"""
+import os
+import logging
+from typing import Dict, Any, Optional
+from .exchange_interface import ExchangeInterface
+from .mexc_interface import MEXCInterface
+from .binance_interface import BinanceInterface
+from .deribit_interface import DeribitInterface
+
+logger = logging.getLogger(__name__)
+
+
+class ExchangeFactory:
+    """Factory class for creating exchange interfaces"""
+    
+    SUPPORTED_EXCHANGES = {
+        'mexc': MEXCInterface,
+        'binance': BinanceInterface,
+        'deribit': DeribitInterface
+    }
+    
+    @classmethod
+    def create_exchange(cls, exchange_name: str, config: Dict[str, Any]) -> Optional[ExchangeInterface]:
+        """Create an exchange interface based on the name and configuration.
+        
+        Args:
+            exchange_name: Name of the exchange ('mexc', 'deribit', 'binance')
+            config: Configuration dictionary for the exchange
+            
+        Returns:
+            Configured exchange interface or None if creation fails
+        """
+        exchange_name = exchange_name.lower()
+        
+        if exchange_name not in cls.SUPPORTED_EXCHANGES:
+            logger.error(f"Unsupported exchange: {exchange_name}")
+            return None
+        
+        try:
+            # Get API credentials from environment variables
+            api_key, api_secret = cls._get_credentials(exchange_name)
+            
+            # Get exchange-specific configuration
+            test_mode = config.get('test_mode', True)
+            trading_mode = config.get('trading_mode', 'simulation')
+            
+            # Create exchange interface
+            exchange_class = cls.SUPPORTED_EXCHANGES[exchange_name]
+            
+            if exchange_name == 'mexc':
+                exchange = exchange_class(
+                    api_key=api_key,
+                    api_secret=api_secret,
+                    test_mode=test_mode,
+                    trading_mode=trading_mode
+                )
+            elif exchange_name == 'deribit':
+                exchange = exchange_class(
+                    api_key=api_key,
+                    api_secret=api_secret,
+                    test_mode=test_mode
+                )
+            else:  # binance and others
+                exchange = exchange_class(
+                    api_key=api_key,
+                    api_secret=api_secret,
+                    test_mode=test_mode
+                )
+            
+            # Test connection
+            if exchange.connect():
+                logger.info(f"Successfully created and connected to {exchange_name} exchange")
+                return exchange
+            else:
+                logger.error(f"Failed to connect to {exchange_name} exchange")
+                return None
+                
+        except Exception as e:
+            logger.error(f"Error creating {exchange_name} exchange: {e}")
+            return None
+    
+    @classmethod
+    def _get_credentials(cls, exchange_name: str) -> tuple[str, str]:
+        """Get API credentials from environment variables.
+        
+        Args:
+            exchange_name: Name of the exchange
+            
+        Returns:
+            Tuple of (api_key, api_secret)
+        """
+        if exchange_name == 'mexc':
+            api_key = os.getenv('MEXC_API_KEY', '')
+            api_secret = os.getenv('MEXC_SECRET_KEY', '')
+        elif exchange_name == 'deribit':
+            api_key = os.getenv('DERIBIT_API_CLIENTID', '')
+            api_secret = os.getenv('DERIBIT_API_SECRET', '')
+        elif exchange_name == 'binance':
+            api_key = os.getenv('BINANCE_API_KEY', '')
+            api_secret = os.getenv('BINANCE_SECRET_KEY', '')
+        else:
+            logger.warning(f"Unknown exchange credentials for {exchange_name}")
+            api_key = api_secret = ''
+        
+        return api_key, api_secret
+    
+    @classmethod
+    def create_multiple_exchanges(cls, exchanges_config: Dict[str, Any]) -> Dict[str, ExchangeInterface]:
+        """Create multiple exchange interfaces from configuration.
+        
+        Args:
+            exchanges_config: Configuration dictionary with exchange settings
+            
+        Returns:
+            Dictionary mapping exchange names to their interfaces
+        """
+        exchanges = {}
+        
+        for exchange_name, config in exchanges_config.items():
+            if exchange_name == 'primary':
+                continue  # Skip the primary exchange indicator
+                
+            if config.get('enabled', False):
+                exchange = cls.create_exchange(exchange_name, config)
+                if exchange:
+                    exchanges[exchange_name] = exchange
+                else:
+                    logger.warning(f"Failed to create {exchange_name} exchange, skipping")
+            else:
+                logger.info(f"Exchange {exchange_name} is disabled, skipping")
+        
+        return exchanges
+    
+    @classmethod
+    def get_primary_exchange(cls, exchanges_config: Dict[str, Any]) -> Optional[ExchangeInterface]:
+        """Get the primary exchange interface.
+        
+        Args:
+            exchanges_config: Configuration dictionary with exchange settings
+            
+        Returns:
+            Primary exchange interface or None
+        """
+        primary_name = exchanges_config.get('primary', 'deribit')
+        primary_config = exchanges_config.get(primary_name, {})
+        
+        if not primary_config.get('enabled', False):
+            logger.error(f"Primary exchange {primary_name} is not enabled")
+            return None
+        
+        return cls.create_exchange(primary_name, primary_config)