honeymaker 0.12.5-aarch64-linux → 0.12.6-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: be39a594078cccd45823dd961e0b538f9b4e4eef2157226d5db7960c8fca4ba2
-  data.tar.gz: 441eee94d7c3081275fdedea9175c18f4720cb0618390a5b520b15add7381765
+  metadata.gz: facaf702a43fc739fe970a71f72017dd240617a8938a53934adb892c968f91cf
+  data.tar.gz: f7076b3470b45e3250f5794894f8e7e6a93cbcf034c76a67e117eea52649e5d1
 SHA512:
-  metadata.gz: 99c9125cb2b808559d92b7c781cb37ae3dc020c88fe4a7f5ce87904ecac8bb8340572a7649e646e70f983df5acec52d00efd0c36df61df0251909ba4dfebca4e
-  data.tar.gz: 5712715c2835590793bd94306738b8d4550af4dfe8c1dda20547f28e134bcaa0864420578545da8c797d00f084ef804fde8628b020938b3d1f33151dca2f9f3a
+  metadata.gz: 8b19a598c52226ea8b503c9b887e0d091cc387937799475af8b65473907c8ce3e5546126cdaa73f1c0610d6c5bcf36f46f181c190a01b14e9c7f8c85d297a637
+  data.tar.gz: 7363a8ca3f95e42abd6dbb6584db23bcb80c6dc2872067e23a930c75d51ff80f737df96a50ec01547051591a4a2725b137d56b5690c0a9f54fe496070180856a

data/lib/honeymaker/exchanges/bingx.rb

@@ -18,7 +18,9 @@ module Honeymaker
               ticker: ticker,
               base: parts[0],
               quote: parts[1],
-              minimum_base_size: product["minQty"]&.to_s,
+              # minQty is deprecated and far above what BingX accepts (~15 USDT on BTC-USDT against a
+              # 0.5 minNotional); the notional is the venue's only real floor.
+              minimum_base_size: "0",
               minimum_quote_size: product["minNotional"]&.to_s,
               maximum_base_size: product["maxQty"]&.to_s,
               maximum_quote_size: product["maxNotional"]&.to_s,

data/lib/honeymaker/exchanges/bitget.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "bigdecimal/util"
+
 module Honeymaker
   module Exchanges
     class Bitget < Exchange
@@ -8,14 +10,16 @@ module Honeymaker
       def get_tickers_info
         with_rescue do
           response = connection.get("/api/v2/spot/public/symbols")
+          products = response.body["data"]
+          prices = products.any? { |p| p["quoteCoin"] != "USDT" } ? usdt_prices : {}
 
