honeymaker 0.12.4-aarch64-linux

data/test/release/push_gems_test.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "tmpdir"
+require "digest"
+require "rubygems/package"
+
+class PushGemsTest < Minitest::Test
+  SCRIPT = File.expand_path("../../script/release/push_gems.sh", __dir__)
+
+  PLATFORMS = %w[x86_64-linux aarch64-linux x86_64-darwin arm64-darwin x64-mingw-ucrt].freeze
+
+  def build_gem(dir, platform)
+    spec = Gem::Specification.new do |s|
+      s.name = "honeymaker"
+      s.version = "9.9.9"
+      s.summary = "t"
+      s.authors = ["t"]
+      s.files = []
+      s.platform = platform
+    end
+    Dir.chdir(dir) { Gem::Package.build(spec) }
+    File.join(dir, spec.file_name)
+  end
+
+  def run_script(gems_dir, published_sha:, push_fails:)
+    Dir.mktmpdir do |bin|
+      log = File.join(bin, "log")
+      File.write(File.join(bin, "gem"), "#!/bin/sh\necho \"push $2\" >> #{log}\n#{push_fails ? 'exit 1' : 'exit 0'}\n")
+      File.write(File.join(bin, "curl"), "#!/bin/sh\necho '{\"sha\":\"#{published_sha}\"}'\n")
+      File.chmod(0o755, File.join(bin, "gem"), File.join(bin, "curl"))
+      out = `PATH=#{bin}:$PATH #{SCRIPT} #{gems_dir} 9.9.9 2>&1`
+      [$?.success?, out, File.exist?(log) ? File.read(log).lines.map { |l| File.basename(l.split.last) } : []]
+    end
+  end
+
+  def full_set(dir)
+    plats = PLATFORMS.map { |pl| build_gem(dir, pl) }
+    [plats, build_gem(dir, "ruby")]
+  end
+
+  def test_platform_gems_first_then_source_and_idempotent_on_identical_rerun
+    Dir.mktmpdir do |dir|
+      plats, source = full_set(dir)
+      ok, _out, order = run_script(dir, published_sha: "x", push_fails: false)
+      assert ok
+      assert_equal plats.map { |g| File.basename(g) } + [File.basename(source)], order
+      ok, out, = run_script(dir, published_sha: Digest::SHA256.file(plats.first).hexdigest, push_fails: true)
+      refute ok, "only the first gem matches the stubbed sha, so the run must stop at the second"
+      assert_includes out, "already published with the same checksum"
+    end
+  end
+
+  def test_mismatched_published_gem_fails
+    Dir.mktmpdir do |dir|
+      full_set(dir)
+      ok, out, = run_script(dir, published_sha: "deadbeef", push_fails: true)
+      refute ok
+      assert_includes out, "differs from the published gem"
+    end
+  end
+
+  def test_missing_or_empty_artifacts_push_nothing_and_fail
+    Dir.mktmpdir do |dir|
+      ok, out, order = run_script(File.join(dir, "nope"), published_sha: "x", push_fails: false)
+      refute ok
+      assert_empty order
+      ok, out, order = run_script(dir, published_sha: "x", push_fails: false)
+      refute ok, out
+      assert_empty order
+      PLATFORMS.first(4).each { |pl| build_gem(dir, pl) }
+      build_gem(dir, "ruby")
+      ok, out, order = run_script(dir, published_sha: "x", push_fails: false)
+      refute ok, "one platform missing must block the whole release"
+      assert_includes out, "missing honeymaker-9.9.9-x64-mingw-ucrt.gem"
+      assert_empty order
+    end
+  end
+end

