honeymaker 0.11.3 → 0.11.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a33b3f43a40a17e8f8655683b4349901db4222a6ec5db4d4a8f82585f0dacdd1
-  data.tar.gz: dde27e04419cb12327dfee7c3ecf69c61f36ddf28c1e9b7e2872c785a726106b
+  metadata.gz: d279d1416ac845778e5bf48218fbacf23498cae10bc1ed589cae28752aa4af8c
+  data.tar.gz: 2aebe8b36d740f1c09bb9ecf21ab205b911f6ce11fc41b0a7bc80898602d016f
 SHA512:
-  metadata.gz: f6b7a44553dbc9a413c6df817f4ffbff0f263c077f163e10bce5389d7aba60c108d956c68f9f713ac2b7fef69c699540e3759a1fb5470162146d746ace18a624
-  data.tar.gz: e53261fd199b590b1d23318d5b2689a59a5b6dc2a402e09b6fb3d63010b1bbb79281e4b3cafd8401964315e51f8a7fbe39e45aa250217e0ed9851c35bc7c494d
+  metadata.gz: ae37fa13ff7ce2db5366a408a4d006f671fcbda1c8931c8bca9c8df8a3c13c1256101a73b364bbffc58971923090d5dd8b0e44b49fdc35f73a0ecee8979f67b6
+  data.tar.gz: 0a00d2949aeba2b30b681a8021b59083de3498d201446e70ba88e1c2ccfa135f6137036620559f1e79cc2f216328639a3bf61d47f1082fa73040aa60389967c0

data/lib/honeymaker/clients/hyperliquid.rb

@@ -130,13 +130,13 @@ module Honeymaker
       # --- Trading (requires hyperliquid-rb gem) ---
 
       def order(coin:, is_buy:, size:, limit_px:, order_type: { limit: { tif: "Gtc" } })
-        with_rescue do
+        with_status_rescue do
           exchange_client.order(coin, is_buy: is_buy, sz: size, limit_px: limit_px, order_type: order_type)
         end
       end
 
       def cancel(coin:, oid:)
-        with_rescue do
+        with_status_rescue do
           exchange_client.cancel(coin, oid)
         end
       end
@@ -157,6 +157,28 @@ module Honeymaker
 
       private
 
+      # 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
+      # answer" — and a caller reading an order placement has to treat that as a request whose fate
+      # is unknown: nothing recorded as rejected, no retry, a line for a human to reconcile against
+      # the venue. But the status is right there on the exception, and it is exactly what tells a
+      # refusal (4xx — the gateway answered, nothing reached the matching engine) from a request the
+      # venue may still have taken (5xx). Hand it back in the same shape every other HTTP failure
+      # has, so one classifier covers both paths.
+      #
+      # Duck-typed on purpose: hyperliquid-rb is an optional dependency loaded only when trading is
+      # used, so its error classes cannot be named here. Anything without a status is classified
+      # exactly as it is everywhere else.
+      def with_status_rescue
+        Result::Success.new(yield)
+      rescue StandardError => e
+        status = e.respond_to?(:status) ? e.status.to_i : 0
+        return with_rescue { raise e } unless status.positive?
+
+        Result::Failure.new(e.message.to_s.empty? ? e.class.to_s : e.message, data: { status: status })
+      end
+
       # Suffix-aware so the whole Hyperliquid cancel family (marginCanceled, scheduledCancel,
       # reduceOnlyCanceled, siblingFilledCanceled, …) maps correctly. A triggered order has fired
       # and become a live resting order → :open. An unmapped status is logged, never swallowed.

data/lib/honeymaker/clients/kraken.rb

@@ -65,9 +65,13 @@ module Honeymaker
         post_private("/0/private/CancelOrder", { nonce: nonce, txid: txid, cl_ord_id: cl_ord_id })
       end
 
