honeymaker 0.12.4-x86_64-linux

data/test/fixtures/kraken_ticker.json

@@ -0,0 +1,16 @@
+{
+  "error": [],
+  "result": {
+    "XBTUSDT": {
+      "a": ["67125.67000", "1", "1.000"],
+      "b": ["67123.45000", "2", "2.000"],
+      "c": ["67124.50000", "0.00100000"],
+      "v": ["1234.56789012", "5678.90123456"],
+      "p": ["67100.00000", "67050.00000"],
+      "t": [12345, 67890],
+      "l": ["66800.00000", "66500.00000"],
+      "h": ["67500.00000", "67800.00000"],
+      "o": "67000.00000"
+    }
+  }
+}

data/test/fixtures/kucoin_orderbook_level1.json

@@ -0,0 +1,10 @@
+{
+  "code": "200000",
+  "data": {
+    "bestBid": "67123.45",
+    "bestBidSize": "1.234567",
+    "bestAsk": "67125.67",
+    "bestAskSize": "0.987654",
+    "time": 1700000000000
+  }
+}

data/test/fixtures/kucoin_symbols.json

@@ -0,0 +1,17 @@
+{
+  "data": [
+    {
+      "symbol": "BTC-USDT",
+      "baseCurrency": "BTC",
+      "quoteCurrency": "USDT",
+      "baseMinSize": "0.00001",
+      "quoteMinSize": "0.1",
+      "baseMaxSize": "10000000000",
+      "quoteMaxSize": "99999999",
+      "baseIncrement": "0.00000001",
+      "quoteIncrement": "0.000001",
+      "priceIncrement": "0.1",
+      "enableTrading": true
+    }
+  ]
+}

data/test/fixtures/mexc_book_ticker.json

@@ -0,0 +1,7 @@
+{
+  "symbol": "BTCUSDT",
+  "bidPrice": "67123.45",
+  "bidQty": "1.234567",
+  "askPrice": "67125.67",
+  "askQty": "0.987654"
+}

data/test/fixtures/mexc_exchange_info.json

@@ -0,0 +1,64 @@
+{
+  "_provenance": "Real capture: GET https://api.mexc.com/api/v3/exchangeInfo (2026-09-05), trimmed to two symbols and to the fields this parser reads. MEXC returns status \"1\" for every symbol and PERCENT_PRICE_BY_SIDE as its only filter \u2014 it emits neither \"TRADING\" nor LOT_SIZE/PRICE_FILTER/MIN_NOTIONAL. Re-capture and diff rather than hand-editing; mexc_test.rb asserts this file's SHA-256.",
+  "timezone": "CST",
+  "symbols": [
+    {
+      "symbol": "METALUSDT",
+      "status": "1",
+      "baseAsset": "METAL",
+      "baseAssetPrecision": 2,
+      "quoteAsset": "USDT",
+      "quotePrecision": 5,
+      "quoteAssetPrecision": 5,
+      "orderTypes": [
+        "LIMIT",
+        "MARKET",
+        "LIMIT_MAKER"
+      ],
+      "isSpotTradingAllowed": true,
+      "isMarginTradingAllowed": false,
+      "quoteAmountPrecision": "1",
+      "baseSizePrecision": "0.1",
+      "permissions": [
+        "SPOT"
+      ],
+      "filters": [
+        {
+          "filterType": "PERCENT_PRICE_BY_SIDE",
+          "bidMultiplierUp": "0.2",
+          "askMultiplierDown": "0.2"
+        }
+      ],
+      "maxQuoteAmount": "2000000"
+    },
+    {
+      "symbol": "PALMAIUSDT",
+      "status": "1",
+      "baseAsset": "PALMAI",
+      "baseAssetPrecision": 2,
+      "quoteAsset": "USDT",
+      "quotePrecision": 4,
+      "quoteAssetPrecision": 4,
+      "orderTypes": [
+        "LIMIT",
+        "MARKET",
+        "LIMIT_MAKER"
+      ],
+      "isSpotTradingAllowed": false,
+      "isMarginTradingAllowed": false,
+      "quoteAmountPrecision": "1",
+      "baseSizePrecision": "0",
+      "permissions": [
+        "SPOT"
+      ],
+      "filters": [
+        {
+          "filterType": "PERCENT_PRICE_BY_SIDE",
+          "bidMultiplierUp": "0.2",
+          "askMultiplierDown": "0.2"
+        }
+      ],
+      "maxQuoteAmount": "2000000"
+    }
+  ]
+}

