honeymaker 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 07736f839ae1cb3df2941e94e0170ebcea93e080631a42ce2dbc83ea85c8ca71
+  data.tar.gz: 3574dff97c256b910fa3941ac4968295955ce8ff11997dc2b6f50ddb146aaf45
+SHA512:
+  metadata.gz: 51079a9c330fb03e8bb806d30040b3774ea27244551b6a13443eb20fc3c061b41ac025802b04c2276e7c5412ed85895bb6d49dae310f05edc54a20e2595f447b
+  data.tar.gz: 301512a5685a2f19858b7f60dc99c6f53b584acbfbcf275491f55488eeac534e856eaa3dbbc679dc28d53dbfe331c8327cd834a2f830c478949e29ee421e3741

data/.github/workflows/test.yml

@@ -0,0 +1,18 @@
+name: Test
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: "3.4"
+          bundler-cache: true
+      - run: bundle exec rake test

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Deltabadger
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,37 @@
+# Honeymaker
+
+Ruby clients for cryptocurrency exchange APIs. Originally extracted from [Deltabadger](https://github.com/deltabadger/deltabadger).
+
+## Supported Exchanges
+
+Binance, Binance US, Kraken, Coinbase, Bybit, KuCoin, Bitget, MEXC, Bitvavo, Gemini, Hyperliquid, BingX, Bitrue, BitMart.
+
+## Installation
+
+```ruby
+gem "honeymaker"
+```
+
+## Usage
+
+```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
+```
+
+## License
+
+MIT

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task default: :test

data/lib/honeymaker/exchange.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  class Exchange
+    OPTIONS = {
+      request: {
+        open_timeout: 5,
+        read_timeout: 30,
+        write_timeout: 5
+      }
+    }.freeze
+
+    def get_tickers_info
+      raise NotImplementedError, "#{self.class} must implement #get_tickers_info"
+    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?
+      Result::Failure.new(error_message)
+    rescue StandardError => e
+      msg = e.message
+      Result::Failure.new((msg && !msg.empty?) ? msg : "Unknown error")
+    end
+
+    def build_connection(url, content_type_match: nil)
+      Faraday.new(url: url, **OPTIONS) do |config|
+        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.adapter :net_http_persistent do |http|
+          http.idle_timeout = 100
+        end
+      end
+    end
+  end
+end

data/lib/honeymaker/exchanges/binance.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Exchanges
+    class Binance < Exchange
+      BASE_URL = "https://api.binance.com"
+
+      def get_tickers_info
+        with_rescue do
+          response = connection.get("/api/v3/exchangeInfo") do |req|
+            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"]) }
+
+            {
+              ticker: ticker,
+              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"]),
+              quote_decimals: product["quoteAssetPrecision"],
+              price_decimals: Utils.decimals(price_filter["tickSize"]),
+              available: status == "TRADING"
+            }
+          end.compact
+        end
+      end
+
+      private
+
+      def connection
+        @connection ||= build_connection(self.class::BASE_URL)
+      end
+    end
+  end
+end

data/lib/honeymaker/exchanges/binance_us.rb

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

data/lib/honeymaker/exchanges/bingx.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Exchanges
+    class BingX < Exchange
+      BASE_URL = "https://open-api.bingx.com"
+
+      def get_tickers_info
+        with_rescue do
+          response = connection.get("/openApi/spot/v1/common/symbols")
+
+          response.body["data"]["symbols"].filter_map do |product|
+            ticker = product["symbol"]
+            parts = ticker.split("-")
+            next unless parts.size == 2
+
+            {
+              ticker: ticker,
+              base: parts[0],
+              quote: parts[1],
+              minimum_base_size: product["minQty"]&.to_s,
+              minimum_quote_size: product["minNotional"]&.to_s,
+              maximum_base_size: product["maxQty"]&.to_s,
+              maximum_quote_size: product["maxNotional"]&.to_s,
+              base_decimals: Utils.decimals(product["stepSize"]),
+              quote_decimals: Utils.decimals(product["tickSize"]),
+              price_decimals: Utils.decimals(product["tickSize"]),
+              available: product["status"].to_i == 1
+            }
+          end
+        end
+      end
+
+      private
+
+      def connection
+        @connection ||= build_connection(BASE_URL, content_type_match: //)
+      end
+    end
+  end
+end

data/lib/honeymaker/exchanges/bitget.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Exchanges
+    class Bitget < Exchange
+      BASE_URL = "https://api.bitget.com"
+
+      def get_tickers_info
+        with_rescue do
+          response = connection.get("/api/v2/spot/public/symbols")
+
+          response.body["data"].map do |product|
+            {
+              ticker: product["symbol"],
+              base: product["baseCoin"],
+              quote: product["quoteCoin"],
+              minimum_base_size: product["minTradeAmount"],
+              minimum_quote_size: product["minTradeUSDT"],
+              maximum_base_size: product["maxTradeAmount"],
+              maximum_quote_size: nil,
+              base_decimals: product["quantityPrecision"].to_i,
+              quote_decimals: product["quotePrecision"].to_i,
+              price_decimals: product["pricePrecision"].to_i,
+              available: product["status"] == "online"
+            }
+          end.compact
+        end
+      end
+
+      private
+
+      def connection
+        @connection ||= build_connection(BASE_URL)
+      end
+    end
+  end
+end

data/lib/honeymaker/exchanges/bitmart.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Exchanges
+    class BitMart < Exchange
+      BASE_URL = "https://api-cloud.bitmart.com"
+
+      def get_tickers_info
+        with_rescue do
+          response = connection.get("/spot/v1/symbols/details")
+
+          response.body["data"]["symbols"].filter_map do |product|
+            {
+              ticker: product["symbol"],
+              base: product["base_currency"],
+              quote: product["quote_currency"],
+              minimum_base_size: product["base_min_size"],
+              minimum_quote_size: product["min_buy_amount"],
+              maximum_base_size: nil,
+              maximum_quote_size: nil,
+              base_decimals: Utils.decimals(product["base_min_size"]),
+              quote_decimals: Utils.decimals(product["quote_increment"]),
+              price_decimals: product["price_max_precision"].to_i,
+              available: product["trade_status"] == "trading"
+            }
+          end
+        end
+      end
+
+      private
+
+      def connection
+        @connection ||= build_connection(BASE_URL)
+      end
+    end
+  end
+end

data/lib/honeymaker/exchanges/bitrue.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Exchanges
+    class Bitrue < Exchange
+      BASE_URL = "https://openapi.bitrue.com"
+
+      def get_tickers_info
+        with_rescue do
+          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" }
+
+            {
+              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"),
+              maximum_quote_size: nil,
+              base_decimals: if lot_size_filter
+                               Utils.decimals(lot_size_filter["stepSize"])
+                             else
+                               product["baseAssetPrecision"]
+                             end,
+              quote_decimals: product["quotePrecision"],
+              price_decimals: if price_filter
+                                Utils.decimals(price_filter["tickSize"])
+                              else
+                                product["quotePrecision"]
+                              end,
+              available: product["status"] == "TRADING"
+            }
+          end
+        end
+      end
+
+      private
+
+      def connection
+        @connection ||= build_connection(BASE_URL)
+      end
+    end
+  end
+end

data/lib/honeymaker/exchanges/bitvavo.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Exchanges
+    class Bitvavo < Exchange
+      BASE_URL = "https://api.bitvavo.com"
+
+      def get_tickers_info
+        with_rescue do
+          response = connection.get("/v2/markets")
+
+          response.body.map do |product|
+            market = product["market"]
+            base, quote = market.split("-")
+
+            {
+              ticker: market,
+              base: base,
+              quote: quote,
+              minimum_base_size: product["minOrderInBaseAsset"],
+              minimum_quote_size: product["minOrderInQuoteAsset"],
+              maximum_base_size: nil,
+              maximum_quote_size: nil,
+              base_decimals: product["pricePrecision"] || 8,
+              quote_decimals: product["pricePrecision"] || 8,
+              price_decimals: product["pricePrecision"] || 8,
+              available: product["status"] == "trading"
+            }
+          end.compact
+        end
+      end
+
+      private
+
+      def connection
+        @connection ||= build_connection(BASE_URL)
+      end
+    end
+  end
+end

data/lib/honeymaker/exchanges/bybit.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Exchanges
+    class Bybit < Exchange
+      BASE_URL = "https://api.bybit.com"
+
+      def get_tickers_info
+        with_rescue do
+          response = connection.get("/v5/market/instruments-info") do |req|
+            req.params = { category: "spot" }
+          end
+
+          response.body["result"]["list"].map do |product|
+            lot_size_filter = product["lotSizeFilter"]
+            price_filter = product["priceFilter"]
+
+            {
+              ticker: product["symbol"],
+              base: product["baseCoin"],
+              quote: product["quoteCoin"],
+              minimum_base_size: lot_size_filter["minOrderQty"],
+              minimum_quote_size: lot_size_filter["minOrderAmt"],
+              maximum_base_size: lot_size_filter["maxOrderQty"],
+              maximum_quote_size: lot_size_filter["maxOrderAmt"],
+              base_decimals: Utils.decimals(lot_size_filter["basePrecision"]),
+              quote_decimals: Utils.decimals(lot_size_filter["quotePrecision"]),
+              price_decimals: Utils.decimals(price_filter["tickSize"]),
+              available: product["status"] == "Trading"
+            }
+          end.compact
+        end
+      end
+
+      private
+
+      def connection
+        @connection ||= build_connection(BASE_URL)
+      end
+    end
+  end
+end

data/lib/honeymaker/exchanges/coinbase.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Exchanges
+    class Coinbase < Exchange
+      BASE_URL = "https://api.coinbase.com"
+
+      ASSET_BLACKLIST = [
+        "RENDER",    # has the same external_id as RNDR
+        "ZETACHAIN", # has the same external_id as ZETA
+        "WAXL"       # has the same external_id as AXL
+      ].freeze
+
+      def get_tickers_info
+        with_rescue do
+          response = connection.get("/api/v3/brokerage/market/products")
+
+          response.body["products"].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,
+              quote: quote,
+              minimum_base_size: product["base_min_size"],
+              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),
+              available: true
+            }
+          end.compact
+        end
+      end
+
+      private
+
+      def connection
+        @connection ||= build_connection(BASE_URL)
+      end
+    end
+  end
+end

