honeymaker 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 07736f839ae1cb3df2941e94e0170ebcea93e080631a42ce2dbc83ea85c8ca71
-  data.tar.gz: 3574dff97c256b910fa3941ac4968295955ce8ff11997dc2b6f50ddb146aaf45
+  metadata.gz: ff95afc5916845501bc9cbb7c625979f9f06662608d0e47bfbf9ec4bb7be686b
+  data.tar.gz: 978d54c3f108c0a037c627250bd277d6c1e5159d940c10a1579e54d0f96523d3
 SHA512:
-  metadata.gz: 51079a9c330fb03e8bb806d30040b3774ea27244551b6a13443eb20fc3c061b41ac025802b04c2276e7c5412ed85895bb6d49dae310f05edc54a20e2595f447b
-  data.tar.gz: 301512a5685a2f19858b7f60dc99c6f53b584acbfbcf275491f55488eeac534e856eaa3dbbc679dc28d53dbfe331c8327cd834a2f830c478949e29ee421e3741
+  metadata.gz: aec9b76d37ca978445002ba6243c73c857b6a3e9bfc4b7fd43f8c73091a7606503df1076da8af93856a4a6a74fb9e72c32af20237b74b3e339339cc5b168d3d3
+  data.tar.gz: 630b79116ad0d74be37993f412aa4b81f371cdc58fae756fd5c08fe7496a887c458aee0b9e6439575d89268a6f8f0c8b78bc7734d35ac8debe0c16185d7280a1

data/README.md

@@ -1,5 +1,9 @@
 # Honeymaker
 
