honeymaker 0.12.3 → 0.12.4

data/ext/honeymaker_native/src/ruby_decimal.rs

@@ -0,0 +1,90 @@
+use honeymaker_core::num::Num;
+use magnus::{Ruby, Value, prelude::*, value::BoxValue};
+
+/// Ruby's BigDecimal behind the core's Num trait. BoxValue registers the object with the GC,
+/// so it is safe inside the Vecs and structs the normalizers return. Calls retain the GVL.
+pub struct RubyDecimal(BoxValue<Value>);
+
+impl RubyDecimal {
+    pub fn value(&self) -> Value {
+        *self.0
+    }
+
+    fn wrap(v: Value) -> Self {
+        RubyDecimal(BoxValue::new(v))
+    }
+
+    fn ruby() -> Ruby {
+        Ruby::get().expect("called on a Ruby thread")
+    }
+}
+
+impl Num for RubyDecimal {
+    type Error = magnus::Error;
+
+    fn parse(text: &str) -> Result<Self, magnus::Error> {
+        Ok(Self::wrap(
+            Self::ruby()
+                .module_kernel()
+                .funcall("BigDecimal", (text,))?,
+        ))
+    }
+
+    fn parse_to_s(v: &serde_json::Value) -> Result<Self, magnus::Error> {
+        let ruby = Self::ruby();
+        let obj = BoxValue::new(crate::convert::from_json(&ruby, v)?);
+        let text = BoxValue::new(obj.funcall::<_, _, Value>("to_s", ())?);
+        Ok(Self::wrap(
+            ruby.module_kernel().funcall("BigDecimal", (*text,))?,
+        ))
+    }
+
+    fn parse_json(v: &serde_json::Value) -> Result<Self, magnus::Error> {
+        let ruby = Self::ruby();
+        let obj = BoxValue::new(crate::convert::from_json(&ruby, v)?);
+        Ok(Self::wrap(
+            ruby.module_kernel().funcall("BigDecimal", (*obj,))?,
+        ))
+    }
+
+    fn string_op(
+        v: &serde_json::Value,
+        op: honeymaker_core::semantics::StringOp<'_>,
+    ) -> Result<serde_json::Value, magnus::Error> {
+        use honeymaker_core::semantics::StringOp;
+        let ruby = Self::ruby();
+        let obj = BoxValue::new(crate::convert::from_json(&ruby, v)?);
+        let result: Value = match op {
+            StringOp::Index(key) => obj.funcall("[]", (key,))?,
+            StringOp::Split(sep) => obj.funcall("split", (sep,))?,
+            StringOp::First => obj.funcall("[]", (0,))?,
+            StringOp::DowncaseSymbol | StringOp::Symbol => {
+                let text = BoxValue::new(if matches!(op, StringOp::DowncaseSymbol) {
+                    obj.funcall("downcase", ())?
+                } else {
+                    *obj
+                });
+                // Validate now, in legacy's evaluation order, before parsing decimals.
+                text.funcall::<_, _, Value>("to_sym", ())?;
+                *text
+            }
+        };
+        crate::convert::to_json(&ruby, result)
+    }
+
+    fn add(&self, o: &Self) -> Result<Self, magnus::Error> {
+        Ok(Self::wrap(self.value().funcall("+", (o.value(),))?))
+    }
+
+    fn sub(&self, o: &Self) -> Result<Self, magnus::Error> {
+        Ok(Self::wrap(self.value().funcall("-", (o.value(),))?))
+    }
+
+    fn div(&self, o: &Self) -> Result<Self, magnus::Error> {
+        Ok(Self::wrap(self.value().funcall("/", (o.value(),))?))
+    }
+
+    fn is_zero(&self) -> Result<bool, magnus::Error> {
+        self.value().funcall("zero?", ())
+    }
+}

data/lib/honeymaker/clients/bybit.rb

@@ -96,6 +96,15 @@ module Honeymaker
         })
       end
 