-      def get_tradable_asset_pairs(pairs: nil, info: nil, country_code: nil)
+      # aclass_base: "all" also returns tokenized equities (xStocks); omitted, Kraken serves only the
+      # "currency" class. Note the asset-class parameter is spelled differently per endpoint —
+      # aclass_base here, asset_class on Ticker/OHLC/Depth/AddOrder.
+      def get_tradable_asset_pairs(pairs: nil, info: nil, country_code: nil, aclass_base: nil)
         get_public("/0/public/AssetPairs", {
-          pair: pairs ? pairs.join(",") : nil, info: info, country_code: country_code
+          pair: pairs ? pairs.join(",") : nil, info: info, country_code: country_code,
+          aclass_base: aclass_base
         })
       end
 

data/lib/honeymaker/exchanges/kraken.rb

@@ -48,15 +48,25 @@ module Honeymaker
 
       def get_tickers_info
         with_rescue do
-          response = connection.get("/0/public/AssetPairs")
+          # aclass_base=all, not a bare call: the default response carries only the "currency" class,
+          # so Kraken tokenized equities (xStocks) are invisible without it. One request returns both
+          # classes and they are disjoint.
+          response = connection.get("/0/public/AssetPairs", { aclass_base: "all" })
 
           error = response.body["error"]
           return Result::Failure.new(*error) if error.is_a?(Array) && error.any?
 
-          response.body["result"].filter_map do |_, info|
+          # Every tokenized pair is returned TWICE - once under an SPV key (NVDASPVUSD), once under
+          # the x key (NVDAxUSD) - sharing one wsname and altname. Currency pairs are never
+          # duplicated, so keying by wsname collapses exactly the aliases and nothing else.
+          deduped = response.body["result"].each_with_object({}) do |(_, info), acc|
             wsname = info["wsname"]
-            next unless wsname && !wsname.empty?
+            next if wsname.nil? || wsname.empty?
 
+            acc[wsname] ||= info
+          end
+
+          deduped.filter_map do |wsname, info|
             base, quote = wsname.split("/")
 
             {
@@ -71,7 +81,15 @@ module Honeymaker
               quote_decimals: info["cost_decimals"],
               price_decimals: info["pair_decimals"],
               available: true,
-              trading_enabled: info.key?("status") ? info["status"] == "online" : true
+              # Tokenized equities are listed but never tradable through this client: AddOrder needs
+              # an asset_class parameter it does not send, and Kraken closes the tokenized order
+              # books to EEA clients over the API regardless of that. Listing them anyway is what
+              # lets a holding be resolved and valued.
+              trading_enabled: if info["aclass_base"] == "tokenized_asset"
+                                 false
+                               else
+                                 info.key?("status") ? info["status"] == "online" : true
+                               end
             }
           end
         end

data/lib/honeymaker/version.rb

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

data/test/fixtures/kraken_asset_pairs.json

@@ -10,7 +10,34 @@
       "cost_decimals": 5,
       "pair_decimals": 1,
       "ordermin": "0.00010000",
-      "costmin": "0.50000"
+      "costmin": "0.50000",
+      "aclass_base": "currency"
+    },
+    "NVDAxUSD": {
+      "altname": "NVDAxUSD",
+      "wsname": "NVDAx/USD",
+      "aclass_base": "tokenized_asset",
+      "base": "NVDAx",
+      "quote": "ZUSD",
+      "lot_decimals": 8,
+      "cost_decimals": 5,
+      "pair_decimals": 2,
+      "ordermin": "0.00000001",
+      "costmin": "0.5",
+      "status": "online"
+    },
+    "NVDASPVUSD": {
+      "altname": "NVDAxUSD",
+      "wsname": "NVDAx/USD",
+      "aclass_base": "tokenized_asset",
+      "base": "NVDAx",
+      "quote": "ZUSD",
+      "lot_decimals": 8,
+      "cost_decimals": 5,
+      "pair_decimals": 2,
+      "ordermin": "0.00000001",
+      "costmin": "0.5",
+      "status": "online"
     }
   }
 }

