honeymaker 0.12.3 → 0.12.4

data/script/release/push_gems.sh

@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+# Push built gems: platform gems first, the source gem last. Idempotent: a gem already on
+# rubygems.org is accepted only if byte-identical (a rerun after a partial publish).
+set -euo pipefail
+dir="${1:?gem dir}"
+version="${2:?version}"
+api="${RUBYGEMS_API:-https://rubygems.org}"
+# Exactly the release set, or nothing is pushed: 5 platform gems + the source gem.
+expected=(x86_64-linux aarch64-linux x86_64-darwin arm64-darwin x64-mingw-ucrt)
+for plat in "${expected[@]}"; do
+  [ -f "$dir/honeymaker-$version-$plat.gem" ] || { echo "::error::missing honeymaker-$version-$plat.gem" >&2; exit 1; }
+done
+[ -f "$dir/honeymaker-$version.gem" ] || { echo "::error::missing honeymaker-$version.gem (source)" >&2; exit 1; }
+count=$(find "$dir" -maxdepth 1 -name '*.gem' | wc -l | tr -d ' ')
+[ "$count" = 6 ] || { echo "::error::expected 6 gems in $dir, found $count" >&2; exit 1; }
+push() {
+  local g="$1" ver plat sha remote
+  if gem push "$g"; then return 0; fi
+  ver=$(ruby -rrubygems/package -e 'print Gem::Package.new(ARGV[0]).spec.version' "$g")
+  plat=$(ruby -rrubygems/package -e 'print Gem::Package.new(ARGV[0]).spec.platform' "$g")
+  sha=$(ruby -rdigest -e 'print Digest::SHA256.file(ARGV[0]).hexdigest' "$g")
+  remote=$(curl -fsS "$api/api/v2/rubygems/honeymaker/versions/${ver}.json?platform=${plat}" \
+           | ruby -rjson -e 'print JSON.parse($stdin.read)["sha"]')
+  if [ "$sha" != "$remote" ]; then echo "::error::$g differs from the published gem" >&2; return 1; fi
+  echo "$g already published with the same checksum"
+}
+for plat in "${expected[@]}"; do push "$dir/honeymaker-$version-$plat.gem"; done
+push "$dir/honeymaker-$version.gem"

data/script/vectors/kraken.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# Regenerates crates/honeymaker/tests/vectors/*.json from the LEGACY Ruby implementation.
+#   bundle exec ruby -Ilib script/vectors/kraken.rb
+require "honeymaker"
+require "json"
+require "bigdecimal"
+
+out_dir = File.expand_path("../../crates/honeymaker/tests/vectors", __dir__)
+
+secrets = [
+  Base64.strict_encode64("test_secret_key_1234567890123456"),
+  "dGVzd A==\n!!-_x", "abc", "=abc", "", "   ", "a", "ab==cd", "not base64 at all ~~~",
+  Base64.strict_encode64((0..255).to_a.pack("C*"))
+]
+bodies = [
+  [["nonce", "1727000000000001"]],
+  [["nonce", "1727000000000002"], ["ordertype", "market"], ["type", "buy"], ["volume", "0.001"], ["pair", "XBTUSDT"],
+   ["oflags", "viqc"], ["close[ordertype]", "limit"]],
+  [["nonce", "1727000000000003"], ["txid", "O1,O2"], ["consolidate_taker", "true"]],
+  [["nonce", "1727000000000004"], ["asset", "a b~*-._/,:[]\u00e9+&="]]
+]
+paths = %w[/0/private/BalanceEx /0/private/AddOrder /0/private/QueryOrders /0/private/Earn/Allocations]
+
+signing = []
+secrets.each do |secret|
+  [["key", secret], ["", secret], ["key", ""]].each do |key, sec|
+    bodies.each_with_index do |pairs, i|
+      body = URI.encode_www_form(pairs)
+      c = Honeymaker::Clients::Kraken.new(api_key: key, api_secret: sec)
+      signing << { api_key: key, api_secret: sec, path: paths[i], pairs: pairs, body: body,
+                   decoded_secret_hex: Base64.decode64(sec).unpack1("H*"),
+                   headers: c.send(:private_headers, paths[i], body).transform_keys(&:to_s) }
+    end
+  end
+end
+
+decimal_inputs = ["0.5", "1", "-0", "-0.0000", "0.0000000001", "123456789012345678901234567890.123456789",
+                  "1e-9", "1E5", " 1.5 ", "1_000.5", ".5", "5.", "+2", "", "abc", "1,5", "0x10", "NaN",
+                  "Infinity", "-Infinity", "1d2", "true"]
+decimals = decimal_inputs.map do |s|
+  v = BigDecimal(s)
+  { input: s, ok: true, finite: v.finite?, plain: v.finite? ? v.to_s("F") : v.to_s, sign: v.sign }
+rescue ArgumentError => e
+  { input: s, ok: false, error: e.message }
+end
+
+File.write(File.join(out_dir, "kraken_signing.json"), JSON.pretty_generate(signing))
+File.write(File.join(out_dir, "decimal.json"), JSON.pretty_generate(decimals))
+puts "wrote #{signing.size} signing vectors, #{decimals.size} decimals"

