honeymaker 0.12.2 → 0.12.4

data/ext/honeymaker_native/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "honeymaker_native" # rb-sys finds the extension by this package name
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+publish = false
+
+[lib]
+name = "honeymaker_native" # Init_honeymaker_native, loaded as honeymaker/honeymaker_native
+crate-type = ["cdylib"]
+
+[dependencies]
+honeymaker-core = { package = "honeymaker", path = "../../crates/honeymaker" }
+magnus = "0.9"
+serde_json = { version = "1", features = ["preserve_order", "arbitrary_precision"] }

data/ext/honeymaker_native/extconf.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "mkmf"
+require "rb_sys/mkmf"
+
+create_rust_makefile("honeymaker/honeymaker_native")

data/ext/honeymaker_native/src/convert.rs

@@ -0,0 +1,150 @@
+//! Ruby ⇄ JSON values. Root Ruby objects across calls with BoxValue; only Rust-owned JSON
+//! values go in Rust collections. Ruby containers are filled as each element is created.
+
+use magnus::{
+    Float, Integer, RArray, RHash, RString, Ruby, Value,
+    encoding::EncodingCapable,
+    r_hash::ForEach,
+    value::{BoxValue, ReprValue},
+};
+
+pub fn to_json(ruby: &Ruby, v: Value) -> Result<serde_json::Value, magnus::Error> {
+    use serde_json::Value as J;
+    let v = BoxValue::new(v);
+    if v.is_nil() {
+        return Ok(J::Null);
+    }
+    if v.is_kind_of(ruby.class_true_class()) {
+        return Ok(J::Bool(true));
+    }
+    if v.is_kind_of(ruby.class_false_class()) {
+        return Ok(J::Bool(false));
+    }
+    if let Some(s) = RString::from_value(*v) {
+        // Copy before any Ruby call: the borrowed slice cannot survive a GC/mutation.
+        let bytes = unsafe { s.as_slice() }.to_vec();
+        if s.enc_get() == ruby.utf8_encindex()
+            && let Ok(text) = std::str::from_utf8(&bytes)
+        {
+            return Ok(J::String(text.to_string()));
+        }
+        let encoding: Value = s.funcall("encoding", ())?;
+        let name: String = encoding.funcall("name", ())?;
+        return Ok(serde_json::json!({honeymaker_core::semantics::RUBY_STRING: [bytes, name]}));
+    }
+    if Integer::from_value(*v).is_some() || Float::from_value(*v).is_some() {
+        // Preserve Float#to_s exactly: legacy passes these digits to BigDecimal.
+        // Non-finite floats use the sentinel understood by semantics::to_s.
+        let text: String = v.funcall("to_s", ())?;
+        return Ok(match text.parse::<serde_json::Number>() {
+            Ok(n) => J::Number(n),
+            Err(_) => J::Object(serde_json::Map::from_iter([(
+                honeymaker_core::semantics::RUBY_FLOAT.to_string(),
+                J::String(text),
+            )])),
+        });
+    }
+    if let Some(a) = RArray::from_value(*v) {
+        let a = BoxValue::new(a);
+        let mut out = Vec::with_capacity(a.len());
+        for i in 0..a.len() {
+            out.push(to_json(ruby, a.entry(i as isize)?)?);
+        }
+        return Ok(J::Array(out));
+    }
+    if let Some(h) = RHash::from_value(*v) {
+        let h = BoxValue::new(h);
+        let mut m = serde_json::Map::new();
+        h.foreach(|k: Value, val: Value| {
+            let k = BoxValue::new(k);
+            let val = BoxValue::new(val);
+            let key = RString::from_value(*k).ok_or_else(|| shape(ruby, "non-string key"))?;
+            let prefix = honeymaker_core::semantics::RUBY_KEY;
+            let key = match key.to_string() {
+                Ok(text) if !text.starts_with("\0ruby_") => text,
+                _ => format!("{prefix}{}", to_json(ruby, *k)?),
+            };
+            m.insert(key, to_json(ruby, *val)?);
+            Ok(ForEach::Continue)
+        })?;
+        return Ok(J::Object(m));
+    }
+    Err(shape(ruby, &format!("unsupported value {}", v.inspect())))
+}
+
+pub fn from_json(ruby: &Ruby, v: &serde_json::Value) -> Result<Value, magnus::Error> {
+    use serde_json::Value as J;
+    Ok(match v {
+        J::Null => ruby.qnil().as_value(),
+        J::Bool(true) => ruby.qtrue().as_value(),
+        J::Bool(false) => ruby.qfalse().as_value(),
+        J::String(s) => ruby.str_new(s).as_value(),
+        J::Number(n) => {
+            let text = n.to_string();
+            let conv = if text.contains(['.', 'e', 'E']) {
+                "Float"
+            } else {
+                "Integer"
+            };
+            ruby.module_kernel().funcall(conv, (text,))?
+        }
+        J::Array(a) => {
+            let out = BoxValue::new(ruby.ary_new_capa(a.len()));
+            for e in a {
+                out.push(from_json(ruby, e)?)?;
+            }
+            out.as_value()
+        }
+        J::Object(m) => {
+            if let Some(J::Array(parts)) = m
+                .get(honeymaker_core::semantics::RUBY_STRING)
+                .filter(|_| m.len() == 1)
+            {
+                let bytes: Vec<u8> = serde_json::from_value(parts[0].clone())
+                    .map_err(|_| shape(ruby, "invalid Ruby string bytes"))?;
+                let out = BoxValue::new(ruby.str_from_slice(&bytes));
+                out.funcall::<_, _, Value>(
+                    "force_encoding",
+                    (parts[1].as_str().unwrap_or("UTF-8"),),
+                )?;
+                return Ok(out.as_value());
+            }
+            if let Some(J::String(text)) = m
+                .get(honeymaker_core::semantics::RUBY_FLOAT)
+                .filter(|_| m.len() == 1)
+            {
+                let f = match text.as_str() {
+                    "Infinity" => f64::INFINITY,
+                    "-Infinity" => f64::NEG_INFINITY,
+                    _ => f64::NAN,
+                };
+                // Kernel#Float("Infinity") raises, so build the float directly.
+                return Ok(ruby.float_from_f64(f).as_value());
+            }
+            let h = BoxValue::new(ruby.hash_new());
+            for (k, val) in m {
+                let key =
+                    BoxValue::new(from_json(ruby, &honeymaker_core::semantics::object_key(k))?);
+                let value = from_json(ruby, val)?;
+                h.aset(*key, value)?;
+            }
+            h.as_value()
+        }
+    })
+}
+
+// Used by the normalizers added in subsequent tasks.
+#[allow(dead_code)]
+pub fn sym(s: &str) -> Value {
+    Ruby::get()
+        .expect("called on a Ruby thread")
+        .sym_new(s)
+        .as_value()
+}
+
+pub fn shape(ruby: &Ruby, msg: &str) -> magnus::Error {
+    let class = ruby
+        .eval::<magnus::ExceptionClass>("Honeymaker::Native::ShapeError")
+        .unwrap_or_else(|_| ruby.exception_standard_error());
+    magnus::Error::new(class, msg.to_string())
+}