data/test/honeymaker/client_test.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::ClientTest < Minitest::Test
+  def test_default_options
+    assert_equal 5, Honeymaker::Client::OPTIONS[:request][:open_timeout]
+    assert_equal 30, Honeymaker::Client::OPTIONS[:request][:read_timeout]
+    assert_equal 10, Honeymaker::Client::OPTIONS[:request][:write_timeout]
+  end
+
+  def test_authenticated_with_credentials
+    client = Honeymaker::Client.new(api_key: "key", api_secret: "secret")
+    assert client.send(:authenticated?)
+  end
+
+  def test_not_authenticated_without_credentials
+    client = Honeymaker::Client.new
+    refute client.send(:authenticated?)
+  end
+
+  def test_not_authenticated_with_empty_credentials
+    client = Honeymaker::Client.new(api_key: "", api_secret: "")
+    refute client.send(:authenticated?)
+  end
+
+  def test_with_rescue_wraps_success
+    client = Honeymaker::Client.new
+    result = client.send(:with_rescue) { { "status" => "ok" } }
+    assert result.success?
+    assert_equal({ "status" => "ok" }, result.data)
+  end
+
+  def test_with_rescue_wraps_faraday_error
+    client = Honeymaker::Client.new
+    result = client.send(:with_rescue) { raise Faraday::TimeoutError, "timeout" }
+    assert result.failure?
+  end
+
+  def test_with_rescue_wraps_standard_error
+    client = Honeymaker::Client.new
+    result = client.send(:with_rescue) { raise StandardError, "boom" }
+    assert result.failure?
+    assert_equal ["StandardError: boom"], result.errors
+  end
+
+  # A bug in this gem, in a vendor gem, or in the caller is NOT an exchange error, but it lands in
+  # the same Result::Failure. Callers classify failure text to decide "out of funds" / "bad key" /
+  # "retry me", so an unlabelled TypeError reads as something the venue said and gets filed and
+  # reported as one. Naming the class makes the true source unmistakable, and the flag lets a
+  # caller refuse to classify it at all.
+  def test_with_rescue_names_the_exception_class_for_non_api_errors
+    client = Honeymaker::Client.new
+    result = client.send(:with_rescue) { raise TypeError, "String can't be coerced into Float" }
+    assert result.failure?
+    assert_equal ["TypeError: String can't be coerced into Float"], result.errors
+    assert result.data[:client_error], "a local exception must be flagged, not passed off as the venue's"
+  end
+
+  def test_with_rescue_labels_an_empty_message_with_its_class
+    client = Honeymaker::Client.new
+    result = client.send(:with_rescue) { raise NoMethodError, "" }
+    assert result.failure?
+    assert_equal ["NoMethodError"], result.errors
+  end
+
+  # Network failures reach callers through this branch too, and the transient-retry matchers key
+  # off substrings of them. Prefixing must not break that.
+  def test_with_rescue_keeps_network_substrings_matchable
+    client = Honeymaker::Client.new
+    result = client.send(:with_rescue) { raise Net::ReadTimeout, "Net::ReadTimeout with #<TCPSocket:(closed)>" }
+    assert_includes result.errors.first, "Net::ReadTimeout"
+  end
+
+  # An exchange error is not ours: it must stay unflagged and unprefixed so the venue's own text
+  # reaches the classifiers verbatim.
+  def test_with_rescue_does_not_flag_api_errors
+    client = Honeymaker::Client.new
+    result = client.send(:with_rescue) { raise Faraday::TimeoutError, "timeout" }
+    assert result.failure?
+    assert_nil result.data[:client_error]
+  end
+
+  def test_hmac_sha256
+    client = Honeymaker::Client.new
+    sig = client.send(:hmac_sha256, "secret", "data")
+    expected = OpenSSL::HMAC.hexdigest("sha256", "secret", "data")
+    assert_equal expected, sig
+  end
+end

