honeymaker 0.1.0 → 0.2.0

data/lib/honeymaker/clients/kraken.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "digest"
+require "uri"
+
+module Honeymaker
+  module Clients
+    class Kraken < Client
+      URL = "https://api.kraken.com"
+
+      def query_orders_info(txid:, trades: nil, userref: nil, consolidate_taker: true)
+        post_private("/0/private/QueryOrders", {
+          nonce: nonce, trades: trades, userref: userref,
+          txid: txid, consolidate_taker: consolidate_taker
+        })
+      end
+
+      def add_order(ordertype:, type:, volume:, pair:, userref: nil, cl_ord_id: nil,
+                    displayvol: nil, price: nil, price2: nil, trigger: nil, leverage: nil,
+                    reduce_only: nil, stptype: nil, oflags: [], timeinforce: nil,
+                    starttm: nil, expiretm: nil, close: nil, close_price: nil,
+                    close_price2: nil, deadline: nil, validate: nil)
+        post_private("/0/private/AddOrder", {
+          "nonce" => nonce, "ordertype" => ordertype, "type" => type,
+          "volume" => volume, "pair" => pair, "userref" => userref,
+          "cl_ord_id" => cl_ord_id, "displayvol" => displayvol,
+          "price" => price, "price2" => price2, "trigger" => trigger,
+          "leverage" => leverage, "reduce_only" => reduce_only,
+          "stptype" => stptype,
+          "oflags" => oflags.any? ? oflags.join(",") : nil,
+          "timeinforce" => timeinforce, "starttm" => starttm,
+          "expiretm" => expiretm, "close[ordertype]" => close,
+          "close[price]" => close_price, "close[price2]" => close_price2,
+          "deadline" => deadline, "validate" => validate
+        })
+      end
+
+      def cancel_order(txid: nil, cl_ord_id: nil)
+        post_private("/0/private/CancelOrder", { nonce: nonce, txid: txid, cl_ord_id: cl_ord_id })
+      end
+
+      def get_tradable_asset_pairs(pairs: nil, info: nil, country_code: nil)
+        get_public("/0/public/AssetPairs", {
+          pair: pairs ? pairs.join(",") : nil, info: info, country_code: country_code
+        })
+      end
+
+      def get_asset_info(assets: nil, aclass: nil)
+        get_public("/0/public/Assets", { asset: assets ? assets.join(",") : nil, aclass: aclass })
+      end
+
+      def get_ticker_information(pair: nil)
+        get_public("/0/public/Ticker", { pair: pair })
+      end
+
+      def get_extended_balance
+        post_private("/0/private/BalanceEx", { nonce: nonce })
+      end
+
+      def get_ohlc_data(pair:, interval: nil, since: nil)
+        get_public("/0/public/OHLC", { pair: pair, interval: interval, since: since })
+      end
+
+      def get_withdraw_addresses(asset: nil, method: nil)
+        post_private("/0/private/WithdrawAddresses", { nonce: nonce, asset: asset, method: method })
+      end
+
+      def get_withdraw_methods(asset: nil)
+        post_private("/0/private/WithdrawMethods", { nonce: nonce, asset: asset })
+      end
+
+      def withdraw(asset:, key:, amount:, address: nil)
+        post_private("/0/private/Withdraw", { nonce: nonce, asset: asset, key: key, amount: amount, address: address })
+      end
+
+      private
+
+      def get_public(path, params = {})
+        with_rescue do
+          response = connection.get do |req|
+            req.url path
+            req.headers = public_headers
+            req.params = params.compact
+          end
+          response.body
+        end
+      end
+
+      def post_private(path, body = {})
+        with_rescue do
+          response = connection.post do |req|
+            req.url path
+            req.body = URI.encode_www_form(body.compact)
+            req.headers = private_headers(req.path, req.body)
+          end
+          response.body
+        end
+      end
+
+      def nonce
+        (Time.now.utc.to_f * 1_000_000).to_i
+      end
+
+      def private_headers(path, body)
+        return public_headers unless authenticated?
+
+        request_nonce = URI.decode_www_form(body).to_h["nonce"]
+        data = "#{request_nonce}#{body}"
+        message = path + Digest::SHA256.digest(data)
+        decoded_key = Base64.decode64(@api_secret)
+        begin
+          hmac = OpenSSL::HMAC.digest("sha512", decoded_key, message)
+        rescue OpenSSL::HMACError
+          return public_headers
+        end
+        signature = Base64.strict_encode64(hmac)
+
+        {
+          "API-Key": @api_key,
+          "API-Sign": signature,
+          Accept: "application/json",
+          "Content-Type": "application/x-www-form-urlencoded",
+          "User-Agent": "Honeymaker Ruby"
+        }
+      end
+
+      def public_headers
+        { Accept: "application/json", "Content-Type": "application/json", "User-Agent": "Honeymaker Ruby" }
+      end
+    end
+  end
+end

