WebSocket API Documentation

# GlobalHub - for user-specific real-time updates
wss://your-domain.com/GlobalHub

# PublicMarketData - for market data streaming
wss://your-domain.com/PublicMarketData

// Listen for login request
globalHub.on("LR", () => {
    // Send JWT token
    globalHub.invoke("WebSocketLogin", "your-jwt-token");
});

// Listen for login success
globalHub.on("LS", () => {
    console.log("Authenticated successfully");
});

// Listen for login failure
globalHub.on("LF", () => {
    console.log("Authentication failed");
});

// Sign the timestamp with your API secret
const crypto = require("crypto");

const apiKey = "your-api-key";
const apiSecret = "your-api-secret";
const timestamp = Date.now();
const signature = crypto
    .createHmac("sha256", apiSecret)
    .update(timestamp.toString())
    .digest("hex");

// Send API key login
globalHub.invoke("WebSocketLoginWithApiKey", apiKey, signature, timestamp);

// Same response events: LS (success) / LF (failure)
globalHub.on("LS", () => console.log("API key auth successful"));
globalHub.on("LF", () => console.log("API key auth failed"));

// Authenticate (optional - only for private events)
marketHub.invoke("Authenticate", "your-jwt-token");

// Listen for auth result
marketHub.on("AuthSuccess", (data) => {
    console.log("Authenticated as user:", data.userId);
});

marketHub.on("AuthFailed", (data) => {
    console.log("Auth failed:", data.reason);
});

{
  "connectionId": "abc123...",
  "serverTimeUtc": "2025-01-15T10:30:00Z",
  "availableOrderBooks": [
    { "orderBookId": 1, "symbol": "BTCUSDT", "orderBookType": "Spot" },
    { "orderBookId": 2, "symbol": "ETHUSDT", "orderBookType": "Spot" }
  ]
}

{
  "c": "snapshot",
  "s": 42,
  "t": 1709500000000,
  "p": "BTCUSDT",
  "o": "spot",
  "d": 500,
  "b": [["65230.50", "1.234"], ["65230.00", "0.567"]],
  "a": [["65231.00", "0.890"], ["65231.50", "2.345"]],
  "tr": [
    { "i": 1001, "p": "65230.75", "q": "0.100", "m": true, "t": 1709499999500 }
  ]
}

{
  "c": "update",
  "s": 43,
  "t": 1709500000250,
  "p": "BTCUSDT",
  "o": "spot",
  "b": [["65230.50", "1.500"], ["65229.00", "0"]],
  "a": [["65231.00", "0.500"]],
  "tr": [
    { "i": 1002, "p": "65230.50", "q": "0.050", "m": false, "t": 1709500000100 }
  ]
}

{
  "c": "ticker_snapshot",
  "t": 1709500000000,
  "d": [
    {
      "s": "BTCUSDT",
      "o": "spot",
      "p": "65230.50",
      "op": "64800.00",
      "h": "65500.00",
      "l": "64500.00",
      "v": "1234.567",
      "q": "80500000.00",
      "c": 15234,
      "m": "0",
      "f": "0",
      "cd": 0
    }
  ]
}

{
  "c": "ticker_update",
  "t": 1709500000500,
  "d": [
    { "s": "BTCUSDT", "o": "spot", "p": "65231.00", "v": "1234.890" }
  ]
}

{
  "c": "markprice_update",
  "t": 1709500000000,
  "d": [
    {
      "s": "BTCUSDT",
      "m": "65235.50",
      "i": "65234.80",
      "f": "0.00010",
      "t": 1709503600000
    }
  ]
}

globalHub.on("BalanceUpdate", (wallet) => {
    console.log("Balance updated:", wallet);
    // wallet contains: currency, available, locked, total, etc.
});

globalHub.on("OrderUpdate", (order) => {
    console.log("Order updated:", order.orderId, order.status);
});

globalHub.on("TradeUpdate", (trade) => {
    console.log("Trade executed:", trade);
});