data/test/honeymaker/clients/binance_client_test.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::Clients::BinanceTest < Minitest::Test
+  def setup
+    @client = Honeymaker::Clients::Binance.new(api_key: "test_key", api_secret: "test_secret")
+  end
+
+  def test_url
+    assert_equal "https://api.binance.com", Honeymaker::Clients::Binance::URL
+  end
+
+  def test_exchange_information
+    stub_connection(:get, { "symbols" => [{ "symbol" => "BTCUSDT" }] })
+    result = @client.exchange_information
+    assert result.success?
+    assert_equal "BTCUSDT", result.data["symbols"].first["symbol"]
+  end
+
+  def test_new_order
+    stub_connection(:post, { "orderId" => 123, "status" => "FILLED" })
+    result = @client.new_order(symbol: "BTCUSDT", side: "BUY", type: "MARKET", quantity: "0.001")
+    assert result.success?
+    assert_equal "BTCUSDT-123", result.data[:order_id]
+    assert_equal 123, result.data[:raw]["orderId"]
+  end
+
+  def test_query_order
+    stub_connection(:get, {
+      "orderId" => 123, "symbol" => "BTCUSDT", "status" => "FILLED", "type" => "MARKET",
+      "side" => "BUY", "origQty" => "0.001", "origQuoteOrderQty" => "0",
+      "executedQty" => "0.001", "cummulativeQuoteQty" => "50", "price" => "50000"
+    })
+    result = @client.query_order(symbol: "BTCUSDT", order_id: 123)
+    assert result.success?
+    assert_equal :closed, result.data[:status]
+    assert_equal :buy, result.data[:side]
+  end
+
+  def test_account_information
+    stub_connection(:get, { "balances" => [{ "asset" => "BTC", "free" => "0.5" }] })
+    result = @client.account_information
+    assert result.success?
+    assert_equal "BTC", result.data["balances"].first["asset"]
+  end
+
+  def test_cancel_order
+    stub_connection(:delete, { "orderId" => 123, "status" => "CANCELED" })
+    result = @client.cancel_order(symbol: "BTCUSDT", order_id: 123)
+    assert result.success?
+  end
+
+  def test_account_trade_list
+    stub_connection(:get, [{ "symbol" => "BTCUSDT", "id" => 123, "price" => "50000" }])
+    result = @client.account_trade_list(symbol: "BTCUSDT")
+    assert result.success?
+    assert_equal "BTCUSDT", result.data.first["symbol"]
+  end
+
+  def test_deposit_history
+    stub_connection(:get, [{ "coin" => "BTC", "amount" => "0.5", "status" => 1 }])
+    result = @client.deposit_history
+    assert result.success?
+    assert_equal "BTC", result.data.first["coin"]
+  end
+
+  def test_withdraw_history
+    stub_connection(:get, [{ "coin" => "ETH", "amount" => "1.0", "status" => 6 }])
+    result = @client.withdraw_history
+    assert result.success?
+    assert_equal "ETH", result.data.first["coin"]
+  end
+
+  def test_convert_trade_flow
+    stub_connection(:get, { "list" => [{ "quoteId" => "q1", "fromAsset" => "BTC", "toAsset" => "USDT" }] })
+    result = @client.convert_trade_flow(start_time: 1710936000000, end_time: 1711022400000)
+    assert result.success?
+    assert_equal "q1", result.data["list"].first["quoteId"]
+  end
+
+  def test_fiat_payments
+    stub_connection(:get, { "data" => [{ "orderNo" => "f1", "cryptoCurrency" => "BTC" }] })
+    result = @client.fiat_payments(transaction_type: 0)
+    assert result.success?
+  end
+
+  def test_fiat_orders
+    stub_connection(:get, { "data" => [{ "orderNo" => "fo1", "fiatCurrency" => "USD" }] })
+    result = @client.fiat_orders(transaction_type: 0)
+    assert result.success?
+  end
+
+  def test_dust_log
+    stub_connection(:get, { "total" => 1, "userAssetDribblets" => [{ "totalTransferedAmount" => "0.001" }] })
+    result = @client.dust_log
+    assert result.success?
+  end
+
+  def test_asset_dividend
+    stub_connection(:get, { "rows" => [{ "asset" => "BNB", "amount" => "0.1" }], "total" => 1 })
+    result = @client.asset_dividend
+    assert result.success?
+  end
+
+  def test_simple_earn_flexible_rewards
+    stub_connection(:get, { "rows" => [{ "asset" => "USDT", "rewards" => "0.5" }], "total" => 1 })
+    result = @client.simple_earn_flexible_rewards
+    assert result.success?
+  end
+
+  def test_simple_earn_locked_rewards
+    stub_connection(:get, { "rows" => [{ "asset" => "ETH", "rewards" => "0.01" }], "total" => 1 })
+    result = @client.simple_earn_locked_rewards
+    assert result.success?
+  end
+
+  def test_handles_api_error
+    connection = stub
+    connection.stubs(:get).raises(Faraday::ServerError.new("500", { status: 500, body: "Server Error" }))
+    @client.instance_variable_set(:@connection, connection)
+    result = @client.exchange_information
+    assert result.failure?
+  end
+
+  def test_headers_include_api_key
+    headers = @client.send(:headers)
+    assert_equal "test_key", headers[:"X-MBX-APIKEY"]
+  end
+
+  def test_headers_without_auth
+    client = Honeymaker::Clients::Binance.new
+    headers = client.send(:headers)
+    refute headers.key?(:"X-MBX-APIKEY")
+  end
+
+  def test_sign_params
+    sig = @client.send(:sign_params, { symbol: "BTCUSDT", timestamp: 1234567890 })
+    assert sig.is_a?(String)
+    assert_equal 64, sig.length
+  end
+
+  private
+
+  def stub_connection(method, body)
+    response = stub(body: body)
+    connection = stub
+    connection.stubs(method).returns(response)
+    @client.instance_variable_set(:@connection, connection)
+  end
+end

