honeymaker 0.12.4-aarch64-linux

data/lib/honeymaker/exchanges/kraken.rb

@@ -0,0 +1,122 @@
+# 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
+
+      # Patterns are unanchored (except regional_restriction) because the consumer may
+      # pass a sentence-joined error string. transient_nonce is matched first as it is
+      # the more specific/actionable case.
+      ERROR_PATTERNS = [
+        {
+          code: :regional_restriction,
+          pattern: /\AEAccount:Invalid permissions:(?<asset>\S+) trading restricted for (?<country>\w+)\.?\z/
+        },
+        {
+          code: :transient_nonce,
+          pattern: /EAPI:Invalid nonce/
+        },
+        {
+          code: :transient_unavailable,
+          pattern: /EGeneral:Internal error|EService:(?:Unavailable|Busy|Deadline elapsed)/
+        }
+      ].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
+          # aclass_base=all, not a bare call: the default response carries only the "currency" class,
+          # so Kraken tokenized equities (xStocks) are invisible without it. One request returns both
+          # classes and they are disjoint.
+          response = connection.get("/0/public/AssetPairs", { aclass_base: "all" })
+
+          error = response.body["error"]
+          return Result::Failure.new(*error) if error.is_a?(Array) && error.any?
+
+          # Every tokenized pair is returned TWICE - once under an SPV key (NVDASPVUSD), once under
+          # the x key (NVDAxUSD) - sharing one wsname and altname. Currency pairs are never
+          # duplicated, so keying by wsname collapses exactly the aliases and nothing else.
+          deduped = response.body["result"].each_with_object({}) do |(_, info), acc|
+            wsname = info["wsname"]
+            next if wsname.nil? || wsname.empty?
+
+            acc[wsname] ||= info
+          end
+
+          deduped.filter_map do |wsname, info|
+            base, quote = wsname.split("/")
+
+            {
+              ticker: info["altname"],
+              base: base,
+              quote: quote,
+              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"],
+              quote_decimals: info["cost_decimals"],
+              price_decimals: info["pair_decimals"],
+              available: true,
+              # Tokenized equities are listed but never tradable through this client: AddOrder needs
+              # an asset_class parameter it does not send, and Kraken closes the tokenized order
+              # books to EEA clients over the API regardless of that. Listing them anyway is what
+              # lets a holding be resolved and valued.
+              trading_enabled: if info["aclass_base"] == "tokenized_asset"
+                                 false
+                               else
+                                 info.key?("status") ? info["status"] == "online" : true
+                               end
+            }
+          end
+        end
+      end
+
+      def get_bid_ask(symbol)
+        with_rescue do
+          response = connection.get("/0/public/Ticker") do |req|
+            req.params = { pair: symbol }
+          end
+
+          error = response.body["error"]
+          raise StandardError, error.first if error.is_a?(Array) && error.any?
+
+          _key, data = response.body["result"].first
+          {
+            bid: BigDecimal(data["b"][0]),
+            ask: BigDecimal(data["a"][0])
+          }
+        end
+      end
+
+      private
+
+      def connection
+        @connection ||= build_connection(BASE_URL)
+      end
+    end
+  end
+end

data/lib/honeymaker/exchanges/kucoin.rb

@@ -0,0 +1,52 @@
+# 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"].filter_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: true,
+              trading_enabled: product["enableTrading"]
+            }
+          end
+        end
+      end
+
+      def get_bid_ask(symbol)
+        with_rescue do
+          response = connection.get("/api/v1/market/orderbook/level1") do |req|
+            req.params = { symbol: symbol }
+          end
+
+          data = response.body["data"]
+          {
+            bid: BigDecimal(data["bestBid"]),
+            ask: BigDecimal(data["bestAsk"])
+          }
+        end
+      end
+
+      private
+
+      def connection
+        @connection ||= build_connection(BASE_URL)
+      end
+    end
+  end
+end

data/lib/honeymaker/exchanges/mexc.rb

