Ticker Data

class TickerMonitor {
  constructor() {
    this.tickers = {};
    this.listeners = [];
  }

  connect() {
    this.ws = new WebSocket('wss://ws.roxom.com/ws');
    
    this.ws.onopen = () => {
      console.log('Connected to Ticker stream');
      this.subscribeToSymbols(['GOLD-BTC', 'USDT-BTC']);
    };

    this.ws.onmessage = (event) => {
      const data = JSON.parse(event.data);
      
      if (data.topic && data.topic.startsWith('ticker.')) {
        this.handleTickerUpdate(data);
      }
    };
  }

  subscribeToSymbols(symbols) {
    const args = symbols.map(symbol => ({
      channel: 'ticker',
      symbol: symbol
    }));

    this.ws.send(JSON.stringify({
      op: 'subscribe',
      args: args
    }));
  }

  handleTickerUpdate(message) {
    const symbol = message.data.symbol;
    const ticker = message.data;

    // Update local ticker cache
    this.tickers[symbol] = {
      symbol: symbol,
      lastPrice: parseFloat(ticker.lastPrice || 0),
      indexPrice: parseFloat(ticker.indexPrice || 0),
      markPrice: parseFloat(ticker.markPrice || 0),
      bestBid: parseFloat(ticker.bestBid || 0),
      bestAsk: parseFloat(ticker.bestAsk || 0),
      bestBidQty: parseFloat(ticker.bestBidQty || 0),
      bestAskQty: parseFloat(ticker.bestAskQty || 0),
      openInterest: parseFloat(ticker.openInterest || 0),
      openInterestValue: parseFloat(ticker.openInterestValue || 0),
      fundingRate: parseFloat(ticker.fundingRate || 0),
      timestamp: ticker.timestamp,
      lastUpdated: Date.now()
    };

    // Calculate spread
    if (ticker.bestBid && ticker.bestAsk) {
      const spread = this.tickers[symbol].bestAsk - this.tickers[symbol].bestBid;
      const midPrice = (this.tickers[symbol].bestBid + this.tickers[symbol].bestAsk) / 2;
      this.tickers[symbol].spread = spread;
      this.tickers[symbol].spreadPercent = (spread / midPrice) * 100;
    }

    console.log(`${symbol} Ticker Update:`);
    console.log(`  Last: ${ticker.lastPrice} | Mark: ${ticker.markPrice} | Index: ${ticker.indexPrice}`);
    console.log(`  Bid: ${ticker.bestBid} (${ticker.bestBidQty}) | Ask: ${ticker.bestAsk} (${ticker.bestAskQty})`);
    console.log(`  OI: ${ticker.openInterest} contracts (${ticker.openInterestValue} BTC)`);
    console.log(`  Funding Rate: ${(parseFloat(ticker.fundingRate || 0) * 100).toFixed(4)}%`);

    // Notify listeners
    this.notifyListeners(symbol, this.tickers[symbol]);
  }

  addListener(callback) {
    this.listeners.push(callback);
  }

  notifyListeners(symbol, ticker) {
    this.listeners.forEach(callback => {
      try {
        callback(symbol, ticker);
      } catch (error) {
        console.error('Listener error:', error);
      }
    });
  }

  getTicker(symbol) {
    return this.tickers[symbol] || null;
  }

  getAllTickers() {
    return { ...this.tickers };
  }
}

// Usage
const tickerMonitor = new TickerMonitor();

tickerMonitor.addListener((symbol, ticker) => {
  // Check for high funding rates
  if (Math.abs(ticker.fundingRate) > 0.001) {
    console.log(`⚠️  High funding rate on ${symbol}: ${(ticker.fundingRate * 100).toFixed(4)}%`);
  }
  
  // Check for large open interest
  if (ticker.openInterestValue > 100) {
    console.log(`📊 Large OI on ${symbol}: ${ticker.openInterestValue.toFixed(2)} BTC`);
  }
});

tickerMonitor.connect();

import websocket
import json
from typing import Dict, Any, Callable, Optional
from datetime import datetime

