honeymaker 0.12.4-aarch64-linux

data/lib/honeymaker/clients/bybit.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Clients
+    class Bybit < Client
+      URL = "https://api.bybit.com"
+      RECV_WINDOW = "5000"
+      RATE_LIMITS = { default: 100, orders: 200 }.freeze
+
+      def get_coin_query_info
+        get_authenticated("/v5/asset/coin/query-info")
+      end
+
+      def instruments_info(category:, symbol: nil, status: nil, base_coin: nil, limit: nil, cursor: nil)
+        get_public("/v5/market/instruments-info", {
+          category: category, symbol: symbol, status: status,
+          baseCoin: base_coin, limit: limit, cursor: cursor
+        })
+      end
+
+      def tickers(category:, symbol: nil, base_coin: nil, exp_date: nil)
+        get_public("/v5/market/tickers", {
+          category: category, symbol: symbol, baseCoin: base_coin, expDate: exp_date
+        })
+      end
+
+      def orderbook(category:, symbol:, limit: nil)
+        get_public("/v5/market/orderbook", { category: category, symbol: symbol, limit: limit })
+      end
+
+      def kline(category:, symbol:, interval:, start: nil, end_time: nil, limit: nil)
+        get_public("/v5/market/kline", {
+          category: category, symbol: symbol, interval: interval,
+          start: start, end: end_time, limit: limit
+        })
+      end
+
+      def wallet_balance(account_type:, coin: nil)
+        get_authenticated("/v5/account/wallet-balance", { accountType: account_type, coin: coin })
+      end
+
+      def get_balances(account_type: "UNIFIED")
+        result = wallet_balance(account_type: account_type)
+        return result if result.failure?
+
+        return Result::Failure.new(result.data["retMsg"]) unless result.data["retCode"]&.zero?
+
+        balances = {}
+        accounts = result.data.dig("result", "list") || []
+        accounts.each do |account|
+          (account["coin"] || []).each do |coin|
+            symbol = coin["coin"]
+            free = BigDecimal((coin["availableToWithdraw"] || "0").to_s)
+            locked = BigDecimal((coin["locked"] || "0").to_s)
+            next if free.zero? && locked.zero?
+            balances[symbol] = { free: free, locked: locked }
+          end
+        end
+
+        Result::Success.new(balances)
+      end
+
+      def get_order(category:, order_id: nil, symbol: nil, order_link_id: nil)
+        result = get_authenticated("/v5/order/realtime", {
+          category: category, orderId: order_id, symbol: symbol, orderLinkId: order_link_id
+        })
+        return result if result.failure?
+        return Result::Failure.new(result.data["retMsg"]) unless result.data["retCode"]&.zero?
+
+        order_list = result.data.dig("result", "list") || []
+        raw = order_list.first
+        return Result::Failure.new("Order not found") unless raw
+
+        Result::Success.new(normalize_order(raw["orderId"], raw))
+      end
+
+      def create_order(category:, symbol:, side:, order_type:, qty:, price: nil,
+                       time_in_force: nil, market_unit: nil, order_link_id: nil)
+        result = post_authenticated("/v5/order/create", {
+          category: category, symbol: symbol, side: side,
+          orderType: order_type, qty: qty, price: price,
+          timeInForce: time_in_force, marketUnit: market_unit,
+          orderLinkId: order_link_id
+        })
+        return result if result.failure?
+        return Result::Failure.new(result.data["retMsg"]) unless result.data["retCode"]&.zero?
+
+        order_id = result.data.dig("result", "orderId")
+        Result::Success.new({ order_id: order_id, raw: result.data })
+      end
+
+      def cancel_order(category:, symbol:, order_id: nil, order_link_id: nil)
+        post_authenticated("/v5/order/cancel", {
+          category: category, symbol: symbol,
+          orderId: order_id, orderLinkId: order_link_id
+        })
+      end
+
+      # Closed orders that /v5/order/realtime no longer returns.
+      def order_history(category:, symbol: nil, order_id: nil, order_link_id: nil, order_status: nil,
+                        start_time: nil, end_time: nil, limit: nil, cursor: nil)
+        get_authenticated("/v5/order/history", {
+          category: category, symbol: symbol, orderId: order_id, orderLinkId: order_link_id,
+          orderStatus: order_status, startTime: start_time, endTime: end_time, limit: limit, cursor: cursor
+        })
+      end
+
+      def transaction_log(account_type: nil, category: nil, currency: nil, type: nil, start_time: nil, end_time: nil, limit: nil, cursor: nil)
+        get_authenticated("/v5/account/transaction-log", {
+          accountType: account_type, category: category, currency: currency, type: type,
+          startTime: start_time, endTime: end_time, limit: limit, cursor: cursor
+        })
+      end
+
+      def execution_list(category:, symbol: nil, order_id: nil, start_time: nil, end_time: nil, limit: nil, cursor: nil)
+        get_authenticated("/v5/execution/list", {
+          category: category, symbol: symbol, orderId: order_id,
+          startTime: start_time, endTime: end_time, limit: limit, cursor: cursor
+        })
+      end
+
+      def deposit_records(coin: nil, start_time: nil, end_time: nil, limit: nil, cursor: nil)
+        get_authenticated("/v5/asset/deposit/query-record", {
+          coin: coin, startTime: start_time, endTime: end_time, limit: limit, cursor: cursor
+        })
+      end
+
+      # Off-chain deposits from another Bybit user; query-record does not include them.
+      def internal_deposit_records(tx_id: nil, coin: nil, start_time: nil, end_time: nil, limit: nil, cursor: nil)
+        get_authenticated("/v5/asset/deposit/query-internal-record", {
+          txID: tx_id, coin: coin, startTime: start_time, endTime: end_time, limit: limit, cursor: cursor
+        })
+      end
+
+      def withdraw_records(coin: nil, start_time: nil, end_time: nil, limit: nil, cursor: nil, withdraw_type: nil)
+        get_authenticated("/v5/asset/withdraw/query-record", {
+          coin: coin, startTime: start_time, endTime: end_time,
+          limit: limit, cursor: cursor, withdrawType: withdraw_type
+        })
+      end
+
+      def withdraw(coin:, chain:, address:, amount:, tag: nil, force_chain: nil)
+        post_authenticated("/v5/asset/withdraw/create", {
+          coin: coin, chain: chain, address: address, amount: amount,
+          tag: tag, forceChain: force_chain, timestamp: timestamp_ms
+        })
+      end
+
+      # --- Margin ---
+
+      def borrow_history(currency: nil, start_time: nil, end_time: nil, limit: nil, cursor: nil)
+        get_authenticated("/v5/account/borrow-history", {
+          currency: currency, startTime: start_time, endTime: end_time, limit: limit, cursor: cursor
+        })
+      end
+
+      def spot_margin_repay_history(start_time: nil, end_time: nil, coin: nil, limit: nil, cursor: nil)
+        get_authenticated("/v5/spot-cross-margin-trade/repay-history", {
+          startTime: start_time, endTime: end_time, coin: coin, limit: limit, cursor: cursor
+        })
+      end
+
+      # --- Futures ---
+
+      def delivery_records(category:, symbol: nil, exp_date: nil, limit: nil, cursor: nil)
+        get_authenticated("/v5/asset/delivery-record", {
+          category: category, symbol: symbol, expDate: exp_date, limit: limit, cursor: cursor
+        })
+      end
+
+      def settlement_records(category:, symbol: nil, limit: nil, cursor: nil)
+        get_authenticated("/v5/asset/settlement-record", {
+          category: category, symbol: symbol, limit: limit, cursor: cursor
+        })
+      end
+
+      # --- Earn ---
+
+      def earn_order_records(order_id: nil, order_type: nil, start_time: nil, end_time: nil, limit: nil, cursor: nil)
+        get_authenticated("/v5/earn/order-records", {
+          orderId: order_id, orderType: order_type,
+          startTime: start_time, endTime: end_time, limit: limit, cursor: cursor
+        })
+      end
+
+      def earn_yield_history(product_id: nil, start_time: nil, end_time: nil, limit: nil, cursor: nil)
+        get_authenticated("/v5/earn/yield-history", {
+          productId: product_id, startTime: start_time, endTime: end_time, limit: limit, cursor: cursor
+        })
+      end
+
+      private
+
+      def normalize_order(order_id, raw)
+        order_type = parse_order_type(raw["orderType"])
+        side = raw["side"]&.downcase&.to_sym
+        status = parse_order_status(raw["orderStatus"])
+
+        price = BigDecimal((raw["avgPrice"] || "0").to_s)
+        price = BigDecimal((raw["price"] || "0").to_s) if price.zero?
+        price = nil if price.zero?
+
+        amount = BigDecimal((raw["qty"] || "0").to_s)
+        amount = nil if amount.zero?
+        amount_exec = BigDecimal((raw["cumExecQty"] || "0").to_s)
+        quote_amount_exec = BigDecimal((raw["cumExecValue"] || "0").to_s)
+
+        {
+          order_id: order_id, status: status, side: side, order_type: order_type,
+          price: price, amount: amount, quote_amount: nil,
+          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 "Created", "Untriggered" then :unknown
+        when "New", "PartiallyFilled" then :open
+        when "Filled" then :closed
+        # PartiallyFilledCanceled is final: a spot order cancelled after a partial fill.
+        when "Cancelled", "PartiallyFilledCanceled", "Expired", "Deactivated" then :cancelled
+        when "Rejected" then :failed
+        else :unknown
+        end
+      end
+
+      def validate_trading_credentials
+        result = wallet_balance(account_type: "UNIFIED")
+        return Result::Failure.new("Invalid trading credentials") if result.failure?
+        result.data["retCode"]&.zero? ? 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_authenticated(path, params = {})
+        with_rescue do
+          params = params.compact
+          response = connection.get do |req|
+            req.url path
+            req.headers = signed_headers("GET", params)
+            req.params = params
+          end
+          response.body
+        end
+      end
+
+      def post_authenticated(path, body = {})
+        with_rescue do
+          body = body.compact
+          response = connection.post do |req|
+            req.url path
+            req.headers = signed_headers("POST", body)
+            req.body = body
+          end
+          response.body
+        end
+      end
+
+      def unauthenticated_headers
+        { Accept: "application/json", "Content-Type": "application/json" }
+      end
+
+      def signed_headers(method, params_or_body)
+        return unauthenticated_headers unless authenticated?
+
+        ts = timestamp_ms
+        payload = if method == "GET"
+                    query_string = Faraday::Utils.build_query(params_or_body)
+                    "#{ts}#{@api_key}#{RECV_WINDOW}#{query_string}"
+                  else
+                    "#{ts}#{@api_key}#{RECV_WINDOW}#{params_or_body.to_json}"
+                  end
+
+        signature = hmac_sha256(@api_secret, payload)
+
+        {
+          "X-BAPI-API-KEY": @api_key,
+          "X-BAPI-SIGN": signature,
+          "X-BAPI-TIMESTAMP": ts.to_s,
+          "X-BAPI-RECV-WINDOW": RECV_WINDOW,
+          Accept: "application/json",
+          "Content-Type": "application/json"
+        }
+      end
+    end
+  end
+end

data/lib/honeymaker/clients/coinbase.rb

@@ -0,0 +1,326 @@
+# frozen_string_literal: true
+
+require "jwt"
+
+module Honeymaker
+  module Clients
+    class Coinbase < Client
+      URL = "https://api.coinbase.com"
+      RATE_LIMITS = { default: 100, orders: 100 }.freeze
+
+      def initialize(api_key: nil, api_secret: nil, proxy: nil, logger: nil)
+        super
+        @api_secret = @api_secret&.gsub('\n', "\n")
+      end
+
+      def get_order(order_id:)
+        result = get("/api/v3/brokerage/orders/historical/#{order_id}")
+        return result if result.failure?
+
+        raw = result.data.is_a?(Hash) && result.data.key?("order") ? result.data["order"] : result.data
+        Result::Success.new(normalize_order(order_id, raw))
+      end
+
+      def list_orders(order_ids: nil, product_ids: nil, product_type: nil, order_status: nil,
+                      time_in_forces: nil, order_types: nil, order_side: nil, start_date: nil,
+                      end_date: nil, order_placement_source: nil, contract_expiry_type: nil,
+                      asset_filters: nil, limit: nil, cursor: nil, sort_by: nil)
+        with_rescue do
+          response = connection.get do |req|
+            req.url "/api/v3/brokerage/orders/historical/batch"
+            req.headers = auth_headers(req)
+            req.params = {
+              order_ids: order_ids, product_ids: product_ids, product_type: product_type,
+              order_status: order_status, time_in_forces: time_in_forces,
+              order_types: order_types, order_side: order_side,
+              start_date: start_date, end_date: end_date,
+              order_placement_source: order_placement_source,
+              contract_expiry_type: contract_expiry_type,
+              asset_filters: asset_filters, limit: limit, cursor: cursor, sort_by: sort_by
+            }.compact
+            req.options.params_encoder = Faraday::FlatParamsEncoder
+          end
+          response.body
+        end
+      end
+
+      def create_order(client_order_id:, product_id:, side:, order_configuration:)
+        result = post("/api/v3/brokerage/orders", {
+          client_order_id: client_order_id, product_id: product_id,
+          side: side, order_configuration: order_configuration
+        })
+        return result if result.failure?
+
+        raw = result.data
+        if raw["success"] == false
+          error_msg = raw.dig("error_response", "message") || "Order creation failed"
+          return Result::Failure.new(error_msg)
+        end
+
+        order_id = raw.dig("success_response", "order_id")
+        Result::Success.new({ order_id: order_id, raw: raw })
+      end
+
+      def cancel_orders(order_ids:)
+        post("/api/v3/brokerage/orders/batch_cancel", { order_ids: order_ids })
+      end
+
+      def list_public_products(limit: nil, offset: nil, product_type: nil, product_ids: nil,
+                               contract_expiry_type: nil, expiring_contract_status: nil,
+                               get_tradability_status: nil, get_all_products: nil)
+        get("/api/v3/brokerage/market/products", {
+          limit: limit, offset: offset, product_type: product_type, product_ids: product_ids,
+          contract_expiry_type: contract_expiry_type,
+          expiring_contract_status: expiring_contract_status,
+          get_tradability_status: get_tradability_status, get_all_products: get_all_products
+        })
+      end
+
+      def get_public_product(product_id:, get_tradability_status: nil)
+        get("/api/v3/brokerage/market/products/#{product_id}", { get_tradability_status: get_tradability_status })
+      end
+
+      def get_public_product_book(product_id:, limit: nil, aggregation_price_increment: nil)
+        with_rescue do
+          response = connection.get do |req|
+            req.url "/api/v3/brokerage/market/product_book"
+            req.headers = auth_headers(req)
+            req.params = {
+              product_id: product_id, limit: limit,
+              aggregation_price_increment: aggregation_price_increment
+            }.compact
+            req.options.params_encoder = Faraday::FlatParamsEncoder
+          end
+          response.body
+        end
+      end
+
+      def get_public_product_candles(product_id:, start_time:, end_time:, granularity:, limit: nil)
+        get("/api/v3/brokerage/market/products/#{product_id}/candles", {
+          start: start_time, end: end_time, granularity: granularity, limit: limit
+        })
+      end
+
+      def get_api_key_permissions
+        get("/api/v3/brokerage/key_permissions")
+      end
+
+      # One page of accounts; pass the response's `cursor` back while `has_next` is true.
+      def list_accounts(limit: nil, cursor: nil)
+        get("/api/v3/brokerage/accounts", { limit: limit, cursor: cursor })
+      end
+
+      def list_portfolios
+        get("/api/v3/brokerage/portfolios")
+      end
+
+      def get_balances(portfolio_uuid: nil)
+        unless portfolio_uuid
+          portfolios_result = list_portfolios
+          return portfolios_result if portfolios_result.failure?
+
+          portfolio = Array(portfolios_result.data["portfolios"]).first
+          return Result::Failure.new("No portfolios found") unless portfolio
+          portfolio_uuid = portfolio["uuid"]
+        end
+
+        result = get_portfolio_breakdown(portfolio_uuid: portfolio_uuid)
+        return result if result.failure?
+
+        balances = {}
+        positions = result.data.dig("breakdown", "spot_positions") || []
+        positions.each do |position|
+          symbol = position["asset"]
+          next unless symbol
+
+          free = BigDecimal((position["available_to_trade_crypto"] || "0").to_s)
+          total = BigDecimal((position["total_balance_crypto"] || "0").to_s)
+          locked = total - free
+          next if free.zero? && locked.zero?
+          balances[symbol] = { free: free, locked: locked }
+        end
+
+        Result::Success.new(balances)
+      end
+
+      def get_portfolio_breakdown(portfolio_uuid:, currency: nil)
+        get("/api/v3/brokerage/portfolios/#{portfolio_uuid}", { currency: currency })
+      end
+
+      def send_money(account_id:, to:, amount:, currency:, idem: nil)
+        post("/v2/accounts/#{account_id}/transactions", {
+          type: "send", to: to, amount: amount, currency: currency, idem: idem
+        })
+      end
+
+      def list_fills(product_id: nil, order_id: nil, start_sequence_timestamp: nil,
+                     end_sequence_timestamp: nil, limit: nil, cursor: nil)
+        with_rescue do
+          response = connection.get do |req|
+            req.url "/api/v3/brokerage/orders/historical/fills"
+            req.headers = auth_headers(req)
+            req.params = {
+              product_id: product_id, order_id: order_id,
+              start_sequence_timestamp: start_sequence_timestamp,
+              end_sequence_timestamp: end_sequence_timestamp,
+              limit: limit, cursor: cursor
+            }.compact
+            req.options.params_encoder = Faraday::FlatParamsEncoder
+          end
+          response.body
+        end
+      end
+
+      def list_transactions(account_id:, limit: nil, starting_after: nil)
+        get("/v2/accounts/#{account_id}/transactions", { limit: limit, starting_after: starting_after })
+      end
+
+      private
+
+      def get(path, params = {})
+        with_rescue do
+          response = connection.get do |req|
+            req.url path
+            req.headers = auth_headers(req)
+            req.params = params.compact
+          end
+          response.body
+        end
+      end
+
+      def post(path, body = {})
+        with_rescue do
+          response = connection.post do |req|
+            req.url path
+            req.headers = auth_headers(req)
+            req.body = body.compact
+          end
+          response.body
+        end
+      end
+
+      def normalize_order(order_id, raw)
+        order_type = parse_order_type(raw["order_type"])
+        side = raw["side"]&.downcase&.to_sym
+        status = parse_order_status(raw["status"])
+
+        price = BigDecimal((raw["average_filled_price"] || "0").to_s)
+
+        case order_type
+        when :limit
+          config = (raw["order_configuration"] || {})["limit_limit_gtc"] || {}
+          amount = config["base_size"] ? BigDecimal(config["base_size"].to_s) : nil
+          quote_amount = config["quote_size"] ? BigDecimal(config["quote_size"].to_s) : nil
+          price = BigDecimal(config["limit_price"].to_s) if price.zero? && config["limit_price"]
+        when :market
+          config = (raw["order_configuration"] || {})["market_market_ioc"] || {}
+          amount = config["base_size"] ? BigDecimal(config["base_size"].to_s) : nil
+          quote_amount = config["quote_size"] ? BigDecimal(config["quote_size"].to_s) : nil
+        else
+          amount = nil
+          quote_amount = nil
+        end
+
+        price = nil if price.zero?
+
+        amount_exec = BigDecimal((raw["filled_size"] || "0").to_s)
+        total_value = BigDecimal((raw["total_value_after_fees"] || "0").to_s)
+        outstanding = BigDecimal((raw["outstanding_hold_amount"] || "0").to_s)
+        quote_amount_exec = total_value - outstanding
+
+        {
+          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", "UNKNOWN_ORDER_STATUS" then :unknown
+        when "OPEN" then :open
+        when "FILLED" then :closed
+        when "CANCELLED", "EXPIRED" then :cancelled
+        when "FAILED" then :failed
+        else :unknown
+        end
+      end
+
+      def validate_trading_credentials
+        # List accounts — if it works, the key has trading access
+        result = list_accounts
+        return Result::Failure.new("Invalid trading credentials") if result.failure?
+        Result::Success.new(true)
+      end
+
+      def validate_read_credentials
+        result = get_api_key_permissions
+        return Result::Failure.new("Invalid read credentials") if result.failure?
+        Result::Success.new(true)
+      end
+
+      def auth_headers(req)
+        return unauthenticated_headers unless authenticated?
+
+        timestamp = Time.now.utc.to_i
+        method = req.http_method.to_s.upcase
+        request_host = URI(URL).host
+        request_path = req.path
+
+        jwt_payload = {
+          sub: @api_key,
+          iss: "coinbase-cloud",
+          nbf: timestamp,
+          exp: timestamp + 120,
+          uri: "#{method} #{request_host}#{request_path}"
+        }
+
+        signing_key = ecdsa_key? ? ecdsa_signing_key : ed25519_signing_key
+        return unauthenticated_headers if signing_key.nil?
+
+        algorithm = ecdsa_key? ? "ES256" : "EdDSA"
+        jwt = JWT.encode(jwt_payload, signing_key, algorithm, { kid: @api_key, nonce: SecureRandom.hex })
+
+        { Authorization: "Bearer #{jwt}", Accept: "application/json", "Content-Type": "application/json" }
+      end
+
+      def unauthenticated_headers
+        { Accept: "application/json", "Content-Type": "application/json" }
+      end
+
+      def ecdsa_key?
+        @api_secret&.start_with?("-----BEGIN EC PRIVATE KEY-----")
+      end
+
+      def ecdsa_signing_key
+        OpenSSL::PKey::EC.new(@api_secret)
+      rescue OpenSSL::PKey::ECError
+        nil
+      end
+
+      def ed25519_signing_key
+        require "rbnacl"
+        decoded_key = Base64.decode64(@api_secret)
+        seed = decoded_key[0...32]
+        RbNaCl::Signatures::Ed25519::SigningKey.new(seed)
+      rescue LoadError, RbNaCl::LengthError
+        nil
+      end
+    end
+  end
+end