data/ext/honeymaker_native/src/kraken.rs

@@ -0,0 +1,362 @@
+use crate::convert::{self, sym};
+use crate::ruby_decimal::RubyDecimal;
+use honeymaker_core::kraken::normalize::{self, Finished};
+use honeymaker_core::kraken::requests::{Fields, Method, layout};
+use honeymaker_core::kraken::sign::{self, Credentials};
+use honeymaker_core::kraken::trades::aggregate;
+use honeymaker_core::num::NormError;
+use magnus::{
+    RArray, RHash, RString, Ruby, Value, encoding::EncodingCapable, prelude::*, r_hash::ForEach,
+    value::BoxValue,
+};
+
+#[magnus::wrap(class = "Honeymaker::Native::Ext::Kraken", free_immediately)]
+pub struct Kraken {
+    creds: Option<Credentials>,
+    /// Legacy keys the nonce store by the raw api_key; nil gets its own slot.
+    nonce_key: Option<String>,
+}
+
+pub(crate) fn norm(ruby: &Ruby, e: NormError<magnus::Error>) -> magnus::Error {
+    match e {
+        NormError::Num(err) => err, // Ruby's own ArgumentError from BigDecimal()
+        NormError::Shape(msg) => convert::shape(ruby, &msg),
+    }
+}
+
+fn headers(ruby: &Ruby, pairs: &[(String, String)]) -> Result<RHash, magnus::Error> {
+    let h = ruby.hash_new();
+    for (k, v) in pairs {
+        h.aset(k.as_str(), v.as_str())?;
+    }
+    Ok(h)
+}
+
+pub(crate) fn verdict<T>(
+    ruby: &Ruby,
+    f: Finished<T>,
+    ok: impl FnOnce(T) -> Result<Value, magnus::Error>,
+) -> Result<RArray, magnus::Error> {
+    let out = ruby.ary_new();
+    match f {
+        Finished::Ok(v) => {
+            out.push(ruby.str_new("ok"))?;
+            out.push(ok(v)?)?;
+        }
+        // The Ruby wrapper builds its Failure from result.data["error"], exactly as legacy.
+        Finished::Venue(_) => out.push(ruby.str_new("venue"))?,
+        Finished::Unreadable => out.push(ruby.str_new("unreadable"))?,
+    }
+    Ok(out)
+}
+
+fn opt_dec(ruby: &Ruby, d: &Option<RubyDecimal>) -> Value {
+    d.as_ref()
+        .map(|d| d.value())
+        .unwrap_or_else(|| ruby.qnil().as_value())
+}
+
+fn side_symbol(ruby: &Ruby, value: Option<&serde_json::Value>) -> Result<Value, magnus::Error> {
+    match value {
+        Some(v) => convert::from_json(ruby, v)?.funcall("to_sym", ()),
+        None => Ok(ruby.qnil().as_value()),
+    }
+}
+
+impl Kraken {
+    fn new(api_key: Option<String>, api_secret: Option<String>) -> Self {
+        let creds = match (&api_key, &api_secret) {
+            (None, None) => None,
+            (k, s) => Some(Credentials {
+                api_key: k.clone().unwrap_or_default(),
+                api_secret: s.clone().unwrap_or_default(),
+            }),
+        };
+        Kraken {
+            creds,
+            nonce_key: api_key,
+        }
+    }
+
+    fn layout_for(
+        ruby: &Ruby,
+        op: &str,
+        want: Method,
+    ) -> Result<(&'static str, Fields), magnus::Error> {
+        match layout(op) {
+            Some((m, path, fields)) if m == want => Ok((path, fields)),
+            _ => Err(convert::shape(
+                ruby,
+                &format!("unknown Kraken {want:?} op {op}"),
+            )),
+        }
+    }
+
+    /// → [path, [["nonce", Integer], [wire, original value], ...]] (nils dropped, legacy order)
+    fn build_post(
+        ruby: &Ruby,
+        rb_self: &Self,
+        op: String,
+        params: RHash,
+    ) -> Result<RArray, magnus::Error> {
+        let (path, fields) = Self::layout_for(ruby, &op, Method::Post)?;
+        let pairs = ruby.ary_new();
+        let nonce = ruby.ary_new();
+        nonce.push(ruby.str_new("nonce"))?;
+        nonce.push(ruby.integer_from_u64(sign::next_nonce(rb_self.nonce_key.as_deref())))?;
+        pairs.push(nonce)?;
+        for (wire, name) in fields {
+            let v: Value = params.aref(ruby.str_new(name))?;
+            if !v.is_nil() {
+                let pair = ruby.ary_new();
+                pair.push(ruby.str_new(wire))?;
+                pair.push(v)?;
+                pairs.push(pair)?;
+            }
+        }
+        let out = ruby.ary_new();
+        out.push(ruby.str_new(path))?;
+        out.push(pairs)?;
+        Ok(out)
+    }
+
+    /// Signs the exact body Ruby encoded: legacy private_headers(req.path, req.body).
+    fn sign(
+        ruby: &Ruby,
+        rb_self: &Self,
+        path: String,
+        body: String,
+    ) -> Result<RHash, magnus::Error> {
+        headers(
+            ruby,
+            &sign::private_headers(&path, &body, rb_self.creds.as_ref()),
+        )
+    }
+
+    /// → [path, {wire => original value} (nils dropped), public headers]
+    fn build_get(
+        ruby: &Ruby,
+        _rb_self: &Self,
+        op: String,
+        params: RHash,
+    ) -> Result<RArray, magnus::Error> {
+        let (path, fields) = Self::layout_for(ruby, &op, Method::Get)?;
+        let query = ruby.hash_new();
+        for (wire, name) in fields {
+            let v: Value = params.aref(ruby.str_new(name))?;
+            if !v.is_nil() {
+                query.aset(ruby.str_new(wire), v)?;
+            }
+        }
+        let out = ruby.ary_new();
+        out.push(ruby.str_new(path))?;
+        out.push(query)?;
+        out.push(headers(ruby, &sign::public_headers())?)?;
+        Ok(out)
+    }
+
+    fn finish(
+        ruby: &Ruby,
+        _rb_self: &Self,
+        op: String,
+        data: Value,
+    ) -> Result<RArray, magnus::Error> {
+        let json = convert::to_json(ruby, data)?;
+        match op.as_str() {
+            "balances" => verdict(
+                ruby,
+                normalize::balances::<RubyDecimal>(&json).map_err(|e| norm(ruby, e))?,
+                |list| {
+                    let h = ruby.hash_new();
+                    for b in list {
+                        let e = ruby.hash_new();
+                        e.aset(sym("free"), b.free.value())?;
+                        e.aset(sym("locked"), b.locked.value())?;
+                        h.aset(convert::from_json(ruby, &b.asset)?, e)?;
+                    }
+                    Ok(h.as_value())
+                },
+            ),
+            "query_orders_info" => verdict(
+                ruby,
+                normalize::orders::<RubyDecimal>(&json).map_err(|e| norm(ruby, e))?,
+                |list| {
+                    let h = ruby.hash_new();
+                    for o in list {
+                        let e = ruby.hash_new();
+                        e.aset(sym("order_id"), convert::from_json(ruby, &o.order_id)?)?;
+                        e.aset(sym("status"), sym(o.status.as_str()))?;
+                        e.aset(sym("side"), side_symbol(ruby, o.side.as_ref())?)?;
+                        e.aset(sym("order_type"), sym(o.order_type.as_str()))?;
+                        e.aset(sym("price"), opt_dec(ruby, &o.price))?;
+                        e.aset(sym("amount"), opt_dec(ruby, &o.amount))?;
+                        e.aset(sym("quote_amount"), opt_dec(ruby, &o.quote_amount))?;
+                        e.aset(sym("amount_exec"), o.amount_exec.value())?;
+                        e.aset(sym("quote_amount_exec"), o.quote_amount_exec.value())?;
+                        h.aset(convert::from_json(ruby, &o.order_id)?, e)?; // the wrapper appends :raw last
+                    }
+                    Ok(h.as_value())
+                },
+            ),
+            "add_order" => verdict(
+                ruby,
+                normalize::add_order::<RubyDecimal>(&json).map_err(|e| norm(ruby, e))?,
+                |id| convert::from_json(ruby, &id),
+            ),
+            "tickers_info" => verdict(
+                ruby,
+                normalize::tickers::<RubyDecimal>(&json).map_err(|e| norm(ruby, e))?,
+                |list| {
+                    let out = ruby.ary_new();
+                    for t in list {
+                        let h = ruby.hash_new();
+                        h.aset(sym("ticker"), convert::from_json(ruby, &t.ticker)?)?;
+                        h.aset(sym("base"), convert::from_json(ruby, &t.base)?)?;
+                        h.aset(sym("quote"), convert::from_json(ruby, &t.quote)?)?;
+                        h.aset(
+                            sym("minimum_base_size"),
+                            convert::from_json(ruby, &t.minimum_base_size)?,
+                        )?;
+                        h.aset(
+                            sym("minimum_quote_size"),
+                            convert::from_json(ruby, &t.minimum_quote_size)?,
+                        )?;
+                        h.aset(sym("maximum_base_size"), ruby.qnil())?;
+                        h.aset(sym("maximum_quote_size"), ruby.qnil())?;
+                        h.aset(
+                            sym("base_decimals"),
+                            convert::from_json(ruby, &t.base_decimals)?,
+                        )?;
+                        h.aset(
+                            sym("quote_decimals"),
+                            convert::from_json(ruby, &t.quote_decimals)?,
+                        )?;
+                        h.aset(
+                            sym("price_decimals"),
+                            convert::from_json(ruby, &t.price_decimals)?,
+                        )?;
+                        h.aset(sym("available"), ruby.qtrue())?;
+                        h.aset(sym("trading_enabled"), t.trading_enabled)?;
+                        out.push(h)?;
+                    }
+                    Ok(out.as_value())
+                },
+            ),
+            "bid_ask" => verdict(
+                ruby,
+                normalize::bid_ask::<RubyDecimal>(&json).map_err(|e| norm(ruby, e))?,
+                |(bid, ask)| {
+                    let h = ruby.hash_new();
+                    h.aset(sym("bid"), bid.value())?;
+                    h.aset(sym("ask"), ask.value())?;
+                    Ok(h.as_value())
+                },
+            ),
+            other => Err(convert::shape(ruby, &format!("unknown finish op {other}"))),
+        }
+    }
+
+    /// by_order: { otxid => [Ruby trade hashes] } in first-seen order → legacy aggregate hashes.
+    fn aggregate_trades(ruby: &Ruby, by_order: RHash) -> Result<RHash, magnus::Error> {
+        let out = ruby.hash_new();
+        by_order.foreach(|otxid: Value, trades: RArray| {
+            let mut json = Vec::with_capacity(trades.len());
+            for i in 0..trades.len() {
+                json.push(convert::to_json(ruby, trades.entry(i as isize)?)?); // Rust values only
+            }
+            let a = aggregate::<RubyDecimal>(&json).map_err(|e| norm(ruby, e))?;
+            let first: Value = trades.entry(0)?;
+            let times = ruby.ary_new();
+            for i in 0..trades.len() {
+                let t: Value = trades.entry(i as isize)?;
+                let time: Value = t.funcall("[]", ("time",))?;
+                times.push(time.funcall::<_, _, Value>("to_f", ())?)?;
+            }
+            let h = ruby.hash_new();
+            h.aset(
+                sym("order_id"),
+                first.funcall::<_, _, Value>("[]", ("ordertxid",))?,
+            )?;
+            h.aset(sym("status"), sym("closed"))?;
+            h.aset(sym("side"), side_symbol(ruby, a.side.as_ref())?)?;
+            h.aset(sym("order_type"), sym(a.order_type.as_str()))?;
+            h.aset(sym("price"), opt_dec(ruby, &a.price))?;
+            h.aset(sym("amount"), ruby.qnil())?;
+            h.aset(sym("quote_amount"), ruby.qnil())?;
+            h.aset(sym("amount_exec"), a.vol.value())?;
+            h.aset(sym("quote_amount_exec"), a.cost.value())?;
+            h.aset(sym("fee"), a.fee.value())?;
+            h.aset(sym("pair"), first.funcall::<_, _, Value>("[]", ("pair",))?)?;
+            h.aset(sym("trade_count"), trades.len())?;
+            h.aset(
+                sym("last_trade_at"),
+                times.funcall::<_, _, Value>("max", ())?,
+            )?;
+            let raw = ruby.hash_new();
+            raw.aset(ruby.str_new("trades"), trades)?;
+            h.aset(sym("raw"), raw)?;
+            out.aset(otxid, h)?;
+            Ok(ForEach::Continue)
+        })?;
+        Ok(out)
+    }
+
+    fn classify_error(ruby: &Ruby, message: RString) -> Result<Value, magnus::Error> {
+        let message = BoxValue::new(message);
+        let encoding: Value = message.funcall("encoding", ())?;
+        if !encoding.funcall::<_, _, bool>("ascii_compatible?", ())?
+            || !message.funcall::<_, _, bool>("valid_encoding?", ())?
+        {
+            // Let Ruby raise its exact regexp encoding exception before byte matching.
+            message.funcall::<_, _, Value>("match", ("",))?;
+        }
+        let bytes = unsafe { message.as_slice() }.to_vec();
+        Ok(match normalize::classify_error(&bytes) {
+            None => ruby.qnil().as_value(),
+            Some((code, caps)) => {
+                let h = ruby.hash_new();
+                h.aset(sym("code"), sym(code))?;
+                for (k, v) in caps {
+                    let capture = BoxValue::new(ruby.str_from_slice(&v));
+                    capture.enc_associate(message.enc_get())?;
+                    h.aset(sym(k), *capture)?;
+                }
+                h.as_value()
+            }
+        })
+    }
+
+    fn set_fixed_nonce(n: Option<u64>) {
+        sign::set_fixed_nonce(n);
+    }
+
+    fn reset_nonce_state() {
+        sign::reset_nonces();
+    }
+}
+
+pub fn define(ruby: &Ruby, ext: magnus::RModule) -> Result<(), magnus::Error> {
+    let c = ext.define_class("Kraken", ruby.class_object())?;
+    c.define_singleton_method("new", magnus::function!(Kraken::new, 2))?;
+    c.define_method("build_post", magnus::method!(Kraken::build_post, 2))?;
+    c.define_method("sign", magnus::method!(Kraken::sign, 2))?;
+    c.define_method("build_get", magnus::method!(Kraken::build_get, 2))?;
+    c.define_singleton_method(
+        "classify_error",
+        magnus::function!(Kraken::classify_error, 1),
+    )?;
+    c.define_method("finish", magnus::method!(Kraken::finish, 2))?;
+    c.define_singleton_method(
+        "aggregate_trades",
+        magnus::function!(Kraken::aggregate_trades, 1),
+    )?;
+    c.define_singleton_method(
+        "fixed_nonce=",
+        magnus::function!(Kraken::set_fixed_nonce, 1),
+    )?;
+    c.define_singleton_method(
+        "reset_nonce_state!",
+        magnus::function!(Kraken::reset_nonce_state, 0),
+    )?;
+    Ok(())
+}