@@ -0,0 +1,56 @@
+# 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"].filter_map do |product|
+            f = Utils.parse_filters(product["filters"])
+
+            {
+              ticker: product["symbol"],
+              base: product["baseAsset"],
+              quote: product["quoteAsset"],
+              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: f[:lot_size] ? Utils.decimals(f[:lot_size]["stepSize"]) : product["baseAssetPrecision"],
+              quote_decimals: product["quoteAssetPrecision"],
+              price_decimals: f[:price] ? Utils.decimals(f[:price]["tickSize"]) : product["quotePrecision"],
+              available: true,
+              # MEXC encodes status as "1", not Binance's "TRADING" — every symbol it returns is "1".
+              # isSpotTradingAllowed is the real gate: ~5% of listed symbols reject a spot order.
+              # `!= false` keeps the fail-open default if the key is ever absent, matching the siblings.
+              trading_enabled: product["status"] == "1" && product["isSpotTradingAllowed"] != false
+            }
+          end
+        end
+      end
+
+      def get_bid_ask(symbol)
+        with_rescue do
+          response = connection.get("/api/v3/ticker/bookTicker") do |req|
+            req.params = { symbol: symbol }
+          end
+
+          {
+            bid: BigDecimal(response.body["bidPrice"]),
+            ask: BigDecimal(response.body["askPrice"])
+          }
+        end
+      end
+
+      private
+
+      def connection
+        @connection ||= build_connection(BASE_URL)
+      end
+    end
+  end
+end

data/lib/honeymaker/native/kraken.rb