class TickerTracker:
    def __init__(self):
        self.tickers: Dict[str, Dict] = {}
        self.listeners: List[Callable] = []
        self.ws = None
        
    def connect(self):
        self.ws = websocket.WebSocketApp(
            "wss://ws.roxom.com/ws",
            on_open=self.on_open,
            on_message=self.on_message,
            on_error=self.on_error,
            on_close=self.on_close
        )
        
        self.ws.run_forever()
    
    def on_open(self, ws):
        print("📡 Connected to Ticker stream")
        self.subscribe_to_symbols(['GOLD-BTC', 'USDT-BTC'])
    
    def subscribe_to_symbols(self, symbols):
        subscribe_msg = {
            "op": "subscribe",
            "args": [{"channel": "ticker", "symbol": symbol} for symbol in symbols]
        }
        self.ws.send(json.dumps(subscribe_msg))
    
    def on_message(self, ws, message):
        try:
            data = json.loads(message)
            
            if data.get('topic', '').startswith('ticker.'):
                self.handle_ticker_update(data)
        except json.JSONDecodeError as e:
            print(f"❌ JSON decode error: {e}")
    
    def handle_ticker_update(self, message):
        ticker_data = message['data']
        symbol = ticker_data['symbol']
        
        # Parse ticker data with null handling
        last_price = float(ticker_data['lastPrice']) if ticker_data.get('lastPrice') else None
        index_price = float(ticker_data['indexPrice']) if ticker_data.get('indexPrice') else None
        mark_price = float(ticker_data['markPrice']) if ticker_data.get('markPrice') else None
        best_bid = float(ticker_data['bestBid']) if ticker_data.get('bestBid') else None
        best_ask = float(ticker_data['bestAsk']) if ticker_data.get('bestAsk') else None
        best_bid_qty = float(ticker_data['bestBidQty']) if ticker_data.get('bestBidQty') else None
        best_ask_qty = float(ticker_data['bestAskQty']) if ticker_data.get('bestAskQty') else None
        open_interest = float(ticker_data['openInterest']) if ticker_data.get('openInterest') else None
        open_interest_value = float(ticker_data['openInterestValue']) if ticker_data.get('openInterestValue') else None
        funding_rate = float(ticker_data['fundingRate']) if ticker_data.get('fundingRate') else None
        
        # Calculate derived values
        spread = None
        spread_percent = None
        if best_bid and best_ask:
            spread = best_ask - best_bid
            mid_price = (best_bid + best_ask) / 2
            spread_percent = (spread / mid_price) * 100 if mid_price > 0 else 0
        
        # Update ticker cache
        self.tickers[symbol] = {
            'symbol': symbol,
            'last_price': last_price,
            'index_price': index_price,
            'mark_price': mark_price,
            'best_bid': best_bid,
            'best_ask': best_ask,
            'best_bid_qty': best_bid_qty,
            'best_ask_qty': best_ask_qty,
            'open_interest': open_interest,
            'open_interest_value': open_interest_value,
            'funding_rate': funding_rate,
            'spread': spread,
            'spread_percent': spread_percent,
            'timestamp': ticker_data['timestamp'],
            'last_updated': datetime.now()
        }
        
        # Display ticker update
        print(f"\n{symbol} Ticker Update:")
        print(f"  Last: {last_price:.8f} | Mark: {mark_price:.8f} | Index: {index_price:.8f}")
        print(f"  Bid: {best_bid:.8f} ({best_bid_qty}) | Ask: {best_ask:.8f} ({best_ask_qty})")
        print(f"  OI: {open_interest} contracts ({open_interest_value:.8f} BTC)")
        print(f"  Funding Rate: {(funding_rate * 100):.4f}%")
        
        # Notify listeners
        self.notify_listeners(symbol, self.tickers[symbol])
    
    def add_listener(self, callback):
        self.listeners.append(callback)
    
    def notify_listeners(self, symbol, ticker):
        for callback in self.listeners:
            try:
                callback(symbol, ticker)
            except Exception as e:
                print(f"❌ Listener error: {e}")
    
    def get_ticker(self, symbol) -> Optional[Dict]:
        return self.tickers.get(symbol)
    
    def get_all_tickers(self) -> Dict:
        return self.tickers.copy()
    
    def on_error(self, ws, error):
        print(f"🚨 WebSocket error: {error}")
    
    def on_close(self, ws, close_status_code, close_msg):
        print("❌ Ticker connection closed")

# Usage
tracker = TickerTracker()

# Add custom ticker handler
def ticker_handler(symbol, ticker):
    # Alert on high funding rates
    if ticker['funding_rate'] and abs(ticker['funding_rate']) > 0.001:
        print(f"⚠️  High funding rate on {symbol}: {(ticker['funding_rate'] * 100):.4f}%")
    
    # Alert on large open interest
    if ticker['open_interest_value'] and ticker['open_interest_value'] > 100:
        print(f"📊 Large OI on {symbol}: {ticker['open_interest_value']:.2f} BTC")

tracker.add_listener(ticker_handler)
tracker.connect()