honeymaker 0.12.4-aarch64-linux

data/lib/honeymaker.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "faraday/net_http_persistent"
+require "json"
+
+require_relative "honeymaker/version"
+require_relative "honeymaker/result"
+require_relative "honeymaker/utils"
+require_relative "honeymaker/exchange"
+require_relative "honeymaker/client"
+require_relative "honeymaker/native"
+require_relative "honeymaker/clients/binance"
+require_relative "honeymaker/clients/binance_us"
+require_relative "honeymaker/clients/kraken"
+require_relative "honeymaker/clients/coinbase"
+require_relative "honeymaker/clients/bybit"
+require_relative "honeymaker/clients/mexc"
+require_relative "honeymaker/clients/bitget"
+require_relative "honeymaker/clients/kucoin"
+require_relative "honeymaker/clients/bitvavo"
+require_relative "honeymaker/clients/gemini"
+require_relative "honeymaker/clients/bingx"
+require_relative "honeymaker/clients/bitrue"
+require_relative "honeymaker/clients/hyperliquid"
+require_relative "honeymaker/clients/kraken_futures"
+require_relative "honeymaker/exchanges/binance"
+require_relative "honeymaker/exchanges/binance_us"
+require_relative "honeymaker/exchanges/kraken"
+require_relative "honeymaker/exchanges/coinbase"
+require_relative "honeymaker/exchanges/mexc"
+require_relative "honeymaker/exchanges/gemini"
+require_relative "honeymaker/exchanges/bitvavo"
+require_relative "honeymaker/exchanges/bitget"
+require_relative "honeymaker/exchanges/bybit"
+require_relative "honeymaker/exchanges/kucoin"
+require_relative "honeymaker/exchanges/hyperliquid"
+require_relative "honeymaker/exchanges/bingx"
+require_relative "honeymaker/exchanges/bitrue"
+
+if Honeymaker::Native.enabled?("kraken")
+  Honeymaker::Native.load! # fail at boot, not at the first order
+  require_relative "honeymaker/native/kraken"
+end
+
+module Honeymaker
+  class Error < StandardError; end
+
+  EXCHANGES = {
+    "binance" => Exchanges::Binance,
+    "binance_us" => Exchanges::BinanceUs,
+    "kraken" => Native.enabled?("kraken") ? Native::KrakenExchange : Exchanges::Kraken,
+    "coinbase" => Exchanges::Coinbase,
+    "mexc" => Exchanges::Mexc,
+    "gemini" => Exchanges::Gemini,
+    "bitvavo" => Exchanges::Bitvavo,
+    "bitget" => Exchanges::Bitget,
+    "bybit" => Exchanges::Bybit,
+    "kucoin" => Exchanges::Kucoin,
+    "hyperliquid" => Exchanges::Hyperliquid,
+    "bingx" => Exchanges::BingX,
+    "bitrue" => Exchanges::Bitrue
+  }.freeze
+
+  CLIENTS = {
+    "binance" => Clients::Binance,
+    "binance_us" => Clients::BinanceUs,
+    "kraken" => Native.enabled?("kraken") ? Native::KrakenClient : Clients::Kraken,
+    "coinbase" => Clients::Coinbase,
+    "bybit" => Clients::Bybit,
+    "mexc" => Clients::Mexc,
+    "bitget" => Clients::Bitget,
+    "kucoin" => Clients::Kucoin,
+    "bitvavo" => Clients::Bitvavo,
+    "gemini" => Clients::Gemini,
+    "bingx" => Clients::BingX,
+    "bitrue" => Clients::Bitrue,
+    "hyperliquid" => Clients::Hyperliquid,
+    "kraken_futures" => Clients::KrakenFutures
+  }.freeze
+
+  def self.backend(name)
+    Native.enabled?(name) ? :native : :ruby
+  end
+
+  def self.exchange(name)
+    klass = EXCHANGES[name.to_s]
+    raise Error, "Unknown exchange: #{name}" unless klass
+    klass.new
+  end
+
+  def self.client(name, **kwargs)
+    klass = CLIENTS[name.to_s]
+    raise Error, "Unknown exchange: #{name}" unless klass
+    klass.new(**kwargs)
+  end
+end