data/lib/honeymaker/clients/kucoin.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Clients
+    class Kucoin < Client
+      URL = "https://api.kucoin.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_symbols
+        get_public("/api/v2/symbols")
+      end
+
+      def get_ticker(symbol:)
+        get_public("/api/v1/market/orderbook/level1", { symbol: symbol })
+      end
+
+      def get_all_tickers
+        get_public("/api/v1/market/allTickers")
+      end
+
+      def get_klines(symbol:, type:, start_at: nil, end_at: nil)
+        get_public("/api/v1/market/candles", {
+          symbol: symbol, type: type, startAt: start_at, endAt: end_at
+        })
+      end
+
+      def get_accounts(currency: nil, type: nil)
+        get_signed("/api/v1/accounts", { currency: currency, type: type })
+      end
+
+      def place_order(client_oid:, side:, symbol:, type:, size: nil, funds: nil, price: nil,
+                      time_in_force: nil, stp: nil)
+        post_signed("/api/v1/orders", {
+          clientOid: client_oid, side: side, symbol: symbol, type: type,
+          size: size, funds: funds, price: price,
+          timeInForce: time_in_force, stp: stp
+        })
+      end
+
+      def get_order(order_id:)
+        get_signed("/api/v1/orders/#{order_id}")
+      end
+
+      def cancel_order(order_id:)
+        delete_signed("/api/v1/orders/#{order_id}")
+      end
+
+      def get_currencies
+        get_public("/api/v3/currencies")
+      end
+
+      def get_withdrawal_quotas(currency:, chain: nil)
+        get_signed("/api/v1/withdrawals/quotas", { currency: currency, chain: chain })
+      end
+
+      def withdraw(currency:, address:, amount:, chain: nil, memo: nil)
+        post_signed("/api/v1/withdrawals", {
+          currency: currency, address: address, amount: amount,
+          chain: chain, memo: memo
+        })
+      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 delete_signed(path)
+        with_rescue do
+          ts = timestamp_ms.to_s
+          pre_sign = "#{ts}DELETE#{path}"
+
+          response = connection.delete do |req|
+            req.url path
+            req.headers = signed_headers(ts, pre_sign)
+          end
+          response.body
+        end
+      end
+
+      def unauthenticated_headers
+        { Accept: "application/json", "Content-Type": "application/json" }
+      end
+
+      def signed_headers(timestamp, pre_sign)
+        signature = Base64.strict_encode64(OpenSSL::HMAC.digest("sha256", @api_secret, pre_sign))
+        signed_passphrase = Base64.strict_encode64(
+          OpenSSL::HMAC.digest("sha256", @api_secret, @passphrase)
+        )
+        {
+          "KC-API-KEY": @api_key,
+          "KC-API-SIGN": signature,
+          "KC-API-TIMESTAMP": timestamp,
+          "KC-API-PASSPHRASE": signed_passphrase,
+          "KC-API-KEY-VERSION": "2",
+          Accept: "application/json",
+          "Content-Type": "application/json"
+        }
+      end
+    end
+  end
+end