data/test/smoke.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# Runs against an INSTALLED gem (no bundler, no -Ilib) on native CI runners.
+# EXPECT_PLATFORM=x86_64-linux (platform gem) or EXPECT_PLATFORM=ruby (source gem, compiled on install).
+require "honeymaker"
+
+Honeymaker::Native.load!
+abort "native #{Honeymaker::Native::Ext.version} != gem #{Honeymaker::VERSION}" unless Honeymaker::Native::Ext.version == Honeymaker::VERSION
+spec = Gem.loaded_specs.fetch("honeymaker")
+expected = ENV.fetch("EXPECT_PLATFORM")
+abort "installed platform #{spec.platform} != #{expected}" unless spec.platform.to_s == expected
+puts "smoke ok #{RUBY_VERSION} #{RUBY_PLATFORM} #{spec.full_name}"
+
+require "uri"
+ext = Honeymaker::Native::Ext::Kraken.new("k", "c2VjcmV0")
+path, pairs = ext.build_post("get_extended_balance", {})
+body = URI.encode_www_form(pairs)
+headers = ext.sign(path, body)
+abort "bad build #{path} #{body} #{headers.keys}" unless path == "/0/private/BalanceEx" && body.start_with?("nonce=") && headers["API-Sign"]
+puts "smoke kraken ok"
+
+require_relative "support/kraken_signing_smoke"
+KrakenSigningSmoke.verify!
+puts "smoke kraken signing vector ok"

data/test/support/fixture_helper.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "json"
+
+module FixtureHelper
+  def fixture_path(name)
+    File.join(File.dirname(__FILE__), "..", "fixtures", name)
+  end
+
+  def load_fixture(name)
+    JSON.parse(File.read(fixture_path(name)))
+  end
+end

data/test/support/kraken_signing_smoke.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "json"
+
+module KrakenSigningSmoke
+  VECTORS = File.expand_path("../../crates/honeymaker/tests/vectors/kraken_signing.json", __dir__)
+
+  def self.verify!
+    vector = JSON.parse(File.read(VECTORS)).find do |entry|
+      !entry.fetch("api_key").empty? && !entry.fetch("api_secret").empty?
+    end
+    abort "no authenticated Kraken signing vector" unless vector
+
+    signer = Honeymaker::Native::Ext::Kraken.new(vector.fetch("api_key"), vector.fetch("api_secret"))
+    headers = signer.sign(vector.fetch("path"), vector.fetch("body"))
+    %w[API-Key API-Sign].each do |field|
+      abort "Kraken signing vector mismatch: #{field}" unless headers[field] == vector.fetch("headers").fetch(field)
+    end
+    true
+  end
+end

data/test/support/parity_helper.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+require_relative "venue_double"
+
+# Same-process parity; the legacy client is the oracle. Exact comparison: class, value, String
+# encoding, Float#eql?, BigDecimal sign, Hash key order.
+module ParityHelper
+  def self.included(base)
+    base.class_eval do
+      def setup
+        Honeymaker::Native.load!
+        require "honeymaker/native/kraken"
+      rescue LoadError
+        raise if ENV["HONEYMAKER_REQUIRE_NATIVE"]
+
+        skip "native extension not compiled"
+      end
+    end
+  end
+
+  def assert_same_ruby(expected, actual, path = "result")
+    return assert_same_exception(expected, actual, path) if expected.is_a?(Exception)
+
+    assert_equal expected.class, actual.class, "#{path}: class"
+    case expected
+    when Honeymaker::Result
+      assert_same_ruby(expected.errors, actual.errors, "#{path}.errors")
+      assert_same_ruby(expected.data, actual.data, "#{path}.data")
+    when Hash
+      assert_equal expected.keys, actual.keys, "#{path}: keys/order"
+      expected.each { |k, v| assert_same_ruby(v, actual[k], "#{path}[#{k.inspect}]") }
+    when Array
+      assert_equal expected.length, actual.length, "#{path}: length"
+      expected.each_with_index { |v, i| assert_same_ruby(v, actual[i], "#{path}[#{i}]") }
+    when String
+      assert_equal expected.encoding, actual.encoding, "#{path}: encoding"
+      assert_equal expected.b, actual.b, "#{path}: bytes"
+    when Float
+      assert expected.eql?(actual) || (expected.nan? && actual.nan?), "#{path}: #{expected} vs #{actual}"
+    when BigDecimal
+      assert_equal [expected.to_s, expected.sign], [actual.to_s, actual.sign], "#{path}: BigDecimal"
+    else
+      if expected.nil?
+        assert_nil actual, "#{path}: value"
+      else
+        assert_equal expected, actual, "#{path}: value"
+      end
+    end
+  end
+
+  # The one documented divergence (spec §5.1): legacy's incidental NoMethodError/TypeError on a
+  # nonsensical shape vs ShapeError. Never excuses decimal errors (ArgumentError must match exactly).
+  def assert_same_exception(expected, actual, path)
+    assert_kind_of Exception, actual, "#{path}: native returned instead of raising"
+    if actual.is_a?(Honeymaker::Native::ShapeError)
+      assert_includes [NoMethodError, TypeError], expected.class, "#{path}: ShapeError only replaces shape crashes"
+    else
+      assert_equal [expected.class, expected.message], [actual.class, actual.message], path
+    end
+  end
+end

