honeymaker 0.4.0 → 0.5.1

data/lib/honeymaker/clients/bingx.rb

@@ -4,6 +4,7 @@ module Honeymaker
   module Clients
     class BingX < Client
       URL = "https://open-api.bingx.com"
+      RATE_LIMITS = { default: 100, orders: 200 }.freeze
 
       def get_symbols
         get_public("/openApi/spot/v1/common/symbols")
@@ -24,24 +25,50 @@ module Honeymaker
         })
       end
 
-      def get_balances
+      def get_raw_balances
         get_signed("/openApi/spot/v1/account/balance")
       end
 
+      def get_balances
+        result = get_raw_balances
+        return result if result.failure?
+
+        balances = {}
+        raw_balances = result.data.dig("data", "balances") || []
+        raw_balances.each do |balance|
+          symbol = balance["asset"]
+          free = BigDecimal((balance["free"] || "0").to_s)
+          locked = BigDecimal((balance["locked"] || "0").to_s)
+          next if free.zero? && locked.zero?
+          balances[symbol] = { free: free, locked: locked }
+        end
+
+        Result::Success.new(balances)
+      end
+
       def place_order(symbol:, side:, type:, quantity: nil, quote_order_qty: nil, price: nil,
                       time_in_force: nil, client_order_id: nil)