{
  "c": "snapshot",     // message type
  "s": 42,             // BroadcastSeqId
  "t": 1709500000000,  // server timestamp (Unix ms)
  "p": "BTCUSDT",      // pair symbol
  "o": "spot",         // orderbook type
  "d": 500,            // depth level
  "b": [               // bids [[price, qty], ...]
    ["65230.50", "1.234"],
    ["65230.00", "0.567"]
  ],
  "a": [               // asks [[price, qty], ...]
    ["65231.00", "0.890"],
    ["65231.50", "2.345"]
  ],
  "tr": [              // recent trades (last 10)
    { "i": 1001, "p": "65230.75", "q": "0.100", "m": true, "t": 1709499999500 }
  ]
}

{
  "c": "update",        // message type
  "s": 43,              // BroadcastSeqId (continuous)
  "t": 1709500000250,   // server timestamp
  "p": "BTCUSDT",       // pair symbol
  "o": "spot",          // orderbook type
  "b": [["65230.50", "1.500"]],   // changed bids
  "a": [["65231.00", "0"]],       // qty "0" = remove level
  "tr": [               // new trades since last update
    { "i": 1002, "p": "65230.50", "q": "0.050", "m": false, "t": 1709500000100 }
  ]
}

{
  "c": "ticker_snapshot",
  "t": 1709500000000,
  "d": [
    { "s": "BTCUSDT", "o": "spot", "p": "65230.50", "op": "64800.00", "h": "65500.00", "l": "64500.00", "v": "1234.567", "q": "80500000.00", "c": 15234 },
    { "s": "ETHUSDT", "o": "spot", "p": "3450.25", "op": "3400.00", "h": "3480.00", "l": "3390.00", "v": "45678.901", "q": "157000000.00", "c": 28456 }
  ]
}

{
  "c": "ticker_update",
  "t": 1709500000500,
  "d": [
    { "s": "BTCUSDT", "o": "spot", "p": "65231.00", "v": "1234.890" }
  ]
}

{
  "c": "markprice_update",
  "t": 1709500000000,
  "d": [
    { "s": "BTCUSDT", "m": "65235.50", "i": "65234.80", "f": "0.00010", "t": 1709503600000 }
  ]
}

class OrderBookClient {
    constructor(hub, domain, symbol, type) {
        this.hub = hub;
        this.domain = domain;
        this.symbol = symbol;
        this.type = type;
        this.lastSeqId = 0;
        this.bids = new Map();  // price -> qty
        this.asks = new Map();  // price -> qty

        hub.on("OrderBookSnapshot", (msg) => this.onSnapshot(msg));
        hub.on("OrderBookUpdate", (msg) => this.onUpdate(msg));
    }

    onSnapshot(msg) {
        if (msg.p !== this.symbol) return;
        this.bids.clear();
        this.asks.clear();
        msg.b.forEach(([p, q]) => this.bids.set(p, q));
        msg.a.forEach(([p, q]) => this.asks.set(p, q));
        this.lastSeqId = msg.s;
    }

    onUpdate(msg) {
        if (msg.p !== this.symbol) return;

        // Gap detection
        if (msg.s !== this.lastSeqId + 1) {
            console.warn(`Gap: expected ${this.lastSeqId + 1}, got ${msg.s}`);
            this.hub.invoke("RequestReplay",
                this.domain, this.symbol, this.type, this.lastSeqId);
            return;
        }

        // Apply delta
        msg.b.forEach(([p, q]) => {
            q === "0" ? this.bids.delete(p) : this.bids.set(p, q);
        });
        msg.a.forEach(([p, q]) => {
            q === "0" ? this.asks.delete(p) : this.asks.set(p, q);
        });
        this.lastSeqId = msg.s;
    }

    async subscribe(depth = 500) {
        await this.hub.invoke("Subscribe",
            this.domain, this.symbol, this.type, depth);
    }
}

