honeymaker 0.12.5 → 0.12.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b63e4e5855db8e7ada05e58f6dad106bf6f24e29628dfce7e0fd04e062382b5
-  data.tar.gz: 51382cf687f1e6a3136d7c57d1656cca27065c19075075c42d4170ae6e9ffc80
+  metadata.gz: 9b0990bd1855430e5d4b8bdda6132202c74b6e2151c64c9c4aab5edeaae0c8d0
+  data.tar.gz: 5ce771e18c6e07370686d20a55c39e687fdd0340a628538de68fa524aea40f93
 SHA512:
-  metadata.gz: efa5ee0604c2daf571073432447c86cb24706ab1a95d00d318204c26dfcd66c32616e96071ee8b86992ca8f32f5f87fdaa387a30bb748781095466f44b222a0b
-  data.tar.gz: b0bb1d9eac28616b4cc1beae77159ea8221c5ee554d80f3776698b8cca2aa05e05d67c860303fba7cce7a52f61471fcc5398eb6c2bd4438cfe2a348165c73749
+  metadata.gz: 8ae0c506ddab62f846b54818da8c209e52c8c235a789242f946c693efed107290cc6d7aed28548a0788b2ebaf65f5e9b29cdf3ee312fbea1495a4a5504f51938
+  data.tar.gz: 6f1321e294b8dda3574e3199e290986a5ab1a48ba5924aeaa5808914b18678091b5543655071a9a585e91346e6075fe456261621836ca156b601763d533e6dea

data/Cargo.lock