+      # Closed orders that /v5/order/realtime no longer returns.
+      def order_history(category:, symbol: nil, order_id: nil, order_link_id: nil, order_status: nil,
+                        start_time: nil, end_time: nil, limit: nil, cursor: nil)
+        get_authenticated("/v5/order/history", {
+          category: category, symbol: symbol, orderId: order_id, orderLinkId: order_link_id,
+          orderStatus: order_status, startTime: start_time, endTime: end_time, limit: limit, cursor: cursor
+        })
+      end
+
       def transaction_log(account_type: nil, category: nil, currency: nil, type: nil, start_time: nil, end_time: nil, limit: nil, cursor: nil)
         get_authenticated("/v5/account/transaction-log", {
           accountType: account_type, category: category, currency: currency, type: type,
@@ -116,6 +125,13 @@ module Honeymaker
         })
       end
 
+      # Off-chain deposits from another Bybit user; query-record does not include them.
+      def internal_deposit_records(tx_id: nil, coin: nil, start_time: nil, end_time: nil, limit: nil, cursor: nil)
+        get_authenticated("/v5/asset/deposit/query-internal-record", {
+          txID: tx_id, coin: coin, startTime: start_time, endTime: end_time, limit: limit, cursor: cursor
+        })
+      end
+
       def withdraw_records(coin: nil, start_time: nil, end_time: nil, limit: nil, cursor: nil, withdraw_type: nil)
         get_authenticated("/v5/asset/withdraw/query-record", {
           coin: coin, startTime: start_time, endTime: end_time,
@@ -207,9 +223,10 @@ module Honeymaker
       def parse_order_status(status)
         case status
         when "Created", "Untriggered" then :unknown
-        when "New", "PartiallyFilled", "PartiallyFilledCanceled" then :open
+        when "New", "PartiallyFilled" then :open
         when "Filled" then :closed
-        when "Cancelled", "Expired", "Deactivated" then :cancelled
+        # PartiallyFilledCanceled is final: a spot order cancelled after a partial fill.
+        when "Cancelled", "PartiallyFilledCanceled", "Expired", "Deactivated" then :cancelled
         when "Rejected" then :failed
         else :unknown
         end

data/lib/honeymaker/clients/coinbase.rb

@@ -105,8 +105,9 @@ module Honeymaker
         get("/api/v3/brokerage/key_permissions")
       end
 
-      def list_accounts
-        get("/api/v3/brokerage/accounts")
+      # One page of accounts; pass the response's `cursor` back while `has_next` is true.
+      def list_accounts(limit: nil, cursor: nil)
+        get("/api/v3/brokerage/accounts", { limit: limit, cursor: cursor })
       end
 
       def list_portfolios

data/lib/honeymaker/clients/kraken.rb

@@ -148,6 +148,7 @@ module Honeymaker
         return Result::Success.new({}) if wanted.empty?
 
         by_order = Hash.new { |h, k| h[k] = [] }
+        seen = {}
         offset = 0
         pages = 0
         loop do
@@ -161,7 +162,11 @@ module Honeymaker
           trades = result.data.dig("result", "trades") || {}
           break if trades.empty?
 
-          trades.each_value do |t|
+          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

data/lib/honeymaker/exchanges/coinbase.rb

@@ -6,7 +6,7 @@ module Honeymaker
       BASE_URL = "https://api.coinbase.com"
 
       ASSET_BLACKLIST = [
-        "RENDER",    # has the same external_id as RNDR
+        "RNDR",      # delisted; has the same external_id as RENDER
         "ZETACHAIN", # has the same external_id as ZETA
         "WAXL"       # has the same external_id as AXL
       ].freeze
@@ -51,10 +51,11 @@ module Honeymaker
 
       private
 
-      # Coinbase only signals problems explicitly: a `trading_disabled` flag or a non-"online"
-      # `status`. Absent either signal, treat the pair as enabled.
+      # Coinbase only signals problems explicitly: a `trading_disabled`, `is_disabled`, `limit_only`
+      # or `cancel_only` flag, or a non-"online" `status`. Absent any signal, treat the pair as
+      # enabled. limit_only is reported as not tradable, like Kraken's limit_only status.
       def trading_enabled?(product)
-        return false if product["trading_disabled"] == true
+        return false if %w[trading_disabled is_disabled limit_only cancel_only].any? { |flag| product[flag] == true }
         return false if product.key?("status") && product["status"] != "online"
 
         true

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.4"
 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