+[![Gem Version](https://img.shields.io/gem/v/honeymaker)](https://rubygems.org/gems/honeymaker)
+[![CI](https://github.com/deltabadger/honeymaker/actions/workflows/test.yml/badge.svg)](https://github.com/deltabadger/honeymaker/actions)
+[![License](https://img.shields.io/github/license/deltabadger/honeymaker)](LICENSE)
+
 Ruby clients for cryptocurrency exchange APIs. Originally extracted from [Deltabadger](https://github.com/deltabadger/deltabadger).
 
 ## Supported Exchanges

data/lib/honeymaker/client.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "base64"
+require "securerandom"
+
+module Honeymaker
+  class Client
+    OPTIONS = {
+      request: {
+        open_timeout: 5,
+        read_timeout: 30,
+        write_timeout: 10
+      }
+    }.freeze
+
+    attr_reader :api_key, :api_secret
+
+    def initialize(api_key: nil, api_secret: nil, proxy: nil, logger: nil)
+      @api_key = api_key
+      @api_secret = api_secret
+      @proxy = proxy
+      @logger = logger
+    end
+
+    def validate(type = :trading)
+      return Result::Failure.new("No credentials provided") unless authenticated?
+
+      case type
+      when :trading then validate_trading_credentials
+      when :read then validate_read_credentials
+      else raise Error, "Unknown validation type: #{type}. Use :trading or :read"
+      end
+    rescue Error
+      raise
+    rescue StandardError => e
+      Result::Failure.new(e.message)
+    end
+
+    private
+
+    def validate_trading_credentials
+      raise NotImplementedError, "#{self.class} must implement #validate_trading_credentials"
+    end
+
+    def validate_read_credentials
+      raise NotImplementedError, "#{self.class} must implement #validate_read_credentials"
+    end
+
+    def with_rescue
+      Result::Success.new(yield)
+    rescue Faraday::Error => e
+      body = e.respond_to?(:response_body) ? e.response_body : nil
+      error_message = (body && !body.empty?) ? body : e.message.to_s
+      error_message = "Unknown API error" if error_message.nil? || error_message.empty?
+      status = e.respond_to?(:response_status) ? e.response_status : nil
+      Result::Failure.new(error_message, data: { status: status })
+    rescue StandardError => e
+      msg = e.message
+      Result::Failure.new((msg && !msg.empty?) ? msg : "Unknown error")
+    end
+
+    def connection
+      @connection ||= build_client_connection(self.class::URL)
+    end
+
+    def build_client_connection(url, content_type_match: nil)
+      Faraday.new(url: url, **OPTIONS) do |config|
+        config.proxy = @proxy if @proxy
+        config.request :json
+        if content_type_match
+          config.response :json, content_type: content_type_match
+        else
+          config.response :json
+        end
+        config.response :raise_error
+        config.response :logger, @logger, headers: false, bodies: false, log_level: :debug if @logger
+        config.adapter :net_http_persistent do |http|
+          http.idle_timeout = 100
+        end
+      end
+    end
+
+    def authenticated?
+      @api_key && !@api_key.empty? && @api_secret && !@api_secret.empty?
+    end
+
+    def timestamp_ms
+      (Time.now.utc.to_f * 1_000).to_i
+    end
+
+    def hmac_sha256(secret, data)
+      OpenSSL::HMAC.hexdigest("sha256", secret, data)
+    end
+  end
+end

data/lib/honeymaker/clients/binance.rb

@@ -0,0 +1,288 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Clients
+    class Binance < Client
+      URL = "https://api.binance.com"
+
+      def exchange_information(symbol: nil, symbols: nil, permissions: nil, show_permission_sets: nil, symbol_status: nil)
+        with_rescue do
+          response = connection.get do |req|
+            req.url "/api/v3/exchangeInfo"
+            req.headers = headers
+            req.params = {
+              symbol: symbol,
+              symbols: symbols&.to_json,
+              permissions: permissions&.to_json,
+              showPermissionSets: show_permission_sets,
+              symbolStatus: symbol_status
+            }.compact
+          end
+          response.body
+        end
+      end
+
+      def symbol_price_ticker(symbol: nil, symbols: nil)
+        with_rescue do
+          response = connection.get do |req|
+            req.url "/api/v3/ticker/price"
+            req.headers = headers
+            req.params = { symbol: symbol, symbols: symbols&.to_json }.compact
+          end
+          response.body
+        end
+      end
+
+      def symbol_order_book_ticker(symbol: nil, symbols: nil)
+        with_rescue do
+          response = connection.get do |req|
+            req.url "/api/v3/ticker/bookTicker"
+            req.headers = headers
+            req.params = { symbol: symbol, symbols: symbols&.to_json }.compact
+          end
+          response.body
+        end
+      end
+
+      def candlestick_data(symbol:, interval:, start_time: nil, end_time: nil, time_zone: 0, limit: 500)
+        with_rescue do
+          response = connection.get do |req|
+            req.url "/api/v3/klines"
+            req.headers = headers
+            req.params = {
+              symbol: symbol, interval: interval,
+              startTime: start_time, endTime: end_time,
+              timeZone: time_zone, limit: limit
+            }.compact
+          end
+          response.body
+        end
+      end
+
+      def account_information(omit_zero_balances: false, recv_window: 5000)
+        with_rescue do
+          response = connection.get do |req|
+            req.url "/api/v3/account"
+            req.headers = headers
+            req.params = {
+              omitZeroBalances: omit_zero_balances,
+              recvWindow: recv_window,
+              timestamp: timestamp_ms
+            }.compact
+            req.params[:signature] = sign_params(req.params)
+          end
+          response.body
+        end
+      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|
+            req.url "/api/v3/myTrades"
+            req.headers = headers
+            req.params = {
+              symbol: symbol, orderId: order_id,
+              startTime: start_time, endTime: end_time,
+              fromId: from_id, limit: limit,
+              recvWindow: recv_window, timestamp: timestamp_ms
+            }.compact
+            req.params[:signature] = sign_params(req.params)
+          end
+          response.body
+        end
+      end
+
+      def query_order(symbol:, order_id: nil, orig_client_order_id: nil, recv_window: 5000)
+        with_rescue do
+          response = connection.get do |req|
+            req.url "/api/v3/order"
+            req.headers = headers
+            req.params = {
+              symbol: symbol, orderId: order_id,
+              origClientOrderId: orig_client_order_id,
+              recvWindow: recv_window, timestamp: timestamp_ms
+            }.compact
+            req.params[:signature] = sign_params(req.params)
+          end
+          response.body
+        end
+      end
+
+      def all_orders(symbol:, order_id: nil, start_time: nil, end_time: nil, limit: 500, recv_window: 5000)
+        with_rescue do
+          response = connection.get do |req|
+            req.url "/api/v3/allOrders"
+            req.headers = headers
+            req.params = {
+              symbol: symbol, orderId: order_id,
+              startTime: start_time, endTime: end_time,
+              limit: limit, recvWindow: recv_window, timestamp: timestamp_ms
+            }.compact
+            req.params[:signature] = sign_params(req.params)
+          end
+          response.body
+        end
+      end
+
+      def new_order(symbol:, side:, type:, time_in_force: nil, quantity: nil, quote_order_qty: nil,
+                    price: nil, new_client_order_id: nil, strategy_id: nil, strategy_type: nil,
+                    stop_price: nil, trailing_delta: nil, iceberg_qty: nil, new_order_resp_type: nil,
+                    self_trade_prevention_mode: nil, recv_window: 5000)
+        with_rescue do
+          response = connection.post do |req|
+            req.url "/api/v3/order"
+            req.headers = headers
+            req.params = {
+              symbol: symbol, side: side, type: type,
+              timeInForce: time_in_force, quantity: quantity,
+              quoteOrderQty: quote_order_qty, price: price,
+              newClientOrderId: new_client_order_id,
+              strategyId: strategy_id, strategyType: strategy_type,
+              stopPrice: stop_price, trailingDelta: trailing_delta,
+              icebergQty: iceberg_qty, newOrderRespType: new_order_resp_type,
+              selfTradePreventionMode: self_trade_prevention_mode,
+              recvWindow: recv_window, timestamp: timestamp_ms
+            }.compact
+            req.params[:signature] = sign_params(req.params)
+          end
+          response.body
+        end
+      end
+
+      def cancel_order(symbol:, order_id: nil, orig_client_order_id: nil, new_client_order_id: nil,
+                       cancel_restrictions: nil, recv_window: 5000)
+        with_rescue do
+          response = connection.delete do |req|
+            req.url "/api/v3/order"
+            req.headers = headers
+            req.params = {
+              symbol: symbol, orderId: order_id,
+              origClientOrderId: orig_client_order_id,
+              newClientOrderId: new_client_order_id,
+              cancelRestrictions: cancel_restrictions,
+              recvWindow: recv_window, timestamp: timestamp_ms
+            }.compact
+            req.params[:signature] = sign_params(req.params)
+          end
+          response.body
+        end
+      end
+
+      def deposit_history(coin: nil, status: nil, start_time: nil, end_time: nil, offset: nil, limit: 1000, recv_window: 5000)
+        with_rescue do
+          response = connection.get do |req|
+            req.url "/sapi/v1/capital/deposit/hisrec"
+            req.headers = headers
+            req.params = {
+              coin: coin, status: status,
+              startTime: start_time, endTime: end_time,
+              offset: offset, limit: limit,
+              recvWindow: recv_window, timestamp: timestamp_ms
+            }.compact
+            req.params[:signature] = sign_params(req.params)
+          end
+          response.body
+        end
+      end
+
+      def withdraw_history(coin: nil, status: nil, start_time: nil, end_time: nil, offset: nil, limit: 1000, recv_window: 5000)
+        with_rescue do
+          response = connection.get do |req|
+            req.url "/sapi/v1/capital/withdraw/history"
+            req.headers = headers
+            req.params = {
+              coin: coin, status: status,
+              startTime: start_time, endTime: end_time,
+              offset: offset, limit: limit,
+              recvWindow: recv_window, timestamp: timestamp_ms
+            }.compact
+            req.params[:signature] = sign_params(req.params)
+          end
+          response.body
+        end
+      end
+
+      def get_all_coins_information(recv_window: 5000)
+        with_rescue do
+          response = connection.get do |req|
+            req.url "/sapi/v1/capital/config/getall"
+            req.headers = headers
+            req.params = { recvWindow: recv_window, timestamp: timestamp_ms }
+            req.params[:signature] = sign_params(req.params)
+          end
+          response.body
+        end
+      end
+
+      def api_description(recv_window: 5000)
+        with_rescue do
+          response = connection.get do |req|
+            req.url "/sapi/v1/account/apiRestrictions"
+            req.headers = headers
+            req.params = { recvWindow: recv_window, timestamp: timestamp_ms }
+            req.params[:signature] = sign_params(req.params)
+          end
+          response.body
+        end
+      end
+
+      def get_withdraw_addresses(recv_window: 5000)
+        with_rescue do
+          response = connection.get do |req|
+            req.url "/sapi/v1/capital/withdraw/address/list"
+            req.headers = headers
+            req.params = { recvWindow: recv_window, timestamp: timestamp_ms }
+            req.params[:signature] = sign_params(req.params)
+          end
+          response.body
+        end
+      end
+
+      def withdraw(coin:, address:, amount:, network: nil, address_tag: nil, recv_window: 5000)
+        with_rescue do
+          response = connection.post do |req|
+            req.url "/sapi/v1/capital/withdraw/apply"
+            req.headers = headers
+            req.params = {
+              coin: coin, address: address, amount: amount,
+              network: network, addressTag: address_tag,
+              recvWindow: recv_window, timestamp: timestamp_ms
+            }.compact
+            req.params[:signature] = sign_params(req.params)
+          end
+          response.body
+        end
+      end
+
+      private
+
+      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")
+        return Result::Failure.new("Invalid trading credentials") if result.failure?
+
+        code = result.data.is_a?(Hash) ? result.data["code"] : nil
+        code == -2011 ? Result::Success.new(true) : Result::Failure.new("Invalid trading credentials")
+      end
+
+      def validate_read_credentials
+        result = api_description
+        Result.new(data: result.success?, errors: result.success? ? [] : ["Invalid read credentials"])
+      end
+
+      def headers
+        if authenticated?
+          { "X-MBX-APIKEY": @api_key, Accept: "application/json", "Content-Type": "application/json" }
+        else
+          { Accept: "application/json", "Content-Type": "application/json" }
+        end
+      end
+
+      def sign_params(params)
+        return unless @api_secret
+        query = Faraday::Utils.build_query(params)
+        hmac_sha256(@api_secret, query)
+      end
+    end
+  end
+end

data/lib/honeymaker/clients/binance_us.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Clients
+    class BinanceUs < Binance
+      URL = "https://api.binance.us"
+    end
+  end
+end

data/lib/honeymaker/clients/bingx.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Clients
+    class BingX < Client
+      URL = "https://open-api.bingx.com"
+
+      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_balances
+        get_signed("/openApi/spot/v1/account/balance")
+      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", {
+          symbol: symbol, side: side, type: type,
+          quantity: quantity, quoteOrderQty: quote_order_qty,
+          price: price, timeInForce: time_in_force,
+          newClientOrderId: client_order_id
+        })
+      end
+
+      def get_order(symbol:, order_id: nil, client_order_id: nil)
+        get_signed("/openApi/spot/v1/trade/query", {
+          symbol: symbol, orderId: order_id, clientOrderID: client_order_id
+        })
+      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_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
+
+      private
+
+      def validate_trading_credentials
+        result = get_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 connection
+        @connection ||= build_client_connection(URL, content_type_match: //)
+      end
+    end
+  end
+end