@@ -265,7 +265,7 @@ dependencies = [
 
 [[package]]
 name = "honeymaker"
-version = "0.12.5"
+version = "0.12.6"
 dependencies = [
  "base64",
  "bigdecimal",
@@ -278,7 +278,7 @@ dependencies = [
 
 [[package]]
 name = "honeymaker-client"
-version = "0.12.5"
+version = "0.12.6"
 dependencies = [
  "base64",
  "bigdecimal",
@@ -300,7 +300,7 @@ dependencies = [
 
 [[package]]
 name = "honeymaker_native"
-version = "0.12.5"
+version = "0.12.6"
 dependencies = [
  "honeymaker",
  "magnus",

data/Cargo.toml

@@ -3,7 +3,7 @@ members = ["crates/honeymaker", "crates/honeymaker-client", "ext/honeymaker_nati
 resolver = "3"
 
 [workspace.package]
-version = "0.12.5" # lockstep with lib/honeymaker/version.rb (test/native/lockstep_test.rb)
+version = "0.12.6" # lockstep with lib/honeymaker/version.rb (test/native/lockstep_test.rb)
 edition = "2024"
 rust-version = "1.94"
 license = "MIT"

data/crates/honeymaker/src/kraken/normalize.rs

@@ -375,8 +375,8 @@ pub struct Ticker {
     pub base: Value,
     pub quote: Value,
     pub minimum_base_size: Value,
-    /// REAL_COSTMIN[quote] || costmin || 0 as a raw value; the wrapper applies Ruby's `.to_s`
-    /// (Float#to_s gives "5.0e-05" for XBT, which is part of the contract).
+    /// max(costmin || 0, REAL_COSTMIN[quote]) as a raw value (whichever wins, as given); the
+    /// wrapper applies Ruby's `.to_s` (Float#to_s gives "5.0e-05" for XBT, part of the contract).
     pub minimum_quote_size: Value,
     pub base_decimals: Value,
     pub quote_decimals: Value,
@@ -384,6 +384,8 @@ pub struct Ticker {
     pub trading_enabled: bool,
 }
 
+/// Mirror of Honeymaker::Floors::MINIMUM_QUOTE["kraken"] (lib/honeymaker/floors.rb, where each
+/// floor's source is noted); test/parity/kraken_exchange_parity_test.rb checks every quote.
 const REAL_COSTMIN: &[(&str, &str)] = &[
     // JSON literals of the Ruby constants (Integer vs Float kept)
     ("AUD", "10"),
@@ -443,12 +445,18 @@ pub fn tickers<D: Num>(data: &Value) -> R<Vec<Ticker>, D> {
                 let parts = D::string_op(&ws, StringOp::Split("/")).map_err(NormError::Num)?;
                 let base = parts[0].clone();
                 let quote = parts[1].clone();
-                let costmin = REAL_COSTMIN
-                    .iter()
-                    .find(|(k, _)| string_eq(&quote, k))
-                    .map(|(_, lit)| serde_json::from_str::<Value>(lit).expect("literal"))
-                    .or_else(|| info.get("costmin").filter(|v| truthy(Some(v))).cloned())
+                let published = info
+                    .get("costmin")
+                    .filter(|v| truthy(Some(v)))
+                    .cloned()
                     .unwrap_or(Value::from(0));
+                let costmin = match REAL_COSTMIN.iter().find(|(k, _)| string_eq(&quote, k)) {
+                    None => published,
+                    Some((_, lit)) => at_least::<D>(
+                        published,
+                        serde_json::from_str::<Value>(lit).expect("literal"),
+                    )?,
+                };
                 let trading_enabled = if info
                     .get("aclass_base")
                     .is_some_and(|v| string_eq(v, "tokenized_asset"))
@@ -475,6 +483,20 @@ pub fn tickers<D: Num>(data: &Value) -> R<Vec<Ticker>, D> {
     ))
 }
 
+/// Legacy Floors.minimum_quote: `BigDecimal(published.to_s) > BigDecimal(floor.to_s) ? published :
+/// floor`, the floor when published does not parse (`rescue ArgumentError`).
+fn at_least<D: Num>(published: Value, floor: Value) -> Result<Value, NormError<D::Error>> {
+    let Ok(p) = D::parse_to_s(&published) else {
+        return Ok(floor);
+    };
+    let f = D::parse_to_s(&floor).map_err(NormError::Num)?;
+    Ok(if p.gt(&f).map_err(NormError::Num)? {
+        published
+    } else {
+        floor
+    })
+}
+
 /// Legacy: raise error.first if errors; first result entry; BigDecimal(data["b"][0]) (no to_s).
 pub fn bid_ask<D: Num>(data: &Value) -> R<(D, D), D> {
     let obj = data.as_object().ok_or("body is not an object")?;

data/crates/honeymaker/src/num.rs

@@ -23,6 +23,8 @@ pub trait Num: Sized {
     fn sub(&self, other: &Self) -> Result<Self, Self::Error>;
     fn div(&self, other: &Self) -> Result<Self, Self::Error>;
     fn is_zero(&self) -> Result<bool, Self::Error>;
+    /// Legacy `self > other`.
+    fn gt(&self, other: &Self) -> Result<bool, Self::Error>;
 }
 
 #[derive(Debug)]
@@ -112,4 +114,7 @@ impl Num for BigDecimal {
     fn is_zero(&self) -> Result<bool, String> {
         Ok(self == &BigDecimal::from(0))
     }
+    fn gt(&self, o: &Self) -> Result<bool, String> {
+        Ok(self > o)
+    }
 }

data/crates/honeymaker/tests/kraken_stage2.rs

@@ -590,3 +590,30 @@ fn credentials_debug_shows_the_key_and_redacts_the_secret() {
     assert!(shown.contains("<redacted>"), "{shown}");
     assert!(!shown.contains("c2VjcmV0LXNlY3JldA=="), "{shown}");
 }
+
+#[test]
+fn the_cost_floor_is_a_max_never_an_override() {
+    let pair =
+        |ws: &str, costmin: Value| json!({ "altname": ws, "wsname": ws, "costmin": costmin });
+    let body = json!({ "error": [], "result": {
+        "A": pair("XBT/USD", json!("0.5")),  // below the 5 USD floor
+        "B": pair("ETH/USD", json!("12.5")), // above it: the venue's own figure wins
+        "C": pair("SOL/USD", json!("abc")),  // unreadable: the floor
+        "D": pair("SOL/XBT", json!(null)),   // missing: the floor
+        "E": pair("SOL/FOO", json!("0.1")),  // no floor for the quote: published as is
+    }});
+    let Finished::Ok(ts) = normalize::tickers::<BigDecimal>(&body).unwrap() else {
+        panic!("venue refusal")
+    };
+    let got: Vec<Value> = ts.into_iter().map(|t| t.minimum_quote_size).collect();
+    assert_eq!(
+        got,
+        vec![
+            json!(5),
+            json!("12.5"),
+            json!(5),
+            json!(0.00005),
+            json!("0.1")
+        ]
+    );
+}

data/ext/honeymaker_native/src/ruby_decimal.rs

@@ -87,4 +87,8 @@ impl Num for RubyDecimal {
     fn is_zero(&self) -> Result<bool, magnus::Error> {
         self.value().funcall("zero?", ())
     }
+
+    fn gt(&self, o: &Self) -> Result<bool, magnus::Error> {
+        self.value().funcall(">", (o.value(),))
+    }
 }

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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: honeymaker
 version: !ruby/object:Gem::Version
-  version: 0.12.5
+  version: 0.12.6
 platform: ruby
 authors:
 - Deltabadger
@@ -179,6 +179,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
@@ -252,6 +253,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