-          response.body["data"].filter_map do |product|
+          products.filter_map do |product|
             {
               ticker: product["symbol"],
               base: product["baseCoin"],
               quote: product["quoteCoin"],
               minimum_base_size: product["minTradeAmount"],
-              minimum_quote_size: product["minTradeUSDT"],
+              minimum_quote_size: quote_minimum(product["quoteCoin"], product["minTradeUSDT"], prices),
               maximum_base_size: product["maxTradeAmount"],
               maximum_quote_size: nil,
               base_decimals: product["quantityPrecision"].to_i,
@@ -44,6 +48,31 @@ module Honeymaker
 
       private
 
+      # minTradeUSDT is a USDT figure on every pair, whatever its quote
+      # (https://www.bitget.com/docs/catalog/classic-spot-market/classic-spot-market#get-symbol-info), so
+      # on ETHBTC its 1 meant a 1 BTC minimum. Converted at the quote's own USDT price (never the
+      # traded pair's); with no price to convert at, the minimum is left to the venue (0) rather than
+      # guessed. Same rule as deltabadger's Exchanges::Bitget#quote_minimum.
+      def quote_minimum(quote, usdt_minimum, prices)
+        minimum = usdt_minimum.to_s.to_d
+        return usdt_minimum if quote == "USDT" || minimum.zero?
+
+        if (price = prices["#{quote}USDT"].to_d).positive?
+          (minimum / price).to_s("F")
+        elsif (price = prices["USDT#{quote}"].to_d).positive?
+          (minimum * price).to_s("F")
+        else
+          "0"
+        end
+      end
+
+      # symbol => lastPr for the whole market; {} when the read fails, so conversions fall back to 0.
+      def usdt_prices
+        connection.get("/api/v2/spot/market/tickers").body["data"].to_h { |t| [t["symbol"], t["lastPr"]] }
+      rescue StandardError
+        {}
+      end
+
       def connection
         @connection ||= build_connection(BASE_URL)
       end

data/lib/honeymaker/exchanges/hyperliquid.rb

@@ -5,11 +5,6 @@ module Honeymaker
     class Hyperliquid < Exchange
       BASE_URL = "https://api.hyperliquid.xyz"
 
-      # Hyperliquid enforces a hard 10-USDC minimum order value on every spot pair (spotMeta exposes
-      # no per-token base floor). Surfaced as minimum_quote_size so consumers skip/reject sub-10
-      # orders up front instead of having the exchange reject them.
-      MINIMUM_QUOTE_SIZE = 10
-
       def get_tickers_info
         with_rescue do
           response = connection.post("/info") do |req|
@@ -30,7 +25,7 @@ module Honeymaker
               base: base_token["name"],
               quote: quote_token["name"],
               minimum_base_size: nil,
-              minimum_quote_size: MINIMUM_QUOTE_SIZE,
+              minimum_quote_size: Floors.minimum_quote(venue: "hyperliquid", quote: quote_token["name"]),
               maximum_base_size: nil,
               maximum_quote_size: nil,
               base_decimals: base_token["szDecimals"] || 0,

data/lib/honeymaker/exchanges/kraken.rb

@@ -27,25 +27,6 @@ module Honeymaker
         }
       ].freeze
 
-      REAL_COSTMIN = {
-        "AUD" => 10,
-        "CAD" => 5,
-        "CHF" => 5,
-        "DAI" => 5,
-        "ETH" => 0.002,
-        "EUR" => 0.5,
-        "GBP" => 5,
-        "JPY" => 500,
-        "PYUSD" => 5,
-        "RLUSD" => 5,
-        "USD" => 5,
-        "USDC" => 5,
-        "USDQ" => 5,
-        "USDR" => 5,
-        "USDT" => 5,
-        "XBT" => 0.00005
-      }.freeze
-
       def get_tickers_info
         with_rescue do
           # aclass_base=all, not a bare call: the default response carries only the "currency" class,
@@ -74,7 +55,7 @@ module Honeymaker
               base: base,
               quote: quote,
               minimum_base_size: info["ordermin"],
-              minimum_quote_size: (REAL_COSTMIN[quote] || info["costmin"] || 0).to_s,
+              minimum_quote_size: Floors.minimum_quote(venue: "kraken", quote: quote, published: info["costmin"] || 0).to_s,
               maximum_base_size: nil,
               maximum_quote_size: nil,
               base_decimals: info["lot_decimals"],