data/test/honeymaker/clients/hyperliquid_client_test.rb

@@ -190,6 +190,76 @@ class Honeymaker::Clients::HyperliquidTest < Minitest::Test
     assert result.success?
   end
 
+  # == Raised trading errors keep their HTTP status ==
+  #
+  # Order placement goes through hyperliquid-rb, which raises instead of answering. Whether the
+  # venue REFUSED the request or may have TAKEN it is the whole question for a caller deciding
+  # between "record a rejected order" and "a human has to go and look" — and the status is the only
+  # thing that answers it. It must survive the trip.
+
+  # hyperliquid-rb's ClientError/ServerError shape. Rebuilt here because the gem is an optional
+  # dependency this one does not carry.
+  class RaisedWithStatus < StandardError
+    attr_reader :status
+
+    def initialize(message, status:)
+      @status = status
+      super(message)
+    end
+  end
+
+  def test_order_reports_a_refusal_with_its_status
+    @client.stubs(:exchange_client).raises(RaisedWithStatus.new("HTTP 429: rate limited", status: 429))
+
+    result = @client.order(coin: "@142", is_buy: true, size: 1, limit_px: 100)
+
+    assert result.failure?
+    assert_equal 429, result.data[:status]
+    assert_nil result.data[:client_error], "the venue answered — this is not an unknown outcome"
+    assert_equal ["HTTP 429: rate limited"], result.errors
+  end
+
+  # 5xx stays 5xx: a gateway that may have passed the order on is exactly the case a caller must
+  # keep treating as unresolved.
+  def test_order_reports_a_gateway_failure_with_its_status
+    @client.stubs(:exchange_client).raises(RaisedWithStatus.new("HTTP 502: bad gateway", status: 502))
+
+    result = @client.order(coin: "@142", is_buy: true, size: 1, limit_px: 100)
+
+    assert result.failure?
+    assert_equal 502, result.data[:status]
+  end
+
+  def test_cancel_reports_a_refusal_with_its_status
+    @client.stubs(:exchange_client).raises(RaisedWithStatus.new("HTTP 422: unknown oid", status: 422))
+
+    result = @client.cancel(coin: "@142", oid: 1)
+
+    assert result.failure?
+    assert_equal 422, result.data[:status]
+  end
+
+  # Everything the venue did not answer is untouched: a signing crash inside the gem, a network
+  # failure, a bug here. Those stay flagged as ours and unclassifiable.
+  def test_order_leaves_a_statusless_error_classified_as_before
+    @client.stubs(:exchange_client).raises(TypeError, "String can't be coerced into Float")
+
+    result = @client.order(coin: "@142", is_buy: true, size: 1, limit_px: 100)
+
+    assert result.failure?
+    assert result.data[:client_error], "no status means no answer from the venue"
+    assert_equal ["TypeError: String can't be coerced into Float"], result.errors
+  end
+
+  def test_order_wraps_an_accepted_placement
+    @client.stubs(:exchange_client).returns(stub(order: { "status" => "ok" }))
+
+    result = @client.order(coin: "@142", is_buy: true, size: 1, limit_px: 100)
+
+    assert result.success?
+    assert_equal({ "status" => "ok" }, result.data)
+  end
+
   private
 
   def stub_connection(method, body)

data/test/honeymaker/clients/kraken_client_test.rb

@@ -22,6 +22,36 @@ class Honeymaker::Clients::KrakenTest < Minitest::Test
     assert result.data["result"].key?("XBTUSDT")
   end
 
