honeymaker 0.12.3 → 0.12.4

data/crates/honeymaker/src/kraken/requests.rs

@@ -0,0 +1,286 @@
+use super::sign::{Credentials, next_nonce, private_headers, public_headers};
+use crate::encode::www_form;
+use std::collections::BTreeMap;
+
+#[derive(Clone, Debug)]
+pub enum Param {
+    One(String),
+    /// Repeat the wire key, as URI.encode_www_form does for Arrays. `oflags`
+    /// follows the legacy caller instead: join with commas, or omit when empty.
+    Many(Vec<String>),
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Method {
+    Get,
+    Post,
+}
+
+pub struct Built {
+    pub method: Method,
+    pub path: &'static str,
+    /// Wire pairs in legacy field order, retaining repeated keys for Many.
+    /// POST includes nonce first; GET callers encode/sort these as query params.
+    pub pairs: Vec<(String, String)>,
+    /// POST only: the exact form body that is signed.
+    pub body: Option<String>,
+    pub headers: Vec<(String, String)>,
+}
+
+pub type Fields = &'static [(&'static str, &'static str)];
+
+/// Wire order and names as in the legacy hash literals, `(wire name, param name)`. "nonce" goes
+/// first for private calls.
+pub fn layout(op: &str) -> Option<(Method, &'static str, Fields)> {
+    use Method::*;
+    Some(match op {
+        // Rust callers only (the gem has no wrapper for them); wire names from Kraken's REST docs.
+        "open_orders" => (
+            Post,
+            "/0/private/OpenOrders",
+            &[
+                ("trades", "trades"),
+                ("userref", "userref"),
+                ("cl_ord_id", "cl_ord_id"),
+            ],
+        ),
+        "closed_orders" => (
+            Post,
+            "/0/private/ClosedOrders",
+            &[
+                ("trades", "trades"),
+                ("userref", "userref"),
+                ("cl_ord_id", "cl_ord_id"),
+                ("start", "start"),
+                ("end", "end_time"),
+                ("ofs", "ofs"),
+                ("closetime", "closetime"),
+                ("consolidate_taker", "consolidate_taker"),
+            ],
+        ),
+        "query_orders_info" => (
+            Post,
+            "/0/private/QueryOrders",
+            &[
+                ("trades", "trades"),
+                ("userref", "userref"),
+                ("txid", "txid"),
+                ("consolidate_taker", "consolidate_taker"),
+            ],
+        ),
+        "add_order" => (
+            Post,
+            "/0/private/AddOrder",
+            &[
+                ("ordertype", "ordertype"),
+                ("type", "type"),
+                ("volume", "volume"),
+                ("pair", "pair"),
+                ("userref", "userref"),
+                ("cl_ord_id", "cl_ord_id"),
+                ("displayvol", "displayvol"),
+                ("price", "price"),
+                ("price2", "price2"),
+                ("trigger", "trigger"),
+                ("leverage", "leverage"),
+                ("reduce_only", "reduce_only"),
+                ("stptype", "stptype"),
+                ("oflags", "oflags"),
+                ("timeinforce", "timeinforce"),
+                ("starttm", "starttm"),
+                ("expiretm", "expiretm"),
+                ("close[ordertype]", "close"),
+                ("close[price]", "close_price"),
+                ("close[price2]", "close_price2"),
+                ("deadline", "deadline"),
+                ("validate", "validate"),
+            ],
+        ),
+        "cancel_order" => (
+            Post,
+            "/0/private/CancelOrder",
+            &[("txid", "txid"), ("cl_ord_id", "cl_ord_id")],
+        ),
+        "get_tradable_asset_pairs" => (
+            Get,
+            "/0/public/AssetPairs",
+            &[
+                ("pair", "pairs"),
+                ("info", "info"),
+                ("country_code", "country_code"),
+                ("aclass_base", "aclass_base"),
+            ],
+        ),
+        "get_asset_info" => (
+            Get,
+            "/0/public/Assets",
+            &[("asset", "assets"), ("aclass", "aclass")],
+        ),
+        "get_ticker_information" => (Get, "/0/public/Ticker", &[("pair", "pair")]),
+        "get_extended_balance" => (Post, "/0/private/BalanceEx", &[]),
+        "get_api_key_info" => (Post, "/0/private/GetApiKeyInfo", &[]),
+        "get_ohlc_data" => (
+            Get,
+            "/0/public/OHLC",
+            &[
+                ("pair", "pair"),
+                ("interval", "interval"),
+                ("since", "since"),
+            ],
+        ),
+        "get_trades_history" => (
+            Post,
+            "/0/private/TradesHistory",
+            &[
+                ("type", "type"),
+                ("trades", "trades"),
+                ("start", "start"),
+                ("end", "end_time"),
+                ("ofs", "ofs"),
+            ],
+        ),
+        "get_ledgers" => (
+            Post,
+            "/0/private/Ledgers",
+            &[
+                ("asset", "asset"),
+                ("type", "type"),
+                ("start", "start"),
+                ("end", "end_time"),
+                ("ofs", "ofs"),
+            ],
+        ),
+        "get_withdraw_addresses" => (
+            Post,
+            "/0/private/WithdrawAddresses",
+            &[("asset", "asset"), ("method", "method")],
+        ),
+        "get_withdraw_methods" => (Post, "/0/private/WithdrawMethods", &[("asset", "asset")]),
+        "withdraw" => (
+            Post,
+            "/0/private/Withdraw",
+            &[
+                ("asset", "asset"),
+                ("key", "key"),
+                ("amount", "amount"),
+                ("address", "address"),
+            ],
+        ),
+        "get_earn_allocations" => (
+            Post,
+            "/0/private/Earn/Allocations",
+            &[
+                ("ascending", "ascending"),
+                ("converted_asset", "converted_asset"),
+                ("hide_zero_allocations", "hide_zero_allocations"),
+            ],
+        ),
+        _ => return None,
+    })
+}
+
+pub fn build(
+    op: &str,
+    params: &BTreeMap<String, Param>,
+    creds: Option<&Credentials>,
+) -> Result<Built, String> {
+    let (method, path, fields) = layout(op).ok_or_else(|| format!("unknown Kraken op {op}"))?;
+    let mut pairs = Vec::new();
+    for (wire, name) in fields {
+        match params.get(*name) {
+            None => {}
+            Some(Param::Many(v)) if *name == "oflags" => {
+                if !v.is_empty() {
+                    pairs.push((wire.to_string(), v.join(",")));
+                }
+            }
+            Some(Param::Many(v)) => pairs.extend(v.iter().map(|s| (wire.to_string(), s.clone()))),
+            Some(Param::One(s)) => pairs.push((wire.to_string(), s.clone())),
+        }
+    }
+    Ok(match method {
+        Method::Get => Built {
+            method,
+            path,
+            pairs,
+            body: None,
+            headers: public_headers(),
+        },
+        Method::Post => {
+            pairs.insert(
+                0,
+                (
+                    "nonce".into(),
+                    next_nonce(creds.map(|c| c.api_key.as_str())).to_string(),
+                ),
+            );
+            let body = www_form(&pairs);
+            let headers = private_headers(path, &body, creds);
+            Built {
+                method,
+                path,
+                pairs,
+                body: Some(body),
+                headers,
+            }
+        }
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn build_repeats_keys_in_wire_order_after_nonce() {
+        let params = BTreeMap::from([
+            ("consolidate_taker".into(), Param::One("false".into())),
+            ("txid".into(), Param::Many(vec!["O1".into(), "O2".into()])),
+            ("userref".into(), Param::One("7".into())),
+            ("trades".into(), Param::One("true".into())),
+        ]);
+        let built = build("query_orders_info", &params, None).unwrap();
+        assert_eq!(built.method, Method::Post);
+        assert_eq!(built.path, "/0/private/QueryOrders");
+        assert_eq!(built.pairs[0].0, "nonce");
+        assert!(built.pairs[0].1.parse::<u64>().unwrap() > 0);
+        assert_eq!(
+            built.pairs[1..],
+            [
+                ("trades", "true"),
+                ("userref", "7"),
+                ("txid", "O1"),
+                ("txid", "O2"),
+                ("consolidate_taker", "false")
+            ]
+            .map(|(k, v)| (k.to_string(), v.to_string()))
+        );
+        assert_eq!(
+            built.body.unwrap(),
+            format!(
+                "nonce={}&trades=true&userref=7&txid=O1&txid=O2&consolidate_taker=false",
+                built.pairs[0].1
+            )
+        );
+    }
+
+    #[test]
+    fn build_joins_oflags_and_omits_empty_arrays() {
+        let mut params = BTreeMap::from([(
+            "oflags".into(),
+            Param::Many(vec!["viqc".into(), "fciq".into()]),
+        )]);
+        let built = build("add_order", &params, None).unwrap();
+        assert_eq!(built.pairs[1..], [("oflags".into(), "viqc,fciq".into())]);
+        params.insert("oflags".into(), Param::Many(vec![]));
+        assert_eq!(build("add_order", &params, None).unwrap().pairs.len(), 1);
+        params.insert("txid".into(), Param::Many(vec![]));
+        assert_eq!(
+            build("query_orders_info", &params, None)
+                .unwrap()
+                .pairs
+                .len(),
+            1
+        );
+    }
+}

data/crates/honeymaker/src/kraken/sign.rs

@@ -0,0 +1,166 @@
+use crate::encode::ruby_decode64;
+use base64::Engine;
+use hmac::{Hmac, Mac};
+use sha2::{Digest, Sha256, Sha512};
+use std::collections::HashMap;
+use std::sync::Mutex;
+
+#[derive(Clone)]
+pub struct Credentials {
+    pub api_key: String,
+    pub api_secret: String,
+}
+
+/// The secret never reaches a log or a panic message.
+impl std::fmt::Debug for Credentials {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Credentials")
+            .field("api_key", &self.api_key)
+            .field("api_secret", &"<redacted>")
+            .finish()
+    }
+}
+
+impl Credentials {
+    pub fn authenticated(&self) -> bool {
+        !self.api_key.is_empty() && !self.api_secret.is_empty()
+    }
+}
+
+// Kraken rejects a nonce <= the last it saw per API key: µs clock, max(now, last + 1), per key.
+// Cross-process reuse of a key is not protected, as in the legacy gem. The binding calls this
+// with the GVL held, so a fork never finds these mutexes locked.
+static NONCES: Mutex<Option<HashMap<[u8; 32], u64>>> = Mutex::new(None);
+static FIXED: Mutex<Option<u64>> = Mutex::new(None);
+
+pub fn next_nonce(api_key: Option<&str>) -> u64 {
+    if let Some(n) = *FIXED.lock().unwrap_or_else(|p| p.into_inner()) {
+        return n;
+    }
+    let key: [u8; 32] = Sha256::digest(api_key.unwrap_or("\0__no_api_key__").as_bytes()).into();
+    let now = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_micros() as u64;
+    let mut g = NONCES.lock().unwrap_or_else(|p| p.into_inner());
+    let map = g.get_or_insert_with(HashMap::new);
+    let next = now.max(map.get(&key).copied().unwrap_or(0) + 1);
+    map.insert(key, next);
+    next
+}
+
+/// Test hook: every nonce is `n` until reset to None.
+pub fn set_fixed_nonce(n: Option<u64>) {
+    *FIXED.lock().unwrap_or_else(|p| p.into_inner()) = n;
+}
+
+pub fn reset_nonces() {
+    *NONCES.lock().unwrap_or_else(|p| p.into_inner()) = None;
+}
+
+pub fn public_headers() -> Vec<(String, String)> {
+    vec![
+        ("Accept".into(), "application/json".into()),
+        ("Content-Type".into(), "application/json".into()),
+        ("User-Agent".into(), "Honeymaker Ruby".into()),
+    ]
+}
+
+/// Legacy: nonce taken back out of the body; message = path + SHA256(nonce + body);
+/// key = Base64.decode64(secret); HMAC-SHA512; strict Base64.
+pub fn private_headers(
+    path: &str,
+    body: &str,
+    creds: Option<&Credentials>,
+) -> Vec<(String, String)> {
+    let Some(c) = creds.filter(|c| c.authenticated()) else {
+        return public_headers();
+    };
+    let nonce = body
+        .split('&')
+        .find_map(|kv| kv.strip_prefix("nonce="))
+        .unwrap_or("");
+    let mut data = nonce.as_bytes().to_vec();
+    data.extend_from_slice(body.as_bytes());
+    let mut message = path.as_bytes().to_vec();
+    message.extend_from_slice(&Sha256::digest(&data));
+    let mut mac = Hmac::<Sha512>::new_from_slice(&ruby_decode64(c.api_secret.as_bytes()))
+        .expect("HMAC takes any key length");
+    mac.update(&message);
+    let sign = base64::engine::general_purpose::STANDARD.encode(mac.finalize().into_bytes());
+    vec![
+        ("API-Key".into(), c.api_key.clone()),
+        ("API-Sign".into(), sign),
+        ("Accept".into(), "application/json".into()),
+        (
+            "Content-Type".into(),
+            "application/x-www-form-urlencoded".into(),
+        ),
+        ("User-Agent".into(), "Honeymaker Ruby".into()),
+    ]
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // FIXED affects every key, so all nonce tests hold this guard until both stores are reset.
+    static TEST_LOCK: Mutex<()> = Mutex::new(());
+    struct NonceState {
+        _guard: std::sync::MutexGuard<'static, ()>,
+    }
+    impl NonceState {
+        fn new() -> Self {
+            let guard = TEST_LOCK.lock().unwrap_or_else(|p| p.into_inner());
+            set_fixed_nonce(None);
+            reset_nonces();
+            Self { _guard: guard }
+        }
+    }
+    impl Drop for NonceState {
+        fn drop(&mut self) {
+            set_fixed_nonce(None);
+            reset_nonces();
+        }
+    }
+
+    #[test]
+    fn ten_thousand_nonces_are_strictly_increasing() {
+        let _state = NonceState::new();
+        let mut last = next_nonce(Some("monotonic"));
+        for _ in 1..10_000 {
+            let next = next_nonce(Some("monotonic"));
+            assert!(next > last, "{next} <= {last}");
+            last = next;
+        }
+    }
+
+    #[test]
+    fn keys_have_independent_nonce_sequences() {
+        let _state = NonceState::new();
+        let future = u64::MAX - 10_000;
+        let key: [u8; 32] = Sha256::digest(b"key-a").into();
+        NONCES
+            .lock()
+            .unwrap()
+            .get_or_insert_with(HashMap::new)
+            .insert(key, future);
+        assert_eq!(next_nonce(Some("key-a")), future + 1);
+        let b = next_nonce(Some("key-b"));
+        assert!(b < future, "key-a must not advance key-b");
+        assert_eq!(next_nonce(Some("key-a")), future + 2);
+        assert!(next_nonce(Some("key-b")) > b);
+    }
+
+    #[test]
+    fn fixed_nonce_is_returned_until_cleared() {
+        let _state = NonceState::new();
+        set_fixed_nonce(Some(42));
+        for key in [Some("key-a"), Some("key-b"), None] {
+            assert_eq!(next_nonce(key), 42);
+            assert_eq!(next_nonce(key), 42);
+        }
+        set_fixed_nonce(None);
+        assert!(next_nonce(Some("key-a")) > 42);
+    }
+}

data/crates/honeymaker/src/kraken/trades.rs

@@ -0,0 +1,201 @@
+use super::normalize::{dec, order_type};
+use crate::OrderType;
+use crate::num::{NormError, Num};
+use serde_json::Value;
+
+pub struct TradeAggregate<D> {
+    pub side: Option<Value>, // first["type"]&.to_sym (not downcased)
+    pub order_type: OrderType,
+    pub vol: D,
+    pub cost: D,
+    pub fee: D,
+    pub price: Option<D>, // vol.zero? ? nil : cost / vol
+}
+
+/// Per-order executed aggregate over its (non-empty) trades, as legacy `aggregate_trades`.
+pub fn aggregate<D: Num>(trades: &[Value]) -> Result<TradeAggregate<D>, NormError<D::Error>> {
+    let first = trades.first().ok_or("no trades")?;
+    let first = first.as_object().ok_or_else(|| format!("trade: {first}"))?;
+    // Array#sum starts from Integer 0: 0 + BigDecimal("-0") is +0.0, so start from "0" too.
+    let sum = |f: &str| -> Result<D, NormError<D::Error>> {
+        let mut acc = D::parse("0").map_err(NormError::Num)?;
+        for t in trades {
+            acc = acc.add(&dec(t.get(f))?).map_err(NormError::Num)?;
+        }
+        Ok(acc)
+    };
+    let (vol, cost, fee) = (sum("vol")?, sum("cost")?, sum("fee")?);
+    let price = if vol.is_zero().map_err(NormError::Num)? {
+        None
+    } else {
+        Some(cost.div(&vol).map_err(NormError::Num)?)
+    };
+    let side = match first.get("type") {
+        None | Some(Value::Null) => None,
+        Some(v) if crate::semantics::is_string(v) => {
+            Some(D::string_op(v, crate::semantics::StringOp::Symbol).map_err(NormError::Num)?)
+        }
+        Some(other) => return Err(format!("type.to_sym: {other}").into()), // false/1 have no to_sym
+    };
+    Ok(TradeAggregate {
+        side,
+        order_type: order_type(first.get("ordertype")),
+        vol,
+        cost,
+        fee,
+        price,
+    })
+}
+
+use super::requests::Param;
+use crate::semantics::truthy;
+use std::collections::{BTreeMap, HashSet};
+
+pub enum TradesStep<D> {
+    Call(BTreeMap<String, Param>),
+    Done(Vec<(Value, TradeAggregate<D>)>),
+    Venue(Vec<Value>),
+    Unreadable,
+    /// The scan could not be completed; never a partial answer.
+    Incomplete(String),
+}
+
+/// Honeymaker::Clients::Kraken#closed_orders_from_trades for Rust callers, made strict: it completes
+/// (the distinct trades read reach Kraken's count) or it fails. Containers and records must have
+/// Kraken's shape; where Ruby would stop early, trust a malformed container or skip a malformed
+/// record and return what it had, this returns `Incomplete` or a shape error. The gem keeps its
+/// own loop.
+pub struct TradesPager {
+    wanted: Vec<String>,
+    start: Option<i64>,
+    max_pages: u32,
+    offset: u64,
+    /// The largest `count` any page reported: the bar for completeness (R22).
+    count: u64,
+    pages: u32,
+    seen: HashSet<String>,
+    by_order: Vec<(Value, Vec<Value>)>,
+}
+
+impl TradesPager {
+    pub fn new(order_ids: Vec<String>, start: Option<i64>, max_pages: u32) -> Self {
+        Self {
+            wanted: order_ids,
+            start,
+            max_pages,
+            offset: 0,
+            count: 0,
+            pages: 0,
+            seen: HashSet::new(),
+            by_order: Vec::new(),
+        }
+    }
+
+    /// No wanted ids: nothing to ask (legacy's `return Result::Success.new({}) if wanted.empty?`).
+    pub fn start<D: Num>(&mut self) -> Result<TradesStep<D>, NormError<D::Error>> {
+        if self.wanted.is_empty() {
+            return Ok(TradesStep::Done(Vec::new()));
+        }
+        Ok(TradesStep::Call(self.params()))
+    }
+
+    fn params(&self) -> BTreeMap<String, Param> {
+        let mut p = BTreeMap::from([("ofs".to_string(), Param::One(self.offset.to_string()))]);
+        if let Some(s) = self.start {
+            p.insert("start".to_string(), Param::One(s.to_string()));
+        }
+        p
+    }
+
+    fn done<D: Num>(&mut self) -> Result<TradesStep<D>, NormError<D::Error>> {
+        std::mem::take(&mut self.by_order)
+            .into_iter()
+            .map(|(k, trades)| Ok((k, aggregate::<D>(&trades)?)))
+            .collect::<Result<Vec<_>, _>>()
+            .map(TradesStep::Done)
+    }
+
+    pub fn feed<D: Num>(&mut self, data: &Value) -> Result<TradesStep<D>, NormError<D::Error>> {
+        let Some(obj) = data.as_object() else {
+            return Ok(TradesStep::Unreadable);
+        };
+        if let Some(Value::Array(e)) = obj.get("error")
+            && e.iter().any(|x| truthy(Some(x)))
+        {
+            return Ok(TradesStep::Venue(e.clone()));
+        }
+        // dig("result", "trades") raises unless result is nil or a Hash; nil is an unreadable page here.
+        let result = match obj.get("result") {
+            None | Some(Value::Null) => {
+                return Ok(TradesStep::Incomplete(
+                    "TradesHistory answered without a result".into(),
+                ));
+            }
+            Some(Value::Object(m)) => m,
+            Some(other) => return Err(format!("undefined method 'dig' for {other}").into()),
+        };
+        let count = result.get("count").and_then(Value::as_u64);
+        let trades = match result.get("trades") {
+            Some(Value::Object(m)) => m,
+            other => {
+                return Ok(TradesStep::Incomplete(format!(
+                    "TradesHistory trades is not an object: {other:?}"
+                )));
+            }
+        };
+        // Every record must be an order's trade before any is filtered out: a malformed one is an
+        // error, never a skipped row.
+        let mut rows = Vec::with_capacity(trades.len());
+        for (id, t) in trades {
+            match t.get("ordertxid") {
+                Some(Value::String(o)) if t.is_object() => rows.push((id, o.clone(), t)),
+                _ => return Err(format!("trade {id} is not a Kraken trade: {t}").into()),
+            }
+        }
+        for (id, otxid, t) in rows {
+            // Offset paging can serve a trade twice (review ruling 3): count it once.
+            if !self.seen.insert(id.clone()) {
+                continue;
+            }
+            if self.wanted.contains(&otxid) {
+                let key = Value::String(otxid);
+                match self.by_order.iter_mut().find(|(k, _)| *k == key) {
+                    Some((_, v)) => v.push(t.clone()),
+                    None => self.by_order.push((key, vec![t.clone()])),
+                }
+            }
+        }
+        let Some(page_count) = count else {
+            return Ok(TradesStep::Incomplete(format!(
+                "TradesHistory count unreadable: {:?}",
+                result.get("count")
+            )));
+        };
+        // Held to the largest count seen: a shrinking count never lowers the bar (R22).
+        self.count = self.count.max(page_count);
+        let count = self.count;
+        let distinct = self.seen.len() as u64;
+        if distinct >= count {
+            return self.done();
+        }
+        if trades.is_empty() {
+            return Ok(TradesStep::Incomplete(format!(
+                "TradesHistory ended after {distinct} of {count} trades"
+            )));
+        }
+        self.pages += 1;
+        self.offset += trades.len() as u64; // raw rows: the position in Kraken's list
+        if self.offset >= count {
+            return Ok(TradesStep::Incomplete(format!(
+                "TradesHistory served {count} rows but only {distinct} distinct trades"
+            )));
+        }
+        if self.pages >= self.max_pages {
+            return Ok(TradesStep::Incomplete(format!(
+                "more than {} TradesHistory pages",
+                self.max_pages
+            )));
+        }
+        Ok(TradesStep::Call(self.params()))
+    }
+}

data/crates/honeymaker/src/lib.rs

@@ -0,0 +1,10 @@
+//! Unified clients for cryptocurrency exchange APIs: request builders, signing, normalizers.
+//! No Ruby and no I/O. The honeymaker gem wraps it; deltabadger-rs will use it directly.
+
+pub mod encode;
+pub mod kraken;
+pub mod num;
+pub mod semantics;
+pub mod types;
+
+pub use types::{Balance, Order, OrderId, OrderStatus, OrderType, Side};