WebSocket Transaction Streaming

import asyncio
import websockets
import json

async def connect_and_authenticate():
    uri = "wss://data.quantcite.com/api/v1/ws"
    
    async with websockets.connect(uri) as websocket:
        # Send authentication message
        auth_message = {
            "type": "authenticate",
            "api_key": "YOUR_API_KEY"
        }
        await websocket.send(json.dumps(auth_message))
        
        # Wait for authentication response
        response = await websocket.recv()
        auth_data = json.loads(response)
        
        if auth_data.get("type") == "welcome":
            print(f"Authenticated successfully: {auth_data}")
            return websocket
        else:
            print(f"Authentication failed: {auth_data}")
            return None

# Run the connection
websocket = asyncio.run(connect_and_authenticate())

import asyncio
import websockets
import json
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class UnifiedTransactionClient:
    def __init__(self, api_key):
        self.api_key = api_key
        self.uri = "wss://data.quantcite.com/api/v1/ws"
        self.websocket = None
        
    async def connect(self):
        """Connect to WebSocket and authenticate"""
        try:
            self.websocket = await websockets.connect(self.uri)
            logger.info("Connected to QuantCite WebSocket")
            
            # Authenticate
            auth_msg = {
                "type": "authenticate",
                "api_key": self.api_key
            }
            await self.websocket.send(json.dumps(auth_msg))
            
            # Wait for auth confirmation
            auth_response = await self.websocket.recv()
            auth_data = json.loads(auth_response)
            
            if auth_data.get("type") == "welcome":
                logger.info(f"Authentication successful")
                return True
            else:
                logger.error(f"Authentication failed: {auth_data}")
                return False
                
        except Exception as e:
            logger.error(f"Connection failed: {e}")
            return False
    
    async def subscribe_to_transactions(self, exchange, transaction_types=None):
        """Subscribe to transaction updates"""
        if not self.websocket:
            logger.error("Not connected")
            return
            
        subscribe_msg = {
            "action": "subscribe_transactions",
            "exchange": exchange,
            "testnet": False,
            "transaction_types": transaction_types or ["deposits", "withdrawals", "trades"]
        }
        
        await self.websocket.send(json.dumps(subscribe_msg))
        logger.info(f"Subscribed to {exchange} transactions")
    
    async def validate_credentials(self, exchange):
        """Validate exchange credentials"""
        if not self.websocket:
            logger.error("Not connected")
            return
            
        validate_msg = {
            "action": "validate_credentials",
            "exchange": exchange,
            "testnet": False
        }
        
        await self.websocket.send(json.dumps(validate_msg))
    
    async def get_exchanges(self):
        """Get supported exchanges"""
        if not self.websocket:
            logger.error("Not connected")
            return
            
        exchanges_msg = {
            "action": "get_exchanges"
        }
        
        await self.websocket.send(json.dumps(exchanges_msg))
    
    async def listen_for_updates(self):
        """Listen for real-time updates"""
        if not self.websocket:
            logger.error("Not connected")
            return
            
        try:
            async for message in self.websocket:
                data = json.loads(message)
                await self.handle_message(data)
                
        except websockets.exceptions.ConnectionClosed:
            logger.info("Connection closed")
        except Exception as e:
            logger.error(f"Error listening for updates: {e}")
    
    async def handle_message(self, data):
        """Handle incoming WebSocket messages"""
        msg_type = data.get("type")
        
        if msg_type == "transaction_response":
            logger.info(f"Received {data.get('total_transactions', 0)} transactions")
            
        elif msg_type == "validation_response":
            if data.get("success"):
                logger.info(f"Credentials valid for {data.get('exchange')}")
            else:
                logger.error(f"Credentials invalid: {data.get('message')}")
                
        elif msg_type == "exchanges_response":
            exchanges = data.get("exchanges", [])
            logger.info(f"Supported exchanges: {[ex['exchange_name'] for ex in exchanges]}")
            
        elif msg_type == "error":
            logger.error(f"Error: {data.get('error')} - {data.get('message')}")
            
        else:
            logger.info(f"Received {msg_type}: {data}")

async def main():
    # Initialize client
    client = UnifiedTransactionClient("YOUR_API_KEY")
    
    # Connect and authenticate
    if await client.connect():
        # Get supported exchanges
        await client.get_exchanges()
        
        # Validate credentials
        await client.validate_credentials("bybit")
        
        # Subscribe to transactions
        await client.subscribe_to_transactions("bybit", ["deposits", "withdrawals"])
        
        # Listen for updates
        await client.listen_for_updates()

# Run the client
if __name__ == "__main__":
    asyncio.run(main())