honeymaker 0.12.4-x86_64-linux

data/lib/honeymaker/clients/binance_us.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+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

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+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")
+      end
+
+      def get_ticker(symbol: nil)
+        get_public("/openApi/spot/v2/market/ticker", { symbol: symbol })
+      end
+
+      def get_depth(symbol:, limit: nil)
+        get_public("/openApi/spot/v1/market/depth", { symbol: symbol, limit: limit })
+      end
+
+      def get_klines(symbol:, interval:, start_time: nil, end_time: nil, limit: nil)
+        get_public("/openApi/spot/v1/market/kline", {
+          symbol: symbol, interval: interval,
+          startTime: start_time, endTime: end_time, limit: limit
+        })
+      end
+
+      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)
+        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
+        # BingX rejects with HTTP 200 and a non-zero `code`. Without this the rejection fell
+        # through as a Success carrying order_id "#{symbol}-" (nil id): the bot recorded a trade
+        # that was never placed, then polled a malformed id forever.
+        return api_error("BingX", raw) unless raw.is_a?(Hash) && raw["code"].to_i.zero?
+
+        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)
+        result = get_signed("/openApi/spot/v1/trade/query", {
+          symbol: symbol, orderId: order_id, clientOrderID: client_order_id
+        })
+        return result if result.failure?
+        return api_error("BingX", result.data) unless result.data.is_a?(Hash) && result.data["code"].to_i.zero?
+
+        raw = 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)
+        post_signed("/openApi/spot/v1/trade/cancel", {
+          symbol: symbol, orderId: order_id, clientOrderID: client_order_id
+        })
+      end
+
+      def get_all_coins_info
+        get_signed("/openApi/wallets/v1/capital/config/getall")
+      end
+
+      def get_trade_fills(symbol: nil, order_id: nil, start_time: nil, end_time: nil, from_id: nil, limit: nil)
+        get_signed("/openApi/spot/v1/trade/fills", {
+          symbol: symbol, orderId: order_id,
+          startTime: start_time, endTime: end_time, fromId: from_id, limit: limit
+        })
+      end
+
+      def deposit_history(coin: nil, status: nil, start_time: nil, end_time: nil, offset: nil, limit: nil)
+        get_signed("/openApi/wallets/v1/capital/deposit/hisrec", {
+          coin: coin, status: status,
+          startTime: start_time, endTime: end_time, offset: offset, limit: limit
+        })
+      end
+
+      def withdraw_history(coin: nil, status: nil, start_time: nil, end_time: nil, offset: nil, limit: nil, id: nil)
+        get_signed("/openApi/wallets/v1/capital/withdraw/history", {
+          coin: coin, status: status,
+          startTime: start_time, endTime: end_time, offset: offset, limit: limit, id: id
+        })
+      end
+
+      def withdraw(coin:, address:, amount:, network: nil, wallet_type: nil, tag: nil)
+        post_signed("/openApi/wallets/v1/capital/withdraw/apply", {
+          coin: coin, address: address, amount: amount,
+          network: network, walletType: wallet_type, tag: tag
+        })
+      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_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
+
+      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 get_signed(path, params = {})
+        with_rescue do
+          params = params.compact.merge(timestamp: timestamp_ms)
+          params[:signature] = hmac_sha256(@api_secret, Faraday::Utils.build_query(params))
+
+          response = connection.get do |req|
+            req.url path
+            req.headers = { "X-BX-APIKEY": @api_key }
+            req.params = params
+          end
+          response.body
+        end
+      end
+
+      def post_signed(path, params = {})
+        with_rescue do
+          params = params.compact.merge(timestamp: timestamp_ms)
+          params[:signature] = hmac_sha256(@api_secret, Faraday::Utils.build_query(params))
+
+          response = connection.post do |req|
+            req.url path
+            req.headers = { "X-BX-APIKEY": @api_key, "Content-Type": "application/json" }
+            req.params = params
+          end
+          response.body
+        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
+    end
+  end
+end

data/lib/honeymaker/clients/bitget.rb