data/lib/honeymaker/exchanges/gemini.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Exchanges
+    class Gemini < Exchange
+      BASE_URL = "https://api.gemini.com"
+
+      def get_tickers_info
+        with_rescue do
+          symbols_response = connection.get("/v1/symbols")
+          symbols = symbols_response.body
+
+          symbols.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,
+              minimum_base_size: detail["min_order_size"],
+              minimum_quote_size: "0",
+              maximum_base_size: nil,
+              maximum_quote_size: nil,
+              base_decimals: Utils.decimals(tick_size),
+              quote_decimals: Utils.decimals(quote_increment),
+              price_decimals: Utils.decimals(quote_increment),
+              available: detail["status"] == "open"
+            }
+          end.compact
+        end
+      end
+
+      private
+
+      def connection
+        @connection ||= build_connection(BASE_URL)
+      end
+    end
+  end
+end

data/lib/honeymaker/exchanges/hyperliquid.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Exchanges
+    class Hyperliquid < Exchange
+      BASE_URL = "https://api.hyperliquid.xyz"
+
+      def get_tickers_info
+        with_rescue do
+          response = connection.post("/info") do |req|
+            req.body = { type: "spotMeta" }.to_json
+          end
+
+          tokens = response.body["tokens"]
+          universe = response.body["universe"]
+          token_map = tokens.each_with_object({}) { |t, h| h[t["index"]] = t }
+
+          universe.filter_map do |pair|
+            base_token = token_map[pair["tokens"][0]]
+            quote_token = token_map[pair["tokens"][1]]
+            next unless base_token && quote_token
+
+            {
+              ticker: pair["name"],
+              base: base_token["name"],
+              quote: quote_token["name"],
+              minimum_base_size: nil,
+              minimum_quote_size: nil,
+              maximum_base_size: nil,
+              maximum_quote_size: nil,
+              base_decimals: base_token["szDecimals"] || 0,
+              quote_decimals: 2,
+              price_decimals: 5,
+              available: true
+            }
+          end
+        end
+      end
+
+      private
+
+      def connection
+        @connection ||= build_connection(BASE_URL)
+      end
+    end
+  end
+end

