honeymaker 0.12.4-aarch64-linux → 0.12.6-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce03d589763a1ce403d35622db819a32dfa54b6ac86c3fd19941ecb3083a82ff
-  data.tar.gz: 2eef626eca2a9c2ff52e74c3f9b8695f6af426f62d6122331c77241319123f5c
+  metadata.gz: facaf702a43fc739fe970a71f72017dd240617a8938a53934adb892c968f91cf
+  data.tar.gz: f7076b3470b45e3250f5794894f8e7e6a93cbcf034c76a67e117eea52649e5d1
 SHA512:
-  metadata.gz: a3b24b61eaa393c7e7db0a4e30b20d34bafad08aca60961e04480c8efb016b27800555f862a0078857eb69a2cd61e4e69119a372d13480eca34dcba2dff431a0
-  data.tar.gz: a843783dd90df321366ed0c4b35232f66f4a0b44dd0dddb7fb46eababd92eb678219ad57f8814dea50b6f3df7e44aa6f430dd49fea1fca2a62c8c5214a817105
+  metadata.gz: 8b19a598c52226ea8b503c9b887e0d091cc387937799475af8b65473907c8ce3e5546126cdaa73f1c0610d6c5bcf36f46f181c190a01b14e9c7f8c85d297a637
+  data.tar.gz: 7363a8ca3f95e42abd6dbb6584db23bcb80c6dc2872067e23a930c75d51ff80f737df96a50ec01547051591a4a2725b137d56b5690c0a9f54fe496070180856a

data/lib/honeymaker/clients/bingx.rb

@@ -18,10 +18,11 @@ module Honeymaker
         get_public("/openApi/spot/v1/market/depth", { symbol: symbol, limit: limit })
       end
 
-      def get_klines(symbol:, interval:, start_time: nil, end_time: nil, limit: nil)
+      # time_zone: 0 aligns candles to UTC; BingX's default is 8 (UTC+8).
+      def get_klines(symbol:, interval:, start_time: nil, end_time: nil, limit: nil, time_zone: nil)
         get_public("/openApi/spot/v1/market/kline", {
           symbol: symbol, interval: interval,
-          startTime: start_time, endTime: end_time, limit: limit
+          startTime: start_time, endTime: end_time, limit: limit, timeZone: time_zone
         })
       end
 
@@ -87,22 +88,25 @@ module Honeymaker
         get_signed("/openApi/wallets/v1/capital/config/getall")
       end
 
