honeymaker 0.12.3 → 0.12.5

data/lib/honeymaker/native/kraken.rb

@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Honeymaker
+  module Native
+    # Kraken on the Rust core. Signatures and argument expressions are copied from Clients::Kraken
+    # (a test compares signatures). Transport, body encoding and Results are the inherited,
+    # unchanged Ruby: connection + URI.encode_www_form + with_rescue. Rust lays out and signs the
+    # requests and normalizes the answers.
+    class KrakenClient < Honeymaker::Client
+      URL = "https://api.kraken.com"
+      RATE_LIMITS = { default: 1000, orders: 1000 }.freeze
+      UNREADABLE = "Kraken: unreadable response"
+
+      def self.reset_nonce_state!
+        Native.load!
+        Ext::Kraken.reset_nonce_state!
+      end
+
+      def query_orders_info(txid:, trades: nil, userref: nil, consolidate_taker: true)
+        result = post_private("query_orders_info", trades: trades, userref: userref, txid: txid, consolidate_taker: consolidate_taker)
+        finish("query_orders_info", result) do |orders|
+          (result.data["result"] || {}).each { |id, raw| orders[id][:raw] = raw }
+          orders
+        end
+      end
+
+      def add_order(ordertype:, type:, volume:, pair:, userref: nil, cl_ord_id: nil,
+                    displayvol: nil, price: nil, price2: nil, trigger: nil, leverage: nil,
+                    reduce_only: nil, stptype: nil, oflags: [], timeinforce: nil,
+                    starttm: nil, expiretm: nil, close: nil, close_price: nil,
+                    close_price2: nil, deadline: nil, validate: nil)
+        result = post_private("add_order",
+                              ordertype: ordertype, type: type, volume: volume, pair: pair, userref: userref,
+                              cl_ord_id: cl_ord_id, displayvol: displayvol, price: price, price2: price2,
+                              trigger: trigger, leverage: leverage, reduce_only: reduce_only, stptype: stptype,
+                              oflags: oflags.any? ? oflags.join(",") : nil,
+                              timeinforce: timeinforce, starttm: starttm, expiretm: expiretm, close: close,
+                              close_price: close_price, close_price2: close_price2, deadline: deadline, validate: validate)
+        finish("add_order", result) { |order_id| { order_id: order_id, raw: result.data } }
+      end
+
+      def cancel_order(txid: nil, cl_ord_id: nil)
+        post_private("cancel_order", txid: txid, cl_ord_id: cl_ord_id)
+      end
+
+      def get_tradable_asset_pairs(pairs: nil, info: nil, country_code: nil, aclass_base: nil)
+        get_public("get_tradable_asset_pairs", pairs: pairs ? pairs.join(",") : nil, info: info,
+                                               country_code: country_code, aclass_base: aclass_base)
+      end
+
+      def get_asset_info(assets: nil, aclass: nil)
+        get_public("get_asset_info", assets: assets ? assets.join(",") : nil, aclass: aclass)
+      end
+
+      def get_ticker_information(pair: nil)
+        get_public("get_ticker_information", pair: pair)
+      end
+
+      def get_extended_balance
+        post_private("get_extended_balance")
+      end
+
+      def get_api_key_info
+        post_private("get_api_key_info")
+      end
+
+      def get_balances
+        finish("balances", get_extended_balance) { |balances| balances }
+      end
+
+      def get_ohlc_data(pair:, interval: nil, since: nil)
+        get_public("get_ohlc_data", pair: pair, interval: interval, since: since)
+      end
+
+      def get_trades_history(type: nil, trades: nil, start: nil, end_time: nil, ofs: nil)
+        post_private("get_trades_history", type: type, trades: trades, start: start, end_time: end_time, ofs: ofs)
+      end
+
+      def get_ledgers(asset: nil, type: nil, start: nil, end_time: nil, ofs: nil)
+        post_private("get_ledgers", asset: asset, type: type, start: start, end_time: end_time, ofs: ofs)
+      end
+
+      # The paging loop stays Ruby (verbatim legacy) so dig/to_i/include? keep Ruby's
+      # coercions; Rust aggregates. A Rust pager comes with stage 2, when Rust callers need one.
+      def closed_orders_from_trades(order_ids:, start: nil, max_pages: 20)
+        wanted = Array(order_ids)
+        return Result::Success.new({}) if wanted.empty?
+
+        by_order = Hash.new { |h, k| h[k] = [] }
+        seen = {}
+        offset = 0
+        pages = 0
+        loop do
+          result = get_trades_history(start: start, ofs: offset)
+          return result if result.failure?
+          return unreadable unless result.data.is_a?(Hash)
+
+          errors = result.data["error"]
+          return Result::Failure.new(*errors) if errors.is_a?(Array) && errors.any?
+
+          trades = result.data.dig("result", "trades") || {}
+          break if trades.empty?
+
+          trades.each_pair do |trade_id, t|
+            # Offset paging over a list that grows at the top can serve a trade twice: count it once.
+            next if seen.key?(trade_id)
+
+            seen[trade_id] = true
+            otxid = t["ordertxid"]
+            by_order[otxid] << t if wanted.include?(otxid)
+          end
+
+          # Do NOT early-exit when each id has been *seen* — a partial fill can have trades on
+          # later pages. Page the whole [start, now] window (bounded by `start` + max_pages).
+          pages += 1
+          offset += trades.size
+          count = result.data.dig("result", "count").to_i
+          break if offset >= count || pages >= max_pages
+        end
+
+        Native.load!
+        Result::Success.new(Ext::Kraken.aggregate_trades(by_order))
+      end
+
+      def get_withdraw_addresses(asset: nil, method: nil)
+        post_private("get_withdraw_addresses", asset: asset, method: method)
+      end
+
+      def get_withdraw_methods(asset: nil)
+        post_private("get_withdraw_methods", asset: asset)
+      end
+
+      def withdraw(asset:, key:, amount:, address: nil)
+        post_private("withdraw", asset: asset, key: key, amount: amount, address: address)
+      end
+
+      def get_earn_allocations(ascending: nil, converted_asset: nil, hide_zero_allocations: nil)
+        post_private("get_earn_allocations", ascending: ascending, converted_asset: converted_asset,
+                                             hide_zero_allocations: hide_zero_allocations)
+      end
+
+      private
+
+      def validate_trading_credentials
+        result = get_extended_balance
+        return Result::Failure.new("Invalid trading credentials") if result.failure?
+
+        errors = result.data["error"]
+        if errors.is_a?(Array) && errors.none?
+          Result::Success.new(true)
+        else
+          Result::Failure.new("Invalid trading credentials")
+        end
+      end
+
+      def validate_read_credentials
+        validate_trading_credentials
+      end
+
+      def native
+        @native ||= begin
+          Native.load!
+          Ext::Kraken.new(@api_key, @api_secret)
+        end
+      end
+
+      # The legacy post_private: Rust lays out the pairs (nonce first) and signs; Ruby encodes.
+      def post_private(op, params = {})
+        with_rescue do
+          path, pairs = native.build_post(op, params.transform_keys(&:to_s))
+          response = connection.post do |req|
+            req.url path
+            req.body = URI.encode_www_form(pairs)
+            req.headers = native.sign(req.path, req.body)
+          end
+          response.body
+        end
+      end
+
+      # The legacy get_public: Rust lays out the params; Faraday encodes them.
+      def get_public(op, params = {})
+        with_rescue do
+          path, query, headers = native.build_get(op, params.transform_keys(&:to_s))
+          response = connection.get do |req|
+            req.url path
+            req.headers = headers
+            req.params = query
+          end
+          response.body
+        end
+      end
+
+      def finish(op, result)
+        return result if result.failure?
+        # Guard in Ruby, before any conversion: a binary maintenance page must answer like the
+        # hardened legacy, not fail inside the converter.
+        return unreadable unless result.data.is_a?(Hash)
+
+        verdict = native.finish(op, result.data)
+        case verdict[0]
+        when "ok" then Result::Success.new(yield(verdict[1]))
+        when "venue" then Result::Failure.new(*result.data["error"])
+        when "unreadable" then unreadable
+        else raise ShapeError, "unexpected verdict #{verdict[0].inspect}"
+        end
+      end
+
+      def unreadable
+        Result::Failure.new(UNREADABLE, data: { unreadable: true })
+      end
+    end
+
+    class KrakenExchange < Honeymaker::Exchange
+      BASE_URL = "https://api.kraken.com"
+
+      def classify_error(message)
+        return nil if message.nil?
+
+        Native.load!
+        Ext::Kraken.classify_error(message)
+      end
+
+      def get_tickers_info
+        with_rescue do
+          response = connection.get("/0/public/AssetPairs", { aclass_base: "all" })
+          raise ShapeError, "Kraken: catalogue body is not an object" unless response.body.is_a?(Hash)
+
+          verdict = native.finish("tickers_info", response.body)
+          return Result::Failure.new(*response.body["error"]) if verdict[0] == "venue"
+
+          verdict[1].each { |t| t[:minimum_quote_size] = t[:minimum_quote_size].to_s }
+        end
+      end
+
+      def get_bid_ask(symbol)
+        with_rescue do
+          response = connection.get("/0/public/Ticker") { |req| req.params = { pair: symbol } }
+          raise ShapeError, "Kraken: ticker body is not an object" unless response.body.is_a?(Hash)
+
+          verdict = native.finish("bid_ask", response.body)
+          raise StandardError, response.body["error"].first if verdict[0] == "venue"
+
+          verdict[1]
+        end
+      end
+
+      private
+
+      def native
+        @native ||= begin
+          Native.load!
+          Ext::Kraken.new(nil, nil)
+        end
+      end
+
+      def connection
+        @connection ||= build_connection(BASE_URL)
+      end
+    end
+  end
+end

