honeymaker 0.12.3 → 0.12.5

data/Cargo.toml

@@ -0,0 +1,14 @@
+[workspace]
+members = ["crates/honeymaker", "crates/honeymaker-client", "ext/honeymaker_native"]
+resolver = "3"
+
+[workspace.package]
+version = "0.12.5" # lockstep with lib/honeymaker/version.rb (test/native/lockstep_test.rb)
+edition = "2024"
+rust-version = "1.94"
+license = "MIT"
+repository = "https://github.com/deltabadger/honeymaker"
+
+[profile.release]
+lto = true
+codegen-units = 1

data/README.md

@@ -16,6 +16,45 @@ Binance, Binance US, Kraken, Kraken Futures, Coinbase, Bybit, KuCoin, Bitget, ME
 gem "honeymaker"
 ```
 
+## Native extension
+
+Prebuilt native gems support Ruby 3.4 and 4.0 on `x86_64-linux`, `aarch64-linux`,
+`x86_64-darwin`, `arm64-darwin`, and `x64-mingw-ucrt`. A source gem is also published.
+Building from source needs Rust 1.94; in a checkout, run `bundle install` followed by
+`bundle exec rake compile`.
+
+The Ruby backend remains the default. Set `HONEYMAKER_NATIVE=kraken` before requiring
+`honeymaker` to enable the Rust backend for Kraken. `HONEYMAKER_NATIVE` accepts a
+comma-separated list of exchange names; Kraken is currently the supported native backend.
+Other exchanges continue to use Ruby. Unset the variable to return to the Ruby backend.
+
+### Releases
+
+Run `bundle exec rake release` for a patch release, `bundle exec rake release:minor`
+for a minor release, or `bundle exec rake release:major` for a major release. The task
+bumps the gem and Cargo workspace versions together, updates both lockfiles, compiles,
+tests, commits the four version/lock files, and pushes the commit and a `v<version>` tag.
+`bundle exec rake _tag_release` resumes the push without another version bump.
+
+The tag triggers `.github/workflows/release.yml`, which calls the native-gem workflow
+to build and smoke-test all five platform gems and the source gem. Configure the
+GitHub `rubygems` environment with Jan as its required reviewer and configure RubyGems
+trusted publishing for this repository's `release.yml` workflow and `rubygems` environment.
+After Jan approves, CI publishes using trusted publishing, with platform gems first
+and the source gem last.
+
+Recovery:
+
+- **Publish failed partway:** open Actions → the same workflow run → **Re-run failed jobs**.
+  The artifacts are retained, and the push loop skips gems already published with an
+  identical checksum. It stops on any mismatch; never override that.
+- **Workflow cancelled or never finished building:** choose **Re-run all jobs** on the
+  tag's run. `gh workflow run` is not a substitute, because it isn't a tag-push event.
+- **Bump commit pushed but tag push failed:** run
+  `git tag -a v<version> -m v<version> && git push origin v<version>`.
+  `_tag_release` is a no-op once the tag exists locally. If the tag already exists locally,
+  retry just `git push origin v<version>`.
+
 ## Usage
 
 ### Market Data

data/Rakefile

@@ -1,15 +1,28 @@
 # frozen_string_literal: true
 
-require "bundler/gem_tasks"
 require "rake/testtask"
 
+if ENV["HONEYMAKER_RAKEFILE_LIB_ONLY"] != "1" && File.exist?(File.join(__dir__, "honeymaker.gemspec"))
+  require "bundler/gem_tasks"
+  require "rb_sys/extensiontask"
+
+  GEMSPEC = Gem::Specification.load(File.join(__dir__, "honeymaker.gemspec"))
+  RbSys::ExtensionTask.new("honeymaker_native", GEMSPEC) do |ext|
+    ext.lib_dir = "lib/honeymaker"
+    # Core-only edits must rebuild the extension too (the default pattern covers ext/ only).
+    ext.source_pattern = "{**/*,../../crates/honeymaker/**/*,../../Cargo}.{rs,toml,lock}"
+    ext.cross_compile = true
+    ext.cross_platform = %w[x86_64-linux aarch64-linux x86_64-darwin arm64-darwin x64-mingw-ucrt]
+  end
+end
+
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
   t.libs << "lib"
   t.test_files = FileList["test/**/*_test.rb"]
 end
 
-task default: :test
+task default: %i[compile test]
 
 VERSION_FILE = "lib/honeymaker/version.rb"
 
@@ -26,40 +39,39 @@ def bump_version(segment)
   end.join(".")
   content = File.read(VERSION_FILE)
   File.write(VERSION_FILE, content.sub(/VERSION = ".+"/, "VERSION = \"#{new_version}\""))
+  File.write("Cargo.toml", File.read("Cargo.toml").sub(/(\[workspace\.package\][^\[]*?^version = )"[^"]+"/m, "\\1\"#{new_version}\""))
   puts "Bumped version to #{new_version}"
 end
 
-# Bundler's `release` task is defined when this Rakefile loads — it captures
-# the gemspec version at that moment in `Bundler::GemHelper`. If we bump the
-# version mid-run (as a build prerequisite), the gem is published correctly
-# but the final "Pushed <gem> <ver>" log line still prints the old cached
-# version. Fix: bump first, then invoke bundler's release in a subprocess so
-# it re-reads the gemspec fresh.
-
-Rake::Task[:release].clear
+if ENV["HONEYMAKER_RAKEFILE_LIB_ONLY"] != "1" && File.exist?(File.join(__dir__, "honeymaker.gemspec"))
+  Rake::Task[:release].clear
+end
 
 def do_release(segment)
   bump_version(segment)
   sh "bundle install"
+  sh "cargo update --workspace --offline"
+  Rake::Task[:compile].invoke
   Rake::Task[:test].invoke
-  sh %(git add -A && git diff --cached --quiet || git commit -m "v#{current_version}")
-  sh "bundle exec rake _bundler_release"
+  sh %(git add #{VERSION_FILE} Cargo.toml Cargo.lock Gemfile.lock && git commit -m "v#{current_version}")
+  sh "bundle exec rake _tag_release"
 end
 
-task _bundler_release: %w[build release:guard_clean release:source_control_push release:rubygem_push]
+# Pushes the bump commit and the v* tag; .github/workflows/release.yml builds and publishes.
+task _tag_release: %w[release:guard_clean release:source_control_push]
 
-desc "Bump patch, run tests, push to rubygems"
+desc "Bump patch, compile, test, and push a release tag for CI"
 task :release do
   do_release(:patch)
 end
 
 namespace :release do
-  desc "Bump minor, run tests, push to rubygems"
+  desc "Bump minor, compile, test, and push a release tag for CI"
   task :minor do
     do_release(:minor)
   end
 
-  desc "Bump major, run tests, push to rubygems"
+  desc "Bump major, compile, test, and push a release tag for CI"
   task :major do
     do_release(:major)
   end

data/crates/honeymaker/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "honeymaker"
+description = "Unified clients for cryptocurrency exchange APIs"
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+repository.workspace = true
+publish = false # until deltabadger-rs consumes it (spec §2.6)
+
+[dependencies]
+base64 = "0.22"
+bigdecimal = "0.4"
+hmac = "0.12"
+regex = "1"
+serde_json = { version = "1", features = ["preserve_order", "arbitrary_precision"] }
+sha2 = "0.10"
+thiserror = "2"

data/crates/honeymaker/src/encode.rs

@@ -0,0 +1,106 @@
+//! The encoders the legacy Ruby used, byte for byte (tests/vectors).
+
+/// URI.encode_www_form: keep A-Z a-z 0-9 * - . _, space → +, everything else %XX (uppercase).
+pub fn www_form(pairs: &[(String, String)]) -> String {
+    fn enc(s: &str) -> String {
+        let mut o = String::with_capacity(s.len());
+        for &b in s.as_bytes() {
+            match b {
+                b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'*' | b'-' | b'.' | b'_' => {
+                    o.push(b as char)
+                }
+                b' ' => o.push('+'),
+                _ => o.push_str(&format!("%{b:02X}")),
+            }
+        }
+        o
+    }
+    pairs
+        .iter()
+        .map(|(k, v)| format!("{}={}", enc(k), enc(v)))
+        .collect::<Vec<_>>()
+        .join("&")
+}
+
+/// Base64.decode64 = String#unpack1("m"): a literal port of ruby/pack.c's lenient branch
+/// (skips bytes outside the alphabet; '=' in the third/fourth slot ends the input).
+pub fn ruby_decode64(input: &[u8]) -> Vec<u8> {
+    const T: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    let table = |c: u8| -> i32 {
+        T.iter()
+            .position(|&x| x == c)
+            .map(|p| p as i32)
+            .unwrap_or(-1)
+    };
+    let n = input.len();
+    let at = |i: usize| -> u8 { if i < n { input[i] } else { 0 } }; // C strings end in NUL
+    let mut out = Vec::with_capacity(n * 3 / 4 + 3);
+    let mut s = 0usize;
+    let (mut a, mut b, mut c): (i32, i32, i32) = (-1, -1, 0);
+    while s < n {
+        b = -1;
+        c = -1;
+        loop {
+            a = table(at(s));
+            if !(a == -1 && s < n) {
+                break;
+            }
+            s += 1;
+        }
+        if s >= n {
+            break;
+        }
+        s += 1;
+        loop {
+            b = table(at(s));
+            if !(b == -1 && s < n) {
+                break;
+            }
+            s += 1;
+        }
+        if s >= n {
+            break;
+        }
+        s += 1;
+        loop {
+            c = table(at(s));
+            if !(c == -1 && s < n) {
+                break;
+            }
+            if at(s) == b'=' {
+                break;
+            }
+            s += 1;
+        }
+        if at(s) == b'=' || s >= n {
+            break;
+        }
+        s += 1;
+        let mut d;
+        loop {
+            d = table(at(s));
+            if !(d == -1 && s < n) {
+                break;
+            }
+            if at(s) == b'=' {
+                break;
+            }
+            s += 1;
+        }
+        if at(s) == b'=' || s >= n {
+            break;
+        }
+        s += 1;
+        out.push(((a << 2) | (b >> 4)) as u8);
+        out.push(((b << 4) | (c >> 2)) as u8);
+        out.push(((c << 6) | d) as u8);
+        a = -1;
+    }
+    if a != -1 && b != -1 {
+        out.push(((a << 2) | (b >> 4)) as u8);
+        if c != -1 {
+            out.push(((b << 4) | (c >> 2)) as u8);
+        }
+    }
+    out
+}

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

@@ -0,0 +1,140 @@
+//! Find an order by client order id: OpenOrders, then every ClosedOrders page since `start`.
+//! `Absent` comes only from a complete scan; any other end is a refusal, an unreadable page or
+//! `Incomplete`, never a partial answer reported as complete.
+//!
+//! Why this order cannot miss an order placed before the scan began: if it is open when
+//! OpenOrders is read, it is found there. Otherwise it closed earlier and sits in the closed list,
+//! which is newest first, so orders closing during the scan only push it to a higher offset, onto a
+//! page not yet read. Paging can re-read an order; it cannot skip one. Because a re-read row is
+//! not coverage, absence needs the distinct ids read to reach Kraken's count.
+use super::normalize::{Finished, NormalizedOrder, listed_orders};
+use super::requests::Param;
+use crate::num::{NormError, Num};
+use crate::semantics::{self, string_eq};
+use serde_json::Value;
+use std::collections::{BTreeMap, HashSet};
+
+/// Kraken answers 50 closed orders a page; with its `cl_ord_id` filter honoured, one page answers.
+/// ponytail: no pacing between pages. A scan this long trips Kraken's rate limit and ends as a
+/// refusal, which callers treat as "not known yet". Add pacing if a live account ever needs it.
+pub const MAX_CLOSED_PAGES: u32 = 50;
+
+// Keep the specified public API: Found returns the normalized order by value.
+#[allow(clippy::large_enum_variant)]
+pub enum Step<D> {
+    Call(&'static str, BTreeMap<String, Param>),
+    Found(NormalizedOrder<D>),
+    Absent,
+    Venue(Vec<Value>),
+    Unreadable,
+    Incomplete(String),
+}
+
+pub struct ClientIdLookup {
+    cl_ord_id: String,
+    start: i64,
+    closed: bool,
+    /// Raw rows served so far: the `ofs` of the next request.
+    ofs: u64,
+    pages: u32,
+    /// Distinct closed-order ids read: absence needs these to cover Kraken's count.
+    seen: HashSet<String>,
+    /// The largest `count` any page reported: the bar for absence (R22).
+    count: u64,
+}
+
+impl ClientIdLookup {
+    pub fn new(cl_ord_id: &str, start: i64) -> Self {
+        Self {
+            cl_ord_id: cl_ord_id.to_string(),
+            start,
+            closed: false,
+            ofs: 0,
+            pages: 0,
+            seen: HashSet::new(),
+            count: 0,
+        }
+    }
+
+    pub fn first<D>(&self) -> Step<D> {
+        Step::Call(
+            "open_orders",
+            BTreeMap::from([("cl_ord_id".to_string(), Param::One(self.cl_ord_id.clone()))]),
+        )
+    }
+
+    fn closed_page<D>(&self) -> Step<D> {
+        Step::Call(
+            "closed_orders",
+            BTreeMap::from([
+                ("cl_ord_id".to_string(), Param::One(self.cl_ord_id.clone())),
+                ("start".to_string(), Param::One(self.start.to_string())),
+                ("ofs".to_string(), Param::One(self.ofs.to_string())),
+            ]),
+        )
+    }
+
+    /// Feed the parsed body answering the last `Call`.
+    pub fn feed<D: Num>(&mut self, data: &Value) -> Result<Step<D>, NormError<D::Error>> {
+        let key = if self.closed { "closed" } else { "open" };
+        let (orders, count) = match listed_orders::<D>(data, key)? {
+            Finished::Ok(x) => x,
+            Finished::Venue(e) => return Ok(Step::Venue(e)),
+            Finished::Unreadable => return Ok(Step::Unreadable),
+        };
+        let n = orders.len() as u64;
+        let ids: Vec<String> = orders
+            .iter()
+            .map(|o| semantics::to_s(&o.order_id).unwrap_or_else(|_| o.order_id.to_string()))
+            .collect();
+        // Ruby's `echo.to_s == cl_ord_id`: a numeric echo matches its text; string_eq keeps the
+        // binary-string form (to_s has no answer for it) matching too.
+        if let Some(o) = orders.into_iter().find(|o| {
+            o.cl_ord_id.as_ref().is_some_and(|c| {
+                string_eq(c, &self.cl_ord_id)
+                    || semantics::to_s(c).is_ok_and(|t| t == self.cl_ord_id)
+            })
+        }) {
+            return Ok(Step::Found(o));
+        }
+        if !self.closed {
+            self.closed = true;
+            return Ok(self.closed_page());
+        }
+        let Some(page_total) = count.as_ref().and_then(Value::as_u64) else {
+            return Ok(Step::Incomplete(format!(
+                "ClosedOrders count unreadable: {count:?}"
+            )));
+        };
+        // Held to the largest count seen: a shrinking count never lowers the bar (R22).
+        self.count = self.count.max(page_total);
+        let total = self.count;
+        self.seen.extend(ids);
+        self.pages += 1;
+        self.ofs += n;
+        let distinct = self.seen.len() as u64;
+        // Absence needs every distinct closed order read; a duplicate row is not coverage
+        // (review round 3, ruling 1).
+        if distinct >= total {
+            return Ok(Step::Absent);
+        }
+        if n == 0 {
+            return Ok(Step::Incomplete(format!(
+                "ClosedOrders page {} was empty after {distinct} of {total} orders",
+                self.pages
+            )));
+        }
+        if self.ofs >= total {
+            return Ok(Step::Incomplete(format!(
+                "ClosedOrders served {total} rows but only {distinct} distinct orders"
+            )));
+        }
+        if self.pages >= MAX_CLOSED_PAGES {
+            return Ok(Step::Incomplete(format!(
+                "more than {MAX_CLOSED_PAGES} ClosedOrders pages since {}",
+                self.start
+            )));
+        }
+        Ok(self.closed_page())
+    }
+}

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

@@ -0,0 +1,5 @@
+pub mod lookup;
+pub mod normalize;
+pub mod requests;
+pub mod sign;
+pub mod trades;