data/lib/honeymaker/floors.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+
+module Honeymaker
+  # Minimum order values venues enforce but do not publish (or publish too low), found by test
+  # orders. A ticker's minimum_quote_size is max(published, floor): a floor never lowers a minimum
+  # the venue itself raised. Consumed by the venue parsers here and by data-api for venues it
+  # builds itself (Alpaca crypto).
+  module Floors
+    ANY_QUOTE = :any
+
+    # [venue, asset_class] => { quote => floor }. A nil asset class covers every class the venue
+    # lists; ANY_QUOTE covers every quote.
+    MINIMUM_QUOTE = {
+      # Kraken's AssetPairs costmin is below what AddOrder accepts ("EOrder:Cost minimum not met");
+      # these are the per-quote costs it actually enforces. The native core mirrors this table
+      # (crates/honeymaker/src/kraken/normalize.rs REAL_COSTMIN; parity-tested).
+      ["kraken", nil] => {
+        "AUD" => 10,
+        "CAD" => 5,
+        "CHF" => 5,
+        "DAI" => 5,
+        "ETH" => 0.002,
+        "EUR" => 0.5,
+        "GBP" => 5,
+        "JPY" => 500,
+        "PYUSD" => 5,
+        "RLUSD" => 5,
+        "USD" => 5,
+        "USDC" => 5,
+        "USDQ" => 5,
+        "USDR" => 5,
+        "USDT" => 5,
+        "XBT" => 0.00005
+      },
+      # "Order must have minimum value of 10 USDC." on every spot pair; spotMeta publishes no
+      # minimum. The value is measured in USDC whatever the pair's quote, so it covers all quotes.
+      ["hyperliquid", nil] => { ANY_QUOTE => 10 },
+      # "cost basis must be >= minimal amount of order 10" on crypto; the assets API publishes only
+      # min_order_size (base). Stocks are not floored here (notional orders from $1).
+      ["alpaca", "crypto"] => { "USD" => 10 }
+    }.freeze
+
+    # The minimum quote size to store: max(published, floor). Returns published when no floor
+    # applies (nil when neither exists), and the floor when published is missing or not a number.
+    # Whichever wins is returned as given, so callers keep their own formatting.
+    def self.minimum_quote(venue:, quote:, asset_class: nil, published: nil)
+      quotes = MINIMUM_QUOTE[[venue.to_s, asset_class&.to_s]] || MINIMUM_QUOTE[[venue.to_s, nil]] || {}
+      floor = quotes.fetch(quote.to_s) { quotes[ANY_QUOTE] }
+      return published if floor.nil?
+      return floor if published.nil?
+
+      BigDecimal(published.to_s) > BigDecimal(floor.to_s) ? published : floor
+    rescue ArgumentError
+      floor
+    end
+  end
+end

data/lib/honeymaker/version.rb

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

data/lib/honeymaker.rb

@@ -7,6 +7,7 @@ require "json"
 require_relative "honeymaker/version"
 require_relative "honeymaker/result"
 require_relative "honeymaker/utils"
+require_relative "honeymaker/floors"
 require_relative "honeymaker/exchange"
 require_relative "honeymaker/client"
 require_relative "honeymaker/native"

data/test/honeymaker/exchanges/bingx_test.rb

@@ -23,7 +23,7 @@ class Honeymaker::Exchanges::BingXTest < Minitest::Test
     assert_equal "BTC-USDT", ticker[:ticker]
     assert_equal "BTC", ticker[:base]
     assert_equal "USDT", ticker[:quote]
-    assert_equal "0.00001", ticker[:minimum_base_size]
+    assert_equal "0", ticker[:minimum_base_size] # deprecated minQty (0.00001) ignored
     assert_equal "1", ticker[:minimum_quote_size]
     assert_equal "500", ticker[:maximum_base_size]
     assert_equal 5, ticker[:base_decimals]

data/test/honeymaker/exchanges/bitget_test.rb

@@ -54,8 +54,60 @@ class Honeymaker::Exchanges::BitgetTest < Minitest::Test
     assert_equal BigDecimal("67125.67"), result.data[:ask]
   end
 
+  def test_usdt_minimum_on_a_usdt_pair_is_not_converted_and_no_prices_are_read
+    connection = stub
+    connection.expects(:get).with("/api/v2/spot/public/symbols").returns(stub(body: load_fixture("bitget_symbols.json")))
+    @exchange.instance_variable_set(:@connection, connection)
+
+    assert_equal "5", @exchange.get_tickers_info.data.first[:minimum_quote_size]
+  end
+
+  def test_non_usdt_quote_converted_at_the_quotes_own_usdt_price
+    tickers = [{ "symbol" => "BTCUSDT", "lastPr" => "50000" },
+               { "symbol" => "ETHBTC", "lastPr" => "0.05" }] # the traded pair's price: never used
+    data = quote_minimums({ "ETHBTC" => "BTC" }, tickers)
+    assert_equal BigDecimal("0.0001"), BigDecimal(data["ETHBTC"])
+  end
+
+  def test_inverse_usdt_quote_pair_multiplies
+    data = quote_minimums({ "BTCTRY" => "TRY" }, [{ "symbol" => "USDTTRY", "lastPr" => "40" }])
+    assert_equal BigDecimal("200"), BigDecimal(data["BTCTRY"])
+  end
+
+  def test_missing_price_leaves_the_minimum_to_the_venue
+    data = quote_minimums({ "ETHBTC" => "BTC", "XEUR" => "EUR" },
+                          [{ "symbol" => "BTCUSDT", "lastPr" => "0" }, { "symbol" => "ETHBTC", "lastPr" => "0.05" }])
+    assert_equal "0", data["ETHBTC"]
+    assert_equal "0", data["XEUR"]
+  end
+
+  def test_failed_price_read_falls_back_like_a_missing_price
+    data = quote_minimums({ "ETHBTC" => "BTC", "BTCUSDT" => "USDT" }, Faraday::ServerError.new("boom"))
+    assert_equal "0", data["ETHBTC"]
+    assert_equal "5", data["BTCUSDT"]
+  end
+
   private
 