data/lib/honeymaker/exchanges/kraken.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Exchanges
+    class Kraken < Exchange
+      BASE_URL = "https://api.kraken.com"
+
+      ASSET_BLACKLIST = [
+        "COPM" # has the same external_id (ecomi) as OMI
+      ].freeze
+
+      REAL_COSTMIN = {
+        "AUD" => 10,
+        "CAD" => 5,
+        "CHF" => 5,
+        "DAI" => 5,
+        "ETH" => 0.002,
+        "EUR" => 0.5,
+        "GBP" => 5,
+        "JPY" => 500,
+        "PYUSD" => 5,
+        "RLUSD" => 5,
+        "USD" => 5,
+        "USDC" => 5,
+        "USDQ" => 5,
+        "USDR" => 5,
+        "USDT" => 5,
+        "XBT" => 0.00005
+      }.freeze
+
+      def get_tickers_info
+        with_rescue do
+          response = connection.get("/0/public/AssetPairs")
+
+          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"]
+
+            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,
+              base: base,
+              quote: quote,
+              minimum_base_size: minimum_base_size,
+              minimum_quote_size: minimum_quote_size,
+              maximum_base_size: nil,
+              maximum_quote_size: nil,
+              base_decimals: info["lot_decimals"],
+              quote_decimals: info["cost_decimals"],
+              price_decimals: info["pair_decimals"],
+              available: true
+            }
+          end.compact
+        end
+      end
+
+      private
+
+      def connection
+        @connection ||= build_connection(BASE_URL)
+      end
+    end
+  end
+end

