honeymaker 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b69b5d2b1995f1def30eaa09cb003cef99a8763ea383c9f71ea8aa0d05e9ecac
-  data.tar.gz: 54fb293018729bcfd12c26b596da9fae540bfe6574d9de40cae8b6b0407809bb
+  metadata.gz: 3263fa7b4c91808f48416df3570c42d21948759fb5190b9fe523671da953ce29
+  data.tar.gz: ffb885474e57533e933cbeb36d81f6c63586e4b84282322757ebfaef3037b046
 SHA512:
-  metadata.gz: e1903ef50d96bd65cc630b587a2e4d9f8e7e967bd82768fd2c5d883dd06d8e265364fb853949e0f5308a4ba0dfc65980c91c96d9c89f5d1632966dbf756d9d35
-  data.tar.gz: cc74f411106c324c6a12a9b93f02415cc1f14d65d38ee4518b313e487804a87c50c386fb7d9fea0716f21018d46fc42ce82ff9c3496552723c1dfb774318679b
+  metadata.gz: 4c76739afb0c6239ae6af0e2292646c43aba16a6ef1abf004ad1df65b9a305a6ca47976517ae5ca01ffa3ca6e1b3889882315ae33e15ef695b2f97b711764f51
+  data.tar.gz: 4c4c7b51f95757f0ef330c54abdc215dd01bc6dc5242de1c2367b5cbe80188207715b7ab6534cd682b86cf27bc7fed62ae4016bcc46ba94fc89c2b7b88df8104

data/README.md

@@ -18,24 +18,119 @@ gem "honeymaker"
 
 ## Usage
 
+### Market Data
+
 ```ruby
 require "honeymaker"
 
-# Get an exchange client
 exchange = Honeymaker.exchange("binance")
-
-# Fetch trading pair info (symbols, decimals, min/max amounts)
 result = exchange.get_tickers_info
 
 if result.success?
   result.data.each do |ticker|
     puts "#{ticker[:ticker]} — min: #{ticker[:minimum_quote_size]}, decimals: #{ticker[:base_decimals]}"
   end
-else
-  puts "Error: #{result.errors.join(', ')}"
 end
 ```
 
+### Balances
+
+```ruby
+client = Honeymaker.client("binance", api_key: "...", api_secret: "...")
+result = client.get_balances
+
+if result.success?
+  result.data.each do |symbol, balance|
+    puts "#{symbol}: free=#{balance[:free]}, locked=#{balance[:locked]}"
+  end
+end
+# => { "BTC" => { free: BigDecimal("0.5"), locked: BigDecimal("0.1") }, ... }
+```
+
+Coinbase auto-resolves the default portfolio, or pass one explicitly:
+
+```ruby
+client.get_balances(portfolio_uuid: "...")
+```
+
+### Placing Orders
+
+Order placement returns a normalized `{ order_id:, raw: }` hash:
+
+```ruby
+client = Honeymaker.client("binance", api_key: "...", api_secret: "...")
+
+result = client.new_order(symbol: "BTCUSDT", side: "BUY", type: "MARKET", quote_order_qty: "100")
+if result.success?
+  puts result.data[:order_id]  # => "BTCUSDT-123456"
+  puts result.data[:raw]       # full exchange response
+end
+```
+
+Method names vary by exchange (`new_order`, `create_order`, `add_order`, `place_order`, `submit_order`) but the return format is the same.
+
+### Querying Orders
+
+Order queries return a normalized hash with unified status, amounts, and the raw response:
+
+```ruby
+result = client.query_order(symbol: "BTCUSDT", order_id: 123456)
+if result.success?
+  order = result.data
+  order[:order_id]          # => "BTCUSDT-123456"
+  order[:status]            # => :open, :closed, :cancelled, :failed, :unknown
+  order[:side]              # => :buy, :sell
+  order[:order_type]        # => :market, :limit
+  order[:price]             # => BigDecimal — avg fill price
+  order[:amount]            # => BigDecimal — requested base qty (nil if quote-denominated)
+  order[:quote_amount]      # => BigDecimal — requested quote qty (nil if base-denominated)
+  order[:amount_exec]       # => BigDecimal — filled base qty
+  order[:quote_amount_exec] # => BigDecimal — filled quote qty
+  order[:raw]               # => Hash — full exchange response
+end
+```
+
+### Credential Validation
+
+```ruby
+client = Honeymaker.client("binance", api_key: "...", api_secret: "...")
+result = client.validate(:trading)
+result.success? # => true if credentials have trading permissions
+```
+
+### Rate Limits
+
+Each exchange exposes rate limit metadata (milliseconds between requests):
+
+```ruby
+Honeymaker::Clients::Binance.rate_limits
+# => { default: 100, orders: 200 }
+
+Honeymaker::Clients::Kraken.rate_limits
+# => { default: 1000, orders: 1000 }
+```
+
+### Proxy Support
+
+```ruby
+client = Honeymaker.client("binance",
+  api_key: "...", api_secret: "...",
+  proxy: "http://proxy:8100"
+)
+```
+
+## Result Objects
+
+All methods return `Result::Success` or `Result::Failure`:
+
+```ruby
+result = client.get_balances
+result.success?  # true/false
+result.failure?  # true/false
+result.data      # response payload
+result.errors    # array of error messages (empty on success)
+```
+
 ## License
 
 MIT

