WebSocket API Documentation

const crypto = require("crypto");

hub.on("LR", () => {
    const timestamp = Date.now();
    const signature = crypto
        .createHmac("sha256", API_SECRET)
        .update(timestamp.toString())
        .digest("hex");

    hub.invoke("WebSocketLoginWithApiKey", API_KEY, signature, timestamp);
});

using System.Security.Cryptography;
using System.Text;

hub.On("LR", async () =>
{
    var timestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
    using var hmac = new HMACSHA256(Encoding.UTF8.GetBytes(API_SECRET));
    var hash = hmac.ComputeHash(Encoding.UTF8.GetBytes(timestamp.ToString()));
    var signature = Convert.ToHexStringLower(hash);

    await hub.InvokeAsync("WebSocketLoginWithApiKey", API_KEY, signature, timestamp);
});

hub.on("TradeUpdate", (trade) => {
    const isMaker = (trade.orderSide === "Buy" && trade.isBuyerMaker) ||
                    (trade.orderSide === "Sell" && !trade.isBuyerMaker);

    console.log(`Trade ${trade.id}: ${trade.quantity} @ ${trade.price}`);
    console.log(`Liquidity: ${isMaker ? "MAKER" : "TAKER"}`);
});

hub.On<TradeItem>("TradeUpdate", trade =>
{
    var isMaker = (trade.OrderSide == "Buy" && trade.IsBuyerMaker) ||
                  (trade.OrderSide == "Sell" && !trade.IsBuyerMaker);

    Console.WriteLine($"Trade {trade.Id}: {trade.Quantity} @ {trade.Price}");
    Console.WriteLine($"Liquidity: {(isMaker ? "MAKER" : "TAKER")}");
});

// Subscribe
await marketHub.invoke("Subscribe", "socket.darkex.com", "BTCUSDT", "Spot", 500);

// Snapshot (immediate, on subscribe)
marketHub.on("OrderBookSnapshot", (msg) => {
    // msg.s = sequence ID, msg.b = bids, msg.a = asks, msg.tr = recent trades
    initOrderBook(msg);
    lastSeqId = msg.s;
});

// Delta updates (every 250ms)
marketHub.on("OrderBookUpdate", (msg) => {
    if (msg.s !== lastSeqId + 1) {
        // Gap detected - request replay
        marketHub.invoke("RequestReplay", "socket.darkex.com", "BTCUSDT", "Spot", lastSeqId);
        return;
    }
    applyDelta(msg);  // qty "0" = remove level, non-zero = replace
    lastSeqId = msg.s;
});

long lastSeqId = 0;
await marketHub.InvokeAsync("Subscribe", "socket.darkex.com", "BTCUSDT", "Spot", 500);

// Snapshot (immediate, on subscribe)
marketHub.On<OrderBookMessage>("OrderBookSnapshot", msg =>
{
    InitOrderBook(msg);           // msg.S = sequence, msg.B = bids, msg.A = asks, msg.Tr = trades
    lastSeqId = msg.S;
});

// Delta updates (every 250ms)
marketHub.On<OrderBookMessage>("OrderBookUpdate", msg =>
{
    if (msg.S != lastSeqId + 1)   // gap detected - request replay
    {
        marketHub.InvokeAsync("RequestReplay", "socket.darkex.com", "BTCUSDT", "Spot", lastSeqId);
        return;
    }
    ApplyDelta(msg);              // qty "0" = remove level, non-zero = replace
    lastSeqId = msg.S;
});

await marketHub.invoke("SubscribeMiniTickers", "socket.darkex.com");

// Full snapshot (immediate)
marketHub.on("TickerSnapshot", (msg) => {
    // msg.d = array of all tickers
    msg.d.forEach(t => tickers.set(t.s, t));
});

// Delta updates (every 500ms, changed tickers only)
marketHub.on("TickerUpdate", (msg) => {
    msg.d.forEach(t => tickers.set(t.s, { ...tickers.get(t.s), ...t }));
});

