honeymaker 0.12.4 → 0.12.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 78709a467495784c1d111fff613edd1188ad5a7bee608abff82dbee3fdb5842d
-  data.tar.gz: ad8c934dfbe76031ca3c54e74a6e81a79119c0ec489ce415152a56465b8aa234
+  metadata.gz: 3b63e4e5855db8e7ada05e58f6dad106bf6f24e29628dfce7e0fd04e062382b5
+  data.tar.gz: 51382cf687f1e6a3136d7c57d1656cca27065c19075075c42d4170ae6e9ffc80
 SHA512:
-  metadata.gz: 0e45cbd2df342d861721818bf52245f23457a170fbbc0cdf464de89d2e82b5c41d2bd1d9c459ebbd019c87a4fce0c56cb87310a449a19afc0df405a09195f61c
-  data.tar.gz: 76cecab1382c572bb8a8f1f87ed843737ee40d762a4318031f0723ee5fd67f70ff4920471881101a95f620b2fb7c3fc049b143a997fc1db50a8dfc2e97ea5aba
+  metadata.gz: efa5ee0604c2daf571073432447c86cb24706ab1a95d00d318204c26dfcd66c32616e96071ee8b86992ca8f32f5f87fdaa387a30bb748781095466f44b222a0b
+  data.tar.gz: b0bb1d9eac28616b4cc1beae77159ea8221c5ee554d80f3776698b8cca2aa05e05d67c860303fba7cce7a52f61471fcc5398eb6c2bd4438cfe2a348165c73749

data/Cargo.lock

@@ -265,7 +265,7 @@ dependencies = [
 
 [[package]]
 name = "honeymaker"
-version = "0.12.4"
+version = "0.12.5"
 dependencies = [
  "base64",
  "bigdecimal",
@@ -278,7 +278,7 @@ dependencies = [
 
 [[package]]
 name = "honeymaker-client"
-version = "0.12.4"
+version = "0.12.5"
 dependencies = [
  "base64",
  "bigdecimal",
@@ -300,7 +300,7 @@ dependencies = [
 
 [[package]]
 name = "honeymaker_native"
-version = "0.12.4"
+version = "0.12.5"
 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.4" # lockstep with lib/honeymaker/version.rb (test/native/lockstep_test.rb)
+version = "0.12.5" # lockstep with lib/honeymaker/version.rb (test/native/lockstep_test.rb)
 edition = "2024"
 rust-version = "1.94"
 license = "MIT"

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/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/version.rb

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

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/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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: honeymaker
 version: !ruby/object:Gem::Version
-  version: 0.12.4
+  version: 0.12.5
 platform: ruby
 authors:
 - Deltabadger