honeymaker 0.4.0 → 0.5.0

data/lib/honeymaker/clients/bybit.rb

@@ -5,6 +5,7 @@ module Honeymaker
     class Bybit < Client
       URL = "https://api.bybit.com"
       RECV_WINDOW = "5000"
+      RATE_LIMITS = { default: 100, orders: 200 }.freeze
 
       def get_coin_query_info
         get_authenticated("/v5/asset/coin/query-info")
@@ -38,20 +39,54 @@ module Honeymaker
         get_authenticated("/v5/account/wallet-balance", { accountType: account_type, coin: coin })
       end
 
+      def get_balances(account_type: "UNIFIED")
+        result = wallet_balance(account_type: account_type)
+        return result if result.failure?
+
+        return Result::Failure.new(result.data["retMsg"]) unless result.data["retCode"]&.zero?
+
+        balances = {}
+        accounts = result.data.dig("result", "list") || []
+        accounts.each do |account|
+          (account["coin"] || []).each do |coin|
+            symbol = coin["coin"]
+            free = BigDecimal((coin["availableToWithdraw"] || "0").to_s)
+            locked = BigDecimal((coin["locked"] || "0").to_s)
+            next if free.zero? && locked.zero?
+            balances[symbol] = { free: free, locked: locked }
+          end
+        end
+
+        Result::Success.new(balances)
+      end
+
       def get_order(category:, order_id: nil, symbol: nil, order_link_id: nil)