data/lib/honeymaker/exchanges/kucoin.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Exchanges
+    class Kucoin < Exchange
+      BASE_URL = "https://api.kucoin.com"
+
+      def get_tickers_info
+        with_rescue do
+          response = connection.get("/api/v2/symbols")
+
+          response.body["data"].map do |product|
+            {
+              ticker: product["symbol"],
+              base: product["baseCurrency"],
+              quote: product["quoteCurrency"],
+              minimum_base_size: product["baseMinSize"],
+              minimum_quote_size: product["quoteMinSize"],
+              maximum_base_size: product["baseMaxSize"],
+              maximum_quote_size: product["quoteMaxSize"],
+              base_decimals: Utils.decimals(product["baseIncrement"]),
+              quote_decimals: Utils.decimals(product["quoteIncrement"]),
+              price_decimals: Utils.decimals(product["priceIncrement"]),
+              available: product["enableTrading"]
+            }
+          end.compact
+        end
+      end
+
+      private
+
+      def connection
+        @connection ||= build_connection(BASE_URL)
+      end
+    end
+  end
+end

data/lib/honeymaker/exchanges/mexc.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Exchanges
+    class Mexc < Exchange
+      BASE_URL = "https://api.mexc.com"
+
+      def get_tickers_info
+        with_rescue do
+          response = connection.get("/api/v3/exchangeInfo")
+
+          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"]) }
+
+            {
+              ticker: ticker,
+              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: lot_size_filter ? Utils.decimals(lot_size_filter["stepSize"]) : product["baseAssetPrecision"],
+              quote_decimals: product["quoteAssetPrecision"],
+              price_decimals: price_filter ? Utils.decimals(price_filter["tickSize"]) : product["quotePrecision"],
+              available: status == "TRADING"
+            }
+          end.compact
+        end
+      end
+
+      private
+
+      def connection
+        @connection ||= build_connection(BASE_URL)
+      end
+    end
+  end
+end