@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Honeymaker
+  module Native
+    # Kraken on the Rust core. Signatures and argument expressions are copied from Clients::Kraken
+    # (a test compares signatures). Transport, body encoding and Results are the inherited,
+    # unchanged Ruby: connection + URI.encode_www_form + with_rescue. Rust lays out and signs the
+    # requests and normalizes the answers.
+    class KrakenClient < Honeymaker::Client
+      URL = "https://api.kraken.com"
+      RATE_LIMITS = { default: 1000, orders: 1000 }.freeze
+      UNREADABLE = "Kraken: unreadable response"
+
+      def self.reset_nonce_state!
+        Native.load!
+        Ext::Kraken.reset_nonce_state!
+      end
+
+      def query_orders_info(txid:, trades: nil, userref: nil, consolidate_taker: true)
+        result = post_private("query_orders_info", trades: trades, userref: userref, txid: txid, consolidate_taker: consolidate_taker)
+        finish("query_orders_info", result) do |orders|
+          (result.data["result"] || {}).each { |id, raw| orders[id][:raw] = raw }
+          orders
+        end
+      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)
+        result = post_private("add_order",
+                              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: close,
+                              close_price: close_price, close_price2: close_price2, deadline: deadline, validate: validate)
+        finish("add_order", result) { |order_id| { order_id: order_id, raw: result.data } }
+      end
+
+      def cancel_order(txid: nil, cl_ord_id: nil)
+        post_private("cancel_order", txid: txid, cl_ord_id: cl_ord_id)
+      end
+
+      def get_tradable_asset_pairs(pairs: nil, info: nil, country_code: nil, aclass_base: nil)
+        get_public("get_tradable_asset_pairs", pairs: pairs ? pairs.join(",") : nil, info: info,
+                                               country_code: country_code, aclass_base: aclass_base)
+      end
+
+      def get_asset_info(assets: nil, aclass: nil)
+        get_public("get_asset_info", assets: assets ? assets.join(",") : nil, aclass: aclass)
+      end
+
+      def get_ticker_information(pair: nil)
+        get_public("get_ticker_information", pair: pair)
+      end
+
+      def get_extended_balance
+        post_private("get_extended_balance")
+      end
+
+      def get_api_key_info
+        post_private("get_api_key_info")
+      end
+
+      def get_balances
+        finish("balances", get_extended_balance) { |balances| balances }
+      end
+
+      def get_ohlc_data(pair:, interval: nil, since: nil)
+        get_public("get_ohlc_data", pair: pair, interval: interval, since: since)
+      end
+
+      def get_trades_history(type: nil, trades: nil, start: nil, end_time: nil, ofs: nil)
+        post_private("get_trades_history", type: type, trades: trades, start: start, end_time: end_time, ofs: ofs)
+      end
+
+      def get_ledgers(asset: nil, type: nil, start: nil, end_time: nil, ofs: nil)
+        post_private("get_ledgers", asset: asset, type: type, start: start, end_time: end_time, ofs: ofs)
+      end
+
+      # The paging loop stays Ruby (verbatim legacy) so dig/to_i/include? keep Ruby's
+      # coercions; Rust aggregates. A Rust pager comes with stage 2, when Rust callers need one.
+      def closed_orders_from_trades(order_ids:, start: nil, max_pages: 20)
+        wanted = Array(order_ids)
+        return Result::Success.new({}) if wanted.empty?
+
+        by_order = Hash.new { |h, k| h[k] = [] }
+        seen = {}
+        offset = 0
+        pages = 0
+        loop do
+          result = get_trades_history(start: start, ofs: offset)
+          return result if result.failure?
+          return unreadable unless result.data.is_a?(Hash)
+
+          errors = result.data["error"]
+          return Result::Failure.new(*errors) if errors.is_a?(Array) && errors.any?
+
+          trades = result.data.dig("result", "trades") || {}
+          break if trades.empty?
+
+          trades.each_pair do |trade_id, t|
+            # Offset paging over a list that grows at the top can serve a trade twice: count it once.
+            next if seen.key?(trade_id)
+
+            seen[trade_id] = true
+            otxid = t["ordertxid"]
+            by_order[otxid] << t if wanted.include?(otxid)
+          end
+
+          # Do NOT early-exit when each id has been *seen* — a partial fill can have trades on
+          # later pages. Page the whole [start, now] window (bounded by `start` + max_pages).
+          pages += 1
+          offset += trades.size
+          count = result.data.dig("result", "count").to_i
+          break if offset >= count || pages >= max_pages
+        end
+
+        Native.load!
+        Result::Success.new(Ext::Kraken.aggregate_trades(by_order))
+      end
+
+      def get_withdraw_addresses(asset: nil, method: nil)
+        post_private("get_withdraw_addresses", asset: asset, method: method)
+      end
+
+      def get_withdraw_methods(asset: nil)
+        post_private("get_withdraw_methods", asset: asset)
+      end
+
+      def withdraw(asset:, key:, amount:, address: nil)
+        post_private("withdraw", asset: asset, key: key, amount: amount, address: address)
+      end
+
+      def get_earn_allocations(ascending: nil, converted_asset: nil, hide_zero_allocations: nil)
+        post_private("get_earn_allocations", ascending: ascending, converted_asset: converted_asset,
+                                             hide_zero_allocations: hide_zero_allocations)
+      end
+
+      private
+
+      def validate_trading_credentials
+        result = get_extended_balance
+        return Result::Failure.new("Invalid trading credentials") if result.failure?
+
+        errors = result.data["error"]
+        if errors.is_a?(Array) && errors.none?
+          Result::Success.new(true)
+        else
+          Result::Failure.new("Invalid trading credentials")
+        end
+      end
+
+      def validate_read_credentials
+        validate_trading_credentials
+      end
+
+      def native
+        @native ||= begin
+          Native.load!
+          Ext::Kraken.new(@api_key, @api_secret)
+        end
+      end
+
+      # The legacy post_private: Rust lays out the pairs (nonce first) and signs; Ruby encodes.
+      def post_private(op, params = {})
+        with_rescue do
+          path, pairs = native.build_post(op, params.transform_keys(&:to_s))
+          response = connection.post do |req|
+            req.url path
+            req.body = URI.encode_www_form(pairs)
+            req.headers = native.sign(req.path, req.body)
+          end
+          response.body
+        end
+      end
+
+      # The legacy get_public: Rust lays out the params; Faraday encodes them.
+      def get_public(op, params = {})
+        with_rescue do
+          path, query, headers = native.build_get(op, params.transform_keys(&:to_s))
+          response = connection.get do |req|
+            req.url path
+            req.headers = headers
+            req.params = query
+          end
+          response.body
+        end
+      end
+
+      def finish(op, result)
+        return result if result.failure?
+        # Guard in Ruby, before any conversion: a binary maintenance page must answer like the
+        # hardened legacy, not fail inside the converter.
+        return unreadable unless result.data.is_a?(Hash)
+
+        verdict = native.finish(op, result.data)
+        case verdict[0]
+        when "ok" then Result::Success.new(yield(verdict[1]))
+        when "venue" then Result::Failure.new(*result.data["error"])
+        when "unreadable" then unreadable
+        else raise ShapeError, "unexpected verdict #{verdict[0].inspect}"
+        end
+      end
+
+      def unreadable
+        Result::Failure.new(UNREADABLE, data: { unreadable: true })
+      end
+    end
+
+    class KrakenExchange < Honeymaker::Exchange
+      BASE_URL = "https://api.kraken.com"
+
+      def classify_error(message)
+        return nil if message.nil?
+
+        Native.load!
+        Ext::Kraken.classify_error(message)
+      end
+
+      def get_tickers_info
+        with_rescue do
+          response = connection.get("/0/public/AssetPairs", { aclass_base: "all" })
+          raise ShapeError, "Kraken: catalogue body is not an object" unless response.body.is_a?(Hash)
+
+          verdict = native.finish("tickers_info", response.body)
+          return Result::Failure.new(*response.body["error"]) if verdict[0] == "venue"
+
+          verdict[1].each { |t| t[:minimum_quote_size] = t[:minimum_quote_size].to_s }
+        end
+      end
+
+      def get_bid_ask(symbol)
+        with_rescue do
+          response = connection.get("/0/public/Ticker") { |req| req.params = { pair: symbol } }
+          raise ShapeError, "Kraken: ticker body is not an object" unless response.body.is_a?(Hash)
+
+          verdict = native.finish("bid_ask", response.body)
+          raise StandardError, response.body["error"].first if verdict[0] == "venue"
+
+          verdict[1]
+        end
+      end
+
+      private
+
+      def native
+        @native ||= begin
+          Native.load!
+          Ext::Kraken.new(nil, nil)
+        end
+      end
+
+      def connection
+        @connection ||= build_connection(BASE_URL)
+      end
+    end
+  end
+end

