WebSockets

import hashlib
import hmac
import os
import time

import socketio


def sign_ws(secret: str, timestamp: str) -> str:
    message = f"{timestamp}WEBSOCKET/user"
    return hmac.new(secret.encode(), message.encode(), hashlib.sha256).hexdigest()


sio = socketio.Client()


@sio.event(namespace="/user")
def connect():
    timestamp = str(int(time.time() * 1000))
    sio.emit(
        "user-connect",
        {
            "auth": {
                "apiKey": os.environ["HIT_API_KEY"],
                "signature": sign_ws(os.environ["HIT_API_SECRET"], timestamp),
                "timestamp": timestamp,
                "passphrase": os.environ["HIT_API_PASSPHRASE"],
            }
        },
        namespace="/user",
    )


@sio.on("user-authenticated", namespace="/user")
def authenticated(response):
    if response.get("success"):
        sio.emit("initial-data", namespace="/user")
    else:
        raise RuntimeError(response.get("error", "WebSocket authentication failed"))


@sio.on("user-order", namespace="/user")
def user_order(data):
    print("order", data)


@sio.on("user-trade", namespace="/user")
def user_trade(data):
    print("trade", data)


sio.connect("wss://markets.hit.com", namespaces=["/user"], transports=["websocket"])
sio.wait()

use hmac::{Hmac, Mac};
use rust_socketio::{ClientBuilder, Payload};
use serde_json::json;
use sha2::Sha256;
use std::env;
use std::time::{SystemTime, UNIX_EPOCH};

type HmacSha256 = Hmac<Sha256>;

fn timestamp_ms() -> String {
    SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .expect("system clock before unix epoch")
        .as_millis()
        .to_string()
}

fn sign_ws(secret: &str, timestamp: &str) -> String {
    let message = format!("{}WEBSOCKET/user", timestamp);
    let mut mac = HmacSha256::new_from_slice(secret.as_bytes()).expect("hmac accepts any key");
    mac.update(message.as_bytes());
    hex::encode(mac.finalize().into_bytes())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let socket = ClientBuilder::new("https://markets.hit.com")
        .namespace("/user")
        .on("user-authenticated", |payload: Payload, _| {
            println!("authenticated: {payload:?}");
        })
        .on("user-order", |payload: Payload, _| {
            println!("order: {payload:?}");
        })
        .on("user-trade", |payload: Payload, _| {
            println!("trade: {payload:?}");
        })
        .connect()?;

    let timestamp = timestamp_ms();
    socket.emit(
        "user-connect",
        json!({
            "auth": {
                "apiKey": env::var("HIT_API_KEY")?,
                "signature": sign_ws(&env::var("HIT_API_SECRET")?, &timestamp),
                "timestamp": timestamp,
                "passphrase": env::var("HIT_API_PASSPHRASE")?
            }
        }),
    )?;

    socket.emit("initial-data", json!({}))?;
    std::thread::park();
    Ok(())
}