data/lib/honeymaker/result.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  class Result
+    attr_reader :data, :errors
+
+    def initialize(data:, errors:)
+      @data = data
+      @errors = errors
+    end
+
+    def success?
+      errors.empty?
+    end
+
+    def failure?
+      !success?
+    end
+
+    class Success < Result
+      def initialize(data = nil)
+        @data = data
+        @errors = []
+      end
+    end
+
+    class Failure < Result
+      def initialize(*errors, **kwargs)
+        @data = kwargs[:data]
+        @errors = errors.empty? ? ["Error"] : errors
+      end
+    end
+  end
+end

data/lib/honeymaker/utils.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Utils
+    def self.decimals(num)
+      str = num.to_s.sub(/\.?0+$/, "")
+      return 0 unless str.include?(".")
+      str.split(".").last.length
+    end
+  end
+end

data/lib/honeymaker/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  VERSION = "0.1.0"
+end

data/lib/honeymaker.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "faraday/net_http_persistent"
+require "json"
+
+require_relative "honeymaker/version"
+require_relative "honeymaker/result"
+require_relative "honeymaker/utils"
+require_relative "honeymaker/exchange"
+require_relative "honeymaker/exchanges/binance"
+require_relative "honeymaker/exchanges/binance_us"
+require_relative "honeymaker/exchanges/kraken"
+require_relative "honeymaker/exchanges/coinbase"
+require_relative "honeymaker/exchanges/mexc"
+require_relative "honeymaker/exchanges/gemini"
+require_relative "honeymaker/exchanges/bitvavo"
+require_relative "honeymaker/exchanges/bitget"
+require_relative "honeymaker/exchanges/bybit"
+require_relative "honeymaker/exchanges/kucoin"
+require_relative "honeymaker/exchanges/hyperliquid"
+require_relative "honeymaker/exchanges/bingx"
+require_relative "honeymaker/exchanges/bitrue"
+require_relative "honeymaker/exchanges/bitmart"
+
+module Honeymaker
+  class Error < StandardError; end
+
+  EXCHANGES = {
+    "binance" => Exchanges::Binance,
+    "binance_us" => Exchanges::BinanceUs,
+    "kraken" => Exchanges::Kraken,
+    "coinbase" => Exchanges::Coinbase,
+    "mexc" => Exchanges::Mexc,
+    "gemini" => Exchanges::Gemini,
+    "bitvavo" => Exchanges::Bitvavo,
+    "bitget" => Exchanges::Bitget,
+    "bybit" => Exchanges::Bybit,
+    "kucoin" => Exchanges::Kucoin,
+    "hyperliquid" => Exchanges::Hyperliquid,
+    "bingx" => Exchanges::BingX,
+    "bitrue" => Exchanges::Bitrue,
+    "bitmart" => Exchanges::BitMart
+  }.freeze
+
+  def self.exchange(name)
+    klass = EXCHANGES[name.to_s]
+    raise Error, "Unknown exchange: #{name}" unless klass
+    klass.new
+  end
+end

data/sig/honeymaker.rbs

@@ -0,0 +1,4 @@
+module Honeymaker
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

data/test/fixtures/binance_exchange_info.json

