honeymaker 0.12.4-aarch64-linux

data/lib/honeymaker/exchanges/binance.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Exchanges
+    class Binance < Exchange
+      BASE_URL = "https://api.binance.com"
+
+      def get_tickers_info
+        with_rescue do
+          response = connection.get("/api/v3/exchangeInfo") do |req|
+            req.params = { permissions: "SPOT" }
+          end
+
+          response.body["symbols"].filter_map do |product|
+            f = Utils.parse_filters(product["filters"])
+
+            {
+              ticker: product["symbol"],
+              base: product["baseAsset"],
+              quote: product["quoteAsset"],
+              minimum_base_size: f[:lot_size]["minQty"],
+              minimum_quote_size: f[:notional]["minNotional"],
+              maximum_base_size: f[:lot_size]["maxQty"],
+              maximum_quote_size: f[:notional]["maxNotional"],
+              base_decimals: Utils.decimals(f[:lot_size]["stepSize"]),
+              quote_decimals: product["quoteAssetPrecision"],
+              price_decimals: Utils.decimals(f[:price]["tickSize"]),
+              available: true,
+              trading_enabled: product["status"] == "TRADING"
+            }
+          end
+        end
+      end
+
+      def get_bid_ask(symbol)
+        with_rescue do
+          response = connection.get("/api/v3/ticker/bookTicker") do |req|
+            req.params = { symbol: symbol }
+          end
+
+          {
+            bid: BigDecimal(response.body["bidPrice"]),
+            ask: BigDecimal(response.body["askPrice"])
+          }
+        end
+      end
+
+      private
+
+      def connection
+        @connection ||= build_connection(self.class::BASE_URL)
+      end
+    end
+  end
+end

data/lib/honeymaker/exchanges/binance_us.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Exchanges
+    class BinanceUs < Binance
+      BASE_URL = "https://api.binance.us"
+    end
+  end
+end

