honeymaker 0.11.4 → 0.11.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2367ab9c6994586eb565f383f4b897d7a7bdcfb5cf68c0593da80f6b4d4b0497
-  data.tar.gz: 585589c4bc524266bed905b142913b6072e5ff8824602cdf5691e6ac2046bf39
+  metadata.gz: 79df37d9e336e6aae8b38cbe4af40655742da763a47842b3b0128355130c2c48
+  data.tar.gz: 8a821ce866ad46433104a085375f5ac3073ac159c44e0b31f4f57170414a99fc
 SHA512:
-  metadata.gz: b4d5824b776181fff4494c1f4fe76e8ff46e21faf198cb23a894ea836fcfb4bc4f3eb8c0eec2315cc072a065ce9de5b4fd9e34d50f52390368069c5fbd091b13
-  data.tar.gz: f63b8235706bc5257bc1710939fc68f315316650966476a55ff4a25c1de35bb3035f42f54a94105fd1e446bcb4c6e684b65b2418bb16db68f7310c5bdb17dd16
+  metadata.gz: ea5bbaf9abffab526e1929b0c6e9d3ebc80af1e609fdb696a5c141585d57e643d99370acb1dcf458f6fe7c02df22c269b240e316ca68dfbd8295ef1b882ae4a4
+  data.tar.gz: 8dca53d930a98f7259f3c73d6e3827e40647fbf6ceaefd857c2795e1c499c630f335912c23a030a2a72aa326d578b1529d55bb825e2e54c08db56e794339da1f

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/exchanges/gemini.rb

@@ -5,13 +5,24 @@ module Honeymaker
     class Gemini < Exchange
       BASE_URL = "https://api.gemini.com"
 
+      # Gemini has no bulk symbol-details endpoint, so the catalogue is one request per symbol --
+      # ~350 of them against a public limit of 120/min. Unpaced they ran at ~208/min, and a single
+      # dropped connection failed the whole catalogue: the adapter retries nothing on its own.
+      REQUEST_INTERVAL = 0.5
+      REQUEST_ATTEMPTS = 3
+      TRANSIENT_ERRORS = [
+        Faraday::ConnectionFailed, Faraday::TimeoutError, Faraday::RequestTimeoutError,
+        Faraday::TooManyRequestsError, Faraday::ServerError
+      ].freeze
+
       def get_tickers_info
         with_rescue do
-          symbols_response = connection.get("/v1/symbols")
-          symbols = symbols_response.body
+          symbols = catalogue_get("/v1/symbols")
 
           symbols.filter_map do |symbol|
-            detail = connection.get("/v1/symbols/details/#{symbol}").body
+            # A symbol that still fails raises, failing the WHOLE catalogue. Never skip it: callers
+            # read a pair missing from the catalogue as delisted, and data-api revokes it.
+            detail = catalogue_get("/v1/symbols/details/#{symbol}")
 
             tick_size = detail["tick_size"]&.to_s || "0.01"
             quote_increment = detail["quote_increment"]&.to_s || "0.01"
@@ -50,6 +61,20 @@ module Honeymaker
       def connection
         @connection ||= build_connection(BASE_URL)
       end
+
+      def catalogue_get(path)
+        attempt = 1
+        begin
+          sleep(REQUEST_INTERVAL)
+          connection.get(path).body
+        rescue *TRANSIENT_ERRORS
+          raise if attempt >= REQUEST_ATTEMPTS
+
+          sleep(2**attempt)
+          attempt += 1
+          retry
+        end
+      end
     end
   end
 end

data/lib/honeymaker/version.rb

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

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/exchanges/gemini_test.rb

@@ -7,6 +7,9 @@ class Honeymaker::Exchanges::GeminiTest < Minitest::Test
 
   def setup
     @exchange = Honeymaker::Exchanges::Gemini.new
+    # Recorded, not slept: the pacing and the backoff are asserted as a sequence.
+    sleeps = @sleeps = []
+    @exchange.define_singleton_method(:sleep) { |seconds| sleeps << seconds }
   end
 
   def test_get_tickers_info_parses_response