-        post_signed("/openApi/spot/v1/trade/order", {
+        result = post_signed("/openApi/spot/v1/trade/order", {
           symbol: symbol, side: side, type: type,
           quantity: quantity, quoteOrderQty: quote_order_qty,
           price: price, timeInForce: time_in_force,
           newClientOrderId: client_order_id
         })
+        return result if result.failure?
+
+        raw = result.data
+        order_id = raw.dig("data", "orderId") || raw.dig("data", "data", "orderId")
+        Result::Success.new({ order_id: "#{symbol}-#{order_id}", raw: raw })
       end
 
       def get_order(symbol:, order_id: nil, client_order_id: nil)
-        get_signed("/openApi/spot/v1/trade/query", {
+        result = get_signed("/openApi/spot/v1/trade/query", {
           symbol: symbol, orderId: order_id, clientOrderID: client_order_id
         })
+        return result if result.failure?
+
+        raw = result.data.is_a?(Hash) && result.data.key?("data") ? result.data["data"] : result.data
+        Result::Success.new(normalize_order("#{symbol}-#{raw['orderId']}", raw))
       end
 
       def cancel_order(symbol:, order_id: nil, client_order_id: nil)
@@ -78,10 +105,75 @@ module Honeymaker
         })
       end
 
+      # --- Futures ---
+
+      def futures_income(symbol: nil, income_type: nil, start_time: nil, end_time: nil, limit: nil)
+        with_rescue do
+          params = {
+            symbol: symbol, incomeType: income_type,
+            startTime: start_time, endTime: end_time, limit: limit,
+            timestamp: timestamp_ms
+          }.compact
+          params[:signature] = hmac_sha256(@api_secret, Faraday::Utils.build_query(params))
+
+          response = futures_connection.get do |req|
+            req.url "/openApi/swap/v2/user/income"
+            req.headers = { "X-BX-APIKEY": @api_key }
+            req.params = params
+          end
+          response.body
+        end
+      end
+
       private
 
+      def normalize_order(order_id, raw)
+        order_type = parse_order_type(raw["type"])
+        side = raw["side"]&.downcase&.to_sym
+        status = parse_order_status(raw["status"])
+
+        amount = BigDecimal((raw["origQty"] || "0").to_s)
+        amount = nil if amount.zero?
+        quote_amount = raw["origQuoteOrderQty"] ? BigDecimal(raw["origQuoteOrderQty"].to_s) : nil
+        quote_amount = nil if quote_amount&.zero?
+
+        amount_exec = BigDecimal((raw["executedQty"] || "0").to_s)
+        quote_amount_exec = BigDecimal((raw["cummulativeQuoteQty"] || "0").to_s)
+        quote_amount_exec = nil if quote_amount_exec.negative?
+
+        price = BigDecimal((raw["price"] || "0").to_s)
+        if price.zero? && quote_amount_exec&.positive? && amount_exec.positive?
+          price = quote_amount_exec / amount_exec
+        end
+        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 "NEW", "PARTIALLY_FILLED", "PENDING" then :open
+        when "FILLED" then :closed
+        when "CANCELED", "EXPIRED" then :cancelled
+        when "REJECTED", "FAILED" then :failed
+        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["code"]&.to_i&.zero? ? Result::Success.new(true) : Result::Failure.new("Invalid trading credentials")
       end
@@ -128,6 +220,10 @@ module Honeymaker
         end
       end
 
+      def futures_connection
+        @futures_connection ||= build_client_connection("https://open-api.bingx.com", content_type_match: //)
+      end
+
       def connection
         @connection ||= build_client_connection(URL, content_type_match: //)
       end

data/lib/honeymaker/clients/bitget.rb

@@ -4,6 +4,7 @@ module Honeymaker
   module Clients
     class Bitget < Client
       URL = "https://api.bitget.com"
+      RATE_LIMITS = { default: 100, orders: 200 }.freeze
 
       attr_reader :passphrase
 
@@ -39,15 +40,46 @@ module Honeymaker
         get_signed("/api/v2/spot/account/assets", { coin: coin })
       end
 
+      def get_balances
+        result = get_account_assets
+        return result if result.failure?
+
+        return Result::Failure.new("Bitget API error") unless result.data["code"] == "00000"
+
+        balances = {}
+        (result.data["data"] || []).each do |asset|
+          symbol = asset["coin"]
+          free = BigDecimal((asset["available"] || "0").to_s)
+          locked = BigDecimal((asset["frozen"] || "0").to_s)
+          next if free.zero? && locked.zero?
+          balances[symbol] = { free: free, locked: locked }
+        end
+
+        Result::Success.new(balances)
+      end
+
       def place_order(symbol:, side:, order_type:, size: nil, quote_size: nil, price: nil, force: nil, client_oid: nil)
-        post_signed("/api/v2/spot/trade/place-order", {
+        result = post_signed("/api/v2/spot/trade/place-order", {
           symbol: symbol, side: side, orderType: order_type,
           size: size, quoteSize: quote_size, price: price, force: force, clientOid: client_oid
         })
+        return result if result.failure?
+        return Result::Failure.new("Bitget API error") unless result.data["code"] == "00000"
+
+        order_id = result.data.dig("data", "orderId")
+        Result::Success.new({ order_id: order_id, raw: result.data })
       end
 
       def get_order(order_id: nil, client_oid: nil)
-        get_signed("/api/v2/spot/trade/orderInfo", { orderId: order_id, clientOid: client_oid })
+        result = get_signed("/api/v2/spot/trade/orderInfo", { orderId: order_id, clientOid: client_oid })
+        return result if result.failure?
+        return Result::Failure.new("Bitget API error") unless result.data["code"] == "00000"
+
+        order_list = result.data["data"]
+        raw = order_list.is_a?(Array) ? order_list.first : order_list
+        return Result::Failure.new("Order not found") unless raw
+
+        Result::Success.new(normalize_order(raw["orderId"] || order_id, raw))
       end
 
       def cancel_order(symbol:, order_id: nil, client_oid: nil)
@@ -82,8 +114,137 @@ module Honeymaker
         })
       end
 
+      # --- Margin (Cross) ---
+
+      def margin_crossed_borrow_history(loan_id: nil, coin: nil, start_time: nil, end_time: nil, limit: nil, id_less_than: nil)
+        get_signed("/api/v2/margin/crossed/borrow-history", {
+          loanId: loan_id, coin: coin,
+          startTime: start_time, endTime: end_time, limit: limit, idLessThan: id_less_than
+        })
+      end
+
+      def margin_crossed_repay_history(repay_id: nil, coin: nil, start_time: nil, end_time: nil, limit: nil, id_less_than: nil)
+        get_signed("/api/v2/margin/crossed/repay-history", {
+          repayId: repay_id, coin: coin,
+          startTime: start_time, endTime: end_time, limit: limit, idLessThan: id_less_than
+        })
+      end
+
+      def margin_crossed_interest_history(coin: nil, start_time: nil, end_time: nil, limit: nil, id_less_than: nil)
+        get_signed("/api/v2/margin/crossed/interest-history", {
+          coin: coin, startTime: start_time, endTime: end_time, limit: limit, idLessThan: id_less_than
+        })
+      end
+
+      def margin_crossed_liquidation_history(start_time: nil, end_time: nil, limit: nil, id_less_than: nil)
+        get_signed("/api/v2/margin/crossed/liquidation-history", {
+          startTime: start_time, endTime: end_time, limit: limit, idLessThan: id_less_than
+        })
+      end
+
+      # --- Margin (Isolated) ---
+
+      def margin_isolated_borrow_history(symbol: nil, loan_id: nil, coin: nil, start_time: nil, end_time: nil, limit: nil, id_less_than: nil)
+        get_signed("/api/v2/margin/isolated/borrow-history", {
+          symbol: symbol, loanId: loan_id, coin: coin,
+          startTime: start_time, endTime: end_time, limit: limit, idLessThan: id_less_than
+        })
+      end
+
+      def margin_isolated_repay_history(symbol: nil, repay_id: nil, coin: nil, start_time: nil, end_time: nil, limit: nil, id_less_than: nil)
+        get_signed("/api/v2/margin/isolated/repay-history", {
+          symbol: symbol, repayId: repay_id, coin: coin,
+          startTime: start_time, endTime: end_time, limit: limit, idLessThan: id_less_than
+        })
+      end
+
+      def margin_isolated_interest_history(symbol: nil, coin: nil, start_time: nil, end_time: nil, limit: nil, id_less_than: nil)
+        get_signed("/api/v2/margin/isolated/interest-history", {
+          symbol: symbol, coin: coin,
+          startTime: start_time, endTime: end_time, limit: limit, idLessThan: id_less_than
+        })
+      end
+
+      def margin_isolated_liquidation_history(symbol: nil, start_time: nil, end_time: nil, limit: nil, id_less_than: nil)
+        get_signed("/api/v2/margin/isolated/liquidation-history", {
+          symbol: symbol, startTime: start_time, endTime: end_time, limit: limit, idLessThan: id_less_than
+        })
+      end
+
+      # --- Futures ---
+
+      def futures_account_bills(product_type:, coin: nil, business: nil, start_time: nil, end_time: nil, limit: nil, id_less_than: nil)
+        get_signed("/api/v2/mix/account/bill", {
+          productType: product_type, coin: coin, business: business,
+          startTime: start_time, endTime: end_time, limit: limit, idLessThan: id_less_than
+        })
+      end
+
+      def futures_fills_history(product_type:, symbol: nil, order_id: nil, start_time: nil, end_time: nil, limit: nil, id_less_than: nil)
+        get_signed("/api/v2/mix/order/fills-history", {
+          productType: product_type, symbol: symbol, orderId: order_id,
+          startTime: start_time, endTime: end_time, limit: limit, idLessThan: id_less_than
+        })
+      end
+
+      # --- Earn ---
+
+      def earn_savings_assets(coin: nil, filter: nil)
+        get_signed("/api/v2/earn/savings/assets", { coin: coin, filter: filter })
+      end
+
+      def earn_savings_subscribe_result(coin: nil, start_time: nil, end_time: nil, limit: nil, id_less_than: nil)
+        get_signed("/api/v2/earn/savings/subscribe-result", {
+          coin: coin, startTime: start_time, endTime: end_time, limit: limit, idLessThan: id_less_than
+        })
+      end
+
+      def earn_savings_redeem_result(coin: nil, start_time: nil, end_time: nil, limit: nil, id_less_than: nil)
+        get_signed("/api/v2/earn/savings/redeem-result", {
+          coin: coin, startTime: start_time, endTime: end_time, limit: limit, idLessThan: id_less_than
+        })
+      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["status"])
+
+        price = BigDecimal((raw["priceAvg"] || raw["price"] || "0").to_s)
+        price = nil if price.zero?
+
+        amount = raw["size"] ? BigDecimal(raw["size"].to_s) : nil
+        quote_amount = raw["quoteSize"] ? BigDecimal(raw["quoteSize"].to_s) : nil
+        amount_exec = BigDecimal((raw["baseVolume"] || "0").to_s)
+        quote_amount_exec = BigDecimal((raw["quoteVolume"] || "0").to_s)
+
+        {
+          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&.downcase
+        when "market" then :market
+        when "limit" then :limit
+        else :unknown
+        end
+      end
+
+      def parse_order_status(status)
+        case status
+        when "init", "new" then :unknown
+        when "partial_fill", "live" then :open
+        when "full_fill" then :closed
+        when "cancelled" then :cancelled
+        else :unknown
+        end
+      end
+
       def validate_trading_credentials
         result = get_account_assets
         return Result::Failure.new("Invalid trading credentials") if result.failure?

data/lib/honeymaker/clients/bitmart.rb

@@ -4,6 +4,7 @@ module Honeymaker
   module Clients
     class BitMart < Client
       URL = "https://api-cloud.bitmart.com"
+      RATE_LIMITS = { default: 100, orders: 200 }.freeze
 
       attr_reader :memo
 
@@ -34,16 +35,46 @@ module Honeymaker
         get_signed("/spot/v1/wallet")
       end
 
+      def get_balances
+        result = get_wallet
+        return result if result.failure?
+
+        return Result::Failure.new("BitMart API error") unless result.data["code"] == 1000
+
+        balances = {}
+        (result.data.dig("data", "wallet") || []).each do |wallet|
+          symbol = wallet["id"]
+          free = BigDecimal((wallet["available"] || "0").to_s)
+          locked = BigDecimal((wallet["frozen"] || "0").to_s)
+          next if free.zero? && locked.zero?
+          balances[symbol] = { free: free, locked: locked }
+        end
+
+        Result::Success.new(balances)
+      end
+
       def submit_order(symbol:, side:, type:, size: nil, notional: nil, price: nil, client_order_id: nil)
-        post_signed("/spot/v2/submit_order", {
+        result = post_signed("/spot/v2/submit_order", {
           symbol: symbol, side: side, type: type,
           size: size, notional: notional, price: price,
           client_order_id: client_order_id
         })
+        return result if result.failure?
+        return Result::Failure.new("BitMart API error") unless result.data["code"] == 1000
+
+        order_id = result.data.dig("data", "order_id")
+        Result::Success.new({ order_id: order_id.to_s, raw: result.data })
       end
 
       def get_order(order_id:)
-        post_signed("/spot/v2/order_detail", { orderId: order_id })
+        result = post_signed("/spot/v2/order_detail", { orderId: order_id })
+        return result if result.failure?
+        return Result::Failure.new("BitMart API error") unless result.data["code"] == 1000
+
+        raw = result.data["data"]
+        return Result::Failure.new("Order not found") unless raw
+
+        Result::Success.new(normalize_order(order_id.to_s, raw))
       end
 
       def cancel_order(symbol:, order_id: nil, client_order_id: nil)
@@ -79,8 +110,83 @@ module Honeymaker
         })
       end
 
+      # --- Margin ---
+
+      def margin_borrow_records(symbol: nil, borrow_id: nil, start_time: nil, end_time: nil, n: nil)
+        get_signed("/spot/v1/margin/isolated/borrow_record", {
+          symbol: symbol, borrow_id: borrow_id, start_time: start_time, end_time: end_time, N: n
+        })
+      end
+
+      def margin_repay_records(symbol: nil, repay_id: nil, currency: nil, start_time: nil, end_time: nil, n: nil)
+        get_signed("/spot/v1/margin/isolated/repay_record", {
+          symbol: symbol, repay_id: repay_id, currency: currency, start_time: start_time, end_time: end_time, N: n
+        })
+      end
+
+      # --- Futures ---
+
+      def futures_transaction_history(start_time: nil, end_time: nil, page_num: nil, page_size: nil, flow_type: nil)
+        get_signed("/contract/private/transaction-history", {
+          start_time: start_time, end_time: end_time,
+          page_num: page_num, page_size: page_size, flow_type: flow_type
+        })
+      end
+
+      def futures_trades(symbol:, start_time: nil, end_time: nil, page_num: nil, page_size: nil)
+        get_signed("/contract/private/trades", {
+          symbol: symbol, start_time: start_time, end_time: end_time,
+          page_num: page_num, page_size: page_size
+        })
+      end
+
       private
 
+      def normalize_order(order_id, raw)
+        order_type = parse_order_type(raw["type"])
+        side = raw["side"]&.downcase&.to_sym
+        status = parse_order_status(raw["status"])
+
+        amount = BigDecimal((raw["size"] || "0").to_s)
+        amount = nil if amount.zero?
+        quote_amount = raw["notional"] ? BigDecimal(raw["notional"].to_s) : nil
+        quote_amount = nil if quote_amount&.zero?
+
+        amount_exec = BigDecimal((raw["filled_size"] || "0").to_s)
+        quote_amount_exec = BigDecimal((raw["filled_notional"] || "0").to_s)
+        quote_amount_exec = nil if quote_amount_exec.negative?
+
+        price = BigDecimal((raw["price"] || "0").to_s)
+        if price.zero? && quote_amount_exec&.positive? && amount_exec.positive?
+          price = quote_amount_exec / amount_exec
+        end
+        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 "new", "partially_filled" then :open
+        when "filled" then :closed
+        when "canceled", "expired", "partially_canceled" then :cancelled
+        when "rejected", "failed" then :failed
+        else :unknown
+        end
+      end
+
       def validate_trading_credentials
         result = get_wallet
         return Result::Failure.new("Invalid trading credentials") if result.failure?

data/lib/honeymaker/clients/bitrue.rb

@@ -4,6 +4,7 @@ module Honeymaker
   module Clients
     class Bitrue < Client
       URL = "https://openapi.bitrue.com"
+      RATE_LIMITS = { default: 100, orders: 200 }.freeze
 
       def exchange_information
         get_public("/api/v1/exchangeInfo")
@@ -28,21 +29,45 @@ module Honeymaker
         get_signed("/api/v1/account", { recvWindow: recv_window })
       end
 
+      def get_balances
+        result = account_information
+        return result if result.failure?
+
+        balances = {}
+        Array(result.data["balances"]).each do |balance|
+          symbol = balance["asset"]
+          free = BigDecimal(balance["free"].to_s)
+          locked = BigDecimal(balance["locked"].to_s)
+          next if free.zero? && locked.zero?
+          balances[symbol] = { free: free, locked: locked }
+        end
+
+        Result::Success.new(balances)
+      end
+
       def query_order(symbol:, order_id: nil, orig_client_order_id: nil, recv_window: 5000)
-        get_signed("/api/v1/order", {
+        result = get_signed("/api/v1/order", {
           symbol: symbol, orderId: order_id,
           origClientOrderId: orig_client_order_id, recvWindow: recv_window
         })
+        return result if result.failure?
+
+        raw = result.data
+        Result::Success.new(normalize_order("#{symbol}-#{raw['orderId']}", raw))
       end
 
       def new_order(symbol:, side:, type:, time_in_force: nil, quantity: nil, quote_order_qty: nil,
                     price: nil, new_client_order_id: nil, recv_window: 5000)
-        post_signed("/api/v1/order", {
+        result = post_signed("/api/v1/order", {
           symbol: symbol, side: side, type: type,
           timeInForce: time_in_force, quantity: quantity,
           quoteOrderQty: quote_order_qty, price: price,
           newClientOrderId: new_client_order_id, recvWindow: recv_window
         })
+        return result if result.failure?
+
+        raw = result.data
+        Result::Success.new({ order_id: "#{symbol}-#{raw['orderId']}", raw: raw })
       end
 
       def cancel_order(symbol:, order_id: nil, orig_client_order_id: nil, recv_window: 5000)
@@ -59,8 +84,71 @@ module Honeymaker
         })
       end
 
+      # --- Futures ---
+
+      def futures_account(recv_window: 5000)
+        with_rescue do
+          response = futures_connection.get do |req|
+            req.url "/fapi/v1/account"
+            req.headers = auth_headers
+            req.params = { recvWindow: recv_window, timestamp: timestamp_ms }.compact
+            req.params[:signature] = sign_params(req.params)
+          end
+          response.body
+        end
+      end
+
       private
 
+      def futures_connection
+        @futures_connection ||= build_client_connection("https://fapi.bitrue.com")
+      end
+
+      def normalize_order(order_id, raw)
+        order_type = parse_order_type(raw["type"])
+        side = raw["side"]&.downcase&.to_sym
+        status = parse_order_status(raw["status"])
+
+        amount = BigDecimal((raw["origQty"] || "0").to_s)
+        amount = nil if amount.zero?
+        quote_amount = raw["origQuoteOrderQty"] ? BigDecimal(raw["origQuoteOrderQty"].to_s) : nil
+        quote_amount = nil if quote_amount&.zero?
+
+        amount_exec = BigDecimal((raw["executedQty"] || "0").to_s)
+        quote_amount_exec = BigDecimal((raw["cummulativeQuoteQty"] || "0").to_s)
+        quote_amount_exec = nil if quote_amount_exec.negative?
+
+        price = BigDecimal((raw["price"] || "0").to_s)
+        if price.zero? && quote_amount_exec&.positive? && amount_exec.positive?
+          price = quote_amount_exec / amount_exec
+        end
+        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 "NEW", "PARTIALLY_FILLED" then :open
+        when "FILLED" then :closed
+        when "CANCELED", "EXPIRED" then :cancelled
+        when "REJECTED" then :failed
+        else :unknown
+        end
+      end
+
       def validate_trading_credentials
         result = account_information
         result.success? ? Result::Success.new(true) : Result::Failure.new("Invalid trading credentials")