var tickers = new Dictionary<string, Ticker>();
await marketHub.InvokeAsync("SubscribeMiniTickers", "socket.darkex.com");

// Full snapshot (immediate)
marketHub.On<TickerMessage>("TickerSnapshot", msg =>
{
    foreach (var t in msg.D) tickers[t.S] = t;
});

// Delta updates (every 500ms, changed tickers only)
marketHub.On<TickerMessage>("TickerUpdate", msg =>
{
    foreach (var t in msg.D) tickers[t.S] = t;   // merge changed fields into your cached ticker
});

import * as signalR from "@microsoft/signalr";
const crypto = require("crypto");

const API_KEY = "your-api-key";
const API_SECRET = "your-api-secret";
const DOMAIN = "socket.darkex.com";

// === State ===
const positions = new Map();
const openOrders = new Map();
const balances = new Map();

// === GlobalHub (Private Data) ===
const globalHub = new signalR.HubConnectionBuilder()
    .withUrl("wss://socket.darkex.com/GlobalHub", {
        transport: signalR.HttpTransportType.WebSockets,
        skipNegotiation: true
    })
    .withAutomaticReconnect([0, 1000, 5000, 10000])
    .build();

// === PublicMarketData Hub ===
const marketHub = new signalR.HubConnectionBuilder()
    .withUrl("wss://socket.darkex.com/PublicMarketData", {
        transport: signalR.HttpTransportType.WebSockets,
        skipNegotiation: true
    })
    .withAutomaticReconnect([0, 1000, 5000, 10000])
    .build();

// --- Private Event Handlers ---
globalHub.on("FuturesAccountUpdate", (account) => {
    account.positions.forEach(pos => {
        pos.quantity > 0
            ? positions.set(pos.positionId, pos)
            : positions.delete(pos.positionId);
    });
});

globalHub.on("OrderUpdate", (order) => {
    if (order.status === "New" || order.status === "PartiallyFilled") {
        openOrders.set(order.orderId, order);
    } else {
        openOrders.delete(order.orderId);
    }
});

globalHub.on("TradeUpdate", (trade) => {
    const isMaker = (trade.orderSide === "Buy" && trade.isBuyerMaker) ||
                    (trade.orderSide === "Sell" && !trade.isBuyerMaker);
    console.log(`Trade: ${trade.symbol} ${trade.quantity} @ ${trade.price} [${isMaker ? "MAKER" : "TAKER"}]`);
});

globalHub.on("BalanceUpdate", (wallet) => {
    balances.set(`${wallet.type}:${wallet.symbol}`, wallet);
});

// --- Authentication ---
globalHub.on("LR", () => {
    const timestamp = Date.now();
    const signature = crypto
        .createHmac("sha256", API_SECRET)
        .update(timestamp.toString())
        .digest("hex");
    globalHub.invoke("WebSocketLoginWithApiKey", API_KEY, signature, timestamp);
});

globalHub.on("LS", async () => {
    console.log("Authenticated");

    // Fetch initial state via REST
    const [pos, ord, bal] = await Promise.all([
        fetch("/fapi/v1/positionRisk", { headers: authHeaders }).then(r => r.json()),
        fetch("/fapi/v1/openOrders", { headers: authHeaders }).then(r => r.json()),
        fetch("/fapi/v1/balance", { headers: authHeaders }).then(r => r.json())
    ]);

    pos.forEach(p => positions.set(p.positionId, p));
    ord.forEach(o => openOrders.set(o.orderId, o));
    bal.forEach(b => balances.set(`${b.type}:${b.symbol}`, b));
    console.log("State initialized");
});

// --- Market Data Handlers ---
let lastSeqId = 0;
marketHub.on("OrderBookSnapshot", (msg) => {
    initOrderBook(msg);
    lastSeqId = msg.s;
});