@@ -38,6 +41,73 @@ class Honeymaker::Exchanges::GeminiTest < Minitest::Test
     assert ticker[:trading_enabled]
   end
 
+  def test_get_tickers_info_paces_every_request
+    stub_catalogue(%w[btcusd ethusd])
+
+    assert @exchange.get_tickers_info.success?
+    assert_equal [0.5, 0.5, 0.5], @sleeps
+  end
+
+  def test_get_tickers_info_retries_a_dropped_detail_request
+    connection = stub_catalogue(%w[btcusd ethusd])
+    connection.stubs(:get).with("/v1/symbols/details/ethusd")
+              .raises(Faraday::ConnectionFailed, "end of file reached")
+              .then.returns(detail_response)
+
+    result = @exchange.get_tickers_info
+
+    assert result.success?
+    assert_equal 2, result.data.size
+    assert_equal [0.5, 0.5, 0.5, 2, 0.5], @sleeps
+  end
+
+  def test_get_tickers_info_retries_the_symbols_request
+    connection = stub_catalogue(%w[btcusd])
+    connection.stubs(:get).with("/v1/symbols")
+              .raises(Faraday::TooManyRequestsError, "429")
+              .then.returns(stub(body: %w[btcusd]))
+
+    result = @exchange.get_tickers_info
+
+    assert result.success?
+    assert_equal 1, result.data.size
+  end
+
+  def test_get_tickers_info_retries_every_transient_error_class
+    Honeymaker::Exchanges::Gemini::TRANSIENT_ERRORS.each do |error_class|
+      setup
+      connection = stub_catalogue(%w[btcusd])
+      connection.stubs(:get).with("/v1/symbols/details/btcusd")
+                .raises(error_class, "transient").then.returns(detail_response)
+
+      assert @exchange.get_tickers_info.success?, "#{error_class} should be retried"
+    end
+  end
+
+  # All or nothing: data-api reads a pair missing from the catalogue as delisted, so a symbol that
+  # keeps failing must fail the whole catalogue, and nothing after it is fetched.
+  def test_get_tickers_info_fails_whole_catalogue_when_a_symbol_keeps_failing
+    connection = stub_catalogue(%w[btcusd ethusd solusd])
+    connection.expects(:get).with("/v1/symbols/details/ethusd").times(3)
+              .raises(Faraday::ConnectionFailed, "end of file reached")
+    connection.expects(:get).with("/v1/symbols/details/solusd").never
+
+    result = @exchange.get_tickers_info
+
+    assert result.failure?
+    assert_nil result.data
+    assert_equal ["end of file reached"], result.errors
+    assert_equal [0.5, 0.5, 0.5, 2, 0.5, 4, 0.5], @sleeps
+  end
+
+  def test_get_tickers_info_does_not_retry_a_non_transient_error
+    connection = stub_catalogue(%w[btcusd])
+    connection.expects(:get).with("/v1/symbols/details/btcusd").once
+              .raises(Faraday::ResourceNotFound, "404")
+
+    assert @exchange.get_tickers_info.failure?
+  end
+
   def test_get_bid_ask_parses_response
     body = load_fixture("gemini_pubticker.json")
     stub_connection(body)
@@ -51,6 +121,19 @@ class Honeymaker::Exchanges::GeminiTest < Minitest::Test
 
   private
 
+  def detail_response
+    stub(body: load_fixture("gemini_symbol_detail.json"))
+  end
+
+  # Every symbol resolves to the one detail fixture; a test overrides a path to make it fail.
+  def stub_catalogue(symbols)
+    connection = stub
+    connection.stubs(:get).with("/v1/symbols").returns(stub(body: symbols))
+    connection.stubs(:get).with { |path| path.start_with?("/v1/symbols/details/") }.returns(detail_response)
+    @exchange.instance_variable_set(:@connection, connection)
+    connection
+  end
+
   def stub_connection(body)
     response = stub(body: body)
     connection = stub

metadata

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