data/ext/honeymaker_native/src/lib.rs

@@ -0,0 +1,90 @@
+use magnus::{Error, Ruby, function, prelude::*};
+
+mod convert;
+mod kraken;
+mod ruby_decimal;
+
+fn version() -> &'static str {
+    env!("CARGO_PKG_VERSION")
+}
+
+fn roundtrip_for_tests(ruby: &Ruby, v: magnus::Value) -> Result<magnus::Value, Error> {
+    let j = convert::to_json(ruby, v)?;
+    convert::from_json(ruby, &j)
+}
+
+fn decimal_for_tests(text: String) -> Result<magnus::Value, Error> {
+    use honeymaker_core::num::Num;
+    Ok(ruby_decimal::RubyDecimal::parse(&text)?.value())
+}
+
+fn to_s_for_tests(ruby: &Ruby, v: magnus::Value) -> Result<String, Error> {
+    let j = convert::to_json(ruby, v)?;
+    honeymaker_core::semantics::to_s(&j).map_err(|msg| convert::shape(ruby, &msg))
+}
+
+fn decimal_convert_for_tests(
+    ruby: &Ruby,
+    v: magnus::Value,
+    stringify: bool,
+) -> Result<magnus::Value, Error> {
+    use honeymaker_core::num::Num;
+    use ruby_decimal::RubyDecimal;
+    let j = convert::to_json(ruby, v)?;
+    let decimal = if stringify {
+        RubyDecimal::parse_to_s(&j)?
+    } else {
+        RubyDecimal::parse_json(&j)?
+    };
+    Ok(decimal.value())
+}
+
+fn decimal_arithmetic_for_tests(
+    ruby: &Ruby,
+    left: String,
+    right: String,
+) -> Result<magnus::RArray, Error> {
+    use honeymaker_core::num::Num;
+    use magnus::value::BoxValue;
+    use ruby_decimal::RubyDecimal;
+
+    // Keep the decimals on the Rust heap across collection and compaction, as normalizers will.
+    let mut decimals = vec![RubyDecimal::parse(&left)?, RubyDecimal::parse(&right)?];
+    let sum = decimals[0].add(&decimals[1])?;
+    decimals.push(sum);
+    decimals.push(decimals[0].sub(&decimals[1])?);
+    decimals.push(decimals[0].div(&decimals[1])?);
+    ruby.gc_start();
+    let gc = BoxValue::new(ruby.class_object().const_get::<_, magnus::RModule>("GC")?);
+    if gc.respond_to("compact", false)? {
+        gc.funcall::<_, _, magnus::Value>("compact", ())?;
+    }
+    let out = BoxValue::new(ruby.ary_new_capa(4));
+    for decimal in &decimals[2..] {
+        out.push(decimal.value())?;
+    }
+    out.push(decimals[0].is_zero()?)?;
+    Ok(*out)
+}
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    use magnus::value::BoxValue;
+    ruby.require("bigdecimal")?;
+    let native = BoxValue::new(ruby.define_module("Honeymaker")?.define_module("Native")?);
+    let ext = BoxValue::new(native.define_module("Ext")?);
+    kraken::define(ruby, *ext)?;
+    ext.define_singleton_method("version", function!(version, 0))?;
+    ext.define_singleton_method("roundtrip_for_tests", function!(roundtrip_for_tests, 1))?;
+    ext.define_singleton_method("decimal_for_tests", function!(decimal_for_tests, 1))?;
+    ext.define_singleton_method("to_s_for_tests", function!(to_s_for_tests, 1))?;
+    ext.define_singleton_method(
+        "decimal_convert_for_tests",
+        function!(decimal_convert_for_tests, 2),
+    )?;
+    ext.define_singleton_method(
+        "decimal_arithmetic_for_tests",
+        function!(decimal_arithmetic_for_tests, 2),
+    )?;
+    Ok(())
+}