+  # Without aclass_base Kraken serves only the "currency" class, so tokenized equities are invisible.
+  def test_get_tradable_asset_pairs_forwards_aclass_base
+    captured = nil
+    req = stub("req")
+    req.stubs(:url)
+    req.stubs(:headers=)
+    req.stubs(:params=).with { |p| captured = p; true }
+    connection = stub
+    connection.stubs(:get).yields(req).returns(stub(body: { "error" => [], "result" => {} }))
+    @client.instance_variable_set(:@connection, connection)
+
+    assert @client.get_tradable_asset_pairs(aclass_base: "all").success?
+    assert_equal "all", captured[:aclass_base]
+  end
+
+  def test_get_tradable_asset_pairs_omits_aclass_base_when_not_asked
+    captured = nil
+    req = stub("req")
+    req.stubs(:url)
+    req.stubs(:headers=)
+    req.stubs(:params=).with { |p| captured = p; true }
+    connection = stub
+    connection.stubs(:get).yields(req).returns(stub(body: { "error" => [], "result" => {} }))
+    @client.instance_variable_set(:@connection, connection)
+
+    @client.get_tradable_asset_pairs
+
+    refute captured.key?(:aclass_base), "params are compacted, so nil must not be sent"
+  end
+
   def test_get_ticker_information
     stub_connection(:get, { "error" => [], "result" => { "XBTUSDT" => { "a" => ["50000"] } } })
     result = @client.get_ticker_information(pair: "XBTUSDT")

data/test/honeymaker/exchanges/kraken_test.rb

@@ -9,6 +9,45 @@ class Honeymaker::Exchanges::KrakenTest < Minitest::Test
     @exchange = Honeymaker::Exchanges::Kraken.new
   end
 
+  # Tokenized equities (xStocks) live behind aclass_base and are invisible to a bare AssetPairs call.
+  # aclass_base=all returns currency + tokenized in one request; the two sets are disjoint.
+  def test_get_tickers_info_requests_every_asset_class
+    response = stub(body: load_fixture("kraken_asset_pairs.json"))
+    connection = stub
+    connection.expects(:get).with("/0/public/AssetPairs", { aclass_base: "all" }).returns(response)
+    @exchange.instance_variable_set(:@connection, connection)
+
+    assert @exchange.get_tickers_info.success?
+  end
+
+  # Kraken returns every tokenized pair TWICE - once under an SPV key, once under the x key - with
+  # one shared wsname and altname. Only tokenized pairs are double-keyed; currency pairs never are.
+  # Mapping the raw response would ingest each of them twice.
+  def test_get_tickers_info_deduplicates_the_spv_alias
+    body = load_fixture("kraken_asset_pairs.json")
+    stub_request(body)
+
+    result = @exchange.get_tickers_info
+
+    nvda = result.data.select { |t| t[:base] == "NVDAx" }
+    assert_equal 1, nvda.size, "NVDAxUSD and NVDASPVUSD are one pair"
+    assert_equal "NVDAxUSD", nvda.first[:ticker]
+  end
+
+  # Listed, so a holding can be resolved and valued; not tradable, because AddOrder needs an
+  # asset_class parameter this client does not send, and Kraken closes the tokenized order books to
+  # EEA clients over the API regardless.
+  def test_tokenized_pairs_are_listed_but_not_trading_enabled
+    body = load_fixture("kraken_asset_pairs.json")
+    stub_request(body)
+
+    nvda = @exchange.get_tickers_info.data.find { |t| t[:base] == "NVDAx" }
+
+    assert_equal "online", body["result"]["NVDAxUSD"]["status"]
+    assert nvda[:available], "listed, so balances resolve"
+    refute nvda[:trading_enabled], "we cannot place these orders"
+  end
+
   def test_get_tickers_info_parses_response
     body = load_fixture("kraken_asset_pairs.json")
     stub_request(body)
@@ -68,7 +107,9 @@ class Honeymaker::Exchanges::KrakenTest < Minitest::Test
     result = @exchange.get_tickers_info
 
     assert result.success?
-    assert_empty result.data
+    # Asserts the wsname-less pair is dropped, not that the whole response is - the fixture now
+    # carries a tokenized pair too.
+    refute result.data.any? { |t| t[:ticker] == "XBTUSDT" }
   end
 
   def test_get_tickers_info_uses_real_costmin

metadata

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