data/lib/honeymaker/client.rb

@@ -3,6 +3,7 @@
 require "openssl"
 require "base64"
 require "securerandom"
+require "bigdecimal"
 
 module Honeymaker
   class Client
@@ -14,6 +15,11 @@ module Honeymaker
       }
     }.freeze
 
+    RATE_LIMITS = {
+      default: 100,
+      orders: 100
+    }.freeze
+
     attr_reader :api_key, :api_secret
 
     def initialize(api_key: nil, api_secret: nil, proxy: nil, logger: nil)
@@ -23,6 +29,14 @@ module Honeymaker
       @logger = logger
     end
 
+    def self.rate_limits
+      self::RATE_LIMITS
+    end
+
+    def get_balances
+      raise NotImplementedError, "#{self.class} must implement #get_balances"
+    end
+
     def validate(type = :trading)
       return Result::Failure.new("No credentials provided") unless authenticated?
 

data/lib/honeymaker/clients/binance.rb

@@ -4,6 +4,7 @@ module Honeymaker
   module Clients
     class Binance < Client
       URL = "https://api.binance.com"
+      RATE_LIMITS = { default: 100, orders: 200 }.freeze
 
       def exchange_information(symbol: nil, symbols: nil, permissions: nil, show_permission_sets: nil, symbol_status: nil)
         with_rescue do
@@ -75,6 +76,22 @@ module Honeymaker
         end
       end
 
+      def get_balances
+        result = account_information(omit_zero_balances: true)
+        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 account_trade_list(symbol:, order_id: nil, start_time: nil, end_time: nil, from_id: nil, limit: 500, recv_window: 5000)
         with_rescue do
           response = connection.get do |req|
@@ -104,7 +121,8 @@ module Honeymaker
             }.compact
             req.params[:signature] = sign_params(req.params)
           end
-          response.body
+          raw = response.body
+          normalize_order("#{symbol}-#{raw['orderId']}", raw)
         end
       end
 
@@ -145,7 +163,8 @@ module Honeymaker
             }.compact
             req.params[:signature] = sign_params(req.params)
           end
-          response.body
+          raw = response.body
+          { order_id: "#{symbol}-#{raw['orderId']}", raw: raw }
         end
       end
 
@@ -363,8 +382,251 @@ module Honeymaker
         end
       end
 