marketHub.on("OrderBookUpdate", (msg) => {
    if (msg.s !== lastSeqId + 1) {
        marketHub.invoke("RequestReplay", DOMAIN, "BTCUSDT", "Spot", lastSeqId);
        return;
    }
    applyDelta(msg);
    lastSeqId = msg.s;
});

// --- Start ---
await Promise.all([globalHub.start(), marketHub.start()]);

// Subscribe to market data (snapshot is pushed automatically)
await marketHub.invoke("Subscribe", DOMAIN, "BTCUSDT", "Spot", 500);
await marketHub.invoke("SubscribeMiniTickers", DOMAIN);

using System.Security.Cryptography;
using System.Text;
using Microsoft.AspNetCore.SignalR.Client;

const string ApiKey = "your-api-key";
const string ApiSecret = "your-api-secret";
const string Domain = "socket.darkex.com";

// === State ===
var positions = new Dictionary<long, PositionView>();
var openOrders = new Dictionary<long, OrderDetailResponse>();
var balances = new Dictionary<string, ResponseWallet>();
long lastSeqId = 0;

// === GlobalHub (private data) ===
var globalHub = new HubConnectionBuilder()
    .WithUrl("wss://socket.darkex.com/GlobalHub", o =>
    {
        o.Transports = HttpTransportType.WebSockets;
        o.SkipNegotiation = true;
    })
    .WithAutomaticReconnect()
    .Build();

// === PublicMarketData hub ===
var marketHub = new HubConnectionBuilder()
    .WithUrl("wss://socket.darkex.com/PublicMarketData", o =>
    {
        o.Transports = HttpTransportType.WebSockets;
        o.SkipNegotiation = true;
    })
    .WithAutomaticReconnect()
    .Build();

// --- Private event handlers ---
globalHub.On<FuturesAccountView>("FuturesAccountUpdate", account =>
{
    foreach (var pos in account.Positions)
    {
        if (pos.Quantity > 0) positions[pos.PositionId] = pos;
        else positions.Remove(pos.PositionId);
    }
});

globalHub.On<OrderDetailResponse>("OrderUpdate", order =>
{
    if (order.Status is "New" or "PartiallyFilled") openOrders[order.OrderId] = order;
    else openOrders.Remove(order.OrderId);
});

globalHub.On<ResponseWallet>("BalanceUpdate", wallet =>
{
    balances[$"{wallet.Type}:{wallet.Symbol}"] = wallet;
});

// --- Authentication ---
globalHub.On("LR", async () =>
{
    var timestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
    using var hmac = new HMACSHA256(Encoding.UTF8.GetBytes(ApiSecret));
    var hash = hmac.ComputeHash(Encoding.UTF8.GetBytes(timestamp.ToString()));
    var signature = Convert.ToHexStringLower(hash);
    await globalHub.InvokeAsync("WebSocketLoginWithApiKey", ApiKey, signature, timestamp);
});

globalHub.On("LS", () => Console.WriteLine("Authenticated"));   // then fetch initial state via REST

// --- Market data handlers ---
marketHub.On<OrderBookMessage>("OrderBookSnapshot", msg =>
{
    InitOrderBook(msg);
    lastSeqId = msg.S;
});

marketHub.On<OrderBookMessage>("OrderBookUpdate", msg =>
{
    if (msg.S != lastSeqId + 1)
    {
        marketHub.InvokeAsync("RequestReplay", Domain, "BTCUSDT", "Spot", lastSeqId);
        return;
    }
    ApplyDelta(msg);
    lastSeqId = msg.S;
});

// --- Start ---
await globalHub.StartAsync();
await marketHub.StartAsync();

// Subscribe to market data (snapshot pushed automatically)
await marketHub.InvokeAsync("Subscribe", Domain, "BTCUSDT", "Spot", 500);
await marketHub.InvokeAsync("SubscribeMiniTickers", Domain);