data/script/parity/kraken_client_live.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+# Live, read-only comparison of honeymaker-client (examples/probe) against the gem on the real Kraken
+# API, back to back. Places NO order: AddOrder runs only with validate=true, and only when
+# KRAKEN_KEY_CAN_TRADE=1.
+#   bundle exec ruby -Ilib script/parity/kraken_client_live.rb                          # public checks
+#   KRAKEN_API_KEY=… KRAKEN_API_SECRET=… KRAKEN_KNOWN_CL_ORD_ID=… KRAKEN_KNOWN_TXID=… \
+#     [KRAKEN_KEY_CAN_TRADE=1] [LOCAL_PROXY=1] bundle exec ruby -Ilib script/parity/kraken_client_live.rb
+# With a key, the known order (one placed with that cl_ord_id) is mandatory: it is the only proof
+# of Kraken's cl_ord_id filter, count and echo that order_by_client_id's absence rests on.
+# The key must be one lent for this check, never a bot's key: nonces are per key.
+require "honeymaker"
+require "bigdecimal"
+require "json"
+require "open3"
+require "securerandom"
+require "socket"
+require "time"
+
+ROOT = File.expand_path("../..", __dir__)
+system("cargo", "build", "--locked", "--quiet", "-p", "honeymaker-client", "--example", "probe", chdir: ROOT, exception: true)
+PROBE = File.join(ROOT, "target/debug/examples/probe")
+KEY = ENV["KRAKEN_API_KEY"]
+SECRET = ENV["KRAKEN_API_SECRET"]
+PRIVATE = !KEY.to_s.empty?
+KNOWN_CL_ORD_ID = ENV["KRAKEN_KNOWN_CL_ORD_ID"].to_s
+KNOWN_TXID = ENV["KRAKEN_KNOWN_TXID"].to_s
+if PRIVATE && (KNOWN_CL_ORD_ID.empty? || KNOWN_TXID.empty?)
+  abort "FAILED: a private run needs KRAKEN_KNOWN_CL_ORD_ID and KRAKEN_KNOWN_TXID (an order placed with that cl_ord_id)"
+end
+ASSET_MAP = Honeymaker::Clients::Kraken::ASSET_MAP
+FAILURES = []
+
+def rust(call, args, proxy)
+  out, st = Open3.capture2(PROBE, stdin_data: JSON.generate({ call: call, args: args, proxy: proxy, api_key: KEY, api_secret: SECRET }))
+  raise "probe failed" unless st.success?
+
+  sleep 1 # Kraken's private counter decays ~0.33/s
+  JSON.parse(out)
+end
+
+def legacy(proxy) = Honeymaker::Clients::Kraken.new(api_key: KEY, api_secret: SECRET, proxy: proxy)
+def raw_post(proxy, path, params) = legacy(proxy).then { |c| c.send(:post_private, path, { nonce: c.send(:nonce), **params }) }.tap { sleep 1 }
+
+def check(name, ok, detail = nil)
+  puts "#{ok ? 'PASS' : 'FAIL'} #{name}#{" — #{detail}" if detail}"
+  FAILURES << name unless ok
+end
+
+def d(x) = x.nil? ? nil : BigDecimal(x.to_s)
+
+# deltabadger's get_balances for one asset: last matching entry wins (Ruling R9). Rails digs
+# result and hold_trade with dig_or_raise, so a nil there is :raise (the client answers Ambiguous).
+def rails_free(result, sym)
+  return :raise if result.nil?
+
+  result.reduce(BigDecimal("0")) do |free, (code, b)|
+    base = code.split(".").first
+    next free unless (ASSET_MAP[base] || base) == sym
+    return :raise if b["balance"].nil? || b["hold_trade"].nil?
+
+    BigDecimal(b["balance"].to_s) - BigDecimal(b["hold_trade"].to_s)
+  end
+end
+
+def run(proxy)
+  tag = proxy ? " via CONNECT proxy" : ""
+  l = legacy(proxy).get_ticker_information(pair: "XBTEUR")
+  r = rust("prices", { pair: "XBTEUR" }, proxy)
+  if l.success? && r["class"] == "ok"
+    info = l.data["result"].values.first
+    rp = r["value"].transform_values { |v| BigDecimal(v) }
+    sane = rp.values.all?(&:positive?) && rp["bid"] <= rp["ask"]
+    near = ((rp["last"] - BigDecimal(info["c"][0])).abs / rp["last"]) < BigDecimal("0.01")
+    check("Ticker#{tag}", sane && near, "legacy last #{info['c'][0]}, rust last #{r['value']['last']}")
+  else
+    check("Ticker#{tag}", false, "legacy #{l.errors.inspect}, rust #{r.inspect}")
+  end
+  return unless PRIVATE
+
+  bal = legacy(proxy).get_extended_balance.data["result"]
+  syms = bal.to_h.keys.map { |c| b = c.split(".").first; ASSET_MAP[b] || b }.uniq | %w[EUR USD]
+  syms.each do |sym|
+    r = rust("balance", { asset: sym }, proxy)
+    want = rails_free(bal, sym)
+    if want == :raise
+      check("balance #{sym}#{tag} (Rails raises)", r["class"] == "ambiguous", r.inspect)
+    else
+      check("balance #{sym}#{tag}", r["class"] == "ok" && d(r["value"]) == want, "#{r['value']} vs #{want.to_s('F')}")
+    end
+  end
+
+  closed = raw_post(proxy, "/0/private/ClosedOrders", { ofs: 0 }).data["result"]
+  txids = closed["closed"].keys.first(5)
+  if txids.any?
+    q = legacy(proxy).query_orders_info(txid: txids.join(",")).data
+    r = rust("orders", { txids: txids }, proxy)
+    same = r["class"] == "ok" && r["value"].all? do |o|
+      g = q[o["txid"]]
+      g && g[:status].to_s == o["status"] && d(g[:price]) == d(o["price"]) && d(g[:amount]) == d(o["amount"]) &&
+        d(g[:quote_amount]) == d(o["quote_amount"]) && d(g[:amount_exec]) == d(o["amount_exec"]) &&
+        d(g[:quote_amount_exec]) == d(o["quote_amount_exec"]) && (g[:order_type] == :limit) == o["limit"] &&
+        (g[:side] == :sell) == o["sell"]
+    end
+    check("QueryOrders#{tag}", same && r["value"].size == q.size)
+
+    since = Time.now.to_i - (90 * 86_400)
+    lf = legacy(proxy).closed_orders_from_trades(order_ids: txids, start: since).data
+    r = rust("fills_from_trades", { txids: txids, since: Time.at(since).utc.iso8601 }, proxy)
+    same = r["class"] == "ok" && r["value"].size == lf.size && r["value"].all? do |o|
+      a = lf[o["txid"]]
+      a && d(a[:amount_exec]) == d(o["amount_exec"]) && d(a[:quote_amount_exec]) == d(o["quote_amount_exec"]) &&
+        (a[:price].nil? ? o["price"].nil? : (d(o["price"]) - a[:price]).abs <= a[:price].abs * BigDecimal("1e-30"))
+    end
+    check("TradesHistory aggregate#{tag}", same)
+  else
+    puts "SKIP QueryOrders/TradesHistory: the account has no closed orders"
+  end
+
+  nobody = SecureRandom.uuid
+  r = rust("order_by_client_id", { cl_ord_id: nobody, since: (Time.now.utc - 86_400).iso8601 }, proxy)
+  check("order_by_client_id(unknown) is a complete absence#{tag}", r["class"] == "ok" && r["value"].nil?, r.inspect)
+  filtered = raw_post(proxy, "/0/private/ClosedOrders", { cl_ord_id: nobody, ofs: 0 }).data["result"]
+  if closed["count"].to_i.positive?
+    check("ClosedOrders honours the cl_ord_id filter#{tag}", filtered["count"].to_i.zero? && filtered["closed"].to_h.empty?)
+  else
+    puts "SKIP cl_ord_id filter proof: the account has no closed orders"
+  end
+  r = rust("order_by_client_id", { cl_ord_id: KNOWN_CL_ORD_ID, since: (Time.now.utc - (30 * 86_400)).iso8601 }, proxy)
+  check("order_by_client_id finds a real order#{tag}", r["class"] == "ok" && r.dig("value", "txid") == KNOWN_TXID, r.inspect)
+  open_known = raw_post(proxy, "/0/private/OpenOrders", { cl_ord_id: KNOWN_CL_ORD_ID }).data["result"]["open"].to_h
+  if open_known.key?(KNOWN_TXID)
+    check("OpenOrders filters by cl_ord_id and echoes it#{tag}",
+          open_known.keys == [KNOWN_TXID] && open_known[KNOWN_TXID]["cl_ord_id"].to_s == KNOWN_CL_ORD_ID, open_known.keys.inspect)
+  else
+    puts "SKIP OpenOrders echo: the known order is no longer open"
+    closed_known = raw_post(proxy, "/0/private/ClosedOrders", { cl_ord_id: KNOWN_CL_ORD_ID, ofs: 0 }).data["result"]
+    check("ClosedOrders filters by cl_ord_id, counts and echoes it#{tag}",
+          closed_known["count"].to_i == 1 && closed_known["closed"].to_h.keys == [KNOWN_TXID] &&
+            closed_known["closed"][KNOWN_TXID]["cl_ord_id"].to_s == KNOWN_CL_ORD_ID, closed_known.inspect)
+  end
+
+  return unless ENV["KRAKEN_KEY_CAN_TRADE"] == "1"
+
+  deadline = -> { (Time.now.utc + 30).iso8601(3) }
+  l = legacy(proxy).add_order(ordertype: "market", type: "buy", volume: "0.0001", pair: "XBTEUR",
+                              cl_ord_id: SecureRandom.uuid, deadline: deadline.call, validate: true)
+  sleep 1
+  r = rust("add_order_validate", { pair: "XBTEUR", kind: "market", volume: "0.0001", quote_volume: false,
+                                   cl_ord_id: SecureRandom.uuid, deadline: deadline.call }, proxy)
+  check("AddOrder validate=true with cl_ord_id and deadline#{tag}", l.success? && r["class"] == "ok", "legacy #{l.errors.inspect}, rust #{r.inspect}")
+end
+
+# A local CONNECT proxy that only tunnels to api.kraken.com:443, recording each CONNECT line.
+def local_proxy
+  seen = []
+  tcp = TCPServer.new("127.0.0.1", 0)
+  Thread.new do
+    loop do
+      s = tcp.accept
+      Thread.new do
+        head = +""
+        head << s.readpartial(4096) until head.include?("\r\n\r\n")
+        line = head.lines.first.strip
+        seen << line
+        raise "refused #{line}" unless line == "CONNECT api.kraken.com:443 HTTP/1.1"
+
+        up = TCPSocket.new("api.kraken.com", 443)
+        s.write "HTTP/1.1 200 Connection established\r\n\r\n"
+        t = Thread.new { IO.copy_stream(s, up) rescue nil; up.close_write rescue nil }
+        IO.copy_stream(up, s) rescue nil
+        t.join(1)
+      rescue StandardError
+        nil
+      ensure
+        s.close rescue nil
+      end
+    end
+  end
+  ["http://127.0.0.1:#{tcp.addr[1]}", seen]
+end
+
+puts "private checks: #{PRIVATE ? 'on' : 'off (no key)'}; AddOrder validate: #{ENV['KRAKEN_KEY_CAN_TRADE'] == '1' ? 'on' : 'off'}"
+run(nil)
+if ENV["LOCAL_PROXY"] == "1"
+  url, seen = local_proxy
+  run(url)
+  check("both backends tunnelled through the proxy", seen.size >= 2 && seen.uniq == ["CONNECT api.kraken.com:443 HTTP/1.1"], seen.inspect)
+end
+abort "FAILED: #{FAILURES.join(', ')}" if FAILURES.any?
+puts "live comparison passed"

