honeymaker 0.12.4-x86_64-linux

data/lib/honeymaker/clients/kucoin.rb

@@ -0,0 +1,310 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Clients
+    class Kucoin < Client
+      URL = "https://api.kucoin.com"
+      RATE_LIMITS = { default: 100, orders: 200 }.freeze
+
+      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 get_balances(type: "trade")
+        result = get_accounts(type: type)
+        return result if result.failure?
+
+        return api_error("KuCoin", result.data) unless result.data["code"] == "200000"
+
+        balances = {}
+        (result.data["data"] || []).each do |account|
+          symbol = account["currency"]
+          free = BigDecimal((account["available"] || "0").to_s)
+          locked = BigDecimal((account["holds"] || "0").to_s)
+          next if free.zero? && locked.zero?
+          balances[symbol] = { free: free, locked: locked }
+        end
+
+        Result::Success.new(balances)
+      end
+
+      def place_order(client_oid:, side:, symbol:, type:, size: nil, funds: nil, price: nil,
+                      time_in_force: nil, stp: nil)
+        result = 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
+        })
+        return result if result.failure?
+        return api_error("KuCoin", result.data) unless result.data["code"] == "200000"
+
+        order_id = result.data.dig("data", "orderId")
+        Result::Success.new({ order_id: order_id, raw: result.data })
+      end
+
+      def get_order(order_id:)
+        result = get_signed("/api/v1/orders/#{order_id}")
+        return result if result.failure?
+        return api_error("KuCoin", result.data) unless result.data["code"] == "200000"
+
+        raw = result.data["data"]
+        return Result::Failure.new("Order not found") unless raw
+
+        Result::Success.new(normalize_order(order_id, raw))
+      end
+
+      def cancel_order(order_id:)
+        delete_signed("/api/v1/orders/#{order_id}")
+      end
+
+      def get_orderbook(symbol:, limit: 20)
+        get_public("/api/v1/market/orderbook/level2_#{limit}", { symbol: symbol })
+      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 get_fills(order_id: nil, symbol: nil, side: nil, type: nil, start_at: nil, end_at: nil,
+                    trade_type: nil, limit: nil, current_page: nil)
+        get_signed("/api/v1/fills", {
+          orderId: order_id, symbol: symbol, side: side, type: type,
+          startAt: start_at, endAt: end_at, tradeType: trade_type,
+          pageSize: limit, currentPage: current_page
+        })
+      end
+
+      def get_historical_orders(symbol: nil, side: nil, start_at: nil, end_at: nil, current_page: nil, page_size: nil)
+        get_signed("/api/v1/hist-orders", {
+          symbol: symbol, side: side,
+          startAt: start_at, endAt: end_at,
+          currentPage: current_page, pageSize: page_size
+        })
+      end
+
+      def get_deposits(currency: nil, start_at: nil, end_at: nil, status: nil, current_page: nil, page_size: nil)
+        get_signed("/api/v1/deposits", {
+          currency: currency, startAt: start_at, endAt: end_at,
+          status: status, currentPage: current_page, pageSize: page_size
+        })
+      end
+
+      def get_withdrawals(currency: nil, start_at: nil, end_at: nil, status: nil, current_page: nil, page_size: nil)
+        get_signed("/api/v1/withdrawals", {
+          currency: currency, startAt: start_at, endAt: end_at,
+          status: status, currentPage: current_page, pageSize: page_size
+        })
+      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
+
+      # --- Margin ---
+
+      def margin_borrow_history(currency: nil, is_isolated: nil, symbol: nil, order_no: nil, start_time: nil, end_time: nil, current_page: nil, page_size: nil)
+        get_signed("/api/v3/margin/borrow", {
+          currency: currency, isIsolated: is_isolated, symbol: symbol, orderNo: order_no,
+          startTime: start_time, endTime: end_time, currentPage: current_page, pageSize: page_size
+        })
+      end
+
+      def margin_repay_history(currency: nil, is_isolated: nil, symbol: nil, order_no: nil, start_time: nil, end_time: nil, current_page: nil, page_size: nil)
+        get_signed("/api/v3/margin/repay", {
+          currency: currency, isIsolated: is_isolated, symbol: symbol, orderNo: order_no,
+          startTime: start_time, endTime: end_time, currentPage: current_page, pageSize: page_size
+        })
+      end
+
+      def margin_interest_history(currency: nil, is_isolated: nil, symbol: nil, start_time: nil, end_time: nil, current_page: nil, page_size: nil)
+        get_signed("/api/v3/margin/interest", {
+          currency: currency, isIsolated: is_isolated, symbol: symbol,
+          startTime: start_time, endTime: end_time, currentPage: current_page, pageSize: page_size
+        })
+      end
+
+      # --- Futures ---
+
+      def futures_funding_history(symbol:, start_at: nil, end_at: nil, reverse: nil, offset: nil, forward: nil, max_count: nil)
+        with_rescue do
+          params = {
+            symbol: symbol, startAt: start_at, endAt: end_at,
+            reverse: reverse, offset: offset, forward: forward, maxCount: max_count
+          }.compact
+          query_string = params.empty? ? "" : "?#{Faraday::Utils.build_query(params)}"
+          path = "/api/v1/funding-history"
+          ts = timestamp_ms.to_s
+          pre_sign = "#{ts}GET#{path}#{query_string}"
+
+          response = futures_connection.get do |req|
+            req.url path
+            req.headers = signed_headers(ts, pre_sign)
+            req.params = params
+          end
+          response.body
+        end
+      end
+
+      private
+
+      def normalize_order(order_id, raw)
+        order_type = parse_order_type(raw["type"])
+        side = raw["side"]&.downcase&.to_sym
+        status = parse_order_status(raw)
+
+        deal_funds = BigDecimal((raw["dealFunds"] || "0").to_s)
+        deal_size = BigDecimal((raw["dealSize"] || "0").to_s)
+        price = deal_funds.positive? && deal_size.positive? ? deal_funds / deal_size : BigDecimal((raw["price"] || "0").to_s)
+        price = nil if price.zero?
+
+        amount = raw["size"] ? BigDecimal(raw["size"].to_s) : nil
+        quote_amount = raw["funds"] ? BigDecimal(raw["funds"].to_s) : nil
+
+        {
+          order_id: order_id, status: status, side: side, order_type: order_type,
+          price: price, amount: amount, quote_amount: quote_amount,
+          amount_exec: deal_size, quote_amount_exec: deal_funds, raw: raw
+        }
+      end
+
+      def parse_order_type(type)
+        case type&.downcase
+        when "market" then :market
+        when "limit" then :limit
+        else :unknown
+        end
+      end
+
+      def parse_order_status(raw)
+        if raw["cancelExist"]
+          :cancelled
+        elsif raw["isActive"]
+          :open
+        else
+          BigDecimal((raw["dealSize"] || "0").to_s).positive? ? :closed : :unknown
+        end
+      end
+
+      def validate_trading_credentials
+        result = get_accounts(type: "trade")
+        return Result::Failure.new("Invalid trading credentials") if result.failure?
+        result.data["code"] == "200000" ? Result::Success.new(true) : Result::Failure.new("Invalid trading credentials")
+      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 = 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
+
+      def futures_connection
+        @futures_connection ||= build_client_connection("https://api-futures.kucoin.com")
+      end
+    end
+  end
+end