const hub = new signalR.HubConnectionBuilder()
    .withUrl("https://your-domain.com/PublicMarketData", {
        transport: signalR.HttpTransportType.WebSockets,
        skipNegotiation: true
    })
    .withAutomaticReconnect([0, 1000, 5000, 10000, 30000])
    .build();

hub.onreconnecting((error) => {
    console.log("Reconnecting...", error);
    showReconnectingUI();
});

hub.onreconnected((connectionId) => {
    console.log("Reconnected:", connectionId);
    hideReconnectingUI();

    // Re-subscribe to all streams
    resubscribeAll();
});

hub.onclose((error) => {
    console.log("Connection closed:", error);
    // Attempt manual reconnect after delay
    setTimeout(() => hub.start(), 5000);
});

async function resubscribeAll() {
    // Re-authenticate if needed
    if (authToken) {
        await hub.invoke("Authenticate", authToken);
    }

    // Re-subscribe to order books
    for (const sub of activeSubscriptions) {
        await hub.invoke("Subscribe",
            sub.domain, sub.symbol, sub.type, sub.depth);
    }

    // Re-subscribe to tickers
    if (tickerSubscribed) {
        await hub.invoke("SubscribeMiniTickers", currentDomain);
    }
}

import * as signalR from "@microsoft/signalr";

const DOMAIN = "darkex.com";
const WS_URL = "https://your-domain.com/PublicMarketData";

class MarketDataClient {
    constructor() {
        this.hub = new signalR.HubConnectionBuilder()
            .withUrl(WS_URL, {
                transport: signalR.HttpTransportType.WebSockets,
                skipNegotiation: true
            })
            .withAutomaticReconnect([0, 1000, 5000, 10000])
            .build();

        this.setupEventHandlers();
    }

    setupEventHandlers() {
        // Connection events
        this.hub.on("Connected", (data) => {
            console.log("Connected:", data.connectionId);
            console.log("Available order books:", data.availableOrderBooks.length);
        });

        // Order book events
        this.hub.on("Subscribed", (data) => {
            console.log("Subscribed to OB:", data.orderBookId, "Depth:", data.depthLevel);
        });

        this.hub.on("OrderBookSnapshot", (msg) => {
            console.log(`Snapshot [${msg.p}]: ${msg.b.length} bids, ${msg.a.length} asks, seq=${msg.s}`);
        });

        this.hub.on("OrderBookUpdate", (msg) => {
            console.log(`Update [${msg.p}]: seq=${msg.s}`);
        });

        // Ticker events
        this.hub.on("MiniTickerSubscribed", (data) => {
            console.log("Ticker subscribed:", data.tickerCount, "tickers");
        });

        this.hub.on("TickerSnapshot", (msg) => {
            console.log("Ticker snapshot:", msg.d.length, "tickers");
        });

        this.hub.on("TickerUpdate", (msg) => {
            msg.d.forEach(t => console.log(`${t.s}: ${t.p}`));
        });

        // Mark price events
        this.hub.on("MarkPriceUpdate", (msg) => {
            msg.d.forEach(mp => console.log(`MarkPrice [${mp.s}]: ${mp.m}`));
        });

        // Error handling
        this.hub.on("Error", (err) => {
            console.error("Server error:", err.code, err.message);
        });

        // Pong
        this.hub.on("Pong", (pong) => {
            const rtt = Date.now() - pong.t1;
            console.log(`Pong: RTT=${rtt}ms`);
        });

        // Reconnection
        this.hub.onreconnected(() => this.resubscribe());
    }

    async connect() {
        await this.hub.start();
        console.log("Hub started");
    }

    async subscribeTicker() {
        await this.hub.invoke("SubscribeMiniTickers", DOMAIN);
    }

    async subscribeOrderBook(symbol, type = "Spot", depth = 500) {
        await this.hub.invoke("Subscribe", DOMAIN, symbol, type, depth);
    }