data/lib/honeymaker/exchanges/bingx.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Exchanges
+    class BingX < Exchange
+      BASE_URL = "https://open-api.bingx.com"
+
+      def get_tickers_info
+        with_rescue do
+          response = connection.get("/openApi/spot/v1/common/symbols")
+
+          response.body["data"]["symbols"].filter_map do |product|
+            ticker = product["symbol"]
+            parts = ticker.split("-")
+            next unless parts.size == 2
+
+            {
+              ticker: ticker,
+              base: parts[0],
+              quote: parts[1],
+              minimum_base_size: product["minQty"]&.to_s,
+              minimum_quote_size: product["minNotional"]&.to_s,
+              maximum_base_size: product["maxQty"]&.to_s,
+              maximum_quote_size: product["maxNotional"]&.to_s,
+              base_decimals: Utils.decimals(product["stepSize"]),
+              quote_decimals: Utils.decimals(product["tickSize"]),
+              price_decimals: Utils.decimals(product["tickSize"]),
+              available: true,
+              trading_enabled: product["status"].to_i == 1
+            }
+          end
+        end
+      end
+
+      def get_bid_ask(symbol)
+        with_rescue do
+          response = connection.get("/openApi/spot/v2/market/ticker") do |req|
+            req.params = { symbol: symbol }
+          end
+
+          data = response.body["data"].first
+          {
+            bid: BigDecimal(data["bestBidPrice"]),
+            ask: BigDecimal(data["bestAskPrice"])
+          }
+        end
+      end
+
+      private
+
+      def connection
+        @connection ||= build_connection(BASE_URL, content_type_match: //)
+      end
+    end
+  end
+end

data/lib/honeymaker/exchanges/bitget.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Exchanges
+    class Bitget < Exchange
+      BASE_URL = "https://api.bitget.com"
+
+      def get_tickers_info
+        with_rescue do
+          response = connection.get("/api/v2/spot/public/symbols")
+
+          response.body["data"].filter_map do |product|
+            {
+              ticker: product["symbol"],
+              base: product["baseCoin"],
+              quote: product["quoteCoin"],
+              minimum_base_size: product["minTradeAmount"],
+              minimum_quote_size: product["minTradeUSDT"],
+              maximum_base_size: product["maxTradeAmount"],
+              maximum_quote_size: nil,
+              base_decimals: product["quantityPrecision"].to_i,
+              quote_decimals: product["quotePrecision"].to_i,
+              price_decimals: product["pricePrecision"].to_i,
+              available: true,
+              trading_enabled: product["status"] == "online"
+            }
+          end
+        end
+      end
+
+      def get_bid_ask(symbol)
+        with_rescue do
+          response = connection.get("/api/v2/spot/market/tickers") do |req|
+            req.params = { symbol: symbol }
+          end
+
+          ticker = response.body["data"].first
+          {
+            bid: BigDecimal(ticker["bestBid"]),
+            ask: BigDecimal(ticker["bestAsk"])
+          }
+        end
+      end
+
+      private
+
+      def connection
+        @connection ||= build_connection(BASE_URL)
+      end
+    end
+  end
+end

data/lib/honeymaker/exchanges/bitrue.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Exchanges
+    class Bitrue < Exchange
+      BASE_URL = "https://openapi.bitrue.com"
+
+      def get_tickers_info
+        with_rescue do
+          response = connection.get("/api/v1/exchangeInfo")
+
+          response.body["symbols"].filter_map do |product|
+            f = Utils.parse_filters(product["filters"] || [])
+
+            {
+              ticker: product["symbol"],
+              base: product["baseAsset"]&.upcase,
+              quote: product["quoteAsset"]&.upcase,
+              minimum_base_size: f[:lot_size]&.dig("minQty"),
+              minimum_quote_size: f[:lot_size]&.dig("minVal"),
+              maximum_base_size: f[:lot_size]&.dig("maxQty"),
+              maximum_quote_size: nil,
+              base_decimals: f[:lot_size] ? Utils.decimals(f[:lot_size]["stepSize"]) : product["baseAssetPrecision"],
+              quote_decimals: product["quotePrecision"],
+              price_decimals: f[:price] ? Utils.decimals(f[:price]["tickSize"]) : product["quotePrecision"],
+              available: true,
+              trading_enabled: product["status"] == "TRADING"
+            }
+          end
+        end
+      end
+
+      def get_bid_ask(symbol)
+        with_rescue do
+          response = connection.get("/api/v1/ticker/bookTicker") do |req|
+            req.params = { symbol: symbol }
+          end
+
+          {
+            bid: BigDecimal(response.body["bidPrice"]),
+            ask: BigDecimal(response.body["askPrice"])
+          }
+        end
+      end
+
+      private
+
+      def connection
+        @connection ||= build_connection(BASE_URL)
+      end
+    end
+  end
+end

data/lib/honeymaker/exchanges/bitvavo.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Exchanges
+    class Bitvavo < Exchange
+      BASE_URL = "https://api.bitvavo.com"
+
+      def get_tickers_info
+        with_rescue do
+          response = connection.get("/v2/markets")
+
+          response.body.filter_map do |product|
+            market = product["market"]
+            base, quote = market.split("-")
+
+            {
+              ticker: market,
+              base: base,
+              quote: quote,
+              minimum_base_size: product["minOrderInBaseAsset"],
+              minimum_quote_size: product["minOrderInQuoteAsset"],
+              maximum_base_size: nil,
+              maximum_quote_size: nil,
+              base_decimals: product["quantityDecimals"] || 8,
+              quote_decimals: product["notionalDecimals"] || 8,
+              price_decimals: count_decimals(product.fetch("tickSize")),
+              available: true,
+              trading_enabled: product["status"] == "trading"
+            }
+          end
+        end
+      end
+
+      def get_bid_ask(symbol)
+        with_rescue do
+          response = connection.get("/v2/ticker/book") do |req|
+            req.params = { market: symbol }
+          end
+
+          {
+            bid: BigDecimal(response.body["bid"]),
+            ask: BigDecimal(response.body["ask"])
+          }
+        end
+      end
+
+      private
+
+      # Bitvavo's tickSize is always a power of ten (e.g. "1.00", "0.0000100"),
+      # so the count of significant decimal places is the price precision.
+      def count_decimals(value)
+        # Strip trailing zeros AND a dangling dot so whole-number ticks like
+        # "1.00" -> "1" yield 0 (Ruby's "1.".split(".") would wrongly give ["1"]).
+        str = value.to_s.sub(/\.?0+$/, "")
+        return 0 unless str.include?(".")
+
+        str.split(".").last.length
+      end
+
+      def connection
+        @connection ||= build_connection(BASE_URL)
+      end
+    end
+  end
+end

data/lib/honeymaker/exchanges/bybit.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Exchanges
+    class Bybit < Exchange
+      BASE_URL = "https://api.bybit.com"
+
+      def get_tickers_info
+        with_rescue do
+          response = connection.get("/v5/market/instruments-info") do |req|
+            req.params = { category: "spot" }
+          end
+
+          response.body["result"]["list"].filter_map do |product|
+            lot_size_filter = product["lotSizeFilter"]
+            price_filter = product["priceFilter"]
+
+            {
+              ticker: product["symbol"],
+              base: product["baseCoin"],
+              quote: product["quoteCoin"],
+              minimum_base_size: lot_size_filter["minOrderQty"],
+              minimum_quote_size: lot_size_filter["minOrderAmt"],
+              maximum_base_size: lot_size_filter["maxOrderQty"],
+              maximum_quote_size: lot_size_filter["maxOrderAmt"],
+              base_decimals: Utils.decimals(lot_size_filter["basePrecision"]),
+              quote_decimals: Utils.decimals(lot_size_filter["quotePrecision"]),
+              price_decimals: Utils.decimals(price_filter["tickSize"]),
+              available: true,
+              trading_enabled: product["status"] == "Trading"
+            }
+          end
+        end
+      end
+
+      def get_bid_ask(symbol)
+        with_rescue do
+          response = connection.get("/v5/market/tickers") do |req|
+            req.params = { category: "spot", symbol: symbol }
+          end
+
+          ticker = response.body["result"]["list"].first
+          {
+            bid: BigDecimal(ticker["bid1Price"]),
+            ask: BigDecimal(ticker["ask1Price"])
+          }
+        end
+      end
+
+      private
+
+      def connection
+        @connection ||= build_connection(BASE_URL)
+      end
+    end
+  end
+end

data/lib/honeymaker/exchanges/coinbase.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Exchanges
+    class Coinbase < Exchange
+      BASE_URL = "https://api.coinbase.com"
+
+      ASSET_BLACKLIST = [
+        "RNDR",      # delisted; has the same external_id as RENDER
+        "ZETACHAIN", # has the same external_id as ZETA
+        "WAXL"       # has the same external_id as AXL
+      ].freeze
+
+      def get_tickers_info
+        with_rescue do
+          response = connection.get("/api/v3/brokerage/market/products")
+
+          response.body["products"].filter_map do |product|
+            ticker = product["product_id"]
+            base, quote = ticker.split("-")
+            next if ASSET_BLACKLIST.include?(base)
+
+            {
+              ticker: ticker,
+              base: base,
+              quote: quote,
+              minimum_base_size: product["base_min_size"],
+              minimum_quote_size: product["quote_min_size"],
+              maximum_base_size: product["base_max_size"],
+              maximum_quote_size: product["quote_max_size"],
+              base_decimals: Utils.decimals(product["base_increment"]),
+              quote_decimals: Utils.decimals(product["quote_increment"]),
+              price_decimals: Utils.decimals(product["price_increment"]),
+              available: true,
+              trading_enabled: trading_enabled?(product)
+            }
+          end
+        end
+      end
+
+      def get_bid_ask(symbol)
+        with_rescue do
+          response = connection.get("/api/v3/brokerage/market/products/#{symbol}")
+
+          {
+            bid: BigDecimal(response.body["bid"]),
+            ask: BigDecimal(response.body["ask"])
+          }
+        end
+      end
+
+      private
+
+      # Coinbase only signals problems explicitly: a `trading_disabled`, `is_disabled`, `limit_only`
+      # or `cancel_only` flag, or a non-"online" `status`. Absent any signal, treat the pair as
+      # enabled. limit_only is reported as not tradable, like Kraken's limit_only status.
+      def trading_enabled?(product)
+        return false if %w[trading_disabled is_disabled limit_only cancel_only].any? { |flag| product[flag] == true }
+        return false if product.key?("status") && product["status"] != "online"
+
+        true
+      end
+
+      def connection
+        @connection ||= build_connection(BASE_URL)
+      end
+    end
+  end
+end

data/lib/honeymaker/exchanges/gemini.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Exchanges
+    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
+
+      # A symbol still failing after its retries is usually the venue or the connection, not the
+      # instrument, and each costs up to ~100 s. Past this many in one run the venue itself is down, so
+      # the whole catalogue fails, as any failure did before.
+      # ponytail: flat per-run budget; raise it if a rollout ever 5xxs a bigger family than this.
+      NO_ANSWER_LIMIT = 10
+
+      # /v1/symbols says what Gemini lists; the details only describe it. A listed symbol whose details
+      # cannot be read this run is SET ASIDE: left out of the catalogue and named in
+      # #unreadable_symbols, which callers must read as "unknown", never as delisted. Gemini lists new
+      # symbols before it can describe them (details/gramsgd answered 400 InvalidSymbol for hours on
+      # 2026-09-22), and failing the whole catalogue for that one left every Gemini pair without a
+      # verdict.
+      def get_tickers_info
+        @unreadable_symbols = {}
+        with_rescue do
+          symbols = catalogue_get("/v1/symbols")
+          no_answers = 0
+
+          tickers = symbols.filter_map do |symbol|
+            describe(symbol, catalogue_get("/v1/symbols/details/#{symbol}"))
+          rescue *TRANSIENT_ERRORS => e
+            raise if (no_answers += 1) >= NO_ANSWER_LIMIT
+
+            set_aside(symbol, e)
+          rescue StandardError => e
+            set_aside(symbol, e)
+          end
+          tickers = set_aside_shared_pairs(tickers)
+          if tickers.empty? && @unreadable_symbols.any?
+            raise Error, "Gemini: no symbol could be read, e.g. #{@unreadable_symbols.first.join(': ')}"
+          end
+
+          tickers
+        end
+      end
+
+      def get_bid_ask(symbol)
+        with_rescue do
+          response = connection.get("/v1/pubticker/#{symbol.downcase}")
+
+          {
+            bid: BigDecimal(response.body["bid"]),
+            ask: BigDecimal(response.body["ask"])
+          }
+        end
+      end
+
+      private
+
+      def connection
+        @connection ||= build_connection(BASE_URL)
+      end
+
+      def describe(symbol, detail)
+        return unless spot?(symbol, detail)
+
+        tick_size = detail["tick_size"]&.to_s || "0.01"
+        quote_increment = detail["quote_increment"]&.to_s || "0.01"
+
+        {
+          ticker: symbol.upcase,
+          base: detail["base_currency"].upcase,
+          quote: detail["quote_currency"].upcase,
+          minimum_base_size: detail["min_order_size"],
+          minimum_quote_size: "0",
+          maximum_base_size: nil,
+          maximum_quote_size: nil,
+          base_decimals: Utils.decimals(tick_size),
+          quote_decimals: Utils.decimals(quote_increment),
+          price_decimals: Utils.decimals(quote_increment),
+          available: true,
+          trading_enabled: detail["status"] == "open"
+        }
+      end
+
+      # Gemini lists perpetual swaps beside spot, under the same base and quote (BTCGUSDPERP is
+      # BTC/GUSD, product_type "swap"), so only product_type tells them apart. An instrument without
+      # one is not assumed to be spot: it is set aside. So is a body that is not an object -- JSON
+      # served as text/plain arrives as a String, and String#[] finds "product_type" inside it.
+      def spot?(symbol, detail)
+        raise Error, "Gemini #{symbol}: details are not an object" unless detail.is_a?(Hash)
+
+        product_type = detail["product_type"]
+        raise Error, "Gemini #{symbol}: no product_type in its details" unless product_type.is_a?(String) && !product_type.empty?
+        # A missing status would otherwise read as "not open" and revoke the pair.
+        raise Error, "Gemini #{symbol}: no status in its details" unless detail["status"].is_a?(String)
+
+        product_type == "spot"
+      end
+
+      # One pair, one instrument. Two would leave callers to pick one by list order, so neither is
+      # picked: both are set aside until Gemini lists only one.
+      def set_aside_shared_pairs(tickers)
+        shared = tickers.group_by { |t| [t[:base], t[:quote]] }.values.reject(&:one?)
+        shared.each do |group|
+          claim = "Gemini #{group.first[:base]}/#{group.first[:quote]} is claimed by #{group.map { |t| t[:ticker] }.join(' and ')}"
+          group.each { |t| @unreadable_symbols[t[:ticker]] = claim }
+        end
+        tickers - shared.flatten
+      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/exchanges/hyperliquid.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Exchanges
+    class Hyperliquid < Exchange
+      BASE_URL = "https://api.hyperliquid.xyz"
+
+      # Hyperliquid enforces a hard 10-USDC minimum order value on every spot pair (spotMeta exposes
+      # no per-token base floor). Surfaced as minimum_quote_size so consumers skip/reject sub-10
+      # orders up front instead of having the exchange reject them.
+      MINIMUM_QUOTE_SIZE = 10
+
+      def get_tickers_info
+        with_rescue do
+          response = connection.post("/info") do |req|
+            req.body = { type: "spotMeta" }.to_json
+          end
+
+          tokens = response.body["tokens"]
+          universe = response.body["universe"]
+          token_map = tokens.each_with_object({}) { |t, h| h[t["index"]] = t }
+
+          universe.filter_map do |pair|
+            base_token = token_map[pair["tokens"][0]]
+            quote_token = token_map[pair["tokens"][1]]
+            next unless base_token && quote_token
+
+            {
+              ticker: pair["name"],
+              base: base_token["name"],
+              quote: quote_token["name"],
+              minimum_base_size: nil,
+              minimum_quote_size: MINIMUM_QUOTE_SIZE,
+              maximum_base_size: nil,
+              maximum_quote_size: nil,
+              base_decimals: base_token["szDecimals"] || 0,
+              quote_decimals: 2,
+              price_decimals: 5,
+              available: true,
+              trading_enabled: true
+            }
+          end
+        end
+      end
+
+      def get_bid_ask(symbol)
+        with_rescue do
+          response = connection.post("/info") do |req|
+            req.body = { type: "allMids" }.to_json
+          end
+
+          price = BigDecimal(response.body[symbol])
+          {
+            bid: price,
+            ask: price
+          }
+        end
+      end
+
+      private
+
+      def connection
+        @connection ||= build_connection(BASE_URL)
+      end
+    end
+  end
+end