@@ -0,0 +1,318 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Clients
+    class Bitget < Client
+      URL = "https://api.bitget.com"
+      RATE_LIMITS = { default: 100, orders: 200 }.freeze
+
+      attr_reader :passphrase
+
+      def initialize(api_key: nil, api_secret: nil, passphrase: nil, proxy: nil, logger: nil)
+        super(api_key: api_key, api_secret: api_secret, proxy: proxy, logger: logger)
+        @passphrase = passphrase
+      end
+
+      def get_coins
+        get_public("/api/v2/spot/public/coins")
+      end
+
+      def get_symbols
+        get_public("/api/v2/spot/public/symbols")
+      end
+
+      def get_tickers(symbol: nil)
+        get_public("/api/v2/spot/market/tickers", { symbol: symbol })
+      end
+
+      def get_orderbook(symbol:, limit: nil)
+        get_public("/api/v2/spot/market/orderbook", { symbol: symbol, limit: limit })
+      end
+
+      def get_candles(symbol:, granularity:, start_time: nil, end_time: nil, limit: nil)
+        get_public("/api/v2/spot/market/candles", {
+          symbol: symbol, granularity: granularity,
+          startTime: start_time, endTime: end_time, limit: limit
+        })
+      end
+
+      def get_account_assets(coin: nil)
+        get_signed("/api/v2/spot/account/assets", { coin: coin })
+      end
+
+      def get_balances
+        result = get_account_assets
+        return result if result.failure?
+
+        return api_error("Bitget", result.data) 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)
+        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 api_error("Bitget", result.data) unless result.data["code"] == "00000"
+
+        order_id = result.data.dig("data", "orderId")
+        Result::Success.new({ order_id: "#{symbol}-#{order_id}", raw: result.data })
+      end
+
+      def get_order(order_id: nil, client_oid: nil)
+        result = get_signed("/api/v2/spot/trade/orderInfo", { orderId: order_id, clientOid: client_oid })
+        return result if result.failure?
+        return api_error("Bitget", result.data) 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)
+        post_signed("/api/v2/spot/trade/cancel-order", {
+          symbol: symbol, orderId: order_id, clientOid: client_oid
+        })
+      end
+
+      def get_fills(symbol: nil, order_id: nil, start_time: nil, end_time: nil, limit: nil, id_less_than: nil)
+        get_signed("/api/v2/spot/trade/fills", {
+          symbol: symbol, orderId: order_id,
+          startTime: start_time, endTime: end_time, limit: limit, idLessThan: id_less_than
+        })
+      end
+
+      def deposit_list(coin: nil, start_time: nil, end_time: nil, limit: nil, id_less_than: nil)
+        get_signed("/api/v2/spot/wallet/deposit-records", {
+          coin: coin, startTime: start_time, endTime: end_time, limit: limit, idLessThan: id_less_than
+        })
+      end
+
+      def withdrawal_list(coin: nil, start_time: nil, end_time: nil, limit: nil, id_less_than: nil)
+        get_signed("/api/v2/spot/wallet/withdrawal-records", {
+          coin: coin, startTime: start_time, endTime: end_time, limit: limit, idLessThan: id_less_than
+        })
+      end
+
+      def withdraw(coin:, address:, size:, transfer_type: nil, chain: nil, tag: nil, client_oid: nil)
+        post_signed("/api/v2/spot/wallet/withdrawal", {
+          coin: coin, transferType: transfer_type, address: address,
+          size: size, chain: chain, tag: tag, clientOid: client_oid
+        })
+      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 "partially_filled", "live" then :open
+        when "filled" 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?
+        result.data["code"] == "00000" ? 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.headers = unauthenticated_headers
+            req.params = params.compact
+          end
+          response.body
+        end
+      end
+
+      def get_signed(path, params = {})
+        with_rescue do
+          params = params.compact
+          query_string = params.empty? ? "" : "?#{Faraday::Utils.build_query(params)}"
+          ts = timestamp_ms.to_s
+          pre_sign = "#{ts}GET#{path}#{query_string}"
+
+          response = connection.get do |req|
+            req.url path
+            req.headers = signed_headers(ts, pre_sign)
+            req.params = params
+          end
+          response.body
+        end
+      end
+
+      def post_signed(path, body = {})
+        with_rescue do
+          body = body.compact
+          ts = timestamp_ms.to_s
+          pre_sign = "#{ts}POST#{path}#{body.to_json}"
+
+          response = connection.post do |req|
+            req.url path
+            req.headers = signed_headers(ts, pre_sign)
+            req.body = body
+          end
+          response.body
+        end
+      end
+
+      def unauthenticated_headers
+        { Accept: "application/json", "Content-Type": "application/json" }
+      end
+
+      def signed_headers(timestamp, pre_sign)
+        mac = Base64.strict_encode64(OpenSSL::HMAC.digest("sha256", @api_secret, pre_sign))
+        {
+          "ACCESS-KEY": @api_key,
+          "ACCESS-SIGN": mac,
+          "ACCESS-TIMESTAMP": timestamp,
+          "ACCESS-PASSPHRASE": @passphrase,
+          Accept: "application/json",
+          "Content-Type": "application/json",
+          locale: "en-US"
+        }
+      end
+    end
+  end
+end