honeymaker 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 07736f839ae1cb3df2941e94e0170ebcea93e080631a42ce2dbc83ea85c8ca71
-  data.tar.gz: 3574dff97c256b910fa3941ac4968295955ce8ff11997dc2b6f50ddb146aaf45
+  metadata.gz: e80ebeeb8222d978465b6fca4f757d13eeae098395f99c2ec2223196c55c2b4b
+  data.tar.gz: 5f00b757a6872a409bdce15b5e77c7370148195397b5827064e49b0f57379ea6
 SHA512:
-  metadata.gz: 51079a9c330fb03e8bb806d30040b3774ea27244551b6a13443eb20fc3c061b41ac025802b04c2276e7c5412ed85895bb6d49dae310f05edc54a20e2595f447b
-  data.tar.gz: 301512a5685a2f19858b7f60dc99c6f53b584acbfbcf275491f55488eeac534e856eaa3dbbc679dc28d53dbfe331c8327cd834a2f830c478949e29ee421e3741
+  metadata.gz: 428f23c82dd3d1ae22f5fa05f00cd0036691fd397541b058d541ac7f5ba09936a464959a8c81ff11fa46ccab1c68fbfefe4d8fe7f97f06084fb32aca6e994112
+  data.tar.gz: a79cbc1061092903465d37be4f1a0627332a05f583bbbd3289b1f46319e76623ad99563f13d2101dcdb9eb07cabc5038d50ec8a9229dc12c1bc32c719f2dd877

data/lib/honeymaker/client.rb

@@ -0,0 +1,74 @@
+# 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
+
+    private
+
+    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,240 @@
+# 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 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 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,105 @@
+# 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 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 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

data/lib/honeymaker/clients/bitget.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Clients
+    class Bitget < Client
+      URL = "https://api.bitget.com"
+
+      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 place_order(symbol:, side:, order_type:, size:, price: nil, force: nil, client_oid: nil)
+        post_signed("/api/v2/spot/trade/place-order", {
+          symbol: symbol, side: side, orderType: order_type,
+          size: size, price: price, force: force, clientOid: client_oid
+        })
+      end
+
+      def get_order(order_id: nil, client_oid: nil)
+        get_signed("/api/v2/spot/trade/orderInfo", { orderId: order_id, clientOid: client_oid })
+      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 withdraw(coin:, transfer_type:, address:, size:, 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
+
+      private
+
+      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

data/lib/honeymaker/clients/bitmart.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Clients
+    class BitMart < Client
+      URL = "https://api-cloud.bitmart.com"
+
+      attr_reader :memo
+
+      def initialize(api_key: nil, api_secret: nil, memo: nil, proxy: nil, logger: nil)
+        super(api_key: api_key, api_secret: api_secret, proxy: proxy, logger: logger)
+        @memo = memo
+      end
+
+      def get_symbols_details
+        get_public("/spot/v1/symbols/details")
+      end
+
+      def get_ticker(symbol: nil)
+        get_public("/spot/quotation/v3/ticker", { symbol: symbol })
+      end
+
+      def get_depth(symbol:, limit: nil)
+        get_public("/spot/quotation/v3/books", { symbol: symbol, limit: limit })
+      end
+
+      def get_klines(symbol:, step:, before: nil, after_time: nil, limit: nil)
+        get_public("/spot/quotation/v3/lite-klines", {
+          symbol: symbol, step: step, before: before, after: after_time, limit: limit
+        })
+      end
+
+      def get_wallet
+        get_signed("/spot/v1/wallet")
+      end
+
+      def submit_order(symbol:, side:, type:, size: nil, notional: nil, price: nil, client_order_id: nil)
+        post_signed("/spot/v2/submit_order", {
+          symbol: symbol, side: side, type: type,
+          size: size, notional: notional, price: price,
+          client_order_id: client_order_id
+        })
+      end
+
+      def get_order(order_id:)
+        post_signed("/spot/v2/order_detail", { orderId: order_id })
+      end
+
+      def cancel_order(symbol:, order_id: nil, client_order_id: nil)
+        post_signed("/spot/v3/cancel_order", {
+          symbol: symbol, order_id: order_id, client_order_id: client_order_id
+        })
+      end
+
+      def withdraw(currency:, amount:, address:, address_memo: nil, destination: nil)
+        post_signed("/account/v1/withdraw/apply", {
+          currency: currency, amount: amount,
+          destination: destination || "To Digital Address",
+          address: address, address_memo: address_memo
+        })
+      end
+
+      private
+
+      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
+          ts = timestamp_ms.to_s
+          query_string = params.compact.empty? ? "" : "?#{Faraday::Utils.build_query(params.compact)}"
+          pre_sign = "#{ts}##{@memo}##{query_string}"
+
+          response = connection.get do |req|
+            req.url path
+            req.headers = signed_headers(ts, pre_sign)
+            req.params = params.compact
+          end
+          response.body
+        end
+      end
+
+      def post_signed(path, body = {})
+        with_rescue do
+          ts = timestamp_ms.to_s
+          body_json = body.compact.to_json
+          pre_sign = "#{ts}##{@memo}##{body_json}"
+
+          response = connection.post do |req|
+            req.url path
+            req.headers = signed_headers(ts, pre_sign)
+            req.body = body.compact
+          end
+          response.body
+        end
+      end
+
+      def signed_headers(timestamp, pre_sign)
+        signature = hmac_sha256(@api_secret, pre_sign)
+        {
+          "X-BM-KEY": @api_key,
+          "X-BM-SIGN": signature,
+          "X-BM-TIMESTAMP": timestamp,
+          Accept: "application/json",
+          "Content-Type": "application/json"
+        }
+      end
+    end
+  end
+end