data/test/honeymaker/clients/binance_us_client_test.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::Clients::BinanceUsTest < Minitest::Test
+  def test_inherits_from_binance
+    client = Honeymaker::Clients::BinanceUs.new
+    assert_kind_of Honeymaker::Clients::Binance, client
+  end
+
+  def test_url
+    assert_equal "https://api.binance.us", Honeymaker::Clients::BinanceUs::URL
+  end
+
+  def test_exchange_information
+    client = Honeymaker::Clients::BinanceUs.new(api_key: "k", api_secret: "s")
+    response = stub(body: { "symbols" => [] })
+    connection = stub
+    connection.stubs(:get).returns(response)
+    client.instance_variable_set(:@connection, connection)
+
+    result = client.exchange_information
+    assert result.success?
+  end
+end

data/test/honeymaker/clients/bingx_client_test.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::Clients::BingXTest < Minitest::Test
+  def setup
+    @client = Honeymaker::Clients::BingX.new(api_key: "test_key", api_secret: "test_secret")
+  end
+
+  def test_url
+    assert_equal "https://open-api.bingx.com", Honeymaker::Clients::BingX::URL
+  end
+
+  def test_get_symbols
+    stub_connection(:get, { "data" => { "symbols" => [{ "symbol" => "BTC-USDT" }] } })
+    result = @client.get_symbols
+    assert result.success?
+  end
+
+  def test_get_ticker
+    stub_connection(:get, { "data" => [{ "symbol" => "BTC-USDT" }] })
+    result = @client.get_ticker(symbol: "BTC-USDT")
+    assert result.success?
+  end
+
+  def test_get_balances
+    stub_connection(:get, { "data" => { "balances" => [{ "asset" => "BTC" }] } })
+    result = @client.get_balances
+    assert result.success?
+  end
+
+  def test_place_order
+    stub_connection(:post, { "data" => { "orderId" => "123" } })
+    result = @client.place_order(symbol: "BTC-USDT", side: "BUY", type: "MARKET", quantity: "0.001")
+    assert result.success?
+  end
+
+  def test_get_order
+    stub_connection(:get, { "data" => { "orderId" => "123" } })
+    result = @client.get_order(symbol: "BTC-USDT", order_id: "123")
+    assert result.success?
+  end
+
+  # BingX rejects with HTTP 200 and a non-zero `code`. Without a guard the rejection was read as
+  # a placed order and handed back as order_id "BTC-USDT-" (nil id), so a bot recorded a trade
+  # that does not exist and then polled a malformed id forever.
+  def test_place_order_fails_on_nonzero_code
+    stub_connection(:post, { "code" => 100004, "msg" => "insufficient balance" })
+    result = @client.place_order(symbol: "BTC-USDT", side: "BUY", type: "MARKET", quantity: "0.001")
+    assert result.failure?
+    assert_includes result.errors.first, "insufficient balance"
+  end
+
+  def test_get_order_fails_on_nonzero_code
+    stub_connection(:get, { "code" => 80016, "msg" => "Order does not exist" })
+    result = @client.get_order(symbol: "BTC-USDT", order_id: "123")
+    assert result.failure?
+    assert_includes result.errors.first, "Order does not exist"
+  end
+
+  def test_place_order_succeeds_on_zero_code
+    stub_connection(:post, { "code" => 0, "data" => { "orderId" => "123" } })
+    result = @client.place_order(symbol: "BTC-USDT", side: "BUY", type: "MARKET", quantity: "0.001")
+    assert result.success?
+    assert_equal "BTC-USDT-123", result.data[:order_id]
+  end
+
+  def test_cancel_order
+    stub_connection(:post, { "data" => { "orderId" => "123" } })
+    result = @client.cancel_order(symbol: "BTC-USDT", order_id: "123")
+    assert result.success?
+  end
+
+  def test_withdraw
+    stub_connection(:post, { "data" => { "id" => "w1" } })
+    result = @client.withdraw(coin: "BTC", address: "addr", amount: "0.1")
+    assert result.success?
+  end
+
+  def test_get_trade_fills
+    stub_connection(:get, { "data" => [{ "tradeId" => "t1" }] })
+    result = @client.get_trade_fills(symbol: "BTC-USDT")
+    assert result.success?
+  end
+
+  def test_deposit_history
+    stub_connection(:get, [{ "coin" => "BTC" }])
+    result = @client.deposit_history
+    assert result.success?
+  end
+
+  def test_withdraw_history
+    stub_connection(:get, [{ "coin" => "ETH" }])
+    result = @client.withdraw_history
+    assert result.success?
+  end
+
+  private
+
+  def stub_connection(method, body)
+    response = stub(body: body)
+    connection = stub
+    connection.stubs(method).returns(response)
+    @client.instance_variable_set(:@connection, connection)
+  end
+end