data/lib/honeymaker/native.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  # Rust-backed venue logic. A process picks its backend per exchange once, when honeymaker is
+  # required: HONEYMAKER_NATIVE=kraken. With the flag off the extension is never loaded.
+  module Native
+    # A venue payload whose shape legacy would have tripped over with an incidental NoMethodError
+    # or TypeError. Still a StandardError, which is all consumers rescue.
+    class ShapeError < StandardError; end
+
+    SUPPORTED = %w[kraken].freeze
+
+    class << self
+      def enabled
+        @enabled ||= begin
+          names = ENV.fetch("HONEYMAKER_NATIVE", "").split(",").map { |name| name.strip.downcase }.reject(&:empty?).uniq
+          unsupported = names - SUPPORTED
+          unless unsupported.empty?
+            raise ArgumentError, "Unsupported HONEYMAKER_NATIVE names: #{unsupported.join(', ')}; supported names: #{SUPPORTED.join(', ')}"
+          end
+          names.freeze
+        end
+      end
+
+      def enabled?(name)
+        name = name.to_s.strip.downcase
+        names = enabled
+        SUPPORTED.include?(name) && names.include?(name)
+      end
+
+      def load!
+        return if defined?(Ext)
+
+        begin
+          require "honeymaker/#{RUBY_VERSION[/\A\d+\.\d+/]}/honeymaker_native" # fat platform gem
+        rescue LoadError
+          require "honeymaker/honeymaker_native" # compiled from source / rake compile
+        end
+      end
+    end
+  end
+end

data/lib/honeymaker/result.rb

@@ -0,0 +1,46 @@
+# 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
+
+    def or(other)
+      return data if success?
+
+      other
+    end
+
+    def ==(other)
+      return false unless other.is_a?(Result)
+
+      data == other.data && errors == other.errors
+    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,39 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Utils
+    def self.decimals(num)
+      return 0 if num.nil?
+      str = num.to_s.sub(/\.?0+$/, "")
+      return 0 unless str.include?(".")
+      str.split(".").last.length
+    end
+
+    # The exception classes behind an error, outermost first, following both Faraday's
+    # #wrapped_exception and Ruby's #cause (adapters nest them differently), each named once.
+    # Reported on a transport failure so a caller can tell where it happened; see Client#with_rescue.
+    def self.error_chain(error, limit: 10)
+      names = []
+      seen = {}.compare_by_identity # exceptions, not classes: adapters re-wrap in the same class
+      queue = [error]
+      until queue.empty? || seen.size >= limit
+        node = queue.shift
+        next if seen.key?(node)
+
+        seen[node] = true
+        names << node.class.name unless names.include?(node.class.name)
+        queue << node.wrapped_exception if node.respond_to?(:wrapped_exception) && node.wrapped_exception
+        queue << node.cause if node.cause
+      end
+      names
+    end
+
+    def self.parse_filters(filters)
+      {
+        price: filters.find { |f| f["filterType"] == "PRICE_FILTER" },
+        lot_size: filters.find { |f| f["filterType"] == "LOT_SIZE" },
+        notional: filters.find { |f| %w[NOTIONAL MIN_NOTIONAL].include?(f["filterType"]) }
+      }
+    end
+  end
+end

data/lib/honeymaker/version.rb

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