honeymaker 0.10.0 → 0.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bbfab70631b45882e86a1f4af9ea69b9c32c98840a383183b69ebae133b2f3bf
-  data.tar.gz: 3d65a28ae18b85f5de60959aac90e327471ff617488956538442b6841ddc4bd9
+  metadata.gz: c0d4a030c628dda5a597efb6ff65b552ce961cfb855e7f6affa668a8f0e6f492
+  data.tar.gz: 43372bdcc5a896dcf83e7f8fcd913d091a1b2c79b61e03e2b1e430dc20821ee0
 SHA512:
-  metadata.gz: 00f3d5d33b5c1d231be4f1bafb5815083bc26cafae31a8cfe2c4403be217ece9120f7195bc6f5fa15d14286950c9f8817762767a4824f0c29396a6b679ca483e
-  data.tar.gz: 3209e5756f1aab9c2af0537c533b3b2dbadf468c635c5f882d4f85362679597495d78f9ec77a2f7ca1b10a8c1c534687d19b95be73989ce88fe23fbf5f03120a
+  metadata.gz: aabd7c7f6859af5e36fb7bc301a227603683b9505e78a306b3944b8fba8ed6c5df45c05a9846557b18c59f461bfe3601f7492ede5a02c6125a87a1d9d58e76fe
+  data.tar.gz: ef8db9f4be0d5d60aa65a0d9baa41283b20cf44ddf6f624b4c0617cc5fab6449ac77878b190d0dff2ebca848876461a500b95d6b53f39f9b465fa817567ad923

data/lib/honeymaker/client.rb

@@ -70,8 +70,30 @@ module Honeymaker
       status = e.respond_to?(:response_status) ? e.response_status : nil
       Result::Failure.new(error_message, data: { status: status })
     rescue StandardError => e
+      # NOT an exchange error — a bug here, in a vendor gem, or in the caller, and it arrives in the
+      # same Result::Failure as a genuine venue rejection. Callers classify that text to decide "out
+      # of funds" / "bad key" / "safe to retry", so an unlabelled TypeError gets attributed to the
+      # exchange: a hyperliquid-rb signing crash sat in production order history for three months
+      # reading exactly like a venue rejection. Name the class so the true source is unmistakable,
+      # and flag it so a caller can refuse to classify it as the venue's at all.
+      #
+      # The class is a PREFIX, not a replacement: the network failures that also land here
+      # (Net::ReadTimeout, execution expired, connection refused) are matched by substring for
+      # transient retry, and those matches must keep working.
       msg = e.message
-      Result::Failure.new((msg && !msg.empty?) ? msg : "Unknown error")
+      labelled = (msg && !msg.empty?) ? "#{e.class}: #{msg}" : e.class.to_s
+      Result::Failure.new(labelled, data: { client_error: true })
+    end
+
+    # A business error the exchange returned inside an HTTP-200 envelope (KuCoin's non-"200000"
+    # code, Bitget's non-"00000"). Keep the exchange's own code and message: callers classify on
+    # this text to tell insufficient funds from a bad key from a stale timestamp, so collapsing it
+    # to a bare constant silently disables every one of those checks and leaves the operator with
+    # an unactionable log line. Falls back to the constant only when the body carries no detail.
+    def api_error(exchange, body)
+      detail = body.is_a?(Hash) ? [body["code"], body["msg"] || body["message"]] : []
+      detail = detail.compact.map(&:to_s).reject(&:empty?).join(": ")
+      Result::Failure.new(detail.empty? ? "#{exchange} API error" : "#{exchange} API error #{detail}")
     end
 
     def connection

data/lib/honeymaker/clients/bingx.rb

@@ -57,6 +57,11 @@ module Honeymaker
         return result if result.failure?
 
         raw = result.data
+        # BingX rejects with HTTP 200 and a non-zero `code`. Without this the rejection fell
+        # through as a Success carrying order_id "#{symbol}-" (nil id): the bot recorded a trade
+        # that was never placed, then polled a malformed id forever.
+        return api_error("BingX", raw) unless raw.is_a?(Hash) && raw["code"].to_i.zero?
+
         order_id = raw.dig("data", "orderId") || raw.dig("data", "data", "orderId")
         Result::Success.new({ order_id: "#{symbol}-#{order_id}", raw: raw })
       end
@@ -66,8 +71,9 @@ module Honeymaker
           symbol: symbol, orderId: order_id, clientOrderID: client_order_id
         })
         return result if result.failure?
+        return api_error("BingX", result.data) unless result.data.is_a?(Hash) && result.data["code"].to_i.zero?
 
-        raw = result.data.is_a?(Hash) && result.data.key?("data") ? result.data["data"] : result.data
+        raw = result.data.key?("data") ? result.data["data"] : result.data
         Result::Success.new(normalize_order("#{symbol}-#{raw['orderId']}", raw))
       end
 

data/lib/honeymaker/clients/bitget.rb

@@ -44,7 +44,7 @@ module Honeymaker
         result = get_account_assets
         return result if result.failure?
 