+      # --- Margin ---
+
+      def margin_borrow_repay_history(type:, asset: nil, isolated_symbol: nil, start_time: nil, end_time: nil,
+                                      current: nil, size: nil, recv_window: 5000)
+        with_rescue do
+          response = connection.get do |req|
+            req.url "/sapi/v1/margin/borrow-repay"
+            req.headers = headers
+            req.params = {
+              type: type, asset: asset, isolatedSymbol: isolated_symbol,
+              startTime: start_time, endTime: end_time,
+              current: current, size: size,
+              recvWindow: recv_window, timestamp: timestamp_ms
+            }.compact
+            req.params[:signature] = sign_params(req.params)
+          end
+          response.body
+        end
+      end
+
+      def margin_interest_history(asset: nil, isolated_symbol: nil, start_time: nil, end_time: nil,
+                                  current: nil, size: nil, archived: nil, recv_window: 5000)
+        with_rescue do
+          response = connection.get do |req|
+            req.url "/sapi/v1/margin/interestHistory"
+            req.headers = headers
+            req.params = {
+              asset: asset, isolatedSymbol: isolated_symbol,
+              startTime: start_time, endTime: end_time,
+              current: current, size: size, archived: archived,
+              recvWindow: recv_window, timestamp: timestamp_ms
+            }.compact
+            req.params[:signature] = sign_params(req.params)
+          end
+          response.body
+        end
+      end
+
+      def margin_force_liquidation(start_time: nil, end_time: nil, isolated_symbol: nil,
+                                   current: nil, size: nil, recv_window: 5000)
+        with_rescue do
+          response = connection.get do |req|
+            req.url "/sapi/v1/margin/forceLiquidationRec"
+            req.headers = headers
+            req.params = {
+              startTime: start_time, endTime: end_time,
+              isolatedSymbol: isolated_symbol,
+              current: current, size: size,
+              recvWindow: recv_window, timestamp: timestamp_ms
+            }.compact
+            req.params[:signature] = sign_params(req.params)
+          end
+          response.body
+        end
+      end
+
+      # --- Futures ---
+
+      def futures_income_history(symbol: nil, income_type: nil, start_time: nil, end_time: nil,
+                                 page: nil, limit: 1000, recv_window: 5000)
+        with_rescue do
+          response = usdt_futures_connection.get do |req|
+            req.url "/fapi/v1/income"
+            req.headers = headers
+            req.params = {
+              symbol: symbol, incomeType: income_type,
+              startTime: start_time, endTime: end_time,
+              page: page, limit: limit,
+              recvWindow: recv_window, timestamp: timestamp_ms
+            }.compact
+            req.params[:signature] = sign_params(req.params)
+          end
+          response.body
+        end
+      end
+
+      def coin_futures_income_history(symbol: nil, income_type: nil, start_time: nil, end_time: nil,
+                                      page: nil, limit: 1000, recv_window: 5000)
+        with_rescue do
+          response = coin_futures_connection.get do |req|
+            req.url "/dapi/v1/income"
+            req.headers = headers
+            req.params = {
+              symbol: symbol, incomeType: income_type,
+              startTime: start_time, endTime: end_time,
+              page: page, limit: limit,
+              recvWindow: recv_window, timestamp: timestamp_ms
+            }.compact
+            req.params[:signature] = sign_params(req.params)
+          end
+          response.body
+        end
+      end
+
+      # --- Simple Earn ---
+
+      def simple_earn_flexible_subscriptions(product_id: nil, purchase_id: nil, asset: nil,
+                                             start_time: nil, end_time: nil, current: nil, size: nil)
+        with_rescue do
+          response = connection.get do |req|
+            req.url "/sapi/v1/simple-earn/flexible/history/subscriptionRecord"
+            req.headers = headers
+            req.params = {
+              productId: product_id, purchaseId: purchase_id, asset: asset,
+              startTime: start_time, endTime: end_time,
+              current: current, size: size, timestamp: timestamp_ms
+            }.compact
+            req.params[:signature] = sign_params(req.params)
+          end
+          response.body
+        end
+      end
+
+      def simple_earn_flexible_redemptions(product_id: nil, redeem_id: nil, asset: nil,
+                                           start_time: nil, end_time: nil, current: nil, size: nil)
+        with_rescue do
+          response = connection.get do |req|
+            req.url "/sapi/v1/simple-earn/flexible/history/redemptionRecord"
+            req.headers = headers
+            req.params = {
+              productId: product_id, redeemId: redeem_id, asset: asset,
+              startTime: start_time, endTime: end_time,
+              current: current, size: size, timestamp: timestamp_ms
+            }.compact
+            req.params[:signature] = sign_params(req.params)
+          end
+          response.body
+        end
+      end
+
+      def simple_earn_locked_subscriptions(product_id: nil, purchase_id: nil, asset: nil,
+                                           start_time: nil, end_time: nil, current: nil, size: nil)
+        with_rescue do
+          response = connection.get do |req|
+            req.url "/sapi/v1/simple-earn/locked/history/subscriptionRecord"
+            req.headers = headers
+            req.params = {
+              productId: product_id, purchaseId: purchase_id, asset: asset,
+              startTime: start_time, endTime: end_time,
+              current: current, size: size, timestamp: timestamp_ms
+            }.compact
+            req.params[:signature] = sign_params(req.params)
+          end
+          response.body
+        end
+      end
+
+      def simple_earn_locked_redemptions(product_id: nil, redeem_id: nil, asset: nil,
+                                         start_time: nil, end_time: nil, current: nil, size: nil)
+        with_rescue do
+          response = connection.get do |req|
+            req.url "/sapi/v1/simple-earn/locked/history/redemptionRecord"
+            req.headers = headers
+            req.params = {
+              productId: product_id, redeemId: redeem_id, asset: asset,
+              startTime: start_time, endTime: end_time,
+              current: current, size: size, timestamp: timestamp_ms
+            }.compact
+            req.params[:signature] = sign_params(req.params)
+          end
+          response.body
+        end
+      end
+
+      # --- Transfers ---
+
+      def universal_transfer_history(type:, start_time: nil, end_time: nil, current: nil, size: nil, recv_window: 5000)
+        with_rescue do
+          response = connection.get do |req|
+            req.url "/sapi/v1/asset/transfer"
+            req.headers = headers
+            req.params = {
+              type: type, startTime: start_time, endTime: end_time,
+              current: current, size: size,
+              recvWindow: recv_window, timestamp: timestamp_ms
+            }.compact
+            req.params[:signature] = sign_params(req.params)
+          end
+          response.body
+        end
+      end
+
       private
 