-        get_authenticated("/v5/order/realtime", {
+        result = get_authenticated("/v5/order/realtime", {
           category: category, orderId: order_id, symbol: symbol, orderLinkId: order_link_id
         })
+        return result if result.failure?
+        return Result::Failure.new(result.data["retMsg"]) unless result.data["retCode"]&.zero?
+
+        order_list = result.data.dig("result", "list") || []
+        raw = order_list.first
+        return Result::Failure.new("Order not found") unless raw
+
+        Result::Success.new(normalize_order(raw["orderId"], raw))
       end
 
       def create_order(category:, symbol:, side:, order_type:, qty:, price: nil,
                        time_in_force: nil, market_unit: nil, order_link_id: nil)
-        post_authenticated("/v5/order/create", {
+        result = post_authenticated("/v5/order/create", {
           category: category, symbol: symbol, side: side,
           orderType: order_type, qty: qty, price: price,
           timeInForce: time_in_force, marketUnit: market_unit,
           orderLinkId: order_link_id
         })
+        return result if result.failure?
+        return Result::Failure.new(result.data["retMsg"]) unless result.data["retCode"]&.zero?
+
+        order_id = result.data.dig("result", "orderId")
+        Result::Success.new({ order_id: order_id, raw: result.data })
       end
 
       def cancel_order(category:, symbol:, order_id: nil, order_link_id: nil)
@@ -95,8 +130,91 @@ module Honeymaker
         })
       end
 
+      # --- Margin ---
+
+      def borrow_history(currency: nil, start_time: nil, end_time: nil, limit: nil, cursor: nil)
+        get_authenticated("/v5/account/borrow-history", {
+          currency: currency, startTime: start_time, endTime: end_time, limit: limit, cursor: cursor
+        })
+      end
+
+      def spot_margin_repay_history(start_time: nil, end_time: nil, coin: nil, limit: nil, cursor: nil)
+        get_authenticated("/v5/spot-cross-margin-trade/repay-history", {
+          startTime: start_time, endTime: end_time, coin: coin, limit: limit, cursor: cursor
+        })
+      end
+
+      # --- Futures ---
+
+      def delivery_records(category:, symbol: nil, exp_date: nil, limit: nil, cursor: nil)
+        get_authenticated("/v5/asset/delivery-record", {
+          category: category, symbol: symbol, expDate: exp_date, limit: limit, cursor: cursor
+        })
+      end
+
+      def settlement_records(category:, symbol: nil, limit: nil, cursor: nil)
+        get_authenticated("/v5/asset/settlement-record", {
+          category: category, symbol: symbol, limit: limit, cursor: cursor
+        })
+      end
+
+      # --- Earn ---
+
+      def earn_order_records(order_id: nil, order_type: nil, start_time: nil, end_time: nil, limit: nil, cursor: nil)
+        get_authenticated("/v5/earn/order-records", {
+          orderId: order_id, orderType: order_type,
+          startTime: start_time, endTime: end_time, limit: limit, cursor: cursor
+        })
+      end
+
+      def earn_yield_history(product_id: nil, start_time: nil, end_time: nil, limit: nil, cursor: nil)
+        get_authenticated("/v5/earn/yield-history", {
+          productId: product_id, startTime: start_time, endTime: end_time, limit: limit, cursor: cursor
+        })
+      end
+
       private
 
+      def normalize_order(order_id, raw)
+        order_type = parse_order_type(raw["orderType"])
+        side = raw["side"]&.downcase&.to_sym
+        status = parse_order_status(raw["orderStatus"])
+
+        price = BigDecimal((raw["avgPrice"] || "0").to_s)
+        price = BigDecimal((raw["price"] || "0").to_s) if price.zero?
+        price = nil if price.zero?
+
+        amount = BigDecimal((raw["qty"] || "0").to_s)
+        amount = nil if amount.zero?
+        amount_exec = BigDecimal((raw["cumExecQty"] || "0").to_s)
+        quote_amount_exec = BigDecimal((raw["cumExecValue"] || "0").to_s)
+
+        {
+          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
+        when "Market" then :market
+        when "Limit" then :limit
+        else :unknown
+        end
+      end
+
+      def parse_order_status(status)
+        case status
+        when "Created", "Untriggered" then :unknown
+        when "New", "PartiallyFilled", "PartiallyFilledCanceled" then :open
+        when "Filled" then :closed
+        when "Cancelled", "Expired", "Deactivated" then :cancelled
+        when "Rejected" then :failed
+        else :unknown
+        end
+      end
+
       def validate_trading_credentials
         result = wallet_balance(account_type: "UNIFIED")
         return Result::Failure.new("Invalid trading credentials") if result.failure?

data/lib/honeymaker/clients/coinbase.rb

@@ -6,6 +6,7 @@ module Honeymaker
   module Clients
     class Coinbase < Client
       URL = "https://api.coinbase.com"
+      RATE_LIMITS = { default: 100, orders: 100 }.freeze
 
       def initialize(api_key: nil, api_secret: nil, proxy: nil, logger: nil)
         super
@@ -13,7 +14,11 @@ module Honeymaker
       end
 
       def get_order(order_id:)
-        get("/api/v3/brokerage/orders/historical/#{order_id}")
+        result = get("/api/v3/brokerage/orders/historical/#{order_id}")
+        return result if result.failure?
+
+        raw = result.data.is_a?(Hash) && result.data.key?("order") ? result.data["order"] : result.data
+        Result::Success.new(normalize_order(order_id, raw))
       end
 
       def list_orders(order_ids: nil, product_ids: nil, product_type: nil, order_status: nil,
@@ -40,10 +45,20 @@ module Honeymaker
       end
 
       def create_order(client_order_id:, product_id:, side:, order_configuration:)
-        post("/api/v3/brokerage/orders", {
+        result = post("/api/v3/brokerage/orders", {
           client_order_id: client_order_id, product_id: product_id,
           side: side, order_configuration: order_configuration
         })
+        return result if result.failure?
+
+        raw = result.data
+        if raw["success"] == false
+          error_msg = raw.dig("error_response", "message") || "Order creation failed"
+          return Result::Failure.new(error_msg)
+        end
+
+        order_id = raw.dig("success_response", "order_id")
+        Result::Success.new({ order_id: order_id, raw: raw })
       end
 
       def cancel_orders(order_ids:)
@@ -98,6 +113,35 @@ module Honeymaker
         get("/api/v3/brokerage/portfolios")
       end
 
+      def get_balances(portfolio_uuid: nil)
+        unless portfolio_uuid
+          portfolios_result = list_portfolios
+          return portfolios_result if portfolios_result.failure?
+
+          portfolio = Array(portfolios_result.data["portfolios"]).first
+          return Result::Failure.new("No portfolios found") unless portfolio
+          portfolio_uuid = portfolio["uuid"]
+        end
+
+        result = get_portfolio_breakdown(portfolio_uuid: portfolio_uuid)
+        return result if result.failure?
+
+        balances = {}
+        positions = result.data.dig("breakdown", "spot_positions") || []
+        positions.each do |position|
+          symbol = position["asset"]
+          next unless symbol
+
+          free = BigDecimal((position["available_to_trade_crypto"] || "0").to_s)
+          total = BigDecimal((position["total_balance_crypto"] || "0").to_s)
+          locked = total - free
+          next if free.zero? && locked.zero?
+          balances[symbol] = { free: free, locked: locked }
+        end
+
+        Result::Success.new(balances)
+      end
+
       def get_portfolio_breakdown(portfolio_uuid:, currency: nil)
         get("/api/v3/brokerage/portfolios/#{portfolio_uuid}", { currency: currency })
       end
@@ -154,6 +198,68 @@ module Honeymaker
         end
       end
 
+      def normalize_order(order_id, raw)
+        order_type = parse_order_type(raw["order_type"])
+        side = raw["side"]&.downcase&.to_sym
+        status = parse_order_status(raw["status"])
+
+        price = BigDecimal((raw["average_filled_price"] || "0").to_s)
+
+        case order_type
+        when :limit
+          config = (raw["order_configuration"] || {})["limit_limit_gtc"] || {}
+          amount = config["base_size"] ? BigDecimal(config["base_size"].to_s) : nil
+          quote_amount = config["quote_size"] ? BigDecimal(config["quote_size"].to_s) : nil
+          price = BigDecimal(config["limit_price"].to_s) if price.zero? && config["limit_price"]
+        when :market
+          config = (raw["order_configuration"] || {})["market_market_ioc"] || {}
+          amount = config["base_size"] ? BigDecimal(config["base_size"].to_s) : nil
+          quote_amount = config["quote_size"] ? BigDecimal(config["quote_size"].to_s) : nil
+        else
+          amount = nil
+          quote_amount = nil
+        end
+
+        price = nil if price.zero?
+
+        amount_exec = BigDecimal((raw["filled_size"] || "0").to_s)
+        total_value = BigDecimal((raw["total_value_after_fees"] || "0").to_s)
+        outstanding = BigDecimal((raw["outstanding_hold_amount"] || "0").to_s)
+        quote_amount_exec = total_value - outstanding
+
+        {
+          order_id: order_id,
+          status: status,
+          side: side,
+          order_type: order_type,
+          price: price,
+          amount: amount,
+          quote_amount: quote_amount,
+          amount_exec: amount_exec,
+          quote_amount_exec: quote_amount_exec,
+          raw: raw
+        }
+      end
+
+      def parse_order_type(type)
+        case type
+        when "MARKET" then :market
+        when "LIMIT" then :limit
+        else :unknown
+        end
+      end
+
+      def parse_order_status(status)
+        case status
+        when "PENDING", "UNKNOWN_ORDER_STATUS" then :unknown
+        when "OPEN" then :open
+        when "FILLED" then :closed
+        when "CANCELLED", "EXPIRED" then :cancelled
+        when "FAILED" then :failed
+        else :unknown
+        end
+      end
+
       def validate_trading_credentials
         # List accounts — if it works, the key has trading access
         result = list_accounts

data/lib/honeymaker/clients/gemini.rb

@@ -4,6 +4,7 @@ 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")
@@ -21,20 +22,46 @@ module Honeymaker
         get_public("/v2/candles/#{symbol}/#{time_frame}")
       end
 
-      def get_balances
+      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: [])
-        post_signed("/v1/order/new", {
+        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:)
-        post_signed("/v1/order/status", { order_id: 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:)
@@ -53,10 +80,64 @@ module Honeymaker
         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_balances
+        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

data/lib/honeymaker/clients/hyperliquid.rb

@@ -4,6 +4,7 @@ module Honeymaker
   module Clients
     class Hyperliquid < Client
       URL = "https://api.hyperliquid.xyz"
+      RATE_LIMITS = { default: 200, orders: 200 }.freeze
 
       def spot_meta
         post_info({ type: "spotMeta" })
@@ -17,8 +18,51 @@ module Honeymaker
         post_info({ type: "spotClearinghouseState", user: user })
       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
+
       def order_status(user:, oid:)
-        post_info({ type: "orderStatus", user: user, oid: 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"]
+
+        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)
+
+        Result::Success.new({
+          order_id: "#{coin}-#{oid}",
+          status: status, side: side, order_type: :limit,
+          price: avg_price, amount: ordered_size, quote_amount: nil,
+          amount_exec: amount_exec, quote_amount_exec: quote_amount_exec, raw: raw
+        })
       end
 
       def open_orders(user:)
@@ -38,8 +82,32 @@ module Honeymaker
         post_info(body)
       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
 
+      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
+        end
+      end
+
       def validate_trading_credentials
         return Result::Failure.new("No wallet address provided") unless @api_key
         result = open_orders(user: @api_key)

data/lib/honeymaker/clients/kraken.rb

@@ -8,11 +8,30 @@ module Honeymaker
     class Kraken < Client
       URL = "https://api.kraken.com"
 
+      RATE_LIMITS = { default: 1000, orders: 1000 }.freeze
+
+      ASSET_MAP = {
+        "ZUSD" => "USD", "ZEUR" => "EUR", "ZGBP" => "GBP",
+        "ZJPY" => "JPY", "ZCHF" => "CHF", "ZCAD" => "CAD",
+        "ZAUD" => "AUD", "XXBT" => "XBT", "XETH" => "ETH",
+        "XXDG" => "XDG"
+      }.freeze
+
       def query_orders_info(txid:, trades: nil, userref: nil, consolidate_taker: true)
-        post_private("/0/private/QueryOrders", {
+        result = post_private("/0/private/QueryOrders", {
           nonce: nonce, trades: trades, userref: userref,
           txid: txid, consolidate_taker: consolidate_taker
         })
+        return result if result.failure?
+
+        errors = result.data["error"]
+        return Result::Failure.new(*errors) if errors.is_a?(Array) && errors.any?
+
+        orders = {}
+        (result.data["result"] || {}).each do |order_id, raw|
+          orders[order_id] = normalize_order(order_id, raw)
+        end
+        Result::Success.new(orders)
       end
 
       def add_order(ordertype:, type:, volume:, pair:, userref: nil, cl_ord_id: nil,
@@ -20,7 +39,7 @@ module Honeymaker
                     reduce_only: nil, stptype: nil, oflags: [], timeinforce: nil,
                     starttm: nil, expiretm: nil, close: nil, close_price: nil,
                     close_price2: nil, deadline: nil, validate: nil)
-        post_private("/0/private/AddOrder", {
+        result = post_private("/0/private/AddOrder", {
           "nonce" => nonce, "ordertype" => ordertype, "type" => type,
           "volume" => volume, "pair" => pair, "userref" => userref,
           "cl_ord_id" => cl_ord_id, "displayvol" => displayvol,
@@ -33,6 +52,13 @@ module Honeymaker
           "close[price]" => close_price, "close[price2]" => close_price2,
           "deadline" => deadline, "validate" => validate
         })
+        return result if result.failure?
+
+        errors = result.data["error"]
+        return Result::Failure.new(*errors) if errors.is_a?(Array) && errors.any?
+
+        txid = (result.data.dig("result", "txid") || []).first
+        Result::Success.new({ order_id: txid, raw: result.data })
       end
 
       def cancel_order(txid: nil, cl_ord_id: nil)
@@ -57,6 +83,26 @@ module Honeymaker
         post_private("/0/private/BalanceEx", { nonce: nonce })
       end
 
+      def get_balances
+        result = get_extended_balance
+        return result if result.failure?
+
+        errors = result.data["error"]
+        return Result::Failure.new(*errors) if errors.is_a?(Array) && errors.any?
+
+        balances = {}
+        (result.data["result"] || {}).each do |symbol, balance|
+          mapped_symbol = ASSET_MAP[symbol.split(".").first] || symbol.split(".").first
+          total = BigDecimal(balance["balance"].to_s)
+          locked = BigDecimal((balance["hold_trade"] || "0").to_s)
+          free = total - locked
+          next if free.zero? && locked.zero?
+          balances[mapped_symbol] = { free: free, locked: locked }
+        end
+
+        Result::Success.new(balances)
+      end
+
       def get_ohlc_data(pair:, interval: nil, since: nil)
         get_public("/0/public/OHLC", { pair: pair, interval: interval, since: since })
       end
@@ -87,8 +133,72 @@ module Honeymaker
         post_private("/0/private/Withdraw", { nonce: nonce, asset: asset, key: key, amount: amount, address: address })
       end
 
+      # --- Earn ---
+
+      def get_earn_allocations(ascending: nil, converted_asset: nil, hide_zero_allocations: nil)
+        post_private("/0/private/Earn/Allocations", {
+          nonce: nonce, ascending: ascending,
+          converted_asset: converted_asset,
+          hide_zero_allocations: hide_zero_allocations
+        })
+      end
+
       private
 
+      def normalize_order(order_id, raw)
+        descr = raw["descr"] || {}
+        order_type = parse_order_type(descr["ordertype"])
+        side = descr["type"]&.downcase&.to_sym
+        status = parse_order_status(raw["status"])
+
+        order_flags = (raw["oflags"] || "").split(",")
+        if order_flags.include?("viqc")
+          amount = nil
+          quote_amount = BigDecimal(raw["vol"].to_s)
+        else
+          amount = BigDecimal(raw["vol"].to_s)
+          quote_amount = nil
+        end
+
+        amount_exec = BigDecimal(raw["vol_exec"].to_s)
+        quote_amount_exec = BigDecimal(raw["cost"].to_s)
+
+        price = BigDecimal(raw["price"].to_s)
+        price = BigDecimal(descr["price"].to_s) if price.zero? && order_type == :limit
+        price = nil if price.zero?
+
+        {
+          order_id: order_id,
+          status: status,
+          side: side,
+          order_type: order_type,
+          price: price,
+          amount: amount,
+          quote_amount: quote_amount,
+          amount_exec: amount_exec,
+          quote_amount_exec: quote_amount_exec,
+          raw: raw
+        }
+      end
+
+      def parse_order_type(type)
+        case type
+        when "market" then :market
+        when "limit" then :limit
+        else :unknown
+        end
+      end
+
+      def parse_order_status(status)
+        case status
+        when "pending" then :unknown
+        when "open" then :open
+        when "closed" then :closed
+        when "canceled", "expired" then :cancelled
+        else :unknown
+        end
+      end
+
       def validate_trading_credentials
         result = get_extended_balance
         return Result::Failure.new("Invalid trading credentials") if result.failure?