data/lib/honeymaker/clients/mexc.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Clients
+    class Mexc < Client
+      URL = "https://api.mexc.com"
+
+      def get_all_coins_information
+        get_public("/api/v3/capital/config/getall")
+      end
+
+      def exchange_information
+        get_public("/api/v3/exchangeInfo")
+      end
+
+      def symbol_price_ticker(symbol: nil)
+        get_public("/api/v3/ticker/price", { symbol: symbol })
+      end
+
+      def symbol_order_book_ticker(symbol: nil)
+        get_public("/api/v3/ticker/bookTicker", { symbol: symbol })
+      end
+
+      def candlestick_data(symbol:, interval:, start_time: nil, end_time: nil, limit: 500)
+        get_public("/api/v3/klines", {
+          symbol: symbol, interval: interval,
+          startTime: start_time, endTime: end_time, limit: limit
+        })
+      end
+
+      def account_information(recv_window: 5000)
+        get_signed("/api/v3/account", { recvWindow: recv_window })
+      end
+
+      def query_order(symbol:, order_id: nil, orig_client_order_id: nil, recv_window: 5000)
+        get_signed("/api/v3/order", {
+          symbol: symbol, orderId: order_id,
+          origClientOrderId: orig_client_order_id, recvWindow: recv_window
+        })
+      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/v3/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
+        })
+      end
+
+      def cancel_order(symbol:, order_id: nil, orig_client_order_id: nil,
+                       new_client_order_id: nil, recv_window: 5000)
+        delete_signed("/api/v3/order", {
+          symbol: symbol, orderId: order_id,
+          origClientOrderId: orig_client_order_id,
+          newClientOrderId: new_client_order_id, recvWindow: recv_window
+        })
+      end
+
+      def get_withdraw_addresses(recv_window: 5000)
+        get_signed("/api/v3/capital/withdraw/address", { recvWindow: recv_window })
+      end
+
+      def withdraw(coin:, address:, amount:, network: nil, memo: nil, recv_window: 5000)
+        post_signed("/api/v3/capital/withdraw/apply", {
+          coin: coin, address: address, amount: amount,
+          network: network, memo: memo, recvWindow: recv_window
+        })
+      end
+
+      private
+
+      def get_public(path, params = {})
+        with_rescue do
+          response = connection.get do |req|
+            req.url path
+            req.headers = headers
+            req.params = params.compact
+          end
+          response.body
+        end
+      end
+
+      def get_signed(path, params = {})
+        with_rescue do
+          response = connection.get do |req|
+            req.url path
+            req.headers = headers
+            req.params = params.compact.merge(timestamp: timestamp_ms)
+            req.params[:signature] = sign_params(req.params)
+          end
+          response.body
+        end
+      end
+
+      def post_signed(path, params = {})
+        with_rescue do
+          response = connection.post do |req|
+            req.url path
+            req.headers = headers
+            req.params = params.compact.merge(timestamp: timestamp_ms)
+            req.params[:signature] = sign_params(req.params)
+          end
+          response.body
+        end
+      end
+
+      def delete_signed(path, params = {})
+        with_rescue do
+          response = connection.delete do |req|
+            req.url path
+            req.headers = headers
+            req.params = params.compact.merge(timestamp: timestamp_ms)
+            req.params[:signature] = sign_params(req.params)
+          end
+          response.body
+        end
+      end
+
+      def headers
+        if authenticated?
+          { "X-MEXC-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/exchanges/binance.rb

@@ -11,29 +11,23 @@ module Honeymaker
             req.params = { permissions: "SPOT" }
           end
 
-          response.body["symbols"].map do |product|
-            ticker = product["symbol"]
-            status = product["status"]
-
-            filters = product["filters"]
-            price_filter = filters.find { |f| f["filterType"] == "PRICE_FILTER" }
-            lot_size_filter = filters.find { |f| f["filterType"] == "LOT_SIZE" }
-            notional_filter = filters.find { |f| %w[NOTIONAL MIN_NOTIONAL].include?(f["filterType"]) }
+          response.body["symbols"].filter_map do |product|
+            f = Utils.parse_filters(product["filters"])
 
             {
-              ticker: ticker,
+              ticker: product["symbol"],
               base: product["baseAsset"],
               quote: product["quoteAsset"],
-              minimum_base_size: lot_size_filter["minQty"],
-              minimum_quote_size: notional_filter["minNotional"],
-              maximum_base_size: lot_size_filter["maxQty"],
-              maximum_quote_size: notional_filter["maxNotional"],
-              base_decimals: Utils.decimals(lot_size_filter["stepSize"]),
+              minimum_base_size: f[:lot_size]["minQty"],
+              minimum_quote_size: f[:notional]["minNotional"],
+              maximum_base_size: f[:lot_size]["maxQty"],
+              maximum_quote_size: f[:notional]["maxNotional"],
+              base_decimals: Utils.decimals(f[:lot_size]["stepSize"]),
               quote_decimals: product["quoteAssetPrecision"],
-              price_decimals: Utils.decimals(price_filter["tickSize"]),
-              available: status == "TRADING"
+              price_decimals: Utils.decimals(f[:price]["tickSize"]),
+              available: product["status"] == "TRADING"
             }
-          end.compact
+          end
         end
       end
 

data/lib/honeymaker/exchanges/bitget.rb

@@ -9,7 +9,7 @@ module Honeymaker
         with_rescue do
           response = connection.get("/api/v2/spot/public/symbols")
 
-          response.body["data"].map do |product|
+          response.body["data"].filter_map do |product|
             {
               ticker: product["symbol"],
               base: product["baseCoin"],
@@ -23,7 +23,7 @@ module Honeymaker
               price_decimals: product["pricePrecision"].to_i,
               available: product["status"] == "online"
             }
-          end.compact
+          end
         end
       end
 

data/lib/honeymaker/exchanges/bitrue.rb

@@ -10,29 +10,19 @@ module Honeymaker
           response = connection.get("/api/v1/exchangeInfo")
 
           response.body["symbols"].filter_map do |product|
-            filters = product["filters"] || []
-            price_filter = filters.find { |f| f["filterType"] == "PRICE_FILTER" }
-            lot_size_filter = filters.find { |f| f["filterType"] == "LOT_SIZE" }
+            f = Utils.parse_filters(product["filters"] || [])
 
             {
               ticker: product["symbol"],
               base: product["baseAsset"]&.upcase,
               quote: product["quoteAsset"]&.upcase,
-              minimum_base_size: lot_size_filter&.dig("minQty"),
-              minimum_quote_size: lot_size_filter&.dig("minVal"),
-              maximum_base_size: lot_size_filter&.dig("maxQty"),
+              minimum_base_size: f[:lot_size]&.dig("minQty"),
+              minimum_quote_size: f[:lot_size]&.dig("minVal"),
+              maximum_base_size: f[:lot_size]&.dig("maxQty"),
               maximum_quote_size: nil,
-              base_decimals: if lot_size_filter
-                               Utils.decimals(lot_size_filter["stepSize"])
-                             else
-                               product["baseAssetPrecision"]
-                             end,
+              base_decimals: f[:lot_size] ? Utils.decimals(f[:lot_size]["stepSize"]) : product["baseAssetPrecision"],
               quote_decimals: product["quotePrecision"],
-              price_decimals: if price_filter
-                                Utils.decimals(price_filter["tickSize"])
-                              else
-                                product["quotePrecision"]
-                              end,
+              price_decimals: f[:price] ? Utils.decimals(f[:price]["tickSize"]) : product["quotePrecision"],
               available: product["status"] == "TRADING"
             }
           end

data/lib/honeymaker/exchanges/bitvavo.rb

@@ -9,7 +9,7 @@ module Honeymaker
         with_rescue do
           response = connection.get("/v2/markets")
 
-          response.body.map do |product|
+          response.body.filter_map do |product|
             market = product["market"]
             base, quote = market.split("-")
 
@@ -26,7 +26,7 @@ module Honeymaker
               price_decimals: product["pricePrecision"] || 8,
               available: product["status"] == "trading"
             }