data/test/support/venue_double.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "socket"
+
+# Plain-HTTP local venue: scripted replies, recorded requests. Both backends talk to it through
+# the same legacy Faraday connection, one after the other, so URLs in messages are equal.
+class VenueDouble
+  Request = Struct.new(:method, :target, :headers, :body, keyword_init: true)
+
+  attr_reader :port, :requests
+
+  def initialize(replies)
+    reset!(replies)
+    @tcp = TCPServer.new("127.0.0.1", 0)
+    @port = @tcp.addr[1]
+    @thread = Thread.new { loop { serve(@tcp.accept) } }
+  end
+
+  def reset!(replies)
+    @replies = replies.dup
+    @requests = []
+  end
+
+  def url = "http://127.0.0.1:#{port}"
+
+  def close
+    @thread.kill
+    @tcp.close
+  end
+
+  private
+
+  def serve(sock)
+    Thread.new do
+      loop do
+        req = read_request(sock) or break
+        @requests << req
+        status, headers, body = @replies.length > 1 ? @replies.shift : @replies.first
+        body = body.to_s.b
+        h = { "content-length" => body.bytesize.to_s }.merge(headers)
+        sock.write "HTTP/1.1 #{status} X\r\n#{h.map { |k, v| "#{k}: #{v}\r\n" }.join}\r\n#{body}"
+      end
+    rescue StandardError
+      nil
+    ensure
+      sock.close rescue nil
+    end
+  end
+
+  def read_request(io)
+    head = +""
+    head << io.readpartial(4096) until head.include?("\r\n\r\n")
+    line, *hdrs = head.split("\r\n\r\n", 2).first.split("\r\n")
+    headers = hdrs.to_h { |h| k, v = h.split(": ", 2); [k.downcase, v] }
+    body = head.split("\r\n\r\n", 2)[1].to_s.b
+    body << io.readpartial(4096) while body.bytesize < headers["content-length"].to_i
+    method, target, = line.split(" ")
+    Request.new(method: method, target: target, headers: headers, body: body)
+  rescue EOFError, IOError
+    nil
+  end
+end
+
+# HTTP proxy double: records the first request line of each proxied connection and forwards the
+# bytes to 127.0.0.1:<upstream_port> (absolute-form for http targets, as Net::HTTP sends them).
+class ProxyDouble
+  attr_reader :port, :lines
+
+  def initialize(upstream_port)
+    @lines = []
+    @tcp = TCPServer.new("127.0.0.1", 0)
+    @port = @tcp.addr[1]
+    @thread = Thread.new do
+      loop do
+        s = @tcp.accept
+        Thread.new do
+          head = +""
+          head << s.readpartial(4096) until head.include?("\r\n\r\n")
+          @lines << head.lines.first
+          up = TCPSocket.new("127.0.0.1", upstream_port)
+          up.write(head)
+          t = Thread.new { IO.copy_stream(s, up) rescue nil }
+          IO.copy_stream(up, s) rescue nil
+          t.join(1)
+        rescue StandardError
+          nil
+        ensure
+          s.close rescue nil
+        end
+      end
+    end
+  end
+
+  def url = "http://127.0.0.1:#{port}"
+
+  def close
+    @thread.kill
+    @tcp.close
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "mocha/minitest"
+require "ostruct"
+require "honeymaker"
+
+# Load fixture helpers
+require_relative "support/fixture_helper"