data/script/parity/kraken_live.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+# Read-only live comparison, legacy vs native, back to back against the real Kraken API.
+#   KRAKEN_API_KEY=… KRAKEN_API_SECRET=… KRAKEN_TXIDS=O1,O2 bundle exec ruby -Ilib script/parity/kraken_live.rb
+# Places NO order: AddOrder runs with validate: true.
+require "honeymaker"
+Honeymaker::Native.load!
+require "honeymaker/native/kraken"
+
+# Public checks always run (no key needed). Private checks run only with a key that is OURS or
+# lent for this purpose (a separate key: Kraken nonces are per key, so a bot's own key would race).
+key, secret, proxy = ENV["KRAKEN_API_KEY"], ENV["KRAKEN_API_SECRET"], ENV["PROXY"]
+private_checks = !key.to_s.empty?
+txids = ENV.fetch("KRAKEN_TXIDS", "").split(",").reject(&:empty?)
+abort "KRAKEN_TXIDS must name at least one order when a key is given" if private_checks && txids.empty?
+trade = ENV["KRAKEN_KEY_CAN_TRADE"] == "1" # only then run AddOrder validate: true
+legacy = Honeymaker::Clients::Kraken.new(api_key: key, api_secret: secret, proxy: proxy)
+native = Honeymaker::Native::KrakenClient.new(api_key: key, api_secret: secret, proxy: proxy)
+
+def shape(v)
+  case v
+  when Hash then v.to_h { |k, x| [k, shape(x)] }
+  when Array then v.map { |x| shape(x) }
+  else v.class
+  end
+end
+
+# A raw Kraken envelope that really answered: error == [] and a non-empty result of the given class.
+def envelope?(d, klass = Hash)
+  d.is_a?(Hash) && d["error"] == [] && d["result"].is_a?(klass) && !d["result"].empty?
+end
+
+DYNAMIC = { "GetApiKeyInfo" => ->(d) { d.merge("result" => d["result"].except("nonce", "lastUsed")) } }.freeze
+
+RAW = ->(d) { envelope?(d) }
+checks = [
+  [:equal, "AssetPairs", ->(c) { c.get_tradable_asset_pairs(aclass_base: "all") }, RAW],
+  [:equal, "Assets", ->(c) { c.get_asset_info }, RAW],
+  [:equal, "BalanceEx", ->(c) { c.get_extended_balance }, RAW],
+  [:equal, "balances", ->(c) { c.get_balances }, ->(d) { d.is_a?(Hash) && d.values.all? { |b| b[:free].is_a?(BigDecimal) } }],
+  [:equal, "GetApiKeyInfo", ->(c) { c.get_api_key_info }, RAW],
+  [:equal, "TradesHistory", ->(c) { c.get_trades_history }, ->(d) { envelope?(d) && d["result"]["trades"].is_a?(Hash) }],
+  [:equal, "Ledgers", ->(c) { c.get_ledgers }, ->(d) { envelope?(d) && d["result"]["ledger"].is_a?(Hash) }],
+  [:equal, "QueryOrders", ->(c) { c.query_orders_info(txid: txids.join(",")) }, ->(d) { d.is_a?(Hash) && txids.all? { |t| d.key?(t) } }],
+  [:equal, "closed_orders_from_trades", ->(c) { c.closed_orders_from_trades(order_ids: txids, start: Time.now.to_i - (90 * 86_400)) }, ->(d) { d.is_a?(Hash) }],
+  [:equal, "validate", ->(c) { c.validate(:trading) }, ->(d) { d == true }],
+  [:shape, "Ticker", ->(c) { c.get_ticker_information(pair: "XBTUSD") }, RAW],
+  [:shape, "OHLC", ->(c) { c.get_ohlc_data(pair: "XBTUSD", interval: 1440) }, RAW],
+  [:shape, "AddOrder validate", ->(c) { c.add_order(ordertype: "market", type: "buy", volume: "0.0001", pair: "XBTUSD", validate: true) },
+   ->(d) { d.is_a?(Hash) && envelope?(d[:raw]) && d[:raw]["result"]["descr"].is_a?(Hash) }]
+]
+
+failures = 0
+public_names = %w[AssetPairs Assets Ticker OHLC]
+checks.select! { |_, name, _, _| public_names.include?(name) || private_checks }
+checks.reject! { |_, name, _, _| name == "AddOrder validate" && !trade }
+puts "private checks: #{private_checks ? 'on' : 'off (no key)'}; AddOrder validate: #{trade ? 'on' : 'off'}"
+checks.each do |mode, name, call, valid|
+  l = call.call(legacy)
+  sleep 1 # Kraken's private counter decays ~0.33/s; keep the pair adjacent but polite
+  n = call.call(native)
+  norm = DYNAMIC.fetch(name, ->(d) { d })
+  ok = l.success? && n.success? && valid.call(l.data) && valid.call(n.data) &&
+       (mode == :equal ? norm.call(l.data) == norm.call(n.data) : shape(l.data) == shape(n.data))
+  failures += 1 unless ok
+  puts format("%-26s %-5s %s", name, mode, ok ? "OK" : "FAIL\n  legacy=#{l.inspect[0, 500]}\n  native=#{n.inspect[0, 500]}")
+  sleep 1
+end
+puts failures.zero? ? "LIVE PARITY PASSED" : "LIVE PARITY FAILED: #{failures}"
+exit(failures.zero? ? 0 : 1)