-          end.compact
+          end
         end
       end
 

data/lib/honeymaker/exchanges/bybit.rb

@@ -11,7 +11,7 @@ module Honeymaker
             req.params = { category: "spot" }
           end
 
-          response.body["result"]["list"].map do |product|
+          response.body["result"]["list"].filter_map do |product|
             lot_size_filter = product["lotSizeFilter"]
             price_filter = product["priceFilter"]
 
@@ -28,7 +28,7 @@ module Honeymaker
               price_decimals: Utils.decimals(price_filter["tickSize"]),
               available: product["status"] == "Trading"
             }
-          end.compact
+          end
         end
       end
 

data/lib/honeymaker/exchanges/coinbase.rb

@@ -15,15 +15,11 @@ module Honeymaker
         with_rescue do
           response = connection.get("/api/v3/brokerage/market/products")
 
-          response.body["products"].map do |product|
+          response.body["products"].filter_map do |product|
             ticker = product["product_id"]
             base, quote = ticker.split("-")
             next if ASSET_BLACKLIST.include?(base)
 
-            base_increment = product["base_increment"]
-            quote_increment = product["quote_increment"]
-            price_increment = product["price_increment"]
-
             {
               ticker: ticker,
               base: base,
@@ -32,12 +28,12 @@ module Honeymaker
               minimum_quote_size: product["quote_min_size"],
               maximum_base_size: product["base_max_size"],
               maximum_quote_size: product["quote_max_size"],
-              base_decimals: Utils.decimals(base_increment),
-              quote_decimals: Utils.decimals(quote_increment),
-              price_decimals: Utils.decimals(price_increment),
+              base_decimals: Utils.decimals(product["base_increment"]),
+              quote_decimals: Utils.decimals(product["quote_increment"]),
+              price_decimals: Utils.decimals(product["price_increment"]),
               available: true
             }