data/test/honeymaker/clients/bitget_client_test.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::Clients::BitgetTest < Minitest::Test
+  def setup
+    @client = Honeymaker::Clients::Bitget.new(
+      api_key: "test_key", api_secret: "test_secret", passphrase: "test_pass"
+    )
+  end
+
+  def test_url
+    assert_equal "https://api.bitget.com", Honeymaker::Clients::Bitget::URL
+  end
+
+  def test_accepts_passphrase
+    assert_equal "test_pass", @client.passphrase
+  end
+
+  def test_get_coins
+    stub_connection(:get, { "data" => [{ "coin" => "BTC" }] })
+    result = @client.get_coins
+    assert result.success?
+  end
+
+  def test_get_symbols
+    stub_connection(:get, { "data" => [{ "symbol" => "BTCUSDT" }] })
+    result = @client.get_symbols
+    assert result.success?
+  end
+
+  def test_get_account_assets
+    stub_connection(:get, { "data" => [{ "coin" => "BTC", "available" => "0.5" }] })
+    result = @client.get_account_assets
+    assert result.success?
+  end
+
+  def test_place_order
+    stub_connection(:post, { "code" => "00000", "data" => { "orderId" => "123" } })
+    result = @client.place_order(symbol: "BTCUSDT", side: "buy", order_type: "market", size: "0.001")
+    assert result.success?
+    assert_equal "BTCUSDT-123", result.data[:order_id]
+  end
+
+  def test_place_order_with_quote_size
+    stub_connection(:post, { "code" => "00000", "data" => { "orderId" => "456" } })
+    result = @client.place_order(symbol: "BTCUSDT", side: "buy", order_type: "market", quote_size: "100")
+    assert result.success?
+    assert_equal "BTCUSDT-456", result.data[:order_id]
+  end
+
+  def test_get_order
+    stub_connection(:get, { "code" => "00000", "data" => [{
+      "orderId" => "123", "orderType" => "market", "side" => "buy", "status" => "filled",
+      "priceAvg" => "50000", "size" => "0.001", "baseVolume" => "0.001", "quoteVolume" => "50"
+    }] })
+    result = @client.get_order(order_id: "123")
+    assert result.success?
+    assert_equal :closed, result.data[:status]
+  end
+
+  def test_cancel_order
+    stub_connection(:post, { "data" => { "orderId" => "123" } })
+    result = @client.cancel_order(symbol: "BTCUSDT", order_id: "123")
+    assert result.success?
+  end
+
+  def test_get_candles
+    stub_connection(:get, { "data" => [] })
+    result = @client.get_candles(symbol: "BTCUSDT", granularity: "1min")
+    assert result.success?
+  end
+
+  def test_withdraw
+    stub_connection(:post, { "data" => { "orderId" => "w1" } })
+    result = @client.withdraw(coin: "BTC", address: "addr", size: "0.1")
+    assert result.success?
+  end
+
+  def test_get_fills
+    stub_connection(:get, { "data" => [{ "tradeId" => "t1" }] })
+    result = @client.get_fills(symbol: "BTCUSDT")
+    assert result.success?
+  end
+
+  def test_deposit_list
+    stub_connection(:get, { "data" => [{ "coin" => "BTC" }] })
+    result = @client.deposit_list
+    assert result.success?
+  end
+
+  def test_withdrawal_list
+    stub_connection(:get, { "data" => [{ "coin" => "ETH" }] })
+    result = @client.withdrawal_list
+    assert result.success?
+  end
+
+  def test_signed_headers_include_passphrase
+    ts = "1234567890"
+    headers = @client.send(:signed_headers, ts, "payload")
+    assert_equal "test_key", headers[:"ACCESS-KEY"]
+    assert_equal "test_pass", headers[:"ACCESS-PASSPHRASE"]
+    assert_equal ts, headers[:"ACCESS-TIMESTAMP"]
+    assert headers.key?(:"ACCESS-SIGN")
+  end
+
+  # Bitget signals business errors in an HTTP-200 envelope. Callers classify on this text
+  # (insufficient funds, bad key, stale timestamp), so the code and msg must survive.
+  def test_place_order_keeps_api_code_and_message
+    stub_connection(:post, { "code" => "43012", "msg" => "Insufficient balance" })
+    result = @client.place_order(symbol: "BTCUSDT", side: "buy", order_type: "market", quote_size: "100")
+    assert result.failure?
+    assert_includes result.errors.first, "Insufficient balance"
+    assert_includes result.errors.first, "43012"
+  end
+
+  def test_get_order_keeps_api_code_and_message
+    stub_connection(:get, { "code" => "40008", "msg" => "Request timestamp expired" })
+    result = @client.get_order(order_id: "BTCUSDT-123")
+    assert result.failure?
+    assert_includes result.errors.first, "Request timestamp expired"
+  end
+
+  def test_get_balances_keeps_api_code_and_message
+    stub_connection(:get, { "code" => "40012", "msg" => "Apikey does not exist" })
+    result = @client.get_balances
+    assert result.failure?
+    assert_includes result.errors.first, "Apikey does not exist"
+  end
+
+  def test_api_error_falls_back_when_body_carries_no_detail
+    stub_connection(:post, { "code" => nil })
+    result = @client.place_order(symbol: "BTCUSDT", side: "buy", order_type: "market", quote_size: "100")
+    assert result.failure?
+    assert_equal "Bitget API error", result.errors.first
+  end
+
+  private
+
+  def stub_connection(method, body)
+    response = stub(body: body)
+    connection = stub
+    connection.stubs(method).returns(response)
+    @client.instance_variable_set(:@connection, connection)
+  end
+end