honeymaker 0.12.4-aarch64-linux

data/lib/honeymaker/clients/gemini.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Clients
+    class Gemini < Client
+      URL = "https://api.gemini.com"
+      RATE_LIMITS = { default: 200, orders: 200 }.freeze
+
+      def get_symbols
+        get_public("/v1/symbols")
+      end
+
+      def get_symbol_details(symbol:)
+        get_public("/v1/symbols/details/#{symbol}")
+      end
+
+      def get_ticker(symbol:)
+        get_public("/v1/pubticker/#{symbol}")
+      end
+
+      def get_candles(symbol:, time_frame:)
+        get_public("/v2/candles/#{symbol}/#{time_frame}")
+      end
+
+      def get_price_feed
+        get_public("/v1/pricefeed")
+      end
+
+      def get_approved_addresses(network:)
+        post_signed("/v1/approvedAddresses/account/#{network}")
+      end
+
+      def get_raw_balances
+        post_signed("/v1/balances")
+      end
+
+      def get_balances
+        result = get_raw_balances
+        return result if result.failure?
+
+        balances = {}
+        Array(result.data).each do |balance|
+          symbol = balance["currency"]&.upcase
+          next unless symbol
+          available = BigDecimal((balance["available"] || "0").to_s)
+          amount = BigDecimal((balance["amount"] || "0").to_s)
+          locked = amount - available
+          next if available.zero? && locked.zero?
+          balances[symbol] = { free: available, locked: locked }
+        end
+
+        Result::Success.new(balances)
+      end
+
+      def new_order(symbol:, amount:, price:, side:, type:, client_order_id: nil, options: [])
+        result = post_signed("/v1/order/new", {
+          symbol: symbol, amount: amount, price: price,
+          side: side, type: type, client_order_id: client_order_id,
+          options: options
+        })
+        return result if result.failure?
+
+        raw = result.data
+        Result::Success.new({ order_id: raw["order_id"].to_s, raw: raw })
+      end
+
+      def order_status(order_id:)
+        result = post_signed("/v1/order/status", { order_id: order_id })
+        return result if result.failure?
+
+        raw = result.data
+        Result::Success.new(normalize_order(raw["order_id"].to_s, raw))
+      end
+
+      def cancel_order(order_id:)
+        post_signed("/v1/order/cancel", { order_id: order_id })
+      end
+
+      def get_my_trades(symbol: nil, limit_trades: nil, timestamp: nil)
+        post_signed("/v1/mytrades", { symbol: symbol, limit_trades: limit_trades, timestamp: timestamp })
+      end
+
+      def get_transfers(timestamp: nil, limit_transfers: nil)
+        post_signed("/v1/transfers", { timestamp: timestamp, limit_transfers: limit_transfers })
+      end
+
+      def withdraw(currency:, address:, amount:)
+        post_signed("/v1/withdraw/#{currency}", { address: address, amount: amount })
+      end
+
+      # --- Staking ---
+
+      def staking_history
+        post_signed("/v1/staking/history")
+      end
+
+      def staking_rewards
+        post_signed("/v1/staking/rewards")
+      end
+
+      def staking_balances
+        post_signed("/v1/balances/staking")
+      end
+
+      private
+
+      def normalize_order(order_id, raw)
+        order_type = parse_order_type(raw["type"])
+        side = raw["side"]&.downcase&.to_sym
+        status = parse_gemini_order_status(raw)
+
+        price = BigDecimal((raw["avg_execution_price"] || "0").to_s)
+        price = BigDecimal((raw["price"] || "0").to_s) if price.zero?
+        price = nil if price.zero?
+
+        amount = BigDecimal((raw["original_amount"] || "0").to_s)
+        amount_exec = BigDecimal((raw["executed_amount"] || "0").to_s)
+        quote_amount_exec = price ? (amount_exec * price) : BigDecimal("0")
+
+        {
+          order_id: order_id, status: status, side: side, order_type: order_type,
+          price: price, amount: amount, quote_amount: nil,
+          amount_exec: amount_exec, quote_amount_exec: quote_amount_exec, raw: raw
+        }
+      end
+
+      def parse_order_type(type)
+        case type&.downcase
+        when "exchange limit", "limit" then :limit
+        when "market", "exchange market" then :market
+        else :limit
+        end
+      end
+
+      def parse_gemini_order_status(raw)
+        if raw["is_cancelled"]
+          :cancelled
+        elsif raw["is_live"] && BigDecimal((raw["remaining_amount"] || "0").to_s).positive?
+          :open
+        elsif !raw["is_live"] && BigDecimal((raw["executed_amount"] || "0").to_s).positive?
+          :closed
+        else
+          :unknown
+        end
+      end
+
+      def validate_trading_credentials
+        result = get_raw_balances
+        return Result::Failure.new("Invalid trading credentials") if result.failure?
+        result.data.is_a?(Array) ? Result::Success.new(true) : Result::Failure.new("Invalid trading credentials")
+      end
+
+      def validate_read_credentials
+        validate_trading_credentials
+      end
+
+      def get_public(path, params = {})
+        with_rescue do
+          response = connection.get do |req|
+            req.url path
+            req.params = params.compact
+          end
+          response.body
+        end
+      end
+
+      def post_signed(path, body = {})
+        with_rescue do
+          payload = body.compact.merge(request: path, nonce: timestamp_ms.to_s)
+          encoded_payload = Base64.strict_encode64(payload.to_json)
+          # HMAC-SHA384, not SHA256: https://developer.gemini.com/authentication/api-key
+          signature = OpenSSL::HMAC.hexdigest("sha384", @api_secret, encoded_payload)
+
+          response = connection.post do |req|
+            req.url path
+            req.headers = {
+              "X-GEMINI-APIKEY": @api_key,
+              "X-GEMINI-PAYLOAD": encoded_payload,
+              "X-GEMINI-SIGNATURE": signature,
+              Accept: "application/json",
+              "Content-Type": "text/plain"
+            }
+          end
+          response.body
+        end
+      end
+    end
+  end
+end