metadata

@@ -0,0 +1,254 @@
+--- !ruby/object:Gem::Specification
+name: honeymaker
+version: !ruby/object:Gem::Version
+  version: 0.12.4
+platform: aarch64-linux
+authors:
+- Deltabadger
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2026-10-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: faraday-net_http_persistent
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: net-http-persistent
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: jwt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: bigdecimal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Unified interface for cryptocurrency exchange APIs — market data, trading,
+  balances, and orders. Supports Binance, Kraken, Coinbase, Bybit, KuCoin, Bitget,
+  MEXC, and more.
+email:
+- hello@deltabadger.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/native-gems.yml"
+- ".github/workflows/release.yml"
+- ".github/workflows/test.yml"
+- LICENSE
+- README.md
+- Rakefile
+- crates/honeymaker/tests/vectors/decimal.json
+- crates/honeymaker/tests/vectors/kraken_add_order_wire.json
+- crates/honeymaker/tests/vectors/kraken_signing.json
+- crates/honeymaker/tests/vectors/kraken_trades_pager.json
+- lib/honeymaker.rb
+- lib/honeymaker/3.4/honeymaker_native.so
+- lib/honeymaker/4.0/honeymaker_native.so
+- lib/honeymaker/client.rb
+- lib/honeymaker/clients/binance.rb
+- lib/honeymaker/clients/binance_us.rb
+- lib/honeymaker/clients/bingx.rb
+- lib/honeymaker/clients/bitget.rb
+- lib/honeymaker/clients/bitrue.rb
+- lib/honeymaker/clients/bitvavo.rb
+- lib/honeymaker/clients/bybit.rb
+- lib/honeymaker/clients/coinbase.rb
+- lib/honeymaker/clients/gemini.rb
+- lib/honeymaker/clients/hyperliquid.rb
+- lib/honeymaker/clients/kraken.rb
+- lib/honeymaker/clients/kraken_futures.rb
+- lib/honeymaker/clients/kucoin.rb
+- lib/honeymaker/clients/mexc.rb
+- lib/honeymaker/exchange.rb
+- lib/honeymaker/exchanges/binance.rb
+- lib/honeymaker/exchanges/binance_us.rb
+- lib/honeymaker/exchanges/bingx.rb
+- lib/honeymaker/exchanges/bitget.rb
+- lib/honeymaker/exchanges/bitrue.rb
+- lib/honeymaker/exchanges/bitvavo.rb
+- lib/honeymaker/exchanges/bybit.rb
+- lib/honeymaker/exchanges/coinbase.rb
+- lib/honeymaker/exchanges/gemini.rb
+- lib/honeymaker/exchanges/hyperliquid.rb
+- lib/honeymaker/exchanges/kraken.rb
+- lib/honeymaker/exchanges/kucoin.rb
+- lib/honeymaker/exchanges/mexc.rb
+- lib/honeymaker/native.rb
+- lib/honeymaker/native/kraken.rb
+- lib/honeymaker/result.rb
+- lib/honeymaker/utils.rb
+- lib/honeymaker/version.rb
+- script/parity/kraken_client_live.rb
+- script/parity/kraken_live.rb
+- script/parity/kraken_transport.rb
+- script/parity/resolve.c
+- script/release/push_gems.sh
+- script/vectors/kraken.rb
+- script/vectors/kraken_stage2.rb
+- sig/honeymaker.rbs
+- test/fixtures/binance_book_ticker.json
+- test/fixtures/binance_exchange_info.json
+- test/fixtures/bingx_symbols.json
+- test/fixtures/bingx_ticker.json
+- test/fixtures/bitget_symbols.json
+- test/fixtures/bitget_tickers.json
+- test/fixtures/bitmart_symbols.json
+- test/fixtures/bitmart_ticker.json
+- test/fixtures/bitrue_book_ticker.json
+- test/fixtures/bitrue_exchange_info.json
+- test/fixtures/bitvavo_book_ticker.json
+- test/fixtures/bitvavo_markets.json
+- test/fixtures/bybit_instruments.json
+- test/fixtures/bybit_tickers.json
+- test/fixtures/coinbase_product.json
+- test/fixtures/coinbase_products.json
+- test/fixtures/gemini_pubticker.json
+- test/fixtures/gemini_symbol_detail.json
+- test/fixtures/gemini_symbols.json
+- test/fixtures/hyperliquid_all_mids.json
+- test/fixtures/hyperliquid_spot_meta.json
+- test/fixtures/kraken_asset_pairs.json
+- test/fixtures/kraken_ticker.json
+- test/fixtures/kucoin_orderbook_level1.json
+- test/fixtures/kucoin_symbols.json
+- test/fixtures/mexc_book_ticker.json
+- test/fixtures/mexc_exchange_info.json
+- test/honeymaker/client_test.rb
+- test/honeymaker/clients/binance_client_test.rb
+- test/honeymaker/clients/binance_us_client_test.rb
+- test/honeymaker/clients/bingx_client_test.rb
+- test/honeymaker/clients/bitget_client_test.rb
+- test/honeymaker/clients/bitrue_client_test.rb
+- test/honeymaker/clients/bitvavo_client_test.rb
+- test/honeymaker/clients/bybit_client_test.rb
+- test/honeymaker/clients/coinbase_client_test.rb
+- test/honeymaker/clients/gemini_client_test.rb
+- test/honeymaker/clients/honeymaker_client_registry_test.rb
+- test/honeymaker/clients/hyperliquid_client_test.rb
+- test/honeymaker/clients/kraken_client_test.rb
+- test/honeymaker/clients/kraken_futures_client_test.rb
+- test/honeymaker/clients/kucoin_client_test.rb
+- test/honeymaker/clients/mexc_client_test.rb
+- test/honeymaker/clients/validation_test.rb
+- test/honeymaker/error_chain_test.rb
+- test/honeymaker/exchange_test.rb
+- test/honeymaker/exchanges/binance_test.rb
+- test/honeymaker/exchanges/binance_us_test.rb
+- test/honeymaker/exchanges/bingx_test.rb
+- test/honeymaker/exchanges/bitget_test.rb
+- test/honeymaker/exchanges/bitrue_test.rb
+- test/honeymaker/exchanges/bitvavo_test.rb
+- test/honeymaker/exchanges/bybit_test.rb
+- test/honeymaker/exchanges/coinbase_test.rb
+- test/honeymaker/exchanges/gemini_catalogue_test.rb
+- test/honeymaker/exchanges/gemini_test.rb
+- test/honeymaker/exchanges/hyperliquid_test.rb
+- test/honeymaker/exchanges/kraken_test.rb
+- test/honeymaker/exchanges/kucoin_test.rb
+- test/honeymaker/exchanges/mexc_test.rb
+- test/honeymaker/honeymaker_test.rb
+- test/honeymaker/result_test.rb
+- test/honeymaker/utils_test.rb
+- test/native/backend_switch_test.rb
+- test/native/convert_test.rb
+- test/native/gem_isolation_test.rb
+- test/native/loader_test.rb
+- test/native/lockstep_test.rb
+- test/native/signing_smoke_test.rb
+- test/parity/kraken_client_parity_test.rb
+- test/parity/kraken_exchange_parity_test.rb
+- test/release/branch_hardening_test.rb
+- test/release/push_gems_test.rb
+- test/smoke.rb
+- test/support/fixture_helper.rb
+- test/support/kraken_signing_smoke.rb
+- test/support/parity_helper.rb
+- test/support/venue_double.rb
+- test/test_helper.rb
+homepage: https://github.com/deltabadger/honeymaker
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/deltabadger/honeymaker
+  source_code_uri: https://github.com/deltabadger/honeymaker
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: 4.1.dev
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.23
+signing_key: 
+specification_version: 4
+summary: Ruby clients for cryptocurrency exchange APIs
+test_files: []