honeymaker 0.12.4-aarch64-linux

data/lib/honeymaker/clients/kraken.rb

@@ -0,0 +1,379 @@
+# frozen_string_literal: true
+
+require "digest"
+require "uri"
+
+module Honeymaker
+  module Clients
+    class Kraken < Client
+      URL = "https://api.kraken.com"
+      UNREADABLE = "Kraken: unreadable response"
+
+      RATE_LIMITS = { default: 1000, orders: 1000 }.freeze
+
+      ASSET_MAP = {
+        "ZUSD" => "USD", "ZEUR" => "EUR", "ZGBP" => "GBP",
+        "ZJPY" => "JPY", "ZCHF" => "CHF", "ZCAD" => "CAD",
+        "ZAUD" => "AUD", "XXBT" => "XBT", "XETH" => "ETH",
+        "XXDG" => "XDG"
+      }.freeze
+
+      def query_orders_info(txid:, trades: nil, userref: nil, consolidate_taker: true)
+        result = post_private("/0/private/QueryOrders", {
+          nonce: nonce, trades: trades, userref: userref,
+          txid: txid, consolidate_taker: consolidate_taker
+        })
+        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?
+
+        orders = {}
+        (result.data["result"] || {}).each do |order_id, raw|
+          orders[order_id] = normalize_order(order_id, raw)
+        end
+        Result::Success.new(orders)
+      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("/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
+        })
+        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?
+
+        txid = (result.data.dig("result", "txid") || []).first
+        Result::Success.new({ order_id: txid, raw: result.data })
+      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
+
+      # aclass_base: "all" also returns tokenized equities (xStocks); omitted, Kraken serves only the
+      # "currency" class. Note the asset-class parameter is spelled differently per endpoint —
+      # aclass_base here, asset_class on Ticker/OHLC/Depth/AddOrder.
+      def get_tradable_asset_pairs(pairs: nil, info: nil, country_code: nil, aclass_base: nil)
+        get_public("/0/public/AssetPairs", {
+          pair: 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("/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
+
+      # The key's own permission flags (query-funds, withdraw-funds, modify-trades, query-ledger, ...).
+      # Needs no permission itself, so it answers for any valid key.
+      def get_api_key_info
+        post_private("/0/private/GetApiKeyInfo", { nonce: nonce })
+      end
+
+      def get_balances
+        result = get_extended_balance
+        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?
+
+        balances = {}
+        (result.data["result"] || {}).each do |symbol, balance|
+          mapped_symbol = ASSET_MAP[symbol.split(".").first] || symbol.split(".").first
+          total = BigDecimal(balance["balance"].to_s)
+          locked = BigDecimal((balance["hold_trade"] || "0").to_s)
+          free = total - locked
+          next if free.zero? && locked.zero?
+          balances[mapped_symbol] = { free: free, locked: locked }
+        end
+
+        Result::Success.new(balances)
+      end
+
+      def get_ohlc_data(pair:, interval: nil, since: nil)
+        get_public("/0/public/OHLC", { pair: pair, interval: interval, since: since })
+      end
+
+      def get_trades_history(type: nil, trades: nil, start: nil, end_time: nil, ofs: nil)
+        post_private("/0/private/TradesHistory", {
+          nonce: nonce, type: type, trades: trades,
+          start: start, end: end_time, ofs: ofs
+        })
+      end
+
+      def get_ledgers(asset: nil, type: nil, start: nil, end_time: nil, ofs: nil)
+        post_private("/0/private/Ledgers", {
+          nonce: nonce, asset: asset, type: type,
+          start: start, end: end_time, ofs: ofs
+        })
+      end
+
+      # Reconcile orders that QueryOrders has already dropped (Kraken removes terminal
+      # orders within hours) against TradesHistory, which is authoritative for executions
+      # and effectively unbounded in retention. Returns ONLY orders that actually executed,
+      # keyed by ordertxid, each as a per-order executed aggregate. Orders with no trades
+      # (never filled / truly gone) are simply absent from the result.
+      #
+      # `start` should be a unix timestamp bounding the lookback (e.g. the order's creation
+      # time) so we don't page the user's entire trade history.
+      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
+
+        Result::Success.new(by_order.transform_values { |trades| aggregate_trades(trades) })
+      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
+
+      # --- Earn ---
+
+      def get_earn_allocations(ascending: nil, converted_asset: nil, hide_zero_allocations: nil)
+        post_private("/0/private/Earn/Allocations", {
+          nonce: nonce, ascending: ascending,
+          converted_asset: converted_asset,
+          hide_zero_allocations: hide_zero_allocations
+        })
+      end
+
+      private
+
+      # A 2xx body that isn't a JSON object (a maintenance page, "null"): the venue's answer is
+      # unknown, which is not the same as empty. Callers treat data[:unreadable] as ambiguous.
+      def unreadable
+        Result::Failure.new(UNREADABLE, data: { unreadable: true })
+      end
+
+      def aggregate_trades(trades)
+        first = trades.first
+        vol  = trades.sum { |t| BigDecimal(t["vol"].to_s) }
+        cost = trades.sum { |t| BigDecimal(t["cost"].to_s) }
+        fee  = trades.sum { |t| BigDecimal(t["fee"].to_s) }
+        {
+          order_id: first["ordertxid"],
+          status: :closed,                       # only executed orders reach here
+          side: first["type"]&.to_sym,           # buy / sell
+          order_type: parse_order_type(first["ordertype"]),
+          price: vol.zero? ? nil : cost / vol,   # VWAP across (partial) fills
+          amount: nil,                           # original order size unknown from trades
+          quote_amount: nil,
+          amount_exec: vol,
+          quote_amount_exec: cost,
+          fee: fee,
+          pair: first["pair"],
+          trade_count: trades.size,
+          last_trade_at: trades.map { |t| t["time"].to_f }.max,
+          raw: { "trades" => trades }
+        }
+      end
+
+      def normalize_order(order_id, raw)
+        descr = raw["descr"] || {}
+        order_type = parse_order_type(descr["ordertype"])
+        side = descr["type"]&.downcase&.to_sym
+        status = parse_order_status(raw["status"])
+
+        order_flags = (raw["oflags"] || "").split(",")
+        if order_flags.include?("viqc")
+          amount = nil
+          quote_amount = BigDecimal(raw["vol"].to_s)
+        else
+          amount = BigDecimal(raw["vol"].to_s)
+          quote_amount = nil
+        end
+
+        amount_exec = BigDecimal(raw["vol_exec"].to_s)
+        quote_amount_exec = BigDecimal(raw["cost"].to_s)
+
+        price = BigDecimal(raw["price"].to_s)
+        price = BigDecimal(descr["price"].to_s) if price.zero? && order_type == :limit
+        price = nil if price.zero?
+
+        {
+          order_id: order_id,
+          status: status,
+          side: side,
+          order_type: order_type,
+          price: price,
+          amount: amount,
+          quote_amount: quote_amount,
+          amount_exec: amount_exec,
+          quote_amount_exec: quote_amount_exec,
+          raw: raw
+        }
+      end
+
+      def parse_order_type(type)
+        case type
+        when "market" then :market
+        when "limit" then :limit
+        else :unknown
+        end
+      end
+
+      def parse_order_status(status)
+        case status
+        when "pending" then :unknown
+        when "open" then :open
+        when "closed" then :closed
+        when "canceled", "expired" then :cancelled
+        else :unknown
+        end
+      end
+
+      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 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
+
+      # Kraken rejects any request whose nonce is <= the last nonce it saw for the
+      # same API key. We protect against in-process collisions (microsecond bursts,
+      # backward clock corrections) by tracking the last issued nonce per API key
+      # under a mutex. Cross-process reuse of the same API key (other workers,
+      # other containers, other tools) is not protected here — affected users
+      # should increase the Nonce Window on their Kraken API key.
+      @@nonce_mutex = Mutex.new
+      @@last_nonces = {}
+
+      def self.reset_nonce_state!
+        @@nonce_mutex.synchronize { @@last_nonces.clear }
+      end
+
+      def nonce
+        key = @api_key ? Digest::SHA256.hexdigest(@api_key) : :__no_api_key__
+        @@nonce_mutex.synchronize do
+          candidate = (Time.now.utc.to_f * 1_000_000).to_i
+          @@last_nonces[key] = [candidate, (@@last_nonces[key] || 0) + 1].max
+        end
+      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/kraken_futures.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Honeymaker
+  module Clients
+    class KrakenFutures < Client
+      URL = "https://futures.kraken.com"
+
+      RATE_LIMITS = { default: 500, orders: 500 }.freeze
+
+      def get_accounts
+        get_private("/derivatives/api/v3/accounts")
+      end
+
+      def get_fills(last_fill_time: nil)
+        get_private("/derivatives/api/v3/fills", { lastFillTime: last_fill_time })
+      end
+
+      def get_open_positions
+        get_private("/derivatives/api/v3/openpositions")
+      end
+
+      def historical_funding_rates(symbol:)
+        get_public("/derivatives/api/v3/historicalfundingrates", { symbol: symbol })
+      end
+
+      private
+
+      def validate_trading_credentials
+        result = get_accounts
+        return Result::Failure.new("Invalid trading credentials") if result.failure?
+        Result::Success.new(true)
+      end
+
+      def validate_read_credentials
+        validate_trading_credentials
+      end
+
+      def get_public(path, params = {})
+        with_rescue do
+          response = connection.get do |req|
+            req.url path
+            req.params = params.compact
+          end
+          response.body
+        end
+      end
+
+      def get_private(path, params = {})
+        with_rescue do
+          params = params.compact
+          query_string = params.empty? ? "" : Faraday::Utils.build_query(params)
+          nonce = timestamp_ms.to_s
+
+          post_data = query_string
+          hash_input = "#{post_data}#{nonce}#{path}"
+          sha256_hash = Digest::SHA256.digest(hash_input)
+          decoded_secret = Base64.decode64(@api_secret)
+          hmac = OpenSSL::HMAC.digest("sha512", decoded_secret, sha256_hash)
+          authent = Base64.strict_encode64(hmac)
+
+          response = connection.get do |req|
+            req.url path
+            req.headers = {
+              "APIKey": @api_key,
+              "Authent": authent,
+              "Nonce": nonce,
+              Accept: "application/json"
+            }
+            req.params = params
+          end
+          response.body
+        end
+      end
+    end
+  end
+end