@@ -0,0 +1,30 @@
+{
+  "symbols": [
+    {
+      "symbol": "BTCUSDT",
+      "status": "TRADING",
+      "baseAsset": "BTC",
+      "quoteAsset": "USDT",
+      "quoteAssetPrecision": 8,
+      "filters": [
+        {
+          "filterType": "PRICE_FILTER",
+          "minPrice": "0.01",
+          "maxPrice": "1000000.00",
+          "tickSize": "0.01"
+        },
+        {
+          "filterType": "LOT_SIZE",
+          "minQty": "0.00000100",
+          "maxQty": "9000.00000000",
+          "stepSize": "0.000001"
+        },
+        {
+          "filterType": "NOTIONAL",
+          "minNotional": "5.00000000",
+          "maxNotional": "9000000.00000000"
+        }
+      ]
+    }
+  ]
+}

data/test/fixtures/kraken_asset_pairs.json

@@ -0,0 +1,16 @@
+{
+  "error": [],
+  "result": {
+    "XBTUSDT": {
+      "altname": "XBTUSDT",
+      "wsname": "XBT/USDT",
+      "base": "XXBT",
+      "quote": "USDT",
+      "lot_decimals": 8,
+      "cost_decimals": 5,
+      "pair_decimals": 1,
+      "ordermin": "0.00010000",
+      "costmin": "0.50000"
+    }
+  }
+}

data/test/honeymaker/exchange_test.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::ExchangeTest < Minitest::Test
+  def test_get_tickers_info_raises_not_implemented
+    exchange = Honeymaker::Exchange.new
+    assert_raises(NotImplementedError) { exchange.get_tickers_info }
+  end
+
+  def test_with_rescue_wraps_faraday_errors
+    exchange = Honeymaker::Exchange.new
+    result = exchange.send(:with_rescue) { raise Faraday::TimeoutError, "timeout" }
+    assert result.failure?
+    assert_match(/timeout/, result.errors.first)
+  end
+
+  def test_with_rescue_wraps_standard_errors
+    exchange = Honeymaker::Exchange.new
+    result = exchange.send(:with_rescue) { raise StandardError, "boom" }
+    assert result.failure?
+    assert_equal ["boom"], result.errors
+  end
+
+  def test_with_rescue_returns_success_on_no_error
+    exchange = Honeymaker::Exchange.new
+    result = exchange.send(:with_rescue) { [1, 2, 3] }
+    assert result.success?
+    assert_equal [1, 2, 3], result.data
+  end
+end

data/test/honeymaker/exchanges/binance_test.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::Exchanges::BinanceTest < Minitest::Test
+  include FixtureHelper
+
+  def setup
+    @exchange = Honeymaker::Exchanges::Binance.new
+  end
+
+  def test_get_tickers_info_parses_response
+    body = load_fixture("binance_exchange_info.json")
+    stub_connection(body)
+
+    result = @exchange.get_tickers_info
+
+    assert result.success?
+    ticker = result.data.first
+    assert_equal "BTCUSDT", ticker[:ticker]
+    assert_equal "BTC", ticker[:base]
+    assert_equal "USDT", ticker[:quote]
+    assert_equal "0.00000100", ticker[:minimum_base_size]
+    assert_equal "5.00000000", ticker[:minimum_quote_size]
+    assert_equal 6, ticker[:base_decimals]
+    assert_equal 8, ticker[:quote_decimals]
+    assert_equal 2, ticker[:price_decimals]
+    assert ticker[:available]
+  end
+
+  def test_get_tickers_info_handles_api_error
+    connection = stub
+    connection.stubs(:get).raises(Faraday::ServerError.new("500", { status: 500, body: "Internal Server Error" }))
+    @exchange.instance_variable_set(:@connection, connection)
+
+    result = @exchange.get_tickers_info
+
+    assert result.failure?
+  end
+
+  private
+
+  def stub_connection(body)
+    response = stub(body: body)
+    connection = stub
+    connection.stubs(:get).with { |path, &block| block&.call(OpenStruct.new(params: {})); true }.returns(response)
+    @exchange.instance_variable_set(:@connection, connection)
+  end
+end