+  # symbol => quote rows, each with minTradeUSDT 5; tickers is the market's ticker list or the
+  # error its read raises. Returns symbol => minimum_quote_size.
+  def quote_minimums(pairs, tickers)
+    products = pairs.map do |symbol, quote|
+      load_fixture("bitget_symbols.json")["data"].first.merge("symbol" => symbol, "quoteCoin" => quote, "minTradeUSDT" => "5")
+    end
+    connection = stub
+    connection.stubs(:get).with("/api/v2/spot/public/symbols").returns(stub(body: { "data" => products }))
+    if tickers.is_a?(Exception)
+      connection.stubs(:get).with("/api/v2/spot/market/tickers").raises(tickers)
+    else
+      connection.stubs(:get).with("/api/v2/spot/market/tickers").returns(stub(body: { "data" => tickers }))
+    end
+    @exchange.instance_variable_set(:@connection, connection)
+    result = @exchange.get_tickers_info
+    assert result.success?, result.errors.inspect
+    result.data.to_h { |t| [t[:ticker], t[:minimum_quote_size]] }
+  end
+
   def stub_connection(body)
     response = stub(body: body)
     connection = stub

data/test/honeymaker/exchanges/kraken_test.rb

@@ -123,6 +123,18 @@ class Honeymaker::Exchanges::KrakenTest < Minitest::Test
     assert_equal "5", ticker[:minimum_quote_size]
   end
 
+  def test_cost_floor_is_a_max_of_published_and_floor
+    body = load_fixture("kraken_asset_pairs.json")
+    key, info = body["result"].find { |_, i| i["wsname"]&.end_with?("/USDT") }
+    body["result"] = { key => info.merge("costmin" => "0.5") }
+    stub_request(body)
+    assert_equal "5", @exchange.get_tickers_info.data.first[:minimum_quote_size]
+
+    body["result"] = { key => info.merge("costmin" => "12.5") }
+    stub_request(body)
+    assert_equal "12.5", @exchange.get_tickers_info.data.first[:minimum_quote_size]
+  end
+
   def test_get_tickers_info_handles_api_error
     body = { "error" => ["EGeneral:Internal error"], "result" => {} }
     stub_request(body)

data/test/honeymaker/floors_test.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::FloorsTest < Minitest::Test
+  F = Honeymaker::Floors
+
+  def test_max_of_published_and_floor
+    assert_equal 5, F.minimum_quote(venue: "kraken", quote: "USD", published: "0.5")
+    assert_equal "12.5", F.minimum_quote(venue: "kraken", quote: "USD", published: "12.5")
+    assert_equal 5, F.minimum_quote(venue: "kraken", quote: "USD", published: "5.0") # tie: the floor
+  end
+
+  def test_missing_or_unreadable_published_gives_the_floor
+    assert_equal 5, F.minimum_quote(venue: "kraken", quote: "USD")
+    assert_equal 5, F.minimum_quote(venue: "kraken", quote: "USD", published: "abc")
+  end
+
+  def test_no_floor_keeps_published
+    assert_equal "0.1", F.minimum_quote(venue: "kraken", quote: "FOO", published: "0.1")
+    assert_equal "3", F.minimum_quote(venue: "binance", quote: "USDT", published: "3")
+    assert_nil F.minimum_quote(venue: "binance", quote: "USDT")
+  end
+
+  def test_alpaca_floor_is_keyed_by_asset_class
+    assert_equal 10, F.minimum_quote(venue: "alpaca", quote: "USD", asset_class: "crypto", published: "1")
+    assert_equal 10, F.minimum_quote(venue: :alpaca, quote: "USD", asset_class: :crypto)
+    assert_equal "1", F.minimum_quote(venue: "alpaca", quote: "USD", asset_class: "stock", published: "1")
+    assert_nil F.minimum_quote(venue: "alpaca", quote: "USD", asset_class: "stock")
+  end
+
+  def test_hyperliquid_floor_covers_every_quote
+    assert_equal 10, F.minimum_quote(venue: "hyperliquid", quote: "USDC")
+    assert_equal 10, F.minimum_quote(venue: "hyperliquid", quote: "USDT0", published: "1")
+    assert_equal "25", F.minimum_quote(venue: "hyperliquid", quote: "USDC", published: "25")
+  end
+end

