honeymaker 0.12.3 → 0.12.5

data/script/release/push_gems.sh

@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+# Push built gems: platform gems first, the source gem last. Idempotent: a gem already on
+# rubygems.org is accepted only if byte-identical (a rerun after a partial publish).
+set -euo pipefail
+dir="${1:?gem dir}"
+version="${2:?version}"
+api="${RUBYGEMS_API:-https://rubygems.org}"
+# Exactly the release set, or nothing is pushed: 5 platform gems + the source gem.
+expected=(x86_64-linux aarch64-linux x86_64-darwin arm64-darwin x64-mingw-ucrt)
+for plat in "${expected[@]}"; do
+  [ -f "$dir/honeymaker-$version-$plat.gem" ] || { echo "::error::missing honeymaker-$version-$plat.gem" >&2; exit 1; }
+done
+[ -f "$dir/honeymaker-$version.gem" ] || { echo "::error::missing honeymaker-$version.gem (source)" >&2; exit 1; }
+count=$(find "$dir" -maxdepth 1 -name '*.gem' | wc -l | tr -d ' ')
+[ "$count" = 6 ] || { echo "::error::expected 6 gems in $dir, found $count" >&2; exit 1; }
+push() {
+  local g="$1" ver plat sha remote
+  if gem push "$g"; then return 0; fi
+  ver=$(ruby -rrubygems/package -e 'print Gem::Package.new(ARGV[0]).spec.version' "$g")
+  plat=$(ruby -rrubygems/package -e 'print Gem::Package.new(ARGV[0]).spec.platform' "$g")
+  sha=$(ruby -rdigest -e 'print Digest::SHA256.file(ARGV[0]).hexdigest' "$g")
+  remote=$(curl -fsS "$api/api/v2/rubygems/honeymaker/versions/${ver}.json?platform=${plat}" \
+           | ruby -rjson -e 'print JSON.parse($stdin.read)["sha"]')
+  if [ "$sha" != "$remote" ]; then echo "::error::$g differs from the published gem" >&2; return 1; fi
+  echo "$g already published with the same checksum"
+}
+for plat in "${expected[@]}"; do push "$dir/honeymaker-$version-$plat.gem"; done
+push "$dir/honeymaker-$version.gem"

data/script/vectors/kraken.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# Regenerates crates/honeymaker/tests/vectors/*.json from the LEGACY Ruby implementation.
+#   bundle exec ruby -Ilib script/vectors/kraken.rb
+require "honeymaker"
+require "json"
+require "bigdecimal"
+
+out_dir = File.expand_path("../../crates/honeymaker/tests/vectors", __dir__)
+
+secrets = [
+  Base64.strict_encode64("test_secret_key_1234567890123456"),
+  "dGVzd A==\n!!-_x", "abc", "=abc", "", "   ", "a", "ab==cd", "not base64 at all ~~~",
+  Base64.strict_encode64((0..255).to_a.pack("C*"))
+]
+bodies = [
+  [["nonce", "1727000000000001"]],
+  [["nonce", "1727000000000002"], ["ordertype", "market"], ["type", "buy"], ["volume", "0.001"], ["pair", "XBTUSDT"],
+   ["oflags", "viqc"], ["close[ordertype]", "limit"]],
+  [["nonce", "1727000000000003"], ["txid", "O1,O2"], ["consolidate_taker", "true"]],
+  [["nonce", "1727000000000004"], ["asset", "a b~*-._/,:[]\u00e9+&="]]
+]
+paths = %w[/0/private/BalanceEx /0/private/AddOrder /0/private/QueryOrders /0/private/Earn/Allocations]
+
+signing = []
+secrets.each do |secret|
+  [["key", secret], ["", secret], ["key", ""]].each do |key, sec|
+    bodies.each_with_index do |pairs, i|
+      body = URI.encode_www_form(pairs)
+      c = Honeymaker::Clients::Kraken.new(api_key: key, api_secret: sec)
+      signing << { api_key: key, api_secret: sec, path: paths[i], pairs: pairs, body: body,
+                   decoded_secret_hex: Base64.decode64(sec).unpack1("H*"),
+                   headers: c.send(:private_headers, paths[i], body).transform_keys(&:to_s) }
+    end
+  end
+end
+
+decimal_inputs = ["0.5", "1", "-0", "-0.0000", "0.0000000001", "123456789012345678901234567890.123456789",
+                  "1e-9", "1E5", " 1.5 ", "1_000.5", ".5", "5.", "+2", "", "abc", "1,5", "0x10", "NaN",
+                  "Infinity", "-Infinity", "1d2", "true"]
+decimals = decimal_inputs.map do |s|
+  v = BigDecimal(s)
+  { input: s, ok: true, finite: v.finite?, plain: v.finite? ? v.to_s("F") : v.to_s, sign: v.sign }
+rescue ArgumentError => e
+  { input: s, ok: false, error: e.message }
+end
+
+File.write(File.join(out_dir, "kraken_signing.json"), JSON.pretty_generate(signing))
+File.write(File.join(out_dir, "decimal.json"), JSON.pretty_generate(decimals))
+puts "wrote #{signing.size} signing vectors, #{decimals.size} decimals"