data/test/honeymaker/exchanges/kraken_test.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::Exchanges::KrakenTest < Minitest::Test
+  include FixtureHelper
+
+  def setup
+    @exchange = Honeymaker::Exchanges::Kraken.new
+  end
+
+  def test_get_tickers_info_parses_response
+    body = load_fixture("kraken_asset_pairs.json")
+    stub_request(body)
+
+    result = @exchange.get_tickers_info
+
+    assert result.success?
+    ticker = result.data.first
+    assert_equal "XBTUSDT", ticker[:ticker]
+    assert_equal "XBT", ticker[:base]
+    assert_equal "USDT", ticker[:quote]
+    assert_equal "0.00010000", ticker[:minimum_base_size]
+    assert_equal "5", ticker[:minimum_quote_size]
+    assert_equal 8, ticker[:base_decimals]
+    assert_equal 5, ticker[:quote_decimals]
+    assert_equal 1, ticker[:price_decimals]
+    assert ticker[:available]
+  end
+
+  def test_get_tickers_info_skips_pairs_without_wsname
+    body = load_fixture("kraken_asset_pairs.json")
+    body["result"]["XBTUSDT"]["wsname"] = nil
+    stub_request(body)
+
+    result = @exchange.get_tickers_info
+
+    assert result.success?
+    assert_empty result.data
+  end
+
+  def test_get_tickers_info_uses_real_costmin
+    body = load_fixture("kraken_asset_pairs.json")
+    stub_request(body)
+
+    result = @exchange.get_tickers_info
+
+    ticker = result.data.first
+    # USDT is in REAL_COSTMIN with value 5
+    assert_equal "5", ticker[:minimum_quote_size]
+  end
+
+  def test_get_tickers_info_handles_api_error
+    body = { "error" => ["EGeneral:Internal error"], "result" => {} }
+    stub_request(body)
+
+    result = @exchange.get_tickers_info
+
+    assert result.failure?
+    assert_includes result.errors, "EGeneral:Internal error"
+  end
+
+  private
+
+  def stub_request(body)
+    response = stub(body: body)
+    connection = stub
+    connection.stubs(:get).returns(response)
+    @exchange.instance_variable_set(:@connection, connection)
+  end
+end

data/test/honeymaker/honeymaker_test.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class HoneymakerTest < Minitest::Test
+  def test_version
+    refute_nil Honeymaker::VERSION
+  end
+
+  def test_exchange_returns_correct_class
+    exchange = Honeymaker.exchange("binance")
+    assert_instance_of Honeymaker::Exchanges::Binance, exchange
+  end
+
+  def test_exchange_with_symbol
+    exchange = Honeymaker.exchange(:kraken)
+    assert_instance_of Honeymaker::Exchanges::Kraken, exchange
+  end
+
+  def test_exchange_raises_for_unknown
+    assert_raises(Honeymaker::Error) { Honeymaker.exchange("unknown") }
+  end
+
+  def test_all_exchanges_registered
+    assert_equal 14, Honeymaker::EXCHANGES.size
+  end
+end

data/test/honeymaker/result_test.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::ResultTest < Minitest::Test
+  def test_success_is_successful
+    result = Honeymaker::Result::Success.new("data")
+    assert result.success?
+    refute result.failure?
+    assert_equal "data", result.data
+    assert_empty result.errors
+  end
+
+  def test_success_with_nil_data
+    result = Honeymaker::Result::Success.new
+    assert result.success?
+    assert_nil result.data
+  end
+
+  def test_failure_is_not_successful
+    result = Honeymaker::Result::Failure.new("something went wrong")
+    refute result.success?
+    assert result.failure?
+    assert_equal ["something went wrong"], result.errors
+  end
+
+  def test_failure_with_multiple_errors
+    result = Honeymaker::Result::Failure.new("error1", "error2")
+    assert_equal ["error1", "error2"], result.errors
+  end
+
+  def test_failure_with_default_error
+    result = Honeymaker::Result::Failure.new
+    assert_equal ["Error"], result.errors
+  end
+
+  def test_failure_with_data
+    result = Honeymaker::Result::Failure.new("err", data: { partial: true })
+    assert_equal({ partial: true }, result.data)
+    assert_equal ["err"], result.errors
+  end
+end

