honeymaker 0.9.10 → 0.9.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc5bacd0fa2240b323691f78b301b4aadf6d4e13229a05ab1edb621e20aaa89d
-  data.tar.gz: b1a21915e693afd3cadb1e40aa317991db4ea667f08f82974d9607d60770be2e
+  metadata.gz: 50e3e2d9451d404977937fddc4d265c25da9ca8ed848ba6d6c008f24e8e129c9
+  data.tar.gz: a949bcc4a042ce6076986ae76c19fdb4a4bea583f0934fd6e1a5548e492d8898
 SHA512:
-  metadata.gz: d25a9d2f3a4626d684c10b0eda8eecd3c57ca037506869bce682e8c0f2516c61b1122b1536c899f729c7a2642ea3a3ba9427ef816cab8e8f7b1fede7818cf979
-  data.tar.gz: 5e4f0f34aef020640c8d9deea8fb8b1bb596cbc0b37c477005313590d10a55b5c51f2d144e21dfad0ba182929e7a2df470026fb0a7da39e4b6e44f3a5221b699
+  metadata.gz: 9489aa1616d24f9d17b37c603b468426b0354d87aa27a16970165919859565a35195aef1a665348e6e1d24e3ca636eb23901d34c002a2a85f932a99d6a7335b1
+  data.tar.gz: 70f1ebd03b468460c76c28bd5fcc69b975d64562790cef14075e13236e647d2132294a13e2bf3267b822526c6ae7d9905e7c5d18bfe28a0ea4e5548a169e4daa

data/lib/honeymaker/clients/hyperliquid.rb

@@ -57,31 +57,55 @@ module Honeymaker
         Result::Success.new(balances)
       end
 
+      # Hyperliquid's orderStatus body is NESTED:
+      #   { "status" => "order"|"unknownOid",
+      #     "order"  => { "order" => { coin, side, limitPx, sz(remaining), origSz, oid, timestamp, ... },
+      #                   "status" => <real order status>, "statusTimestamp" => ... } }
+      # The real status/sizes live under order["order"]/order["status"] — NOT the top level — and the
+      # body carries NO fills. So the ordered amount is origSz, executed is origSz - remaining sz, and the
+      # exact cost comes from a bounded userFillsByTime (only fetched when something actually executed,
+      # since userFillsByTime is API weight 20 vs orderStatus's weight 2).
       def order_status(user:, oid:)
         result = post_info({ type: "orderStatus", user: user, oid: oid })
         return result if result.failure?
 
         raw = result.data
-        order = raw["order"] || {}
-        fills = raw["fills"] || []
-        status_str = raw["status"]
+        # A distinct not-found signal — aged-out orders are normal; the caller recovers fills / abandons.
+        return Result::Failure.new("unknownOid", data: { not_found: true }) if raw["status"] == "unknownOid"
+
+        wrapper = raw["order"] || {}
+        order = wrapper["order"] || {}
+        status_str = wrapper["status"]
 
         coin = order["coin"]
         side = order["side"] == "B" ? :buy : :sell
         limit_price = BigDecimal((order["limitPx"] || "0").to_s)
-        ordered_size = BigDecimal((order["sz"] || "0").to_s)
-
-        amount_exec = fills.sum { |f| BigDecimal(f["sz"].to_s) }
-        quote_amount_exec = fills.sum { |f| BigDecimal(f["px"].to_s) * BigDecimal(f["sz"].to_s) }
-        avg_price = amount_exec.positive? ? (quote_amount_exec / amount_exec) : limit_price
-        avg_price = nil if avg_price.zero?
-
-        status = parse_order_status(status_str)
+        ordered_size = BigDecimal((order["origSz"] || "0").to_s)
+        remaining_size = BigDecimal((order["sz"] || "0").to_s)
+        amount_exec = [ordered_size - remaining_size, BigDecimal("0")].max
+
+        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
+          # 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_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.
+          quote_amount_exec = matched_quote.positive? ? matched_quote : (limit_price * amount_exec)
+          price = quote_amount_exec / amount_exec
+        end
+        price = nil if price.nil? || price.zero?
 
         Result::Success.new({
-          order_id: "#{coin}-#{oid}",
-          status: status, side: side, order_type: :limit,
-          price: avg_price, amount: ordered_size, quote_amount: nil,
+          order_id: "#{coin}-#{oid}", coin: coin,
+          status: parse_order_status(status_str), side: side, order_type: :limit,
+          price: price, amount: ordered_size, quote_amount: nil,
           amount_exec: amount_exec, quote_amount_exec: quote_amount_exec, raw: raw
         })
       end
@@ -133,13 +157,21 @@ module Honeymaker
 
       private
 
+      # 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.
       def parse_order_status(status)
         case status