data/script/vectors/kraken_stage2.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+# Regenerates the stage-2 vectors from the LEGACY Ruby implementation.
+#   bundle exec ruby -Ilib script/vectors/kraken_stage2.rb
+require "honeymaker"
+require "json"
+require "faraday"
+
+OUT = File.expand_path("../../crates/honeymaker/tests/vectors", __dir__)
+SECRET = Base64.strict_encode64("test_secret_key_1234567890123456")
+NONCE = 1_727_000_000_000_001
+
+def legacy
+  c = Honeymaker::Clients::Kraken.new(api_key: "key", api_secret: SECRET)
+  c.define_singleton_method(:nonce) { NONCE }
+  c
+end
+
+# --- A: AddOrder with cl_ord_id and deadline, as legacy signs and sends it ---
+orders = [
+  { ordertype: "market", type: "buy", volume: "0.0012", pair: "XBTEUR", oflags: ["viqc"],
+    cl_ord_id: "6f1c1a52-7c8e-4d0e-9a57-0b6f0f1d2e3a", deadline: "2026-09-30T12:00:10.000Z" },
+  { ordertype: "limit", type: "buy", volume: "0.00119", pair: "XBTEUR", price: "49870.1", oflags: [],
+    cl_ord_id: "0d9e2c1b-2f4a-4b8c-8d1e-5a6b7c8d9e0f", deadline: "2026-09-30T12:00:10.123Z" },
+  { ordertype: "market", type: "buy", volume: "60", pair: "XBTEUR", oflags: ["viqc"],
+    cl_ord_id: "6f1c1a52-7c8e-4d0e-9a57-0b6f0f1d2e3a", deadline: "2026-09-30T12:00:10.000Z", validate: true }
+]
+wire = orders.map do |args|
+  body = nil
+  stubs = Faraday::Adapter::Test::Stubs.new do |s|
+    s.post("/0/private/AddOrder") do |env|
+      body = env.body
+      [200, { "Content-Type" => "application/json" }, '{"error":[],"result":{"txid":["OTX-1"]}}']
+    end
+  end
+  c = legacy
+  c.instance_variable_set(:@connection, Faraday.new(url: Honeymaker::Clients::Kraken::URL) { |f| f.response :json; f.adapter :test, stubs })
+  raise "legacy did not answer" unless c.add_order(**args).success?
+
+  { args: args, nonce: NONCE, api_key: "key", api_secret: SECRET, body: body,
+    headers: c.send(:private_headers, "/0/private/AddOrder", body).transform_keys(&:to_s) }
+end
+File.write(File.join(OUT, "kraken_add_order_wire.json"), JSON.pretty_generate(wire))
+puts "wrote #{wire.size} AddOrder wire vectors"
+
+# --- B: closed_orders_from_trades, the verbatim Ruby loop (with Task 8's dedupe), over scripted
+# pages. Each case says what the STRICT Rust scan must do: "same" as Ruby (a completed scan, a
+# refusal, an unreadable page or a Ruby exception), "incomplete" where Ruby stopped early or
+# trusted a malformed container and returned what it had, or "error" where Ruby skipped a malformed
+# record that Rust must refuse. The label is what Rust must do, not what Ruby did: some
+# "incomplete" cases are Ruby raises (NoMethodError on trades as a non-empty array, a non-empty
+# string or a number, and on count true or an array), not partial answers. Their "outcome" says so.
+def page(trades, count = :none)
+  result = { "trades" => trades }
+  result["count"] = count unless count == :none
+  { "error" => [], "result" => result }
+end
+
+def trade(o, vol, cost, type: "buy", ordertype: "market", fee: "0.1")
+  { "ordertxid" => o, "vol" => vol, "cost" => cost, "fee" => fee, "type" => type, "ordertype" => ordertype, "time" => 1.5 }
+end
+
+T = ->(i, o = "O1") { { "T#{i}" => trade(o, "1", "2") } }
+cases = [
+  ["one page", :same, %w[O1], 1_700_000_000, 20, [page({ "T1" => trade("O1", "0.0006", "30"), "T2" => trade("O1", "0.0006", "30") }, 2)]],
+  ["partial fill across pages, unwanted skipped", :same, %w[O1 O2], 1_700_000_000, 20,
+   [page({ "T1" => trade("O1", "1", "2"), "T2" => trade("O9", "1", "2") }, 3),
+    page({ "T3" => trade("O1", "1", "2"), "T4" => trade("O2", "2", "8", ordertype: "limit", type: "sell") }, 3)]],
+  ["no wanted ids: no request", :same, [], nil, 20, []],
+  ["a trade on two pages: rows reach count, distinct trades do not", :incomplete, %w[O1], nil, 20,
+   [page({ "T1" => trade("O1", "1", "2"), "T2" => trade("O1", "3", "9") }, 3), page({ "T2" => trade("O1", "3", "9") }, 3)]],
+  ["overlapping pages that cover every trade", :same, %w[O1], nil, 20,
+   [page({ "T1" => trade("O1", "1", "2"), "T2" => trade("O1", "3", "9") }, 3),
+    page({ "T2" => trade("O1", "3", "9"), "T3" => trade("O1", "1", "1") }, 3)]],
+  ["complete exactly at the page cap", :same, %w[O1], nil, 2, [page(T[1], 2), page(T[2], 2)]],
+  ["an empty page after the last trade", :same, %w[O1], nil, 20, [page({}, 0)]],
+  ["a fill beyond the page cap", :incomplete, %w[O1], nil, 2, [page(T[1, "O9"], 3), page(T[2, "O9"], 3), page(T[3], 3)]],
+  ["count as a string", :incomplete, %w[O1], nil, 20, [page(T[1], "2"), page(T[2], "2")]],
+  ["count 1_000 pages to max_pages", :incomplete, %w[O1], nil, 2, [page(T[1], "1_000"), page(T[2], "1_000"), page(T[3], "1_000")]],
+  ["bignum string count", :incomplete, %w[O1], nil, 3, [page(T[1], "99999999999999999999999"), page(T[2], "1"), page(T[3], "1")]],
+  ["bignum integer count", :incomplete, %w[O1], nil, 3, [page(T[1], 10**25), page(T[2], 10**25), page(T[3], 10**25), page(T[4], 10**25)]],
+  ["float count", :incomplete, %w[O1], nil, 20, [page(T[1], 2.9), page(T[2], 2.9), page(T[3], 2.9)]],
+  ["missing count", :incomplete, %w[O1], nil, 20, [page(T[1]), page(T[2])]],
+  ["nil count", :incomplete, %w[O1], nil, 20, [page(T[1], nil), page(T[2])]],
+  ["negative count", :incomplete, %w[O1], nil, 20, [page(T[1], -1), page(T[2])]],
+  *[" 3", "3abc", "0x10", "_3", "3__0", "+3", "-3", "", "abc"].map do |c|
+    ["count #{c.inspect}", :incomplete, %w[O1], nil, 4, (1..4).map { |i| page(T[i], c) }]
+  end,
+  ["empty trades before count", :incomplete, %w[O1], nil, 20, [page({}, 5), page(T[1], 5)]],
+  ["missing trades", :incomplete, %w[O1], nil, 20, [{ "error" => [], "result" => { "count" => 3 } }, page(T[1])]],
+  ["trades false", :incomplete, %w[O1], nil, 20, [page(false, 3), page(T[1])]],
+  ["trades []", :incomplete, %w[O1], nil, 20, [page([], 3), page(T[1])]],
+  ["trades \"\"", :incomplete, %w[O1], nil, 20, [page("", 3), page(T[1])]],
+  ["nil result", :incomplete, %w[O1], nil, 20, [{ "error" => [] }, page(T[1])]],
+  ["result as a string raises", :same, %w[O1], nil, 20, [{ "error" => [], "result" => "x" }]],
+  ["result as an array raises", :same, %w[O1], nil, 20, [{ "error" => [], "result" => [1] }]],
+  ["result false raises", :same, %w[O1], nil, 20, [{ "error" => [], "result" => false }]],
+  ["trades as a non-empty array", :incomplete, %w[O1], nil, 20, [page([1], 1)]],
+  ["trades as a non-empty string", :incomplete, %w[O1], nil, 20, [page("x", 1)]],
+  ["trades as a number", :incomplete, %w[O1], nil, 20, [page(5, 1)]],
+  *[[false, "false"], [[], "[]"], ["", "\"\""], [nil, "null"]].map do |trades, label|
+    ["trades #{label} with count 0", :incomplete, %w[O1], nil, 20, [page(trades, 0)]]
+  end,
+  ["trades missing with count 0", :incomplete, %w[O1], nil, 20, [{ "error" => [], "result" => { "count" => 0 } }]],
+  ["a trade that is a string", :error, %w[O1], nil, 20, [page({ "T1" => "no id here", "T2" => trade("O1", "1", "2") }, 2)]],
+  ["a record without ordertxid", :error, %w[O1], nil, 20, [page({ "T1" => { "vol" => "1", "cost" => "2" } }, 1)]],
+  ["a record with a numeric ordertxid", :error, %w[O1], nil, 20, [page({ "T1" => trade(5, "1", "2") }, 1)]],
+  ["a trade that is a number raises", :same, %w[O1], nil, 20, [page({ "T1" => 5 }, 1)]],
+  ["a trade that is null raises", :same, %w[O1], nil, 20, [page({ "T1" => nil }, 1)]],
+  ["count true", :incomplete, %w[O1], nil, 20, [page(T[1], true)]],
+  ["count as an array", :incomplete, %w[O1], nil, 20, [page(T[1], [1])]],
+  ["refusal on page 2", :same, %w[O1], nil, 20, [page(T[1], 5), { "error" => ["EAPI:Rate limit exceeded"] }]],
+  ["falsy errors are not a refusal", :same, %w[O1], nil, 20, [{ "error" => [nil, false], "result" => { "trades" => T[1], "count" => 1 } }]],
+  ["non-object page 2 is unreadable", :same, %w[O1], nil, 20, [page(T[1], 5), "oops"]],
+  ["pages run out: legacy sees null", :same, %w[O1], nil, 20, [page(T[1], 5)]],
+  ["zero volume has no price", :same, %w[O1], nil, 20, [page({ "T1" => trade("O1", "0", "0") }, 1)]]
+]
+
+pager = cases.map do |name, strict, ids, start, max_pages, pages|
+  texts = pages.map { |p| JSON.generate(p) }
+  queue = texts.dup
+  requests = []
+  c = legacy
+  c.define_singleton_method(:get_trades_history) do |start: nil, ofs: nil, **|
+    requests << [start, ofs]
+    Honeymaker::Result::Success.new(JSON.parse(queue.shift || "null"))
+  end
+  outcome = begin
+    r = c.closed_orders_from_trades(order_ids: ids, start: start, max_pages: max_pages)
+    if r.success?
+      { "ok" => r.data.map do |txid, a|
+        [txid, { "vol" => a[:amount_exec].to_s("F"), "cost" => a[:quote_amount_exec].to_s("F"), "fee" => a[:fee].to_s("F"),
+                 "price" => a[:price]&.to_s("F"), "side" => a[:side]&.to_s, "order_type" => a[:order_type].to_s }]
+      end }
+    elsif r.data.is_a?(Hash) && r.data[:unreadable]
+      { "unreadable" => true }
+    else
+      { "venue" => r.errors }
+    end
+  rescue StandardError => e
+    { "raise" => e.class.name }
+  end
+  { name: name, strict: strict, order_ids: ids, start: start, max_pages: max_pages, pages: texts, requests: requests, outcome: outcome }
+end
+File.write(File.join(OUT, "kraken_trades_pager.json"), JSON.pretty_generate(pager))
+puts "wrote #{pager.size} trades-pager vectors"

