honeymaker 0.12.2 → 0.12.4

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/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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: honeymaker
 version: !ruby/object:Gem::Version
-  version: 0.12.2
+  version: 0.12.4
 platform: ruby
 authors:
 - Deltabadger
@@ -79,19 +79,76 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rb_sys
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.130
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.130
 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: []
+extensions:
+- ext/honeymaker_native/extconf.rb
 extra_rdoc_files: []
 files:
+- ".github/workflows/native-gems.yml"
+- ".github/workflows/release.yml"
 - ".github/workflows/test.yml"
+- Cargo.lock
+- Cargo.toml
 - LICENSE
 - README.md
 - Rakefile
+- crates/honeymaker-client/Cargo.toml
+- crates/honeymaker-client/examples/probe.rs
+- crates/honeymaker-client/src/kraken.rs
+- crates/honeymaker-client/src/lib.rs
+- crates/honeymaker-client/src/transport.rs
+- crates/honeymaker-client/src/transport/connect.rs
+- crates/honeymaker-client/src/transport/io_timeout.rs
+- crates/honeymaker-client/src/transport/response.rs
+- crates/honeymaker-client/tests/classification.rs
+- crates/honeymaker-client/tests/kraken_client.rs
+- crates/honeymaker-client/tests/response.rs
+- crates/honeymaker-client/tests/support/mod.rs
+- crates/honeymaker-client/tests/transport.rs
+- crates/honeymaker/Cargo.toml
+- crates/honeymaker/src/encode.rs
+- crates/honeymaker/src/kraken/lookup.rs
+- crates/honeymaker/src/kraken/mod.rs
+- crates/honeymaker/src/kraken/normalize.rs
+- crates/honeymaker/src/kraken/requests.rs
+- crates/honeymaker/src/kraken/sign.rs
+- crates/honeymaker/src/kraken/trades.rs
+- crates/honeymaker/src/lib.rs
+- crates/honeymaker/src/num.rs
+- crates/honeymaker/src/semantics.rs
+- crates/honeymaker/src/types.rs
+- crates/honeymaker/tests/kraken_stage2.rs
+- crates/honeymaker/tests/kraken_trades_pager.rs
+- crates/honeymaker/tests/kraken_vectors.rs
+- 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
+- ext/honeymaker_native/Cargo.toml
+- ext/honeymaker_native/extconf.rb
+- ext/honeymaker_native/src/convert.rs
+- ext/honeymaker_native/src/kraken.rs
+- ext/honeymaker_native/src/lib.rs
+- ext/honeymaker_native/src/ruby_decimal.rs
 - lib/honeymaker.rb
 - lib/honeymaker/client.rb
 - lib/honeymaker/clients/binance.rb
@@ -122,9 +179,18 @@ files:
 - 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
@@ -189,7 +255,21 @@ files:
 - 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:
@@ -204,14 +284,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.2.0
+      version: 3.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Ruby clients for cryptocurrency exchange APIs
 test_files: []