data/lib/honeymaker/native.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  # Rust-backed venue logic. A process picks its backend per exchange once, when honeymaker is
+  # required: HONEYMAKER_NATIVE=kraken. With the flag off the extension is never loaded.
+  module Native
+    # A venue payload whose shape legacy would have tripped over with an incidental NoMethodError
+    # or TypeError. Still a StandardError, which is all consumers rescue.
+    class ShapeError < StandardError; end
+
+    SUPPORTED = %w[kraken].freeze
+
+    class << self
+      def enabled
+        @enabled ||= begin
+          names = ENV.fetch("HONEYMAKER_NATIVE", "").split(",").map { |name| name.strip.downcase }.reject(&:empty?).uniq
+          unsupported = names - SUPPORTED
+          unless unsupported.empty?
+            raise ArgumentError, "Unsupported HONEYMAKER_NATIVE names: #{unsupported.join(', ')}; supported names: #{SUPPORTED.join(', ')}"
+          end
+          names.freeze
+        end
+      end
+
+      def enabled?(name)
+        name = name.to_s.strip.downcase
+        names = enabled
+        SUPPORTED.include?(name) && names.include?(name)
+      end
+
+      def load!
+        return if defined?(Ext)
+
+        begin
+          require "honeymaker/#{RUBY_VERSION[/\A\d+\.\d+/]}/honeymaker_native" # fat platform gem
+        rescue LoadError
+          require "honeymaker/honeymaker_native" # compiled from source / rake compile
+        end
+      end
+    end
+  end
+end

data/lib/honeymaker/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Honeymaker
-  VERSION = "0.12.3"
+  VERSION = "0.12.5"
 end

data/lib/honeymaker.rb

@@ -9,6 +9,7 @@ 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"
@@ -37,13 +38,18 @@ 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" => Exchanges::Kraken,
+    "kraken" => Native.enabled?("kraken") ? Native::KrakenExchange : Exchanges::Kraken,
     "coinbase" => Exchanges::Coinbase,
     "mexc" => Exchanges::Mexc,
     "gemini" => Exchanges::Gemini,
@@ -59,7 +65,7 @@ module Honeymaker
   CLIENTS = {
     "binance" => Clients::Binance,
     "binance_us" => Clients::BinanceUs,
-    "kraken" => Clients::Kraken,
+    "kraken" => Native.enabled?("kraken") ? Native::KrakenClient : Clients::Kraken,
     "coinbase" => Clients::Coinbase,
     "bybit" => Clients::Bybit,
     "mexc" => Clients::Mexc,
@@ -73,6 +79,10 @@ module Honeymaker
     "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

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)