Orders

import hashlib
import hmac
import json
import os
import secrets
import time

import requests


def units(value: float) -> str:
    return str(round(value * 1_000_000))


def sign(secret: str, timestamp: str, method: str, path: str, body: str = "") -> str:
    message = f"{timestamp}{method.upper()}{path}{body}"
    return hmac.new(secret.encode(), message.encode(), hashlib.sha256).hexdigest()


def request(method: str, path: str, payload: dict | None = None):
    full_path = f"/api/v1{path}"
    timestamp = str(int(time.time() * 1000))
    body = json.dumps(payload, separators=(",", ":")) if payload else ""

    response = requests.request(
        method,
        f"https://hit.com{full_path}",
        headers={
            "Content-Type": "application/json",
            "hit-api-key": os.environ["HIT_API_KEY"],
            "hit-signature": sign(os.environ["HIT_API_SECRET"], timestamp, method, full_path, body),
            "hit-timestamp": timestamp,
            "hit-passphrase": os.environ["HIT_API_PASSPHRASE"],
        },
        data=body or None,
        timeout=10,
    )
    response.raise_for_status()
    return response.json()


order = request(
    "POST",
    "/orders",
    {
        "salt": str(secrets.randbits(256)),
        "taker": "0x0000000000000000000000000000000000000000",
        "tokenId": os.environ["HIT_TOKEN_ID"],
        "makerAmount": units(31),
        "takerAmount": units(50),
        "expiration": 0,
        "side": 0,
        "orderType": "GTC",
    },
)

print(order)

use hmac::{Hmac, Mac};
use reqwest::blocking::Client;
use serde_json::{json, Value};
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 units(value: f64) -> String {
    (value * 1_000_000.0).round().to_string()
}

fn sign(secret: &str, timestamp: &str, method: &str, path: &str, body: &str) -> String {
    let message = format!("{}{}{}{}", timestamp, method.to_uppercase(), path, body);
    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 client = Client::new();
    let path = "/api/v1/orders";
    let timestamp = timestamp_ms();
    let payload = json!({
        "salt": rand::random::<u128>().to_string(),
        "taker": "0x0000000000000000000000000000000000000000",
        "tokenId": env::var("HIT_TOKEN_ID")?,
        "makerAmount": units(31.0),
        "takerAmount": units(50.0),
        "expiration": 0,
        "side": 0,
        "orderType": "GTC"
    });
    let body = serde_json::to_string(&payload)?;
    let signature = sign(&env::var("HIT_API_SECRET")?, &timestamp, "POST", path, &body);

    let order: Value = client
        .post(format!("https://hit.com{}", path))
        .header("Content-Type", "application/json")
        .header("hit-api-key", env::var("HIT_API_KEY")?)
        .header("hit-signature", signature)
        .header("hit-timestamp", timestamp)
        .header("hit-passphrase", env::var("HIT_API_PASSPHRASE")?)
        .body(body)
        .send()?
        .error_for_status()?
        .json()?;

    println!("{order:#}");
    Ok(())
}