-        when "open", "marginCanceled" then :open
         when "filled" then :closed
-        when "canceled", "triggered", "rejected" then :cancelled
-        when "unknownOid" then :unknown
-        else :unknown
+        when "open", "triggered" then :open
+        else
+          str = status.to_s
+          if str.match?(/cancel/i) || str.match?(/reject/i)
+            :cancelled
+          else
+            @logger&.warn("[honeymaker] Unmapped Hyperliquid order status: #{status.inspect}")
+            :unknown
+          end
         end
       end
 

data/lib/honeymaker/version.rb

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

data/test/honeymaker/clients/hyperliquid_client_test.rb

@@ -30,10 +30,146 @@ class Honeymaker::Clients::HyperliquidTest < Minitest::Test
     assert result.success?
   end
 
-  def test_order_status
-    stub_connection(:post, { "status" => "filled" })
-    result = @client.order_status(user: "0xabc", oid: 123)
+  # Hyperliquid's orderStatus body is NESTED: { "status" => "order", "order" => { "order" => {...},
+  # "status" => <real status>, ... } }. The real order status, coin, sizes live under order["order"]
+  # and order["status"] — NOT the top level. orderStatus carries NO "fills" key, so executed cost is
+  # sourced from a bounded userFillsByTime call (only when something actually executed).
+
+  def test_order_status_filled_parses_nested_shape_and_sources_cost_from_fills
+    # Filled: remaining sz == 0, origSz is the ordered amount, real status under the wrapper.
+    # statusTimestamp deliberately DIFFERS from the order timestamp so a parser that bounds
+    # userFillsByTime on the wrong field fails the .with below.
+    order_body = order_status_body(status: "filled", sz: "0.0", orig_sz: "0.00020",
+                                   timestamp: 1781698875556, status_timestamp: 1781699999999)
+    stub_connection(:post, order_body)
+    # Cost comes from a BOUNDED userFillsByTime (type + start == the ORDER timestamp), summing
+    # ONLY this oid's fills (the unrelated-oid fill must be excluded); two fills → VWAP price.
+    @client.expects(:user_fills_by_time)
+           .with(user: "0xabc", start_time: 1781698875556)
+           .returns(Honeymaker::Result::Success.new([
+                                                       fill(oid: 123456789, px: "64000.0", sz: "0.00010"),
+                                                       fill(oid: 123456789, px: "66000.0", sz: "0.00010"),
+                                                       fill(oid: 999999999, px: "1.0", sz: "5.0") # other order
+                                                     ]))
+
+    result = @client.order_status(user: "0xabc", oid: 123456789)
+
+    assert result.success?
+    data = result.data
+    assert_equal :closed, data[:status]
+    assert_equal "@142", data[:coin]
+    assert_equal :buy, data[:side]
+    assert_equal BigDecimal("0.00020"), data[:amount]          # origSz, NOT remaining sz
+    assert_equal BigDecimal("0.00020"), data[:amount_exec]     # origSz - sz, NOT the 5.0 unrelated fill
+    assert_equal BigDecimal("13.0"), data[:quote_amount_exec]  # 6.4 + 6.6, unrelated fill excluded
+    assert_equal BigDecimal("65000"), data[:price]             # 13.0 / 0.0002 volume-weighted
+  end
+
+  def test_order_status_filled_falls_back_to_limit_cost_when_no_matching_fill
+    # userFills can age out / return nothing for THIS oid — a filled order must NEVER report
+    # 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
+
+    result = @client.order_status(user: "0xabc", oid: 123456789)
+
+    assert_equal :closed, result.data[:status]
+    assert_equal BigDecimal("64689.0") * BigDecimal("0.00018"), result.data[:quote_amount_exec]
+    assert_equal BigDecimal("64689.0"), result.data[:price]
+  end
+
+  def test_order_status_propagates_user_fills_failure_for_executed_order
+    # A transient userFills failure must NOT degrade to an estimated cost — propagate it so the
+    # consumer retries and the exact quote_amount_exec is eventually recorded.
+    order_body = order_status_body(status: "filled", sz: "0.0", orig_sz: "0.00018")
+    stub_connection(:post, order_body)
+    @client.expects(:user_fills_by_time).returns(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_order_status_open_does_not_call_user_fills
+    # Resting order: sz == origSz, nothing executed → no weight-20 userFills call.
+    order_body = order_status_body(status: "open", sz: "0.00018", orig_sz: "0.00018")
+    connection = stub
+    connection.expects(:post).once.returns(stub(body: order_body)) # exactly one call — orderStatus only
+    @client.instance_variable_set(:@connection, connection)
+    @client.expects(:user_fills_by_time).never                     # gated on amount_exec > 0
+
+    result = @client.order_status(user: "0xabc", oid: 123456789)
+
+    assert result.success?
+    assert_equal :open, result.data[:status]
+    assert_equal BigDecimal("0"), result.data[:amount_exec]
+    assert_equal BigDecimal("64689.0"), result.data[:price]    # falls back to the limit price
+  end
+
+  def test_order_status_partial_fill_is_open_with_executed_cost
+    order_body = order_status_body(status: "open", sz: "0.00010", orig_sz: "0.00018",
+                                   timestamp: 1781698875556, status_timestamp: 1781699999999)
+    stub_connection(:post, order_body)
+    @client.expects(:user_fills_by_time)
+           .with(user: "0xabc", start_time: 1781698875556)
+           .returns(Honeymaker::Result::Success.new([fill(oid: 123456789, px: "64500.0", sz: "0.00008")]))
+
+    result = @client.order_status(user: "0xabc", oid: 123456789)
+
     assert result.success?
+    assert_equal :open, result.data[:status]
+    assert_equal BigDecimal("0.00008"), result.data[:amount_exec] # origSz - sz
+    assert_equal BigDecimal("64500.0") * BigDecimal("0.00008"), result.data[:quote_amount_exec]
+  end
+
+  def test_order_status_margin_canceled_maps_to_cancelled
+    stub_connection(:post, order_status_body(status: "marginCanceled", sz: "0.00018", orig_sz: "0.00018"))
+    result = @client.order_status(user: "0xabc", oid: 1)
+    assert_equal :cancelled, result.data[:status]
+  end
+
+  def test_order_status_scheduled_cancel_maps_to_cancelled
+    stub_connection(:post, order_status_body(status: "scheduledCancel", sz: "0.00018", orig_sz: "0.00018"))
+    result = @client.order_status(user: "0xabc", oid: 1)
+    assert_equal :cancelled, result.data[:status]
+  end
+
+  def test_order_status_reduce_only_canceled_maps_to_cancelled
+    # Suffix-aware /cancel/i covers the whole cancel family, not just the literals above.
+    stub_connection(:post, order_status_body(status: "reduceOnlyCanceled", sz: "0.00018", orig_sz: "0.00018"))
+    result = @client.order_status(user: "0xabc", oid: 1)
+    assert_equal :cancelled, result.data[:status]
+  end
+
+  def test_order_status_rejected_maps_to_cancelled
+    stub_connection(:post, order_status_body(status: "rejected", sz: "0.00018", orig_sz: "0.00018"))
+    result = @client.order_status(user: "0xabc", oid: 1)
+    assert_equal :cancelled, result.data[:status]
+  end
+
+  def test_order_status_unmapped_status_falls_back_to_unknown
+    # A genuinely new Hyperliquid status must surface as :unknown (and be logged), never crash.
+    stub_connection(:post, order_status_body(status: "someBrandNewStatus", sz: "0.00018", orig_sz: "0.00018"))
+    result = @client.order_status(user: "0xabc", oid: 1)
+    assert_equal :unknown, result.data[:status]
+  end
+
+  def test_order_status_triggered_maps_to_open
+    # A triggered order has fired and become a live resting order → still open.
+    stub_connection(:post, order_status_body(status: "triggered", sz: "0.00018", orig_sz: "0.00018"))
+    result = @client.order_status(user: "0xabc", oid: 1)
+    assert_equal :open, result.data[:status]
+  end
+
+  def test_order_status_unknown_oid_returns_not_found_signal
+    stub_connection(:post, { "status" => "unknownOid" })
+    result = @client.order_status(user: "0xabc", oid: 1)
+
+    assert result.failure?
+    assert_equal({ not_found: true }, result.data)
   end
 
   def test_open_orders
@@ -62,4 +198,25 @@ class Honeymaker::Clients::HyperliquidTest < Minitest::Test
     connection.stubs(method).returns(response)
     @client.instance_variable_set(:@connection, connection)
   end
+
+  def order_status_body(status:, sz:, orig_sz:, coin: "@142", side: "B", limit_px: "64689.0",
+                        oid: 123456789, timestamp: 1781698875556, status_timestamp: 1781699999999)
+    {
+      "status" => "order",
+      "order" => {
+        "order" => {
+          "coin" => coin, "side" => side, "limitPx" => limit_px,
+          "sz" => sz, "origSz" => orig_sz, "oid" => oid, "timestamp" => timestamp,
+          "orderType" => "Limit", "tif" => "Gtc"
+        },
+        "status" => status,
+        "statusTimestamp" => status_timestamp
+      }
+    }
+  end
+
+  def fill(oid:, px:, sz:, coin: "@142", side: "B")
+    { "coin" => coin, "oid" => oid, "px" => px, "sz" => sz, "side" => side,
+      "time" => 1781698875556, "fee" => "0.011", "tid" => 99 }
+  end
 end

metadata

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