-      def get_trade_fills(symbol: nil, order_id: nil, start_time: nil, end_time: nil, from_id: nil, limit: nil)
-        get_signed("/openApi/spot/v1/trade/fills", {
+      # Query transaction details. symbol is required; only the past 7 days; limit ≤ 1000.
+      def get_trade_fills(symbol:, order_id: nil, start_time: nil, end_time: nil, from_id: nil, limit: nil)
+        get_signed("/openApi/spot/v1/trade/myTrades", {
           symbol: symbol, orderId: order_id,
           startTime: start_time, endTime: end_time, fromId: from_id, limit: limit
         })
       end
 
+      # Deposit records: a bare array, offset + limit ≤ 1000.
       def deposit_history(coin: nil, status: nil, start_time: nil, end_time: nil, offset: nil, limit: nil)
-        get_signed("/openApi/wallets/v1/capital/deposit/hisrec", {
+        get_signed("/openApi/api/v3/capital/deposit/hisrec", {
           coin: coin, status: status,
           startTime: start_time, endTime: end_time, offset: offset, limit: limit
         })
       end
 
+      # Withdraw records: a bare array, offset + limit ≤ 1000.
       def withdraw_history(coin: nil, status: nil, start_time: nil, end_time: nil, offset: nil, limit: nil, id: nil)
-        get_signed("/openApi/wallets/v1/capital/withdraw/history", {
+        get_signed("/openApi/api/v3/capital/withdraw/history", {
           coin: coin, status: status,
           startTime: start_time, endTime: end_time, offset: offset, limit: limit, id: id
         })

data/lib/honeymaker/clients/bitrue.rb

@@ -14,14 +14,22 @@ module Honeymaker
         get_public("/api/v1/ticker/price", { symbol: symbol })
       end
 
+      # Without a symbol, /ticker/price answers nothing usable; /ticker/24hr lists every pair
+      # (weight 40) with lastPrice.
+      def ticker_24hr(symbol: nil)
+        get_public("/api/v1/ticker/24hr", { symbol: symbol })
+      end
+
       def symbol_order_book_ticker(symbol: nil)
         get_public("/api/v1/ticker/bookTicker", { symbol: symbol })
       end
 
-      def candlestick_data(symbol:, interval:, start_time: nil, end_time: nil, limit: 500)
+      # Documented: symbol, scale, fromIdx, limit (max 1440). startTime/endTime are not documented and
+      # are ignored; fromIdx (ms) caps the newest candle, so a walk goes back with fromIdx = oldest - 1.
+      def candlestick_data(symbol:, interval:, start_time: nil, end_time: nil, limit: 500, from_idx: nil)
         get_public("/api/v1/market/kline", {
           symbol: symbol, scale: interval, startTime: start_time,
-          endTime: end_time, limit: limit
+          endTime: end_time, limit: limit, fromIdx: from_idx
         })
       end
 
@@ -77,34 +85,56 @@ module Honeymaker
         })
       end
 
-      def get_all_coins_information(recv_window: 5000)
-        get_signed("/api/v1/capital/config/getall", { recvWindow: recv_window })
+      # /api/v1/capital/config/getall redirects to the website. The documented source of withdrawal
+      # networks and fees is the public exchangeInfo `coins[].chainDetail[]`; it is answered here in the
+      # Binance shape the method always promised: [{ "coin", "networkList" => [{ "network",
+      # "withdrawFee", "withdrawMin", "withdrawMax", "withdrawEnable", "depositEnable", "isDefault" }] }].
+      # Bitrue marks no default chain; a chain closed for withdrawal is left out.
+      def get_all_coins_information
+        result = exchange_information
+        return result if result.failure?
+
+        coins = Array(result.data["coins"]).map do |coin|
+          networks = Array(coin["chainDetail"]).select { |c| c["enableWithdraw"] }.map do |c|
+            { "network" => c["chain"], "withdrawFee" => c["withdrawFee"], "withdrawMin" => c["minWithdraw"],
+              "withdrawMax" => c["maxWithdraw"], "withdrawEnable" => true,
+              "depositEnable" => c["enableDeposit"], "isDefault" => false }
+          end
+          { "coin" => coin["coin"].to_s.upcase, "networkList" => networks }
+        end
+        Result::Success.new(coins)
       end
 
-      def withdraw(coin:, address:, amount:, network: nil, address_tag: nil, recv_window: 5000)
-        post_signed("/api/v1/capital/withdraw/apply", {
-          coin: coin, address: address, amount: amount,
-          network: network, addressTag: address_tag, recvWindow: recv_window
+      # POST /api/v1/withdraw/commit: coin without chain name, chainName, addressTo; needs the
+      # withdraw privilege, an IP-limited key and a whitelisted address.
+      def withdraw(coin:, address:, amount:, network:, address_tag: nil, recv_window: 5000)
+        post_signed("/api/v1/withdraw/commit", {
+          coin: coin, amount: amount, addressTo: address,
+          chainName: network, tag: address_tag, recvWindow: recv_window
         })
       end
 
+      # GET /api/v2/myTrades (v1 is undocumented): limit ≤ 1000, a startTime..endTime span ≤ 3 months.
       def account_trade_list(symbol:, start_time: nil, end_time: nil, from_id: nil, limit: 500, recv_window: 5000)
-        get_signed("/api/v1/myTrades", {
+        get_signed("/api/v2/myTrades", {
           symbol: symbol, startTime: start_time, endTime: end_time,
           fromId: from_id, limit: limit, recvWindow: recv_window
         })
       end
 
-      def deposit_history(coin: nil, status: nil, start_time: nil, end_time: nil, offset: nil, limit: 1000, recv_window: 5000)
-        get_signed("/api/v1/capital/deposit/hisrec", {
+      # GET /api/v1/deposit/history and /api/v1/withdraw/history (the /capital/ paths redirect to the
+      # website): coin is required and has no chain suffix; status defaults to 0 (init) — finished is
+      # 1 for a deposit, 5 for a withdrawal; offset + limit ≤ 1000; answers { "code" => 200, "data" => [...] }.
+      def deposit_history(coin:, status: nil, start_time: nil, end_time: nil, offset: nil, limit: 1000, recv_window: 5000)
+        get_signed("/api/v1/deposit/history", {
           coin: coin, status: status,
           startTime: start_time, endTime: end_time,
           offset: offset, limit: limit, recvWindow: recv_window
         })
       end
 
-      def withdraw_history(coin: nil, status: nil, start_time: nil, end_time: nil, offset: nil, limit: 1000, recv_window: 5000)
-        get_signed("/api/v1/capital/withdraw/history", {
+      def withdraw_history(coin:, status: nil, start_time: nil, end_time: nil, offset: nil, limit: 1000, recv_window: 5000)
+        get_signed("/api/v1/withdraw/history", {
           coin: coin, status: status,
           startTime: start_time, endTime: end_time,
           offset: offset, limit: limit, recvWindow: recv_window

data/lib/honeymaker/clients/bitvavo.rb

@@ -90,12 +90,14 @@ module Honeymaker
         })
       end
 
+      # GET /v2/deposit is the deposit ADDRESS, and GET /v2/withdrawal answers 405. The histories are
+      # /v2/depositHistory and /v2/withdrawalHistory: limit ≤ 1000 (default 500), latest first.
       def get_deposit_history(symbol: nil, limit: nil, start_time: nil, end_time: nil)
-        get_signed("/v2/deposit", { symbol: symbol, limit: limit, start: start_time, end: end_time })
+        get_signed("/v2/depositHistory", { symbol: symbol, limit: limit, start: start_time, end: end_time })
       end
 
       def get_withdrawal_history(symbol: nil, limit: nil, start_time: nil, end_time: nil)
-        get_signed("/v2/withdrawal", { symbol: symbol, limit: limit, start: start_time, end: end_time })
+        get_signed("/v2/withdrawalHistory", { symbol: symbol, limit: limit, start: start_time, end: end_time })
       end
 
       def withdraw(symbol:, amount:, address:, payment_id: nil)
@@ -106,8 +108,11 @@ module Honeymaker
 
       # --- History ---
 
-      def get_transactions(limit: nil, start_time: nil, end_time: nil)
-        get_signed("/v2/transactions", { limit: limit, start: start_time, end: end_time })
+      # /v2/transactions is a 404. The transaction history is /v2/account/history: every type (buy,
+      # sell, deposit, withdrawal, staking, ...), fromDate/toDate in ms, page from 1, maxItems ≤ 100;
+      # answers { "items" => [...], "currentPage", "totalPages", "maxItems" }.
+      def get_transactions(limit: nil, start_time: nil, end_time: nil, page: nil, type: nil)
+        get_signed("/v2/account/history", { fromDate: start_time, toDate: end_time, page: page, maxItems: limit, type: type })
       end
 
       private

data/lib/honeymaker/clients/gemini.rb

@@ -84,6 +84,16 @@ module Honeymaker
         post_signed("/v1/transfers", { timestamp: timestamp, limit_transfers: limit_transfers })
       end
 
+      # POST /v2/transfers, which replaces the retiring /v1/transfers: limit_transfers ≤ 50 (default 10),
+      # timestamp in ms, rows carry feeAmount/feeCurrency/txHash; 1 request per 5 s per account.
+      def get_transfers_v2(timestamp: nil, limit_transfers: nil, currency: nil, network: nil, account: nil,
+                           show_completed_deposit_advances: nil)
+        post_signed("/v2/transfers", {
+          timestamp: timestamp, limit_transfers: limit_transfers, currency: currency, network: network,
+          account: account, show_completed_deposit_advances: show_completed_deposit_advances
+        })
+      end
+
       def withdraw(currency:, address:, amount:)
         post_signed("/v1/withdraw/#{currency}", { address: address, amount: amount })
       end

data/lib/honeymaker/clients/hyperliquid.rb

@@ -5,6 +5,20 @@ module Honeymaker
     class Hyperliquid < Client
       URL = "https://api.hyperliquid.xyz"
       RATE_LIMITS = { default: 200, orders: 200 }.freeze
+      # A cap on the userFillsByTime walk for one order's cost: the venue keeps only the 10000 most
+      # recent fills, at most 2000 (500 by the general note) per answer, so 25 pages reach them all.
+      FILLS_PAGES = 25
+
+      NONCE_LOCK = Mutex.new
+      @last_nonce = 0
+
+      # Hyperliquid keeps the 100 highest nonces per signer and refuses a reused one. hyperliquid-rb
+      # signs with the wall clock in ms, so two orders signed in the same ms by one agent collide —
+      # and the app builds a client per call, so the counter lives on the class: strictly
+      # increasing for the whole process, never behind the clock (the venue's own advice).
+      def self.next_nonce
+        NONCE_LOCK.synchronize { @last_nonce = [(Time.now.to_f * 1000).to_i, @last_nonce + 1].max }
+      end
 
       def initialize(api_key: nil, api_secret: nil, proxy: nil, logger: nil)
         super
@@ -87,13 +101,13 @@ module Honeymaker
         quote_amount_exec = BigDecimal("0")
         price = limit_price
         if amount_exec.positive?
-          fills_result = order["timestamp"] ? user_fills_by_time(user: user, start_time: order["timestamp"]) : nil
+          fills_result = order["timestamp"] ? order_fills(user: user, oid: oid, start_time: order["timestamp"], size: amount_exec) : nil
           # A FAILED exact-cost lookup (timeout / rate-limit) is PROPAGATED so the consumer's typed-error
           # retry runs — never record an executed order with an estimated cost just because userFills
           # blipped (that would silently corrupt accounting and skip the retry).
           return fills_result if fills_result&.failure?
 
-          matched = Array(fills_result&.data).select { |f| f["oid"].to_s == oid.to_s }
+          matched = Array(fills_result&.data)
           matched_quote = matched.sum(BigDecimal("0")) { |f| BigDecimal(f["px"].to_s) * BigDecimal(f["sz"].to_s) }
           # userFills SUCCEEDED but has no matching fill (aged out of the window) → estimate from the
           # limit price so a filled order never reports quote_amount_exec 0. Only on success, never failure.
@@ -127,6 +141,11 @@ module Honeymaker
         post_info(body)
       end
 
+      # "missing", "user", "agent" (with the master under data.user), "vault" or "subAccount".
+      def user_role(user:)
+        post_info({ type: "userRole", user: user })
+      end
+
       # --- Trading (requires hyperliquid-rb gem) ---
 
       def order(coin:, is_buy:, size:, limit_px:, order_type: { limit: { tif: "Gtc" } })
@@ -157,6 +176,28 @@ module Honeymaker
 
       private
 
+      # This order's fills, from its timestamp on. One answer is capped, so the walk goes on from the
+      # newest time it saw (inclusive, so fills are deduped by tid) until the order's executed size
+      # is covered or a page brings nothing new.
+      def order_fills(user:, oid:, start_time:, size:)
+        seen = {}
+        matched = []
+        FILLS_PAGES.times do
+          page = user_fills_by_time(user: user, start_time: start_time)
+          return page if page.failure?
+
+          fresh = Array(page.data).reject { |f| seen[f["tid"] || f.hash] }
+          break if fresh.empty?
+
+          fresh.each { |f| seen[f["tid"] || f.hash] = true }
+          matched.concat(fresh.select { |f| f["oid"].to_s == oid.to_s })
+          break if matched.sum(BigDecimal("0")) { |f| BigDecimal(f["sz"].to_s) } >= size
+
+          start_time = fresh.map { |f| f["time"].to_i }.max
+        end
+        Result::Success.new(matched)
+      end
+
       # Trading does not go over this client's Faraday connection: it goes through hyperliquid-rb,
       # which raises its own error for every non-2xx instead of answering. Client#with_rescue can
       # only see an unlabelled StandardError there, so it flags it `client_error` — "no clean
@@ -211,12 +252,30 @@ module Honeymaker
         raise Error, "Trading requires api_secret (agent key)" unless @api_secret && !@api_secret.empty?
         @exchange ||= begin
           require "hyperliquid"
-          ::Hyperliquid::Exchange.new(private_key: @api_secret)
+          build_exchange
         rescue LoadError
           raise Error, "Add 'hyperliquid-rb' to your Gemfile to use Hyperliquid trading"
         end
       end
 
+      # hyperliquid-rb's defaults do not fit a client built per call:
+      # - its Info opens a websocket and a ping thread unless skip_ws, and nothing here ever stops
+      #   them — one leaked socket per trading client. Nothing here subscribes, so never open it;
+      # - its two Transports build their own Faraday without our proxy, so placement and the asset
+      #   lookup went out direct. hyperliquid-rb 0.1.1 has no proxy option; set it on both;
+      # - its nonce is the wall-clock ms (see .next_nonce).
+      def build_exchange
+        exchange = ::Hyperliquid::Exchange.new(private_key: @api_secret, skip_ws: true)
+        if @proxy
+          [exchange.instance_variable_get(:@transport), exchange.info.transport].each do |transport|
+            transport.instance_variable_get(:@connection).proxy = @proxy
+          end
+        end
+        exchange.singleton_class.send(:define_method, :timestamp_ms) { Honeymaker::Clients::Hyperliquid.next_nonce }
+        exchange.singleton_class.send(:private, :timestamp_ms)
+        exchange
+      end
+
       def post_info(body)
         with_rescue do
           response = connection.post do |req|

data/lib/honeymaker/clients/mexc.rb

@@ -6,8 +6,9 @@ module Honeymaker
       URL = "https://api.mexc.com"
       RATE_LIMITS = { default: 100, orders: 200 }.freeze
 
-      def get_all_coins_information
-        get_public("/api/v3/capital/config/getall")
+      # Signed (permission SPOT_WITHDRAW_READ): unsigned, MEXC answers 400 "api key required".
+      def get_all_coins_information(recv_window: 5000)
+        get_signed("/api/v3/capital/config/getall", { recvWindow: recv_window })
       end
 
       def exchange_information
@@ -108,6 +109,19 @@ module Honeymaker
         get_signed("/api/v3/capital/withdraw/address", { recvWindow: recv_window })
       end
 
+      # POST /api/v3/capital/withdraw, the endpoint MEXC replaces /withdraw/apply with ("previous,
+      # offline soon"). It takes netWork — networkList[].netWork from get_all_coins_information, a
+      # different value from the old `network` — and answers a single { "id" } object, not an array.
+      def capital_withdraw(coin:, address:, amount:, net_work: nil, memo: nil, withdraw_order_id: nil,
+                           contract_address: nil, remark: nil, recv_window: 5000)
+        post_signed("/api/v3/capital/withdraw", {
+          coin: coin, address: address, amount: amount, netWork: net_work, memo: memo,
+          withdrawOrderId: withdraw_order_id, contractAddress: contract_address, remark: remark,
+          recvWindow: recv_window
+        })
+      end
+
+      # The previous endpoint, which MEXC marks "offline soon"; see #capital_withdraw.
       def withdraw(coin:, address:, amount:, network: nil, memo: nil, recv_window: 5000)
         post_signed("/api/v3/capital/withdraw/apply", {
           coin: coin, address: address, amount: amount,

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/exchanges/mexc.rb

@@ -16,10 +16,15 @@ module Honeymaker
               ticker: product["symbol"],
               base: product["baseAsset"],
               quote: product["quoteAsset"],
-              minimum_base_size: f[:lot_size]&.[]("minQty"),
-              minimum_quote_size: f[:notional]&.[]("minNotional"),
+              # MEXC sends no LOT_SIZE or NOTIONAL filter (only PERCENT_PRICE_BY_SIDE). Its minimums are
+              # baseSizePrecision ("min order quantity") and quoteAmountPrecision ("min order amount";
+              # quoteAmountPrecisionMarket for a market order, so the larger of the two), and
+              # maxQuoteAmount caps the order value. A filter still wins if MEXC ever sends one.
+              minimum_base_size: f[:lot_size]&.[]("minQty") || product["baseSizePrecision"],
+              minimum_quote_size: f[:notional]&.[]("minNotional") ||
+                product.values_at("quoteAmountPrecision", "quoteAmountPrecisionMarket").compact.max_by { |v| BigDecimal(v.to_s) },
               maximum_base_size: f[:lot_size]&.[]("maxQty"),
-              maximum_quote_size: f[:notional]&.[]("maxNotional"),
+              maximum_quote_size: f[:notional]&.[]("maxNotional") || product["maxQuoteAmount"],
               base_decimals: f[:lot_size] ? Utils.decimals(f[:lot_size]["stepSize"]) : product["baseAssetPrecision"],
               quote_decimals: product["quoteAssetPrecision"],
               price_decimals: f[:price] ? Utils.decimals(f[:price]["tickSize"]) : product["quotePrecision"],

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.4"
+  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/clients/bingx_client_test.rb

@@ -83,16 +83,29 @@ class Honeymaker::Clients::BingXTest < Minitest::Test
     assert result.success?
   end
 
+  # /openApi/spot/v1/trade/fills and /openApi/wallets/v1/capital/{deposit,withdraw}/... answer
+  # 100400 "this api is not exist"; these are the documented paths.
+  def test_get_trade_fills_reads_my_trades
+    @client.expects(:get_signed).with("/openApi/spot/v1/trade/myTrades",
+                                      { symbol: "BTC-USDT", orderId: nil, startTime: 1, endTime: 2, fromId: nil, limit: 500 })
+    @client.get_trade_fills(symbol: "BTC-USDT", start_time: 1, end_time: 2, limit: 500)
+  end
+
   def test_deposit_history
-    stub_connection(:get, [{ "coin" => "BTC" }])
-    result = @client.deposit_history
-    assert result.success?
+    @client.expects(:get_signed).with("/openApi/api/v3/capital/deposit/hisrec", has_entries(offset: 0, limit: 1000))
+           .returns(Honeymaker::Result::Success.new([{ "coin" => "BTC" }]))
+    assert @client.deposit_history(offset: 0, limit: 1000).success?
   end
 
   def test_withdraw_history
-    stub_connection(:get, [{ "coin" => "ETH" }])
-    result = @client.withdraw_history
-    assert result.success?
+    @client.expects(:get_signed).with("/openApi/api/v3/capital/withdraw/history", has_entries(startTime: 1, endTime: 2))
+           .returns(Honeymaker::Result::Success.new([{ "coin" => "ETH" }]))
+    assert @client.withdraw_history(start_time: 1, end_time: 2).success?
+  end
+
+  def test_get_klines_sends_time_zone
+    @client.expects(:get_public).with("/openApi/spot/v1/market/kline", has_entries(symbol: "BTC-USDT", timeZone: 0))
+    @client.get_klines(symbol: "BTC-USDT", interval: "1d", time_zone: 0)
   end
 
   private

data/test/honeymaker/clients/bitrue_client_test.rb

@@ -53,6 +53,54 @@ class Honeymaker::Clients::BitrueTest < Minitest::Test
     assert result.success?
   end
 
+  # The /capital/ paths and /api/v1/myTrades are not in Bitrue's docs; the former redirect to the website.
+  def test_account_trade_list_reads_v2
+    @client.expects(:get_signed).with("/api/v2/myTrades", has_entries(symbol: "BTCUSDT", startTime: 1, endTime: 2, limit: 1000))
+    @client.account_trade_list(symbol: "BTCUSDT", start_time: 1, end_time: 2, limit: 1000)
+  end
+
+  def test_deposit_history
+    @client.expects(:get_signed).with("/api/v1/deposit/history", has_entries(coin: "usdt", status: 1, offset: 0, limit: 1000))
+    @client.deposit_history(coin: "usdt", status: 1, offset: 0)
+  end
+
+  def test_withdraw_history
+    @client.expects(:get_signed).with("/api/v1/withdraw/history", has_entries(coin: "usdt", status: 5))
+    @client.withdraw_history(coin: "usdt", status: 5)
+  end
+
+  def test_withdraw_commits
+    @client.expects(:post_signed).with("/api/v1/withdraw/commit",
+                                       has_entries(coin: "usdt", amount: "10", addressTo: "0xabc", chainName: "TRX"))
+    @client.withdraw(coin: "usdt", address: "0xabc", amount: "10", network: "TRX")
+  end
+
+  def test_get_all_coins_information_reads_exchange_info_chains
+    stub_connection(:get, { "coins" => [{ "coin" => "usdt", "chainDetail" => [
+      { "chain" => "OMNI", "enableWithdraw" => false, "enableDeposit" => false, "withdrawFee" => "1.28" },
+      { "chain" => "TRX", "enableWithdraw" => true, "enableDeposit" => true, "withdrawFee" => "1.00",
+        "minWithdraw" => "2.00", "maxWithdraw" => "2000000.00" }
+    ] }] })
+
+    result = @client.get_all_coins_information
+
+    assert result.success?
+    coin = result.data.first
+    assert_equal "USDT", coin["coin"]
+    assert_equal [{ "network" => "TRX", "withdrawFee" => "1.00", "withdrawMin" => "2.00", "withdrawMax" => "2000000.00",
+                    "withdrawEnable" => true, "depositEnable" => true, "isDefault" => false }], coin["networkList"]
+  end
+
+  def test_ticker_24hr
+    @client.expects(:get_public).with("/api/v1/ticker/24hr", { symbol: nil })
+    @client.ticker_24hr
+  end
+
+  def test_candlestick_data_sends_from_idx
+    @client.expects(:get_public).with("/api/v1/market/kline", has_entries(symbol: "BTCUSDT", scale: "1D", fromIdx: 5, limit: 1440))
+    @client.candlestick_data(symbol: "BTCUSDT", interval: "1D", from_idx: 5, limit: 1440)
+  end
+
   def test_headers_include_api_key
     headers = @client.send(:auth_headers)
     assert_equal "test_key", headers[:"X-MBX-APIKEY"]

data/test/honeymaker/clients/bitvavo_client_test.rb

@@ -95,6 +95,21 @@ class Honeymaker::Clients::BitvavoTest < Minitest::Test
     assert result.success?
   end
 
+  def test_deposit_history_path
+    @client.expects(:get_signed).with("/v2/depositHistory", { symbol: "BTC", limit: 1000, start: 1, end: 2 })
+    @client.get_deposit_history(symbol: "BTC", limit: 1000, start_time: 1, end_time: 2)
+  end
+
+  def test_withdrawal_history_path
+    @client.expects(:get_signed).with("/v2/withdrawalHistory", { symbol: nil, limit: 1000, start: 1, end: 2 })
+    @client.get_withdrawal_history(limit: 1000, start_time: 1, end_time: 2)
+  end
+
+  def test_transactions_read_account_history
+    @client.expects(:get_signed).with("/v2/account/history", { fromDate: 1, toDate: 2, page: 3, maxItems: 100, type: "deposit" })
+    @client.get_transactions(limit: 100, start_time: 1, end_time: 2, page: 3, type: "deposit")
+  end
+
   def test_get_deposit_history
     stub_connection(:get, [{ "symbol" => "BTC", "amount" => "1.0" }])
     result = @client.get_deposit_history

data/test/honeymaker/clients/gemini_client_test.rb

@@ -89,6 +89,21 @@ class Honeymaker::Clients::GeminiTest < Minitest::Test
     assert_equal OpenSSL::HMAC.hexdigest("sha384", "test_secret", payload), request.headers[:"X-GEMINI-SIGNATURE"]
   end
 
+  def test_get_transfers_v2
+    @client.expects(:post_signed).with("/v2/transfers", has_entries(timestamp: 1, limit_transfers: 50))
+           .returns(Honeymaker::Result::Success.new([{ "eid" => 1, "feeCurrency" => "BTC" }]))
+    assert @client.get_transfers_v2(timestamp: 1, limit_transfers: 50).success?
+  end
+
+  def test_get_transfers_v2_signs_the_v2_request
+    connection = stub
+    connection.expects(:post).yields(req = stub_everything).returns(stub(body: []))
+    req.expects(:url).with("/v2/transfers")
+    req.expects(:headers=).with { |h| JSON.parse(Base64.decode64(h[:"X-GEMINI-PAYLOAD"]))["request"] == "/v2/transfers" }
+    @client.instance_variable_set(:@connection, connection)
+    assert @client.get_transfers_v2(limit_transfers: 50).success?
+  end
+
   private
 
   def stub_connection(method, body)

data/test/honeymaker/clients/hyperliquid_client_test.rb

@@ -70,8 +70,10 @@ class Honeymaker::Clients::HyperliquidTest < Minitest::Test
     # quote_amount_exec 0 (the job subtracts the quote delta from missed_quote_amount).
     order_body = order_status_body(status: "filled", sz: "0.0", orig_sz: "0.00018", limit_px: "64689.0")
     stub_connection(:post, order_body)
-    @client.expects(:user_fills_by_time)
-           .returns(Honeymaker::Result::Success.new([fill(oid: 111, px: "1.0", sz: "5.0")])) # no match
+    # no match; the walk reads on until a page brings nothing new
+    @client.expects(:user_fills_by_time).twice
+           .returns(Honeymaker::Result::Success.new([fill(oid: 111, px: "1.0", sz: "5.0", tid: 1)]),
+                    Honeymaker::Result::Success.new([fill(oid: 111, px: "1.0", sz: "5.0", tid: 1)]))
 
     result = @client.order_status(user: "0xabc", oid: 123456789)
 
@@ -190,6 +192,80 @@ class Honeymaker::Clients::HyperliquidTest < Minitest::Test
     assert result.success?
   end
 
+  # One userFillsByTime answer is capped; an order whose fills spill past it must still be costed
+  # exactly, not estimated from the limit price.
+  def test_order_status_reads_fills_past_the_first_page
+    order_body = order_status_body(status: "filled", sz: "0.0", orig_sz: "0.00020")
+    stub_connection(:post, order_body)
+    first = [fill(oid: 1, px: "1.0", sz: "1.0", time: 1781698875556),
+             fill(oid: 123456789, px: "64000.0", sz: "0.00010", time: 1781698875600, tid: 7)]
+    second = [fill(oid: 123456789, px: "64000.0", sz: "0.00010", time: 1781698875600, tid: 7), # boundary re-read
+              fill(oid: 123456789, px: "66000.0", sz: "0.00010", time: 1781698875700)]
+    seq = sequence("pages")
+    @client.expects(:user_fills_by_time).with(user: "0xabc", start_time: 1781698875556).in_sequence(seq)
+           .returns(Honeymaker::Result::Success.new(first))
+    @client.expects(:user_fills_by_time).with(user: "0xabc", start_time: 1781698875600).in_sequence(seq)
+           .returns(Honeymaker::Result::Success.new(second))
+
+    result = @client.order_status(user: "0xabc", oid: 123456789)
+
+    assert_equal BigDecimal("13.0"), result.data[:quote_amount_exec]
+    assert_equal BigDecimal("65000"), result.data[:price]
+  end
+
+  def test_order_status_propagates_a_failed_later_page
+    stub_connection(:post, order_status_body(status: "filled", sz: "0.0", orig_sz: "0.00020"))
+    @client.expects(:user_fills_by_time).twice
+           .returns(Honeymaker::Result::Success.new([fill(oid: 123456789, px: "64000.0", sz: "0.00010")]),
+                    Honeymaker::Result::Failure.new("Net::ReadTimeout"))
+
+    result = @client.order_status(user: "0xabc", oid: 123456789)
+
+    assert result.failure?
+    assert_includes result.errors, "Net::ReadTimeout"
+  end
+
+  def test_user_role
+    connection = stub
+    connection.expects(:post).yields(req = stub_everything).returns(stub(body: { "role" => "agent", "data" => { "user" => "0xm" } }))
+    req.expects(:body=).with({ type: "userRole", user: "0xabc" }.to_json)
+    @client.instance_variable_set(:@connection, connection)
+
+    result = @client.user_role(user: "0xabc")
+
+    assert_equal "agent", result.data["role"]
+  end
+
+  # == Trading client construction ==
+
+  def test_trading_client_opens_no_websocket
+    with_fake_hyperliquid do
+      client = Honeymaker::Clients::Hyperliquid.new(api_key: "0xabc", api_secret: "0x01")
+      assert client.send(:build_exchange).info.skip_ws
+    end
+  end
+
+  def test_trading_client_sends_through_the_configured_proxy
+    with_fake_hyperliquid do
+      client = Honeymaker::Clients::Hyperliquid.new(api_key: "0xabc", api_secret: "0x01", proxy: "http://proxy.local:8080")
+      exchange = client.send(:build_exchange)
+      [exchange.instance_variable_get(:@transport), exchange.info.transport].each do |transport|
+        assert_equal "proxy.local", transport.instance_variable_get(:@connection).proxy.uri.host
+      end
+    end
+  end
+
+  def test_trading_clients_sign_strictly_increasing_nonces_within_one_millisecond
+    with_fake_hyperliquid do
+      Time.stubs(:now).returns(Time.at(1_781_698_875.556))
+      a = Honeymaker::Clients::Hyperliquid.new(api_key: "0xabc", api_secret: "0x01").send(:build_exchange)
+      b = Honeymaker::Clients::Hyperliquid.new(api_key: "0xabc", api_secret: "0x01").send(:build_exchange)
+      nonces = [a.nonce, b.nonce, a.nonce]
+      assert_equal nonces.sort.uniq, nonces
+      assert_operator nonces.first, :>=, 1_781_698_875_556
+    end
+  end
+
   # == Raised trading errors keep their HTTP status ==
   #
   # Order placement goes through hyperliquid-rb, which raises instead of answering. Whether the
@@ -285,8 +361,48 @@ class Honeymaker::Clients::HyperliquidTest < Minitest::Test
     }
   end
 
-  def fill(oid:, px:, sz:, coin: "@142", side: "B")
+  def fill(oid:, px:, sz:, coin: "@142", side: "B", time: 1781698875556, tid: nil)
+    @tid = (@tid || 0) + 1
     { "coin" => coin, "oid" => oid, "px" => px, "sz" => sz, "side" => side,
-      "time" => 1781698875556, "fee" => "0.011", "tid" => 99 }
+      "time" => time, "fee" => "0.011", "tid" => tid || @tid }
+  end
+
+  # hyperliquid-rb's shape, as far as build_exchange touches it. The gem itself is an optional
+  # dependency (native secp256k1) that this bundle does not carry.
+  module FakeHyperliquid
+    class Transport
+      def initialize = @connection = Faraday.new(url: "https://api.hyperliquid.xyz")
+    end
+
+    class Info
+      attr_reader :transport, :skip_ws
+
+      def initialize(skip_ws:)
+        @skip_ws = skip_ws
+        @transport = Transport.new
+      end
+    end
+
+    class Exchange
+      attr_reader :info
+
+      def initialize(private_key:, skip_ws: false)
+        @info = Info.new(skip_ws: skip_ws)
+        @transport = Transport.new
+      end
+
+      def nonce = timestamp_ms
+
+      private
+
+      def timestamp_ms = (Time.now.to_f * 1000).to_i
+    end
+  end
+
+  def with_fake_hyperliquid
+    Object.const_set(:Hyperliquid, FakeHyperliquid)
+    yield
+  ensure
+    Object.send(:remove_const, :Hyperliquid)
   end
 end

data/test/honeymaker/clients/mexc_client_test.rb

@@ -70,6 +70,18 @@ class Honeymaker::Clients::MexcTest < Minitest::Test
     assert result.success?
   end
 
+  def test_capital_withdraw_posts_the_new_endpoint
+    @client.expects(:post_signed).with("/api/v3/capital/withdraw",
+                                       has_entries(coin: "USDT", address: "addr", amount: "10", netWork: "TRX"))
+           .returns(Honeymaker::Result::Success.new({ "id" => "w1" }))
+    assert_equal "w1", @client.capital_withdraw(coin: "USDT", address: "addr", amount: "10", net_work: "TRX").data["id"]
+  end
+
+  def test_get_all_coins_information_is_signed
+    @client.expects(:get_signed).with("/api/v3/capital/config/getall", { recvWindow: 5000 })
+    @client.get_all_coins_information
+  end
+
   def test_withdraw_history
     stub_connection(:get, [{ "coin" => "ETH" }])
     result = @client.withdraw_history

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/exchanges/mexc_test.rb

@@ -71,8 +71,20 @@ class Honeymaker::Exchanges::MexcTest < Minitest::Test
     assert_equal 2, metal[:base_decimals]   # baseAssetPrecision
     assert_equal 5, metal[:quote_decimals]  # quoteAssetPrecision
     assert_equal 5, metal[:price_decimals]  # quotePrecision
-    assert_nil metal[:minimum_base_size]
-    assert_nil metal[:minimum_quote_size]
+    # The minimums live in MEXC's own fields; reading only the (absent) filters reported zero.
+    assert_equal "0.1", metal[:minimum_base_size]      # baseSizePrecision
+    assert_equal "1", metal[:minimum_quote_size]       # quoteAmountPrecision
+    assert_nil metal[:maximum_base_size]
+    assert_equal "2000000", metal[:maximum_quote_size] # maxQuoteAmount
+  end
+
+  # A market order's minimum (quoteAmountPrecisionMarket) can be the larger one.
+  def test_minimum_quote_size_is_the_larger_of_the_limit_and_market_minimums
+    body = load_fixture("mexc_exchange_info.json")
+    body["symbols"].first["quoteAmountPrecisionMarket"] = "5"
+    stub_connection(body)
+
+    assert_equal "5", @exchange.get_tickers_info.data.first[:minimum_quote_size]
   end
 
   def test_get_bid_ask_parses_response

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