data/test/honeymaker/utils_test.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::UtilsTest < Minitest::Test
+  def test_decimals_with_string
+    assert_equal 2, Honeymaker::Utils.decimals("0.01")
+    assert_equal 8, Honeymaker::Utils.decimals("0.00000001")
+    assert_equal 1, Honeymaker::Utils.decimals("0.10000000")
+  end
+
+  def test_decimals_with_integer
+    assert_equal 0, Honeymaker::Utils.decimals(1)
+    assert_equal 0, Honeymaker::Utils.decimals(100)
+  end
+
+  def test_decimals_with_float
+    assert_equal 2, Honeymaker::Utils.decimals(0.01)
+    assert_equal 1, Honeymaker::Utils.decimals(0.1)
+  end
+
+  def test_decimals_with_no_decimals
+    assert_equal 0, Honeymaker::Utils.decimals("1")
+    assert_equal 0, Honeymaker::Utils.decimals("10")
+  end
+end

data/test/support/fixture_helper.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "json"
+
+module FixtureHelper
+  def fixture_path(name)
+    File.join(File.dirname(__FILE__), "..", "fixtures", name)
+  end
+
+  def load_fixture(name)
+    JSON.parse(File.read(fixture_path(name)))
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "mocha/minitest"
+require "honeymaker"
+
+# Load fixture helpers
+require_relative "support/fixture_helper"

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: honeymaker
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Deltabadger
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: faraday-net_http_persistent
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: net-http-persistent
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+description: Unified interface for fetching market data from cryptocurrency exchanges.
+  Supports Binance, Kraken, Coinbase, Bybit, KuCoin, Bitget, MEXC, and more.
+email:
+- hello@deltabadger.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/test.yml"
+- LICENSE
+- README.md
+- Rakefile
+- lib/honeymaker.rb
+- lib/honeymaker/exchange.rb
+- lib/honeymaker/exchanges/binance.rb
+- lib/honeymaker/exchanges/binance_us.rb
+- lib/honeymaker/exchanges/bingx.rb
+- lib/honeymaker/exchanges/bitget.rb
+- lib/honeymaker/exchanges/bitmart.rb
+- lib/honeymaker/exchanges/bitrue.rb
+- lib/honeymaker/exchanges/bitvavo.rb
+- lib/honeymaker/exchanges/bybit.rb
+- lib/honeymaker/exchanges/coinbase.rb
+- lib/honeymaker/exchanges/gemini.rb
+- lib/honeymaker/exchanges/hyperliquid.rb
+- lib/honeymaker/exchanges/kraken.rb
+- lib/honeymaker/exchanges/kucoin.rb
+- lib/honeymaker/exchanges/mexc.rb
+- lib/honeymaker/result.rb
+- lib/honeymaker/utils.rb
+- lib/honeymaker/version.rb
+- sig/honeymaker.rbs
+- test/fixtures/binance_exchange_info.json
+- test/fixtures/kraken_asset_pairs.json
+- test/honeymaker/exchange_test.rb
+- test/honeymaker/exchanges/binance_test.rb
+- test/honeymaker/exchanges/kraken_test.rb
+- test/honeymaker/honeymaker_test.rb
+- test/honeymaker/result_test.rb
+- test/honeymaker/utils_test.rb
+- test/support/fixture_helper.rb
+- test/test_helper.rb
+homepage: https://github.com/deltabadger/honeymaker
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/deltabadger/honeymaker
+  source_code_uri: https://github.com/deltabadger/honeymaker
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: Ruby clients for cryptocurrency exchange APIs
+test_files: []