data/lib/honeymaker/clients/hyperliquid.rb

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Clients
+    class Hyperliquid < Client
+      URL = "https://api.hyperliquid.xyz"
+      RATE_LIMITS = { default: 200, orders: 200 }.freeze
+
+      def initialize(api_key: nil, api_secret: nil, proxy: nil, logger: nil)
+        super
+      end
+
+      def spot_meta
+        post_info({ type: "spotMeta" })
+      end
+
+      def spot_meta_and_asset_ctxs
+        post_info({ type: "spotMetaAndAssetCtxs" })
+      end
+
+      def spot_clearinghouse_state(user:)
+        post_info({ type: "spotClearinghouseState", user: user })
+      end
+
+      def all_mids
+        post_info({ type: "allMids" })
+      end
+
+      def spot_balances(user: nil)
+        user ||= @api_key
+        spot_clearinghouse_state(user: user)
+      end
+
+      def l2_book(coin:)
+        post_info({ type: "l2Book", coin: coin })
+      end
+
+      def candles_snapshot(coin:, interval:, start_time:, end_time:)
+        post_info({ type: "candleSnapshot", req: { coin: coin, interval: interval, startTime: start_time, endTime: end_time } })
+      end
+
+      def get_balances(user: nil)
+        user ||= @api_key
+        result = spot_clearinghouse_state(user: user)
+        return result if result.failure?
+
+        balances = {}
+        (result.data["balances"] || []).each do |balance|
+          symbol = balance["coin"]
+          total = BigDecimal((balance["total"] || "0").to_s)
+          hold = BigDecimal((balance["hold"] || "0").to_s)
+          free = total - hold
+          next if free.zero? && hold.zero?
+          balances[symbol] = { free: free, locked: hold }
+        end
+
+        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
+        # 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["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}", 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
+
+      def open_orders(user:)
+        post_info({ type: "openOrders", user: user })
+      end
+
+      def user_fills(user:, start_time: nil, end_time: nil)
+        body = { type: "userFills", user: user }
+        body[:startTime] = start_time if start_time
+        body[:endTime] = end_time if end_time
+        post_info(body)
+      end
+
+      def user_fills_by_time(user:, start_time:, end_time: nil)
+        body = { type: "userFillsByTime", user: user, startTime: start_time }
+        body[:endTime] = end_time if end_time
+        post_info(body)
+      end
+
+      # --- Trading (requires hyperliquid-rb gem) ---
+
+      def order(coin:, is_buy:, size:, limit_px:, order_type: { limit: { tif: "Gtc" } })
+        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_status_rescue do
+          exchange_client.cancel(coin, oid)
+        end
+      end
+
+      # --- Futures ---
+
+      def user_funding(user:, start_time:, end_time: nil)
+        body = { type: "userFunding", user: user, startTime: start_time }
+        body[:endTime] = end_time if end_time
+        post_info(body)
+      end
+
+      def user_non_funding_ledger_updates(user:, start_time:, end_time: nil)
+        body = { type: "userNonFundingLedgerUpdates", user: user, startTime: start_time }
+        body[:endTime] = end_time if end_time
+        post_info(body)
+      end
+
+      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.
+      def parse_order_status(status)
+        case status
+        when "filled" then :closed
+        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
+
+      def validate_trading_credentials
+        return Result::Failure.new("No wallet address provided") unless @api_key
+        result = open_orders(user: @api_key)
+        result.success? ? Result::Success.new(true) : Result::Failure.new("Invalid credentials")
+      end
+
+      def validate_read_credentials
+        validate_trading_credentials
+      end
+
+      def exchange_client
+        raise Error, "Trading requires api_secret (agent key)" unless @api_secret && !@api_secret.empty?
+        @exchange ||= begin
+          require "hyperliquid"
+          ::Hyperliquid::Exchange.new(private_key: @api_secret)
+        rescue LoadError
+          raise Error, "Add 'hyperliquid-rb' to your Gemfile to use Hyperliquid trading"
+        end
+      end
+
+      def post_info(body)
+        with_rescue do
+          response = connection.post do |req|
+            req.url "/info"
+            req.headers = { Accept: "application/json", "Content-Type": "application/json" }
+            req.body = body.to_json
+          end
+          response.body
+        end
+      end
+    end
+  end
+end