-        return Result::Failure.new("Bitget API error") unless result.data["code"] == "00000"
+        return api_error("Bitget", result.data) unless result.data["code"] == "00000"
 
         balances = {}
         (result.data["data"] || []).each do |asset|
@@ -64,7 +64,7 @@ module Honeymaker
           size: size, quoteSize: quote_size, price: price, force: force, clientOid: client_oid
         })
         return result if result.failure?
-        return Result::Failure.new("Bitget API error") unless result.data["code"] == "00000"
+        return api_error("Bitget", result.data) unless result.data["code"] == "00000"
 
         order_id = result.data.dig("data", "orderId")
         Result::Success.new({ order_id: "#{symbol}-#{order_id}", raw: result.data })
@@ -73,7 +73,7 @@ module Honeymaker
       def get_order(order_id: nil, client_oid: nil)
         result = get_signed("/api/v2/spot/trade/orderInfo", { orderId: order_id, clientOid: client_oid })
         return result if result.failure?
-        return Result::Failure.new("Bitget API error") unless result.data["code"] == "00000"
+        return api_error("Bitget", result.data) unless result.data["code"] == "00000"
 
         order_list = result.data["data"]
         raw = order_list.is_a?(Array) ? order_list.first : order_list

data/lib/honeymaker/clients/kucoin.rb

@@ -39,7 +39,7 @@ module Honeymaker
         result = get_accounts(type: type)
         return result if result.failure?
 
-        return Result::Failure.new("KuCoin API error") unless result.data["code"] == "200000"
+        return api_error("KuCoin", result.data) unless result.data["code"] == "200000"
 
         balances = {}
         (result.data["data"] || []).each do |account|
@@ -61,7 +61,7 @@ module Honeymaker
           timeInForce: time_in_force, stp: stp
         })
         return result if result.failure?
-        return Result::Failure.new("KuCoin API error") unless result.data["code"] == "200000"
+        return api_error("KuCoin", result.data) unless result.data["code"] == "200000"
 
         order_id = result.data.dig("data", "orderId")
         Result::Success.new({ order_id: order_id, raw: result.data })
@@ -70,7 +70,7 @@ module Honeymaker
       def get_order(order_id:)
         result = get_signed("/api/v1/orders/#{order_id}")
         return result if result.failure?
-        return Result::Failure.new("KuCoin API error") unless result.data["code"] == "200000"
+        return api_error("KuCoin", result.data) unless result.data["code"] == "200000"
 
         raw = result.data["data"]
         return Result::Failure.new("Order not found") unless raw

data/lib/honeymaker/version.rb

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

data/test/honeymaker/client_test.rb

@@ -41,7 +41,44 @@ class Honeymaker::ClientTest < Minitest::Test
     client = Honeymaker::Client.new
     result = client.send(:with_rescue) { raise StandardError, "boom" }
     assert result.failure?
-    assert_equal ["boom"], result.errors
+    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

data/test/honeymaker/clients/bingx_client_test.rb

@@ -41,6 +41,30 @@ class Honeymaker::Clients::BingXTest < Minitest::Test
     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")

data/test/honeymaker/clients/bitget_client_test.rb

@@ -104,6 +104,37 @@ class Honeymaker::Clients::BitgetTest < Minitest::Test
     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)

data/test/honeymaker/clients/kucoin_client_test.rb

@@ -107,6 +107,37 @@ class Honeymaker::Clients::KucoinTest < Minitest::Test
     assert_equal expected, headers[:"KC-API-PASSPHRASE"]
   end
 
+  # KuCoin 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" => "200004", "msg" => "Balance insufficient!" })
+    result = @client.place_order(client_oid: "c1", side: "buy", symbol: "BTC-USDT", type: "market", funds: "100")
+    assert result.failure?
+    assert_includes result.errors.first, "Balance insufficient!"
+    assert_includes result.errors.first, "200004"
+  end
+
+  def test_get_order_keeps_api_code_and_message
+    stub_connection(:get, { "code" => "400002", "msg" => "Invalid KC-API-TIMESTAMP." })
+    result = @client.get_order(order_id: "123")
+    assert result.failure?
+    assert_includes result.errors.first, "Invalid KC-API-TIMESTAMP."
+  end
+
+  def test_get_balances_keeps_api_code_and_message
+    stub_connection(:get, { "code" => "400003", "msg" => "KC-API-KEY not exists" })
+    result = @client.get_balances
+    assert result.failure?
+    assert_includes result.errors.first, "KC-API-KEY not exists"
+  end
+
+  def test_api_error_falls_back_when_body_carries_no_detail
+    stub_connection(:post, { "code" => nil })
+    result = @client.place_order(client_oid: "c1", side: "buy", symbol: "BTC-USDT", type: "market", funds: "100")
+    assert result.failure?
+    assert_equal "KuCoin API error", result.errors.first
+  end
+
   private
 
   def stub_connection(method, body)

metadata

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