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())

const WebSocket = require('ws');

const ws = new WebSocket('wss://data.quantcite.com/api/v1/ws');

ws.on('open', () => {
    console.log('Connected to WebSocket');
    
    // Authenticate
    const authMessage = {
        type: 'authenticate',
        api_key: 'YOUR_API_KEY'
    };
    
    ws.send(JSON.stringify(authMessage));
});

ws.on('message', (data) => {
    const message = JSON.parse(data.toString());
    
    if (message.type === 'welcome') {
        console.log('Authenticated successfully:', message);
        // Now you can send other commands
    }
});

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())

const WebSocket = require('ws');

class UnifiedTransactionClient {
    constructor(apiKey) {
        this.apiKey = apiKey;
        this.uri = "wss://data.quantcite.com/api/v1/ws";
        this.ws = null;
    }
    
    async connect() {
        return new Promise((resolve, reject) => {
            this.ws = new WebSocket(this.uri);
            
            this.ws.on('open', () => {
                console.log('Connected to QuantCite WebSocket');
                this.authenticate();
            });
            
            this.ws.on('message', (data) => {
                const message = JSON.parse(data.toString());
                this.handleMessage(message);
                
                if (message.type === 'welcome') {
                    console.log('Authentication successful');
                    resolve(true);
                }
            });
            
            this.ws.on('error', (error) => {
                console.error('WebSocket error:', error);
                reject(error);
            });
        });
    }
    
    authenticate() {
        const authMsg = {
            type: 'authenticate',
            api_key: this.apiKey
        };
        this.ws.send(JSON.stringify(authMsg));
    }
    
    subscribeToTransactions(exchange, transactionTypes = ['deposits', 'withdrawals', 'trades']) {
        const subscribeMsg = {
            action: 'subscribe_transactions',
            exchange: exchange,
            testnet: false,
            transaction_types: transactionTypes
        };
        this.ws.send(JSON.stringify(subscribeMsg));
        console.log(`Subscribed to ${exchange} transactions`);
    }
    
    validateCredentials(exchange) {
        const validateMsg = {
            action: 'validate_credentials',
            exchange: exchange,
            testnet: false
        };
        this.ws.send(JSON.stringify(validateMsg));
    }
    
    getExchanges() {
        const exchangesMsg = {
            action: 'get_exchanges'
        };
        this.ws.send(JSON.stringify(exchangesMsg));
    }
    
    handleMessage(data) {
        switch (data.type) {
            case 'transaction_response':
                console.log(`Received ${data.total_transactions || 0} transactions`);
                break;
                
            case 'validation_response':
                if (data.success) {
                    console.log(`Credentials valid for ${data.exchange}`);
                } else {
                    console.error(`Credentials invalid: ${data.message}`);
                }
                break;
                
            case 'exchanges_response':
                const exchanges = data.exchanges || [];
                console.log(`Supported exchanges: ${exchanges.map(ex => ex.exchange_name)}`);
                break;
                
            case 'error':
                console.error(`Error: ${data.error} - ${data.message}`);
                break;
                
            default:
                console.log(`Received ${data.type}:`, data);
        }
    }
}

// Usage
async function main() {
    const client = new UnifiedTransactionClient('YOUR_API_KEY');
    
    try {
        await client.connect();
        
        // Get supported exchanges
        client.getExchanges();
        
        // Validate credentials
        client.validateCredentials('bybit');
        
        // Subscribe to transactions
        client.subscribeToTransactions('bybit', ['deposits', 'withdrawals']);
        
    } catch (error) {
        console.error('Failed to connect:', error);
    }
}

main();