    async resubscribe() {
        await this.subscribeTicker();
        await this.subscribeOrderBook("BTCUSDT");
    }

    async ping() {
        await this.hub.invoke("Ping", 1, Date.now());
    }
}

// Usage
const client = new MarketDataClient();
await client.connect();
await client.subscribeTicker();
await client.subscribeOrderBook("BTCUSDT", "Spot", 500);

from signalrcore.hub_connection_builder import HubConnectionBuilder
import time

DOMAIN = "darkex.com"
WS_URL = "https://your-domain.com/PublicMarketData"

def on_connected(data):
    print(f"Connected: {data[0]['connectionId']}")
    print(f"Available order books: {len(data[0]['availableOrderBooks'])}")

def on_snapshot(data):
    msg = data[0]
    print(f"Snapshot [{msg['p']}]: {len(msg['b'])} bids, {len(msg['a'])} asks, seq={msg['s']}")

def on_update(data):
    msg = data[0]
    print(f"Update [{msg['p']}]: seq={msg['s']}")

def on_ticker_snapshot(data):
    msg = data[0]
    print(f"Ticker snapshot: {len(msg['d'])} tickers")

def on_ticker_update(data):
    for t in data[0]["d"]:
        print(f"{t['s']}: {t['p']}")

def on_error(data):
    print(f"Error: {data[0]['code']} - {data[0]['message']}")

# Build connection
hub = HubConnectionBuilder() \
    .with_url(WS_URL) \
    .with_automatic_reconnect({
        "type": "raw",
        "keep_alive_interval": 15,
        "reconnect_interval": 5
    }) \
    .build()

# Register handlers
hub.on("Connected", on_connected)
hub.on("OrderBookSnapshot", on_snapshot)
hub.on("OrderBookUpdate", on_update)
hub.on("TickerSnapshot", on_ticker_snapshot)
hub.on("TickerUpdate", on_ticker_update)
hub.on("Error", on_error)

# Connect and subscribe
hub.start()
time.sleep(1)

hub.send("SubscribeMiniTickers", [DOMAIN])
hub.send("Subscribe", [DOMAIN, "BTCUSDT", "Spot", 500])

# Keep alive
try:
    while True:
        hub.send("Ping", [1, int(time.time() * 1000)])
        time.sleep(30)
except KeyboardInterrupt:
    hub.stop()

using Microsoft.AspNetCore.SignalR.Client;

const string Domain = "darkex.com";
const string WsUrl = "https://your-domain.com/PublicMarketData";

var hub = new HubConnectionBuilder()
    .WithUrl(WsUrl, options =>
    {
        options.Transports = HttpTransportType.WebSockets;
        options.SkipNegotiation = true;
    })
    .WithAutomaticReconnect()
    .Build();

// Order book snapshot
hub.On<object>("OrderBookSnapshot", (msg) =>
{
    Console.WriteLine($"Snapshot received");
});

// Order book update
hub.On<object>("OrderBookUpdate", (msg) =>
{
    Console.WriteLine($"Update received");
});

// Ticker events
hub.On<object>("TickerSnapshot", (msg) =>
{
    Console.WriteLine("Ticker snapshot received");
});

hub.On<object>("TickerUpdate", (msg) =>
{
    Console.WriteLine("Ticker update received");
});

// Error
hub.On<object>("Error", (err) =>
{
    Console.WriteLine($"Error: {err}");
});

// Connect
await hub.StartAsync();
Console.WriteLine("Connected!");

// Subscribe
await hub.InvokeAsync("SubscribeMiniTickers", Domain);
await hub.InvokeAsync("Subscribe", Domain, "BTCUSDT", "Spot", 500);

// Keep alive
while (true)
{
    await hub.InvokeAsync("Ping", 1L, DateTimeOffset.UtcNow.ToUnixTimeMilliseconds());
    await Task.Delay(30000);
}

{
  "code": "TENANT_NOT_FOUND",
  "message": "Tenant not found for domain: invalid.com"
}