data/lib/honeymaker/clients/mexc.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Clients
+    class Mexc < Client
+      URL = "https://api.mexc.com"
+      RATE_LIMITS = { default: 100, orders: 200 }.freeze
+
+      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 get_balances
+        result = account_information
+        return result if result.failure?
+
+        balances = {}
+        Array(result.data["balances"]).each do |balance|
+          symbol = balance["asset"]
+          free = BigDecimal(balance["free"].to_s)
+          locked = BigDecimal(balance["locked"].to_s)
+          next if free.zero? && locked.zero?
+          balances[symbol] = { free: free, locked: locked }
+        end
+
+        Result::Success.new(balances)
+      end
+
+      def query_order(symbol:, order_id: nil, orig_client_order_id: nil, recv_window: 5000)
+        result = get_signed("/api/v3/order", {
+          symbol: symbol, orderId: order_id,
+          origClientOrderId: orig_client_order_id, recvWindow: recv_window
+        })
+        return result if result.failure?
+
+        raw = result.data
+        Result::Success.new(normalize_order("#{symbol}-#{raw['orderId']}", raw))
+      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)
+        result = 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
+        })
+        return result if result.failure?
+
+        raw = result.data
+        Result::Success.new({ order_id: "#{symbol}-#{raw['orderId']}", raw: raw })
+      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 account_trade_list(symbol:, order_id: nil, start_time: nil, end_time: nil, limit: 500, recv_window: 5000)
+        get_signed("/api/v3/myTrades", {
+          symbol: symbol, orderId: order_id,
+          startTime: start_time, endTime: end_time, limit: limit, recvWindow: recv_window
+        })
+      end
+
+      def deposit_history(coin: nil, status: nil, start_time: nil, end_time: nil, limit: 1000, recv_window: 5000)
+        get_signed("/api/v3/capital/deposit/hisrec", {
+          coin: coin, status: status,
+          startTime: start_time, endTime: end_time, limit: limit, recvWindow: recv_window
+        })
+      end
+
+      def withdraw_history(coin: nil, status: nil, start_time: nil, end_time: nil, limit: 1000, recv_window: 5000)
+        get_signed("/api/v3/capital/withdraw/history", {
+          coin: coin, status: status,
+          startTime: start_time, endTime: end_time, limit: limit, 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
+
+      # --- Other ---
+
+      def dust_conversion_history(recv_window: 5000)
+        get_signed("/api/v3/capital/convert", { recvWindow: recv_window })
+      end
+
+      def universal_transfer_history(type:, start_time: nil, end_time: nil, page: nil, size: nil, recv_window: 5000)
+        get_signed("/api/v3/capital/transfer", {
+          type: type, startTime: start_time, endTime: end_time,
+          page: page, size: size, recvWindow: recv_window
+        })
+      end
+
+      private
+
+      def normalize_order(order_id, raw)
+        order_type = parse_order_type(raw["type"])
+        side = raw["side"]&.downcase&.to_sym
+        status = parse_order_status(raw["status"])
+
+        amount = BigDecimal(raw["origQty"].to_s)
+        amount = nil if amount.zero?
+        quote_amount = raw["origQuoteOrderQty"] ? BigDecimal(raw["origQuoteOrderQty"].to_s) : nil
+        quote_amount = nil if quote_amount&.zero?
+
+        amount_exec = BigDecimal(raw["executedQty"].to_s)
+        quote_amount_exec = BigDecimal(raw["cummulativeQuoteQty"].to_s)
+        quote_amount_exec = nil if quote_amount_exec.negative?
+
+        price = BigDecimal(raw["price"].to_s)
+        if price.zero? && quote_amount_exec&.positive? && amount_exec.positive?
+          price = quote_amount_exec / amount_exec
+        end
+        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 "NEW", "PARTIALLY_FILLED" then :open
+        when "FILLED" then :closed
+        when "CANCELED", "EXPIRED" then :cancelled
+        when "REJECTED" then :failed
+        else :unknown
+        end
+      end
+
+      def validate_trading_credentials
+        result = account_information
+        result.success? ? Result::Success.new(true) : Result::Failure.new("Invalid trading credentials")
+      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 = 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/exchange.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  class Exchange
+    OPTIONS = {
+      request: {
+        open_timeout: 5,
+        read_timeout: 30,
+        write_timeout: 5
+      }
+    }.freeze
+
+    ERROR_PATTERNS = [].freeze
+
+    def classify_error(message)
+      return nil if message.nil?
+
+      self.class::ERROR_PATTERNS.each do |entry|
+        next unless (match = entry[:pattern].match(message))
+        return { code: entry[:code], **match.named_captures.transform_keys(&:to_sym) }
+      end
+      nil
+    end
+
+    def get_tickers_info
+      raise NotImplementedError, "#{self.class} must implement #get_tickers_info"
+    end
+
+    def get_bid_ask(symbol)
+      raise NotImplementedError, "#{self.class} must implement #get_bid_ask"
+    end
+
+    def get_price(symbol)
+      result = get_bid_ask(symbol)
+      return result if result.failure?
+
+      Result::Success.new((result.data[:bid] + result.data[:ask]) / 2)
+    end
+
+    def tickers_info
+      if @tickers_info_cache && @tickers_info_expires_at && @tickers_info_expires_at > Time.now
+        return Result::Success.new(@tickers_info_cache)
+      end
+
+      result = get_tickers_info
+      if result.success?
+        @tickers_info_cache = result.data
+        @tickers_info_expires_at = Time.now + cache_ttl
+      end
+      result
+    end
+
+    def find_ticker(symbol)
+      result = tickers_info
+      return result if result.failure?
+
+      ticker = result.data.find { |t| t[:ticker] == symbol }
+      ticker ? Result::Success.new(ticker) : Result::Failure.new("Unknown symbol: #{symbol}")
+    end
+
+    def symbols
+      result = tickers_info
+      return result if result.failure?
+
+      Result::Success.new(result.data.map { |t| { base: t[:base], quote: t[:quote] } })
+    end
+
+    def cache_ttl
+      3600
+    end
+
+    # Venue symbols the last #get_tickers_info saw listed but could not describe, symbol => why. They
+    # are missing from the catalogue WITHOUT being delisted: a caller that reads absence as delisting
+    # must keep what it has for them. Empty for a venue whose catalogue is a single request.
+    # It describes the last get_tickers_info call only; the #tickers_info cache does not carry it, so a
+    # caller that needs both reads them from one get_tickers_info.
+    def unreadable_symbols
+      @unreadable_symbols || {}
+    end
+
+    private
+
+    # No HTTP answer means the transport failed, and its text rarely says how ("end of file
+    # reached"). The chain of exception classes does — whether the request never left or may have
+    # landed — so it travels with the failure. Facts only: what they mean is the caller's call.
+    def transport_data(error, status)
+      status.nil? ? { status: nil, error_chain: Utils.error_chain(error) } : { status: status }
+    end
+
+    # Records one instrument the venue lists but whose description could not be read, keyed as the
+    # venue emits its ticker. The reason is what a person needs to see: the venue's own answer when it
+    # gave one ("HTTP 400 {...InvalidSymbol...}"), otherwise the exception.
+    def set_aside(symbol, error)
+      status = error.respond_to?(:response_status) ? error.response_status : nil
+      body = error.respond_to?(:response_body) ? error.response_body.to_s : ""
+      why = body.empty? ? "#{error.class}: #{error.message}" : body
+      (@unreadable_symbols ||= {})[symbol.to_s.upcase] = (status ? "HTTP #{status} #{why}" : why)[0, 200]
+      nil
+    end
+
+    def with_rescue
+      Result::Success.new(yield)
+    rescue Faraday::Error => e
+      body = e.respond_to?(:response_body) ? e.response_body : nil
+      error_message = (body && !body.empty?) ? body : e.message.to_s
+      error_message = "Unknown API error" if error_message.nil? || error_message.empty?
+      status = e.respond_to?(:response_status) ? e.response_status : nil
+      Result::Failure.new(error_message, data: transport_data(e, status))
+    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