data/test/parity/kraken_exchange_parity_test.rb

@@ -43,6 +43,32 @@ class KrakenExchangeParityTest < Minitest::Test
      [500, JSON_CT, "{}"]].each { |reply| assert_parity(reply, &:get_tickers_info) }
   end
 
+  # The native REAL_COSTMIN mirrors Honeymaker::Floors: every floored quote, published below,
+  # above, equal to, missing and unreadable, plus an unfloored quote.
+  def test_cost_floors_match_the_shared_table
+    floors = Honeymaker::Floors::MINIMUM_QUOTE[["kraken", nil]]
+    pairs = {}
+    (floors.keys + ["FOO"]).each do |quote|
+      floor = floors[quote] || 1
+      [(BigDecimal(floor.to_s) / 10).to_s("F"), (BigDecimal(floor.to_s) * 10).to_s("F"), floor.to_s, nil, "abc", floor * 3].each_with_index do |costmin, i|
+        ws = "B#{i}/#{quote}"
+        pairs[ws] = { "altname" => ws, "wsname" => ws, "costmin" => costmin }
+      end
+    end
+    reply = [200, JSON_CT, { "error" => [], "result" => pairs }.to_json]
+    assert_parity(reply, &:get_tickers_info)
+
+    d = VenueDouble.new([reply])
+    e = Honeymaker::Native::KrakenExchange.new
+    e.instance_variable_set(:@connection, e.send(:build_connection, d.url))
+    got = e.get_tickers_info.data.to_h { |t| [t[:ticker], t[:minimum_quote_size]] }
+    assert_equal floors["USD"].to_s, got["B0/USD"]
+    assert_equal "50.0", got["B1/USD"]
+    assert_equal "0.1", got["B0/FOO"]
+  ensure
+    d&.close
+  end
+
   def test_one_malformed_row_fails_the_whole_catalogue_like_legacy
     replies = [false, 1, { "x" => 1 }].map do |bad|
       pairs = { "XXBTZUSD" => { "altname" => "XBTUSD", "wsname" => "XBT/USD", "status" => "online" },

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: honeymaker
 version: !ruby/object:Gem::Version
-  version: 0.12.5
+  version: 0.12.6
 platform: aarch64-linux
 authors:
 - Deltabadger
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-10-16 00:00:00.000000000 Z
+date: 2026-10-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -131,6 +131,7 @@ files:
 - lib/honeymaker/exchanges/kraken.rb
 - lib/honeymaker/exchanges/kucoin.rb
 - lib/honeymaker/exchanges/mexc.rb
+- lib/honeymaker/floors.rb
 - lib/honeymaker/native.rb
 - lib/honeymaker/native/kraken.rb
 - lib/honeymaker/result.rb
@@ -204,6 +205,7 @@ files:
 - test/honeymaker/exchanges/kraken_test.rb
 - test/honeymaker/exchanges/kucoin_test.rb
 - test/honeymaker/exchanges/mexc_test.rb
+- test/honeymaker/floors_test.rb
 - test/honeymaker/honeymaker_test.rb
 - test/honeymaker/result_test.rb
 - test/honeymaker/utils_test.rb