honeymaker 0.12.2 → 0.12.4

data/crates/honeymaker/tests/kraken_trades_pager.rs

@@ -0,0 +1,307 @@
+//! The strict Rust scan against the gem's Ruby loop (script/vectors/kraken_stage2.rb, part B).
+//! "same": identical requests and the same end (aggregates, refusal, unreadable, or an exception,
+//! which is a shape error here). "incomplete" / "error": Ruby returned a partial answer, or skipped a
+//! malformed record; Rust must end Incomplete / with a shape error, having made no request Ruby
+//! did not make.
+use bigdecimal::BigDecimal;
+use honeymaker::kraken::requests::Param;
+use honeymaker::kraken::trades::{TradesPager, TradesStep};
+use serde_json::{Value, json};
+use std::collections::{BTreeMap, VecDeque};
+use std::str::FromStr;
+
+fn load() -> Value {
+    serde_json::from_str(
+        &std::fs::read_to_string(format!(
+            "{}/tests/vectors/kraken_trades_pager.json",
+            env!("CARGO_MANIFEST_DIR")
+        ))
+        .unwrap(),
+    )
+    .unwrap()
+}
+fn int(p: &BTreeMap<String, Param>, k: &str) -> Value {
+    match p.get(k) {
+        Some(Param::One(s)) => json!(s.parse::<i64>().unwrap()),
+        _ => Value::Null,
+    }
+}
+fn dec(v: &Value) -> BigDecimal {
+    BigDecimal::from_str(v.as_str().unwrap()).unwrap()
+}
+
+/// Runs the pager over the pages; returns the (start, ofs) of each request and how it ended.
+fn scan(
+    ids: Vec<String>,
+    start: Option<i64>,
+    max_pages: u32,
+    pages: Vec<Value>,
+) -> (Vec<Value>, Value) {
+    let mut pages: VecDeque<Value> = pages.into();
+    let mut pager = TradesPager::new(ids, start, max_pages);
+    let mut requests = vec![];
+    let mut step = pager.start::<BigDecimal>();
+    let end = loop {
+        match step {
+            Err(_) => break json!({ "raise": true }),
+            Ok(TradesStep::Call(p)) => {
+                assert!(
+                    !p.contains_key("end_time"),
+                    "no `end`: it would filter out fills on clock skew (R22)"
+                );
+                requests.push(json!([int(&p, "start"), int(&p, "ofs")]));
+                step = pager.feed::<BigDecimal>(&pages.pop_front().unwrap_or(Value::Null)); // legacy: queue.shift || "null"
+            }
+            Ok(TradesStep::Done(v)) => {
+                break json!({ "done": v.iter().map(|(t, a)| json!({
+                "txid": t, "vol": a.vol.to_string(), "cost": a.cost.to_string(), "fee": a.fee.to_string(),
+                "price": a.price.as_ref().map(|p| p.to_string()), "side": a.side, "order_type": a.order_type.as_str() })).collect::<Vec<_>>() });
+            }
+            Ok(TradesStep::Venue(e)) => break json!({ "venue": e }),
+            Ok(TradesStep::Unreadable) => break json!({ "unreadable": true }),
+            Ok(TradesStep::Incomplete(_)) => break json!({ "incomplete": true }),
+        }
+    };
+    (requests, end)
+}
+
+#[test]
+fn the_strict_scan_matches_the_ruby_loop_or_refuses_its_partial_answers() {
+    for case in load().as_array().unwrap() {
+        let name = case["name"].as_str().unwrap();
+        let ids = case["order_ids"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .map(|v| v.as_str().unwrap().to_string())
+            .collect();
+        let pages = case["pages"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .map(|t| serde_json::from_str(t.as_str().unwrap()).unwrap())
+            .collect();
+        let (requests, outcome) = scan(
+            ids,
+            case["start"].as_i64(),
+            case["max_pages"].as_u64().unwrap() as u32,
+            pages,
+        );
+        let ruby_requests = case["requests"].as_array().unwrap();
+        let refused = match case["strict"].as_str().unwrap() {
+            "incomplete" => Some(json!({ "incomplete": true })),
+            "error" => Some(json!({ "raise": true })),
+            _ => None,
+        };
+        if let Some(want) = refused {
+            assert_eq!(
+                outcome, want,
+                "{name}: Ruby's answer is partial or skipped a malformed record; Rust must fail"
+            );
+            assert!(
+                requests.len() <= ruby_requests.len()
+                    && requests[..] == ruby_requests[..requests.len()],
+                "{name}: a prefix of Ruby's requests"
+            );
+            continue;
+        }
+        assert_eq!(
+            &Value::Array(requests),
+            &case["requests"],
+            "{name}: requests"
+        );
+        let want = &case["outcome"];
+        if want.get("raise").is_some() {
+            assert_eq!(
+                outcome,
+                json!({ "raise": true }),
+                "{name}: Ruby raised {}",
+                want["raise"]
+            );
+        } else if let Some(ok) = want.get("ok") {
+            let got = outcome["done"]
+                .as_array()
+                .unwrap_or_else(|| panic!("{name}: {outcome}"));
+            assert_eq!(got.len(), ok.as_array().unwrap().len(), "{name}");
+            for (g, w) in got.iter().zip(ok.as_array().unwrap()) {
+                let (txid, w) = (&w[0], &w[1]);
+                assert_eq!(&g["txid"], txid, "{name}: order of first appearance");
+                for k in ["vol", "cost", "fee"] {
+                    assert_eq!(dec(&g[k]), dec(&w[k]), "{name}: {k}");
+                }
+                match (&w["price"], &g["price"]) {
+                    (Value::Null, Value::Null) => {}
+                    (r, g) if !g.is_null() => assert_eq!(dec(g), dec(r), "{name}: price"),
+                    other => panic!("{name}: price {other:?}"),
+                }
+                assert_eq!(
+                    (&g["side"], &g["order_type"]),
+                    (&w["side"], &w["order_type"]),
+                    "{name}"
+                );
+            }
+        } else {
+            assert_eq!(&outcome, want, "{name}");
+        }
+    }
+}
+
+fn page(trades: Value, count: u64) -> Value {
+    json!({ "error": [], "result": { "trades": trades, "count": count } })
+}
+fn t(o: &str, vol: &str, cost: &str) -> Value {
+    json!({ "ordertxid": o, "vol": vol, "cost": cost, "fee": "0.1", "type": "buy", "ordertype": "market" })
+}
+
+#[test]
+fn a_fill_beyond_the_cap_is_an_error() {
+    let (requests, end) = scan(
+        vec!["O1".into()],
+        Some(1),
+        2,
+        vec![
+            page(json!({ "T1": t("O9", "1", "1") }), 3),
+            page(json!({ "T2": t("O9", "1", "1") }), 3),
+            page(json!({ "T3": t("O1", "1", "1") }), 3),
+        ],
+    );
+    assert_eq!(
+        (requests.len(), end),
+        (2, json!({ "incomplete": true })),
+        "never Ok([]) with O1's fill unread"
+    );
+}
+
+#[test]
+fn a_trade_on_two_pages_counts_once_and_completion_needs_every_distinct_trade() {
+    let (_, end) = scan(
+        vec!["O1".into()],
+        Some(1),
+        20,
+        vec![
+            page(
+                json!({ "T1": t("O1", "1", "2"), "T2": t("O1", "3", "9") }),
+                3,
+            ),
+            page(
+                json!({ "T2": t("O1", "3", "9"), "T3": t("O1", "1", "1") }),
+                3,
+            ),
+        ],
+    );
+    let o1 = &end["done"][0];
+    assert_eq!(
+        (dec(&o1["vol"]), dec(&o1["cost"]), dec(&o1["fee"])),
+        (dec(&json!("5")), dec(&json!("12")), dec(&json!("0.3")))
+    );
+    // Rows served reach count 3, but only two distinct trades were seen: never Done.
+    let (_, end) = scan(
+        vec!["O1".into()],
+        Some(1),
+        20,
+        vec![
+            page(
+                json!({ "T1": t("O1", "1", "2"), "T2": t("O1", "3", "9") }),
+                3,
+            ),
+            page(json!({ "T2": t("O1", "3", "9") }), 3),
+        ],
+    );
+    assert_eq!(end, json!({ "incomplete": true }));
+}
+
+#[test]
+fn trades_arriving_mid_scan_fail_closed() {
+    // A new trade lands at the top after page 1: rows shift, T2 is served again, count grows to 4,
+    // and the newcomer is never read. Never Done with a fill possibly missing.
+    let (requests, end) = scan(
+        vec!["O1".into()],
+        Some(1),
+        20,
+        vec![
+            page(
+                json!({ "T1": t("O1", "1", "2"), "T2": t("O1", "1", "2") }),
+                3,
+            ),
+            page(
+                json!({ "T2": t("O1", "1", "2"), "T3": t("O1", "1", "2") }),
+                4,
+            ),
+        ],
+    );
+    assert_eq!((requests.len(), end), (2, json!({ "incomplete": true })));
+    // A count that shrinks between pages never lowers the bar.
+    let (_, end) = scan(
+        vec!["O1".into()],
+        Some(1),
+        20,
+        vec![
+            page(
+                json!({ "T1": t("O1", "1", "2"), "T2": t("O1", "1", "2") }),
+                4,
+            ),
+            page(json!({ "T3": t("O1", "1", "2") }), 3),
+            page(json!({}), 3),
+        ],
+    );
+    assert_eq!(
+        end,
+        json!({ "incomplete": true }),
+        "3 distinct trades against the 4 first reported"
+    );
+}
+
+#[test]
+fn malformed_fills_data_is_never_an_empty_answer() {
+    for trades in [
+        json!(null),
+        json!(false),
+        json!([]),
+        json!(""),
+        json!("x"),
+        json!([1]),
+    ] {
+        let (_, end) = scan(
+            vec!["O1".into()],
+            Some(1),
+            20,
+            vec![page(trades.clone(), 0)],
+        );
+        assert_eq!(
+            end,
+            json!({ "incomplete": true }),
+            "trades {trades} with count 0"
+        );
+    }
+    let (_, end) = scan(
+        vec!["O1".into()],
+        Some(1),
+        20,
+        vec![json!({ "error": [], "result": { "count": 0 } })],
+    );
+    assert_eq!(
+        end,
+        json!({ "incomplete": true }),
+        "trades missing with count 0"
+    );
+    for record in [
+        json!("broken"),
+        json!(5),
+        json!(null),
+        json!({ "vol": "1" }),
+        json!({ "ordertxid": 5 }),
+        json!({ "ordertxid": null }),
+    ] {
+        let (_, end) = scan(
+            vec!["O1".into()],
+            Some(1),
+            20,
+            vec![page(json!({ "T1": record.clone() }), 1)],
+        );
+        assert_eq!(
+            end,
+            json!({ "raise": true }),
+            "record {record}: an error, never skipped"
+        );
+    }
+}

data/crates/honeymaker/tests/kraken_vectors.rs

@@ -0,0 +1,78 @@
+use bigdecimal::BigDecimal;
+use honeymaker::encode::{ruby_decode64, www_form};
+use honeymaker::kraken::sign::{Credentials, private_headers};
+use honeymaker::num::Num;
+use serde_json::Value;
+use std::str::FromStr;
+
+fn load(name: &str) -> Value {
+    serde_json::from_str(
+        &std::fs::read_to_string(format!(
+            "{}/tests/vectors/{name}",
+            env!("CARGO_MANIFEST_DIR")
+        ))
+        .unwrap(),
+    )
+    .unwrap()
+}
+
+fn pairs(v: &Value) -> Vec<(String, String)> {
+    v.as_array()
+        .unwrap()
+        .iter()
+        .map(|p| {
+            (
+                p[0].as_str().unwrap().to_string(),
+                p[1].as_str().unwrap().to_string(),
+            )
+        })
+        .collect()
+}
+
+#[test]
+fn signing_is_byte_identical_to_legacy() {
+    for case in load("kraken_signing.json").as_array().unwrap() {
+        let body = www_form(&pairs(&case["pairs"]));
+        assert_eq!(body, case["body"].as_str().unwrap(), "body");
+        let secret = case["api_secret"].as_str().unwrap();
+        let hex: String = ruby_decode64(secret.as_bytes())
+            .iter()
+            .map(|b| format!("{b:02x}"))
+            .collect();
+        assert_eq!(
+            hex,
+            case["decoded_secret_hex"].as_str().unwrap(),
+            "decode64({secret:?})"
+        );
+        let creds = Credentials {
+            api_key: case["api_key"].as_str().unwrap().into(),
+            api_secret: secret.into(),
+        };
+        let mut got = private_headers(case["path"].as_str().unwrap(), &body, Some(&creds));
+        got.sort();
+        let mut want: Vec<(String, String)> = case["headers"]
+            .as_object()
+            .unwrap()
+            .iter()
+            .map(|(k, v)| (k.clone(), v.as_str().unwrap().to_string()))
+            .collect();
+        want.sort();
+        assert_eq!(got, want, "headers for {case}");
+    }
+}
+
+#[test]
+fn rust_decimal_impl_agrees_with_ruby_on_finite_values() {
+    for case in load("decimal.json").as_array().unwrap() {
+        let got = <BigDecimal as Num>::parse(case["input"].as_str().unwrap());
+        if !case["ok"].as_bool().unwrap() {
+            assert!(got.is_err(), "{case} must not parse");
+        } else if case["finite"].as_bool().unwrap() {
+            assert_eq!(
+                got.unwrap(),
+                BigDecimal::from_str(case["plain"].as_str().unwrap()).unwrap(),
+                "{case}"
+            );
+        }
+    }
+}

data/crates/honeymaker/tests/vectors/decimal.json

@@ -0,0 +1,146 @@
+[
+  {
+    "input": "0.5",
+    "ok": true,
+    "finite": true,
+    "plain": "0.5",
+    "sign": 2
+  },
+  {
+    "input": "1",
+    "ok": true,
+    "finite": true,
+    "plain": "1.0",
+    "sign": 2
+  },
+  {
+    "input": "-0",
+    "ok": true,
+    "finite": true,
+    "plain": "-0.0",
+    "sign": -1
+  },
+  {
+    "input": "-0.0000",
+    "ok": true,
+    "finite": true,
+    "plain": "-0.0",
+    "sign": -1
+  },
+  {
+    "input": "0.0000000001",
+    "ok": true,
+    "finite": true,
+    "plain": "0.0000000001",
+    "sign": 2
+  },
+  {
+    "input": "123456789012345678901234567890.123456789",
+    "ok": true,
+    "finite": true,
+    "plain": "123456789012345678901234567890.123456789",
+    "sign": 2
+  },
+  {
+    "input": "1e-9",
+    "ok": true,
+    "finite": true,
+    "plain": "0.000000001",
+    "sign": 2
+  },
+  {
+    "input": "1E5",
+    "ok": true,
+    "finite": true,
+    "plain": "100000.0",
+    "sign": 2
+  },
+  {
+    "input": " 1.5 ",
+    "ok": true,
+    "finite": true,
+    "plain": "1.5",
+    "sign": 2
+  },
+  {
+    "input": "1_000.5",
+    "ok": true,
+    "finite": true,
+    "plain": "1000.5",
+    "sign": 2
+  },
+  {
+    "input": ".5",
+    "ok": true,
+    "finite": true,
+    "plain": "0.5",
+    "sign": 2
+  },
+  {
+    "input": "5.",
+    "ok": true,
+    "finite": true,
+    "plain": "5.0",
+    "sign": 2
+  },
+  {
+    "input": "+2",
+    "ok": true,
+    "finite": true,
+    "plain": "2.0",
+    "sign": 2
+  },
+  {
+    "input": "",
+    "ok": false,
+    "error": "invalid value for BigDecimal(): \"\""
+  },
+  {
+    "input": "abc",
+    "ok": false,
+    "error": "invalid value for BigDecimal(): \"abc\""
+  },
+  {
+    "input": "1,5",
+    "ok": false,
+    "error": "invalid value for BigDecimal(): \"1,5\""
+  },
+  {
+    "input": "0x10",
+    "ok": false,
+    "error": "invalid value for BigDecimal(): \"0x10\""
+  },
+  {
+    "input": "NaN",
+    "ok": true,
+    "finite": false,
+    "plain": "NaN",
+    "sign": 0
+  },
+  {
+    "input": "Infinity",
+    "ok": true,
+    "finite": false,
+    "plain": "Infinity",
+    "sign": 3
+  },
+  {
+    "input": "-Infinity",
+    "ok": true,
+    "finite": false,
+    "plain": "-Infinity",
+    "sign": -3
+  },
+  {
+    "input": "1d2",
+    "ok": true,
+    "finite": true,
+    "plain": "100.0",
+    "sign": 2
+  },
+  {
+    "input": "true",
+    "ok": false,
+    "error": "invalid value for BigDecimal(): \"true\""
+  }
+]

data/crates/honeymaker/tests/vectors/kraken_add_order_wire.json

@@ -0,0 +1,74 @@
+[
+  {
+    "args": {
+      "ordertype": "market",
+      "type": "buy",
+      "volume": "0.0012",
+      "pair": "XBTEUR",
+      "oflags": [
+        "viqc"
+      ],
+      "cl_ord_id": "6f1c1a52-7c8e-4d0e-9a57-0b6f0f1d2e3a",
+      "deadline": "2026-09-30T12:00:10.000Z"
+    },
+    "nonce": 1727000000000001,
+    "api_key": "key",
+    "api_secret": "dGVzdF9zZWNyZXRfa2V5XzEyMzQ1Njc4OTAxMjM0NTY=",
+    "body": "nonce=1727000000000001&ordertype=market&type=buy&volume=0.0012&pair=XBTEUR&cl_ord_id=6f1c1a52-7c8e-4d0e-9a57-0b6f0f1d2e3a&oflags=viqc&deadline=2026-09-30T12%3A00%3A10.000Z",
+    "headers": {
+      "API-Key": "key",
+      "API-Sign": "WIj+HLMKiN3JisS0SDtgnfgkztRD9vRgVUoeuKogUr/BVsObdxT8KBIMJ87j9x6P5y0cdyrkcjIzm6F1LciAVA==",
+      "Accept": "application/json",
+      "Content-Type": "application/x-www-form-urlencoded",
+      "User-Agent": "Honeymaker Ruby"
+    }
+  },
+  {
+    "args": {
+      "ordertype": "limit",
+      "type": "buy",
+      "volume": "0.00119",
+      "pair": "XBTEUR",
+      "price": "49870.1",
+      "oflags": [],
+      "cl_ord_id": "0d9e2c1b-2f4a-4b8c-8d1e-5a6b7c8d9e0f",
+      "deadline": "2026-09-30T12:00:10.123Z"
+    },
+    "nonce": 1727000000000001,
+    "api_key": "key",
+    "api_secret": "dGVzdF9zZWNyZXRfa2V5XzEyMzQ1Njc4OTAxMjM0NTY=",
+    "body": "nonce=1727000000000001&ordertype=limit&type=buy&volume=0.00119&pair=XBTEUR&cl_ord_id=0d9e2c1b-2f4a-4b8c-8d1e-5a6b7c8d9e0f&price=49870.1&deadline=2026-09-30T12%3A00%3A10.123Z",
+    "headers": {
+      "API-Key": "key",
+      "API-Sign": "szaVyZ0WTnm6BQtuK3TWp6/52uxNxx6U3OCugNj5+pXBf8nPB7qf1dg9wpxWURUf962W+ikCiAv2zJqYijbnhg==",
+      "Accept": "application/json",
+      "Content-Type": "application/x-www-form-urlencoded",
+      "User-Agent": "Honeymaker Ruby"
+    }
+  },
+  {
+    "args": {
+      "ordertype": "market",
+      "type": "buy",
+      "volume": "60",
+      "pair": "XBTEUR",
+      "oflags": [
+        "viqc"
+      ],
+      "cl_ord_id": "6f1c1a52-7c8e-4d0e-9a57-0b6f0f1d2e3a",
+      "deadline": "2026-09-30T12:00:10.000Z",
+      "validate": true
+    },
+    "nonce": 1727000000000001,
+    "api_key": "key",
+    "api_secret": "dGVzdF9zZWNyZXRfa2V5XzEyMzQ1Njc4OTAxMjM0NTY=",
+    "body": "nonce=1727000000000001&ordertype=market&type=buy&volume=60&pair=XBTEUR&cl_ord_id=6f1c1a52-7c8e-4d0e-9a57-0b6f0f1d2e3a&oflags=viqc&deadline=2026-09-30T12%3A00%3A10.000Z&validate=true",
+    "headers": {
+      "API-Key": "key",
+      "API-Sign": "us2T6Ya8LlwwoSU6xZFflnv5yBe7Qvee7Dk4UoHLTRYzIZeDJ/mJo1Tm1Mm4hmnvW9wRuWSvaMD/XlLOei+A5g==",
+      "Accept": "application/json",
+      "Content-Type": "application/x-www-form-urlencoded",
+      "User-Agent": "Honeymaker Ruby"
+    }
+  }
+]