+      def usdt_futures_connection
+        @usdt_futures_connection ||= build_client_connection("https://fapi.binance.com")
+      end
+
+      def coin_futures_connection
+        @coin_futures_connection ||= build_client_connection("https://dapi.binance.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"].to_s)
+        amount = nil if amount.zero?
+        quote_amount = BigDecimal(raw["origQuoteOrderQty"].to_s)
+        quote_amount = nil if quote_amount.zero?
+
+        amount_exec = BigDecimal(raw["executedQty"].to_s)
+        quote_amount_exec = BigDecimal(raw["cummulativeQuoteQty"].to_s)
+        quote_amount_exec = nil if quote_amount_exec.negative?
+
+        price = BigDecimal(raw["price"].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 "PENDING_CANCEL" then :unknown
+        when "NEW", "PENDING_NEW", "PARTIALLY_FILLED" then :open
+        when "FILLED" then :closed
+        when "CANCELED", "EXPIRED", "EXPIRED_IN_MATCH" then :cancelled
+        when "REJECTED" then :failed
+        else :unknown
+        end
+      end
+
       def validate_trading_credentials
         # Try cancelling a non-existent order — error -2011 (ORDER_DOES_NOT_EXIST) means key is valid with trade permission
         result = cancel_order(symbol: "ETHBTC", order_id: "9999999999")

data/lib/honeymaker/clients/binance_us.rb

@@ -4,6 +4,39 @@ module Honeymaker
   module Clients
     class BinanceUs < Binance
       URL = "https://api.binance.us"
+
+      # --- Staking ---
+
+      def staking_history(staking_type: nil, asset: nil, start_time: nil, end_time: nil, page: nil, limit: nil)
+        with_rescue do
+          response = connection.get do |req|
+            req.url "/staking/v1/history"
+            req.headers = headers
+            req.params = {
+              stakingType: staking_type, asset: asset,
+              startTime: start_time, endTime: end_time,
+              page: page, limit: limit, timestamp: timestamp_ms
+            }.compact
+            req.params[:signature] = sign_params(req.params)
+          end
+          response.body
+        end
+      end
+
+      def staking_rewards_history(asset: nil, start_time: nil, end_time: nil, page: nil, limit: nil)
+        with_rescue do
+          response = connection.get do |req|
+            req.url "/staking/v1/rewardsHistory"
+            req.headers = headers
+            req.params = {
+              asset: asset, startTime: start_time, endTime: end_time,
+              page: page, limit: limit, timestamp: timestamp_ms
+            }.compact
+            req.params[:signature] = sign_params(req.params)
+          end
+          response.body
+        end
+      end
     end
   end
 end

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