data/test/fixtures/coinbase_products.json

@@ -11,7 +11,7 @@
       "quote_max_size": "250000000"
     },
     {
-      "product_id": "RENDER-USD",
+      "product_id": "RNDR-USD",
       "base_increment": "0.01",
       "quote_increment": "0.01",
       "price_increment": "0.01",

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

@@ -46,6 +46,31 @@ class Honeymaker::Clients::BybitTest < Minitest::Test
     assert_equal :closed, result.data[:status]
   end
 
+  def test_get_order_partially_filled_canceled_is_cancelled
+    stub_connection(:get, { "retCode" => 0, "retMsg" => "OK", "result" => { "list" => [{
+      "orderId" => "123", "orderType" => "Limit", "side" => "Buy", "orderStatus" => "PartiallyFilledCanceled",
+      "avgPrice" => "50000", "qty" => "0.002", "cumExecQty" => "0.001", "cumExecValue" => "50"
+    }] } })
+    result = @client.get_order(category: "spot", order_id: "123")
+    assert_equal :cancelled, result.data[:status]
+    assert_equal BigDecimal("0.001"), result.data[:amount_exec]
+  end
+
+  def test_order_history
+    @client.expects(:get_authenticated).with("/v5/order/history", {
+      category: "spot", symbol: nil, orderId: "123", orderLinkId: nil, orderStatus: nil,
+      startTime: 1, endTime: 2, limit: 50, cursor: "c"
+    }).returns(Honeymaker::Result::Success.new({ "retCode" => 0 }))
+    assert @client.order_history(category: "spot", order_id: "123", start_time: 1, end_time: 2, limit: 50, cursor: "c").success?
+  end
+
+  def test_internal_deposit_records
+    @client.expects(:get_authenticated).with("/v5/asset/deposit/query-internal-record", {
+      txID: nil, coin: "USDT", startTime: 1, endTime: 2, limit: 50, cursor: "c"
+    }).returns(Honeymaker::Result::Success.new({ "retCode" => 0 }))
+    assert @client.internal_deposit_records(coin: "USDT", start_time: 1, end_time: 2, limit: 50, cursor: "c").success?
+  end
+
   def test_cancel_order
     stub_connection(:post, { "result" => { "orderId" => "123" } })
     result = @client.cancel_order(category: "spot", symbol: "BTCUSDT", order_id: "123")

data/test/honeymaker/clients/coinbase_client_test.rb

@@ -69,6 +69,20 @@ class Honeymaker::Clients::CoinbaseTest < Minitest::Test
     assert result.success?
   end
 
+  def test_list_accounts_passes_cursor_and_limit
+    response = stub(body: { "accounts" => [], "has_next" => false, "cursor" => "" })
+    request = stub(url: nil)
+    request.stubs(:headers=)
+    request.stubs(:http_method).returns(:get)
+    request.stubs(:path).returns("/api/v3/brokerage/accounts")
+    request.expects(:params=).with({ limit: 250, cursor: "c2" })
+    connection = stub
+    connection.stubs(:get).yields(request).returns(response)
+    @client.instance_variable_set(:@connection, connection)
+
+    assert @client.list_accounts(limit: 250, cursor: "c2").success?
+  end
+
   def test_send_money
     stub_connection(:post, { "data" => { "id" => "tx1" } })
     result = @client.send_money(account_id: "acc1", to: "addr", amount: "0.1", currency: "BTC")

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

@@ -223,6 +223,21 @@ class Honeymaker::Clients::KrakenTest < Minitest::Test
     assert_equal BigDecimal("0.00016557"), agg[:amount_exec]
   end
 
+  # A trade that lands at the top of TradesHistory between two page reads pushes TID-2 from page 1
+  # onto page 2. Offset paging then serves TID-2 twice; it must be counted once.
+  def test_closed_orders_from_trades_counts_a_trade_seen_on_two_pages_once
+    t = { "ordertxid" => "OABC", "pair" => "XXBTZUSD", "type" => "buy", "ordertype" => "market",
+          "cost" => "6.0", "vol" => "0.0001", "fee" => "0.01", "time" => 1_700_000_000.0 }
+    p1 = { "error" => [], "result" => { "count" => 3, "trades" => { "TID-1" => t, "TID-2" => t } } }
+    p2 = { "error" => [], "result" => { "count" => 3, "trades" => { "TID-2" => t } } }
+    @client.stubs(:get_trades_history).returns(Honeymaker::Result::Success.new(p1), Honeymaker::Result::Success.new(p2))
+    agg = @client.closed_orders_from_trades(order_ids: ["OABC"], start: 1).data["OABC"]
+    assert_equal BigDecimal("0.0002"), agg[:amount_exec]
+    assert_equal BigDecimal("12.0"), agg[:quote_amount_exec]
+    assert_equal BigDecimal("0.02"), agg[:fee]
+    assert_equal 2, agg[:trade_count]
+  end
+
   private
 
   def assert_strictly_increasing(values)

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