data/script/vectors/kraken_stage2.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+# Regenerates the stage-2 vectors from the LEGACY Ruby implementation.
+#   bundle exec ruby -Ilib script/vectors/kraken_stage2.rb
+require "honeymaker"
+require "json"
+require "faraday"
+
+OUT = File.expand_path("../../crates/honeymaker/tests/vectors", __dir__)
+SECRET = Base64.strict_encode64("test_secret_key_1234567890123456")
+NONCE = 1_727_000_000_000_001
+
+def legacy
+  c = Honeymaker::Clients::Kraken.new(api_key: "key", api_secret: SECRET)
+  c.define_singleton_method(:nonce) { NONCE }
+  c
+end
+
+# --- A: AddOrder with cl_ord_id and deadline, as legacy signs and sends it ---
+orders = [
+  { 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" },
+  { 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" },
+  { 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 }
+]
+wire = orders.map do |args|
+  body = nil
+  stubs = Faraday::Adapter::Test::Stubs.new do |s|
+    s.post("/0/private/AddOrder") do |env|
+      body = env.body
+      [200, { "Content-Type" => "application/json" }, '{"error":[],"result":{"txid":["OTX-1"]}}']
+    end
+  end
+  c = legacy
+  c.instance_variable_set(:@connection, Faraday.new(url: Honeymaker::Clients::Kraken::URL) { |f| f.response :json; f.adapter :test, stubs })
+  raise "legacy did not answer" unless c.add_order(**args).success?
+
+  { args: args, nonce: NONCE, api_key: "key", api_secret: SECRET, body: body,
+    headers: c.send(:private_headers, "/0/private/AddOrder", body).transform_keys(&:to_s) }
+end
+File.write(File.join(OUT, "kraken_add_order_wire.json"), JSON.pretty_generate(wire))
+puts "wrote #{wire.size} AddOrder wire vectors"
+
+# --- B: closed_orders_from_trades, the verbatim Ruby loop (with Task 8's dedupe), over scripted
+# pages. Each case says what the STRICT Rust scan must do: "same" as Ruby (a completed scan, a
+# refusal, an unreadable page or a Ruby exception), "incomplete" where Ruby stopped early or
+# trusted a malformed container and returned what it had, or "error" where Ruby skipped a malformed
+# record that Rust must refuse. The label is what Rust must do, not what Ruby did: some
+# "incomplete" cases are Ruby raises (NoMethodError on trades as a non-empty array, a non-empty
+# string or a number, and on count true or an array), not partial answers. Their "outcome" says so.
+def page(trades, count = :none)
+  result = { "trades" => trades }
+  result["count"] = count unless count == :none
+  { "error" => [], "result" => result }
+end
+
+def trade(o, vol, cost, type: "buy", ordertype: "market", fee: "0.1")
+  { "ordertxid" => o, "vol" => vol, "cost" => cost, "fee" => fee, "type" => type, "ordertype" => ordertype, "time" => 1.5 }
+end
+
+T = ->(i, o = "O1") { { "T#{i}" => trade(o, "1", "2") } }
+cases = [
+  ["one page", :same, %w[O1], 1_700_000_000, 20, [page({ "T1" => trade("O1", "0.0006", "30"), "T2" => trade("O1", "0.0006", "30") }, 2)]],
+  ["partial fill across pages, unwanted skipped", :same, %w[O1 O2], 1_700_000_000, 20,
+   [page({ "T1" => trade("O1", "1", "2"), "T2" => trade("O9", "1", "2") }, 3),
+    page({ "T3" => trade("O1", "1", "2"), "T4" => trade("O2", "2", "8", ordertype: "limit", type: "sell") }, 3)]],
+  ["no wanted ids: no request", :same, [], nil, 20, []],
+  ["a trade on two pages: rows reach count, distinct trades do not", :incomplete, %w[O1], nil, 20,
+   [page({ "T1" => trade("O1", "1", "2"), "T2" => trade("O1", "3", "9") }, 3), page({ "T2" => trade("O1", "3", "9") }, 3)]],
+  ["overlapping pages that cover every trade", :same, %w[O1], nil, 20,
+   [page({ "T1" => trade("O1", "1", "2"), "T2" => trade("O1", "3", "9") }, 3),
+    page({ "T2" => trade("O1", "3", "9"), "T3" => trade("O1", "1", "1") }, 3)]],
+  ["complete exactly at the page cap", :same, %w[O1], nil, 2, [page(T[1], 2), page(T[2], 2)]],
+  ["an empty page after the last trade", :same, %w[O1], nil, 20, [page({}, 0)]],
+  ["a fill beyond the page cap", :incomplete, %w[O1], nil, 2, [page(T[1, "O9"], 3), page(T[2, "O9"], 3), page(T[3], 3)]],
+  ["count as a string", :incomplete, %w[O1], nil, 20, [page(T[1], "2"), page(T[2], "2")]],
+  ["count 1_000 pages to max_pages", :incomplete, %w[O1], nil, 2, [page(T[1], "1_000"), page(T[2], "1_000"), page(T[3], "1_000")]],
+  ["bignum string count", :incomplete, %w[O1], nil, 3, [page(T[1], "99999999999999999999999"), page(T[2], "1"), page(T[3], "1")]],
+  ["bignum integer count", :incomplete, %w[O1], nil, 3, [page(T[1], 10**25), page(T[2], 10**25), page(T[3], 10**25), page(T[4], 10**25)]],
+  ["float count", :incomplete, %w[O1], nil, 20, [page(T[1], 2.9), page(T[2], 2.9), page(T[3], 2.9)]],
+  ["missing count", :incomplete, %w[O1], nil, 20, [page(T[1]), page(T[2])]],
+  ["nil count", :incomplete, %w[O1], nil, 20, [page(T[1], nil), page(T[2])]],
+  ["negative count", :incomplete, %w[O1], nil, 20, [page(T[1], -1), page(T[2])]],
+  *[" 3", "3abc", "0x10", "_3", "3__0", "+3", "-3", "", "abc"].map do |c|
+    ["count #{c.inspect}", :incomplete, %w[O1], nil, 4, (1..4).map { |i| page(T[i], c) }]
+  end,
+  ["empty trades before count", :incomplete, %w[O1], nil, 20, [page({}, 5), page(T[1], 5)]],
+  ["missing trades", :incomplete, %w[O1], nil, 20, [{ "error" => [], "result" => { "count" => 3 } }, page(T[1])]],
+  ["trades false", :incomplete, %w[O1], nil, 20, [page(false, 3), page(T[1])]],
+  ["trades []", :incomplete, %w[O1], nil, 20, [page([], 3), page(T[1])]],
+  ["trades \"\"", :incomplete, %w[O1], nil, 20, [page("", 3), page(T[1])]],
+  ["nil result", :incomplete, %w[O1], nil, 20, [{ "error" => [] }, page(T[1])]],
+  ["result as a string raises", :same, %w[O1], nil, 20, [{ "error" => [], "result" => "x" }]],
+  ["result as an array raises", :same, %w[O1], nil, 20, [{ "error" => [], "result" => [1] }]],
+  ["result false raises", :same, %w[O1], nil, 20, [{ "error" => [], "result" => false }]],
+  ["trades as a non-empty array", :incomplete, %w[O1], nil, 20, [page([1], 1)]],
+  ["trades as a non-empty string", :incomplete, %w[O1], nil, 20, [page("x", 1)]],
+  ["trades as a number", :incomplete, %w[O1], nil, 20, [page(5, 1)]],
+  *[[false, "false"], [[], "[]"], ["", "\"\""], [nil, "null"]].map do |trades, label|
+    ["trades #{label} with count 0", :incomplete, %w[O1], nil, 20, [page(trades, 0)]]
+  end,
+  ["trades missing with count 0", :incomplete, %w[O1], nil, 20, [{ "error" => [], "result" => { "count" => 0 } }]],
+  ["a trade that is a string", :error, %w[O1], nil, 20, [page({ "T1" => "no id here", "T2" => trade("O1", "1", "2") }, 2)]],
+  ["a record without ordertxid", :error, %w[O1], nil, 20, [page({ "T1" => { "vol" => "1", "cost" => "2" } }, 1)]],
+  ["a record with a numeric ordertxid", :error, %w[O1], nil, 20, [page({ "T1" => trade(5, "1", "2") }, 1)]],
+  ["a trade that is a number raises", :same, %w[O1], nil, 20, [page({ "T1" => 5 }, 1)]],
+  ["a trade that is null raises", :same, %w[O1], nil, 20, [page({ "T1" => nil }, 1)]],
+  ["count true", :incomplete, %w[O1], nil, 20, [page(T[1], true)]],
+  ["count as an array", :incomplete, %w[O1], nil, 20, [page(T[1], [1])]],
+  ["refusal on page 2", :same, %w[O1], nil, 20, [page(T[1], 5), { "error" => ["EAPI:Rate limit exceeded"] }]],
+  ["falsy errors are not a refusal", :same, %w[O1], nil, 20, [{ "error" => [nil, false], "result" => { "trades" => T[1], "count" => 1 } }]],
+  ["non-object page 2 is unreadable", :same, %w[O1], nil, 20, [page(T[1], 5), "oops"]],
+  ["pages run out: legacy sees null", :same, %w[O1], nil, 20, [page(T[1], 5)]],
+  ["zero volume has no price", :same, %w[O1], nil, 20, [page({ "T1" => trade("O1", "0", "0") }, 1)]]
+]
+
+pager = cases.map do |name, strict, ids, start, max_pages, pages|
+  texts = pages.map { |p| JSON.generate(p) }
+  queue = texts.dup
+  requests = []
+  c = legacy
+  c.define_singleton_method(:get_trades_history) do |start: nil, ofs: nil, **|
+    requests << [start, ofs]
+    Honeymaker::Result::Success.new(JSON.parse(queue.shift || "null"))
+  end
+  outcome = begin
+    r = c.closed_orders_from_trades(order_ids: ids, start: start, max_pages: max_pages)
+    if r.success?
+      { "ok" => r.data.map do |txid, a|
+        [txid, { "vol" => a[:amount_exec].to_s("F"), "cost" => a[:quote_amount_exec].to_s("F"), "fee" => a[:fee].to_s("F"),
+                 "price" => a[:price]&.to_s("F"), "side" => a[:side]&.to_s, "order_type" => a[:order_type].to_s }]
+      end }
+    elsif r.data.is_a?(Hash) && r.data[:unreadable]
+      { "unreadable" => true }
+    else
+      { "venue" => r.errors }
+    end
+  rescue StandardError => e
+    { "raise" => e.class.name }
+  end
+  { name: name, strict: strict, order_ids: ids, start: start, max_pages: max_pages, pages: texts, requests: requests, outcome: outcome }
+end
+File.write(File.join(OUT, "kraken_trades_pager.json"), JSON.pretty_generate(pager))
+puts "wrote #{pager.size} trades-pager vectors"

data/test/fixtures/coinbase_products.json

@@ -11,7 +11,7 @@
       "quote_max_size": "250000000"
     },
     {
-      "product_id": "RENDER-USD",
+      "product_id": "RNDR-USD",
       "base_increment": "0.01",
       "quote_increment": "0.01",
       "price_increment": "0.01",

data/test/honeymaker/clients/bybit_client_test.rb

@@ -46,6 +46,31 @@ class Honeymaker::Clients::BybitTest < Minitest::Test
     assert_equal :closed, result.data[:status]
   end
 
+  def test_get_order_partially_filled_canceled_is_cancelled
+    stub_connection(:get, { "retCode" => 0, "retMsg" => "OK", "result" => { "list" => [{
+      "orderId" => "123", "orderType" => "Limit", "side" => "Buy", "orderStatus" => "PartiallyFilledCanceled",
+      "avgPrice" => "50000", "qty" => "0.002", "cumExecQty" => "0.001", "cumExecValue" => "50"
+    }] } })
+    result = @client.get_order(category: "spot", order_id: "123")
+    assert_equal :cancelled, result.data[:status]
+    assert_equal BigDecimal("0.001"), result.data[:amount_exec]
+  end
+
+  def test_order_history
+    @client.expects(:get_authenticated).with("/v5/order/history", {
+      category: "spot", symbol: nil, orderId: "123", orderLinkId: nil, orderStatus: nil,
+      startTime: 1, endTime: 2, limit: 50, cursor: "c"
+    }).returns(Honeymaker::Result::Success.new({ "retCode" => 0 }))
+    assert @client.order_history(category: "spot", order_id: "123", start_time: 1, end_time: 2, limit: 50, cursor: "c").success?
+  end
+
+  def test_internal_deposit_records
+    @client.expects(:get_authenticated).with("/v5/asset/deposit/query-internal-record", {
+      txID: nil, coin: "USDT", startTime: 1, endTime: 2, limit: 50, cursor: "c"
+    }).returns(Honeymaker::Result::Success.new({ "retCode" => 0 }))
+    assert @client.internal_deposit_records(coin: "USDT", start_time: 1, end_time: 2, limit: 50, cursor: "c").success?
+  end
+
   def test_cancel_order
     stub_connection(:post, { "result" => { "orderId" => "123" } })
     result = @client.cancel_order(category: "spot", symbol: "BTCUSDT", order_id: "123")

data/test/honeymaker/clients/coinbase_client_test.rb

@@ -69,6 +69,20 @@ class Honeymaker::Clients::CoinbaseTest < Minitest::Test
     assert result.success?
   end
 
+  def test_list_accounts_passes_cursor_and_limit
+    response = stub(body: { "accounts" => [], "has_next" => false, "cursor" => "" })
+    request = stub(url: nil)
+    request.stubs(:headers=)
+    request.stubs(:http_method).returns(:get)
+    request.stubs(:path).returns("/api/v3/brokerage/accounts")
+    request.expects(:params=).with({ limit: 250, cursor: "c2" })
+    connection = stub
+    connection.stubs(:get).yields(request).returns(response)
+    @client.instance_variable_set(:@connection, connection)
+
+    assert @client.list_accounts(limit: 250, cursor: "c2").success?
+  end
+
   def test_send_money
     stub_connection(:post, { "data" => { "id" => "tx1" } })
     result = @client.send_money(account_id: "acc1", to: "addr", amount: "0.1", currency: "BTC")

data/test/honeymaker/clients/kraken_client_test.rb

@@ -223,6 +223,21 @@ class Honeymaker::Clients::KrakenTest < Minitest::Test
     assert_equal BigDecimal("0.00016557"), agg[:amount_exec]
   end
 
+  # A trade that lands at the top of TradesHistory between two page reads pushes TID-2 from page 1
+  # onto page 2. Offset paging then serves TID-2 twice; it must be counted once.
+  def test_closed_orders_from_trades_counts_a_trade_seen_on_two_pages_once
+    t = { "ordertxid" => "OABC", "pair" => "XXBTZUSD", "type" => "buy", "ordertype" => "market",
+          "cost" => "6.0", "vol" => "0.0001", "fee" => "0.01", "time" => 1_700_000_000.0 }
+    p1 = { "error" => [], "result" => { "count" => 3, "trades" => { "TID-1" => t, "TID-2" => t } } }
+    p2 = { "error" => [], "result" => { "count" => 3, "trades" => { "TID-2" => t } } }
+    @client.stubs(:get_trades_history).returns(Honeymaker::Result::Success.new(p1), Honeymaker::Result::Success.new(p2))
+    agg = @client.closed_orders_from_trades(order_ids: ["OABC"], start: 1).data["OABC"]
+    assert_equal BigDecimal("0.0002"), agg[:amount_exec]
+    assert_equal BigDecimal("12.0"), agg[:quote_amount_exec]
+    assert_equal BigDecimal("0.02"), agg[:fee]
+    assert_equal 2, agg[:trade_count]
+  end
+
   private
 
   def assert_strictly_increasing(values)

data/test/honeymaker/exchanges/coinbase_test.rb

@@ -16,7 +16,7 @@ class Honeymaker::Exchanges::CoinbaseTest < Minitest::Test
     result = @exchange.get_tickers_info
 
     assert result.success?
-    # RENDER is blacklisted, so only BTC-USD should remain
+    # RNDR is blacklisted, so only BTC-USD should remain
     assert_equal 1, result.data.size
     ticker = result.data.first
     assert_equal "BTC-USD", ticker[:ticker]
@@ -54,6 +54,26 @@ class Honeymaker::Exchanges::CoinbaseTest < Minitest::Test
     refute result.data.first[:trading_enabled]
   end
 
+  def test_get_tickers_info_disables_restricted_modes
+    %w[limit_only cancel_only is_disabled].each do |flag|
+      body = load_fixture("coinbase_products.json")
+      body["products"].first[flag] = true
+      stub_connection(body)
+
+      ticker = @exchange.get_tickers_info.data.first
+      assert ticker[:available], flag
+      refute ticker[:trading_enabled], flag
+    end
+  end
+
+  def test_keeps_render
+    body = load_fixture("coinbase_products.json")
+    body["products"] << body["products"].last.merge("product_id" => "RENDER-USD")
+    stub_connection(body)
+
+    assert_includes @exchange.get_tickers_info.data.map { |t| t[:base] }, "RENDER"
+  end
+
   def test_filters_blacklisted_assets
     body = load_fixture("coinbase_products.json")
     stub_connection(body)
@@ -61,7 +81,7 @@ class Honeymaker::Exchanges::CoinbaseTest < Minitest::Test
     result = @exchange.get_tickers_info
 
     bases = result.data.map { |t| t[:base] }
-    refute_includes bases, "RENDER"
+    refute_includes bases, "RNDR"
   end
 
   def test_get_bid_ask_parses_response

data/test/native/backend_switch_test.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "open3"
+
+class Honeymaker::Native::BackendSwitchTest < Minitest::Test
+  LIB = File.expand_path("../../lib", __dir__)
+
+  def ruby(env, code)
+    out, status = Open3.capture2e(env, RbConfig.ruby, "-I#{LIB}", "-rbundler/setup", "-e", code)
+    [out.strip, status]
+  end
+
+  def test_flag_off_uses_ruby_and_never_loads_the_extension
+    out, st = ruby({ "HONEYMAKER_NATIVE" => nil }, <<~RUBY)
+      require "honeymaker"
+      print [Honeymaker::CLIENTS["kraken"], Honeymaker::EXCHANGES["kraken"], Honeymaker.backend("kraken"),
+             $LOADED_FEATURES.grep(/honeymaker_native\\.(so|bundle|dll)\\z/).size].join(",")
+    RUBY
+    assert st.success?, out
+    assert_equal "Honeymaker::Clients::Kraken,Honeymaker::Exchanges::Kraken,ruby,0", out
+  end
+
+  def test_unsupported_flags_fail_at_require_time
+    ["binance", " kraken, ,binance ", " KRAKEN, bybit "].each do |flag|
+      out, st = ruby({ "HONEYMAKER_NATIVE" => flag }, 'require "honeymaker"')
+      refute st.success?, out
+      assert_match(/unsupported.*(?:binance|bybit)/i, out)
+      assert_match(/supported.*kraken/i, out)
+    end
+  end
+
+  def test_backend_only_reports_supported_enabled_names
+    out, st = ruby({ "HONEYMAKER_NATIVE" => " KRAKEN, ,kraken " }, <<~RUBY)
+      require "honeymaker"
+      print [Honeymaker.backend(" KRAKEN "), Honeymaker.backend(:binance), Honeymaker.backend("unknown")].join(",")
+    RUBY
+    assert st.success?, out
+    assert_equal "native,ruby,ruby", out
+  end
+
+  def test_flag_on_selects_native_for_kraken_only
+    skip "native extension not compiled" unless Dir[File.join(LIB, "honeymaker", "**", "honeymaker_native.{so,bundle,dll}")].any?
+
+    out, st = ruby({ "HONEYMAKER_NATIVE" => "kraken" }, <<~RUBY)
+      require "honeymaker"
+      print [Honeymaker.client("kraken").class, Honeymaker.exchange("kraken").class, Honeymaker.backend(:kraken),
+             Honeymaker.client("binance").class, $LOADED_FEATURES.grep(/honeymaker_native\\.(so|bundle|dll)\\z/).size].join(",")
+    RUBY
+    assert st.success?, out
+    assert_equal "Honeymaker::Native::KrakenClient,Honeymaker::Native::KrakenExchange,native,Honeymaker::Clients::Binance,1", out
+  end
+end

data/test/native/convert_test.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "bigdecimal"
+
+class Honeymaker::Native::ConvertTest < Minitest::Test
+  def setup
+    Honeymaker::Native.load!
+  rescue LoadError
+    raise if ENV["HONEYMAKER_REQUIRE_NATIVE"]
+
+    skip "native extension not compiled"
+  end
+
+  def ext = Honeymaker::Native::Ext
+
+  def test_numeric_text_matches_ruby_to_s
+    [1.0e-09, -0.0, 0.0, 1.0e20, 1688888888.1234, Float::MIN, Float::MAX,
+     Float::INFINITY, -Float::INFINITY, Float::NAN, 12345678901234567890123].each do |value|
+      assert_equal value.to_s, ext.to_s_for_tests(value)
+    end
+  end
+
+  def test_decimal_json_and_to_s_follow_ruby
+    ["0.5", 12345678901234567890123, 1.0e-09, -0.0, Float::INFINITY,
+     -Float::INFINITY, Float::NAN, nil, true, false, [], { "k" => 1 }].each do |value|
+      [true, false].each do |stringify|
+        want = (BigDecimal(stringify ? value.to_s : value) rescue $!)
+        got = (ext.decimal_convert_for_tests(value, stringify) rescue $!)
+        assert_equal want.class, got.class, [value, stringify].inspect
+        if want.is_a?(Exception)
+          assert_equal want.message, got.message
+        else
+          assert_equal [want.to_s, want.sign], [got.to_s, got.sign]
+        end
+      end
+    end
+  end
+
+  def test_decimal_arithmetic_survives_gc_in_rust_container
+    [["1", "3"], ["-0.0", "2"], ["NaN", "Infinity"], ["1", "0"]].each do |a, b|
+      left, right = BigDecimal(a), BigDecimal(b)
+      want = [left + right, left - right, left / right]
+      GC.stress = true
+      got = ext.decimal_arithmetic_for_tests(a, b)
+      GC.stress = false
+      assert_equal want.map { |n| [n.to_s, n.sign] }, got.take(3).map { |n| [n.to_s, n.sign] }
+      assert_equal left.zero?, got[3]
+    end
+  ensure
+    GC.stress = false
+  end
+
+  def test_non_utf8_strings_roundtrip_with_bytes_and_encoding
+    ["O\xff", "O\xff".b, "é".b, "é".encode("ISO-8859-1")].each do |value|
+      got = ext.roundtrip_for_tests([value]).first
+      assert_equal value.bytes, got.bytes
+      assert_equal value.encoding, got.encoding
+    end
+  end
+
+  def test_invalid_string_hash_keys_roundtrip
+    ["O\xff", "O\xff".b, "é".b].each do |key|
+      got = ext.roundtrip_for_tests({ key => "value" }).keys.first
+      assert_equal key.bytes, got.bytes
+      assert_equal key.encoding, got.encoding
+    end
+  end
+
+  def test_internal_string_sentinel_names_are_ordinary_hash_keys
+    obj = { "\0ruby_string" => [[], "UTF-8"], "\0ruby_key:\"literal\"" => "value" }
+    assert_equal obj, ext.roundtrip_for_tests(obj)
+    assert_equal({ "\0ruby_string" => [[], "UTF-8"] }, ext.roundtrip_for_tests({ "\0ruby_string" => [[], "UTF-8"] }))
+  end
+
+  def test_invalid_decimal_strings_use_rubys_own_errors
+    ["1\xff", "1\xff".b].each do |value|
+      [true, false].each do |stringify|
+        want = (BigDecimal(value) rescue $!)
+        got = (ext.decimal_convert_for_tests(value, stringify) rescue $!)
+        assert_equal [want.class, want.message], [got.class, got.message]
+      end
+    end
+  end
+
+  def test_shape_errors
+    error = assert_raises(Honeymaker::Native::ShapeError) { ext.roundtrip_for_tests({ key: 1 }) }
+    assert_equal "non-string key", error.message
+    error = assert_raises(Honeymaker::Native::ShapeError) { ext.roundtrip_for_tests(:unsupported) }
+    assert_equal "unsupported value :unsupported", error.message
+  end
+
+  def test_false_negative_infinity_nan_and_negative_zero
+    got = ext.roundtrip_for_tests([false, -Float::INFINITY, Float::NAN, -0.0])
+    assert_equal false, got[0]
+    assert_equal(-Float::INFINITY, got[1])
+    assert_predicate got[2], :nan?
+    assert_equal(-Float::INFINITY, 1.0 / got[3])
+  end
+
+  def test_json_roundtrip_is_exact
+    obj = JSON.parse('{"i":12345678901234567890123,"f":1688888888.1234,"e":1e-09,"z":-0.0,"s":"\u00e9","n":null,' \
+                     '"b":true,"a":[1,2.5,"x"],"big":1e400,"o":{"k":{"k2":[]}}}')
+    got = ext.roundtrip_for_tests(obj)
+    assert_equal obj.keys, got.keys
+    obj.keys.each do |k|
+      v = obj[k]
+      assert_equal v.class, got[k].class, k
+      assert(v.is_a?(Float) ? v.eql?(got[k]) : v == got[k], k)
+    end
+    assert_equal Encoding::UTF_8, got["s"].encoding
+  end
+
+  def test_decimal_is_rubys_own
+    ["0.5", "-0.0000", "NaN", "Infinity", "1_000", "1e-9"].each do |s|
+      want = BigDecimal(s)
+      got = ext.decimal_for_tests(s)
+      assert_equal [want.to_s, want.sign], [got.to_s, got.sign], s
+    end
+    ["", "abc", "true", "[]", "{}"].each do |s|
+      want = (BigDecimal(s) rescue $!)
+      got = (ext.decimal_for_tests(s) rescue $!)
+      assert_equal [want.class, want.message], [got.class, got.message], s.inspect
+    end
+  end
+
+  def test_survives_gc_stress_and_compaction
+    obj = JSON.parse({ "rows" => (1..2_000).map { |i| { "id" => "O#{i}", "vol" => "0.#{i}", "t" => i + 0.5 } } }.to_json)
+    GC.stress = true
+    got = ext.roundtrip_for_tests(obj)
+    GC.stress = false
+    GC.compact if GC.respond_to?(:compact)
+    assert_equal obj, got
+  ensure
+    GC.stress = false
+  end
+end

data/test/native/gem_isolation_test.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "open3"
+
+# Spec §2.2: the platform gems cross-compile with nothing but pure-Rust crypto. The async client
+# lives in the same Cargo workspace, so this proves the extension never pulls it in.
+class Honeymaker::Native::GemIsolationTest < Minitest::Test
+  FORBIDDEN = /\A(tokio|tokio-rustls|hyper|hyper-util|rustls|ring|aws-lc-rs|aws-lc-sys|webpki-roots|honeymaker-client) /
+
+  def test_the_extension_does_not_depend_on_the_async_client_stack
+    out, status = Open3.capture2("cargo", "tree", "--locked", "-p", "honeymaker_native", "-e", "normal,build",
+                                 "--prefix", "none", chdir: File.expand_path("../..", __dir__))
+    assert status.success?, "cargo tree failed"
+    assert_empty out.lines.grep(FORBIDDEN).uniq
+  end
+end

data/test/native/loader_test.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::Native::LoaderTest < Minitest::Test
+  def setup
+    Honeymaker::Native.load!
+  rescue LoadError => e
+    raise if ENV["HONEYMAKER_REQUIRE_NATIVE"]
+
+    skip "native extension not compiled (#{e.message})"
+  end
+
+  def test_extension_reports_the_gem_version
+    assert_equal Honeymaker::VERSION, Honeymaker::Native::Ext.version
+  end
+
+  def test_flag_parsing
+    Honeymaker::Native.instance_variable_set(:@enabled, nil)
+    ENV["HONEYMAKER_NATIVE"] = " KRAKEN, ,kraken "
+    assert_equal %w[kraken], Honeymaker::Native.enabled
+    assert Honeymaker::Native.enabled?(:kraken)
+    assert Honeymaker::Native.enabled?(" KRAKEN ")
+    refute Honeymaker::Native.enabled?("bybit")
+  ensure
+    ENV.delete("HONEYMAKER_NATIVE")
+    Honeymaker::Native.instance_variable_set(:@enabled, nil)
+  end
+end

data/test/native/lockstep_test.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "tmpdir"
+
+class Honeymaker::Native::LockstepTest < Minitest::Test
+  def test_cargo_workspace_version_equals_gem_version
+    cargo = File.read(File.expand_path("../../Cargo.toml", __dir__))
+    assert_equal Honeymaker::VERSION, cargo[/^\[workspace\.package\].*?^version = "([^"]+)"/m, 1]
+  end
+
+  def test_bump_updates_cargo_too
+    rakefile = File.expand_path("../../Rakefile", __dir__)
+    Dir.mktmpdir do |dir|
+      FileUtils.mkdir_p(File.join(dir, "lib/honeymaker"))
+      File.write(File.join(dir, "lib/honeymaker/version.rb"), %(module Honeymaker\n  VERSION = "1.2.3"\nend\n))
+      File.write(File.join(dir, "Cargo.toml"), %([workspace]\nmembers = []\n\n[workspace.package]\nversion = "1.2.3" # c\n))
+      out = Dir.chdir(dir) { `HONEYMAKER_RAKEFILE_LIB_ONLY=1 #{RbConfig.ruby} -rrake -e 'load "#{rakefile}"; bump_version(:minor)' 2>&1` }
+      assert_includes out, "1.3.0"
+      assert_includes File.read(File.join(dir, "Cargo.toml")), %(version = "1.3.0" # c)
+    end
+  end
+end

data/test/native/signing_smoke_test.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class KrakenSigningSmokeTest < Minitest::Test
+  def setup
+    Honeymaker::Native.load!
+    require_relative "../support/kraken_signing_smoke"
+  rescue LoadError => e
+    raise if ENV["HONEYMAKER_REQUIRE_NATIVE"]
+
+    skip e.message
+  end
+
+  def test_real_signing_vector
+    assert KrakenSigningSmoke.verify!
+  end
+
+  def test_rejects_incorrect_key_or_signature
+    vector = JSON.parse(File.read(KrakenSigningSmoke::VECTORS)).find { |v| !v.fetch("api_key").empty? && !v.fetch("api_secret").empty? }
+    %w[API-Key API-Sign].each do |field|
+      signer = stub(sign: vector.fetch("headers").merge(field => "wrong"))
+      Honeymaker::Native::Ext::Kraken.stubs(:new).with(vector.fetch("api_key"), vector.fetch("api_secret")).returns(signer)
+      _, stderr = capture_io { assert_raises(SystemExit) { KrakenSigningSmoke.verify! } }
+      assert_match(/#{field}/, stderr)
+    end
+  end
+end