-          end.compact
+          end
         end
       end
 

data/lib/honeymaker/exchanges/gemini.rb

@@ -10,18 +10,16 @@ module Honeymaker
           symbols_response = connection.get("/v1/symbols")
           symbols = symbols_response.body
 
-          symbols.map do |symbol|
+          symbols.filter_map do |symbol|
             detail = connection.get("/v1/symbols/details/#{symbol}").body
 
-            base = detail["base_currency"].upcase
-            quote = detail["quote_currency"].upcase
             tick_size = detail["tick_size"]&.to_s || "0.01"
             quote_increment = detail["quote_increment"]&.to_s || "0.01"
 
             {
               ticker: symbol.upcase,
-              base: base,
-              quote: quote,
+              base: detail["base_currency"].upcase,
+              quote: detail["quote_currency"].upcase,
               minimum_base_size: detail["min_order_size"],
               minimum_quote_size: "0",
               maximum_base_size: nil,
@@ -31,7 +29,7 @@ module Honeymaker
               price_decimals: Utils.decimals(quote_increment),
               available: detail["status"] == "open"
             }
-          end.compact
+          end
         end
       end
 

data/lib/honeymaker/exchanges/kraken.rb

@@ -35,22 +35,18 @@ module Honeymaker
           error = response.body["error"]
           return Result::Failure.new(*error) if error.is_a?(Array) && error.any?
 
-          response.body["result"].map do |_, info|
-            ticker = info["altname"]
-
+          response.body["result"].filter_map do |_, info|
             wsname = info["wsname"]
             next unless wsname && !wsname.empty?
 
             base, quote = wsname.split("/")
-            minimum_base_size = info["ordermin"]
-            minimum_quote_size = (REAL_COSTMIN[quote] || info["costmin"] || 0).to_s
 
             {
-              ticker: ticker,
+              ticker: info["altname"],
               base: base,
               quote: quote,
-              minimum_base_size: minimum_base_size,
-              minimum_quote_size: minimum_quote_size,
+              minimum_base_size: info["ordermin"],
+              minimum_quote_size: (REAL_COSTMIN[quote] || info["costmin"] || 0).to_s,
               maximum_base_size: nil,
               maximum_quote_size: nil,
               base_decimals: info["lot_decimals"],
@@ -58,7 +54,7 @@ module Honeymaker
               price_decimals: info["pair_decimals"],
               available: true
             }
-          end.compact
+          end
         end
       end
 

data/lib/honeymaker/exchanges/kucoin.rb

@@ -9,7 +9,7 @@ module Honeymaker
         with_rescue do
           response = connection.get("/api/v2/symbols")
 
-          response.body["data"].map do |product|
+          response.body["data"].filter_map do |product|
             {
               ticker: product["symbol"],
               base: product["baseCurrency"],
@@ -23,7 +23,7 @@ module Honeymaker
               price_decimals: Utils.decimals(product["priceIncrement"]),
               available: product["enableTrading"]
             }
-          end.compact
+          end
         end
       end