Add market_data_websocket example and update CMake configuration; enhance test discovery timeout

Author: kzhdev

CHANGELOG.md

@@ -9,9 +9,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [unreleased]
 
+### Added
+- Add a `market_data_websocket` example that subscribes to public testnet `allMids` and per-coin `l2Book` WebSocket updates for one or more coins.
+
 ### Changed
 - Normalize line ending to LF
 - Move test CMake setup into `tests/CMakeLists.txt`, register GoogleTest cases with `gtest_discover_tests()`, and keep CI integration tests running as a single executable to avoid repeated testnet setup per discovered test case.
+- Defer GoogleTest discovery to CTest with a longer discovery timeout so test executables are not run during the build.
 - Stabilize the WebSocket partial-unsubscribe integration test by waiting for the next `allMids` event instead of assuming one arrives within a fixed one-second sleep.
 
 ## [0.1.2] - 2026-06-09

CMakeLists.txt

@@ -53,6 +53,9 @@ target_link_libraries(hyperliquid PUBLIC
 if(HYPERLIQUID_BUILD_EXAMPLES)
     add_executable(basic_order examples/basic_order.cpp)
     target_link_libraries(basic_order PRIVATE hyperliquid)
+
+    add_executable(market_data_websocket examples/market_data_websocket.cpp)
+    target_link_libraries(market_data_websocket PRIVATE hyperliquid)
 endif()
 
 if(HYPERLIQUID_BUILD_TESTS)

examples/market_data_websocket.cpp

@@ -0,0 +1,165 @@
+// WebSocket market data example: subscribe to public testnet updates.
+// Usage: market_data_websocket [coin ...] [--seconds N]
+// Defaults: coins=ETH, seconds=30
+
+#include <hyperliquid/hyperliquid.hpp>
+
+#include <atomic>
+#include <chrono>
+#include <cstdlib>
+#include <iostream>
+#include <memory>
+#include <mutex>
+#include <stdexcept>
+#include <string>
+#include <thread>
+#include <vector>
+
+namespace {
+
+struct Options {
+    std::vector<std::string> coins{"ETH"};
+    int seconds = 30;
+};
+
+int parse_positive_int(const std::string& value) {
+    std::size_t parsed = 0;
+    const int result = std::stoi(value, &parsed);
+    if (parsed != value.size() || result <= 0)
+        throw std::invalid_argument("expected a positive integer");
+    return result;
+}
+
+Options parse_options(int argc, char* argv[]) {
+    Options options;
+    std::vector<std::string> coins;
+
+    for (int i = 1; i < argc; ++i) {
+        const std::string arg = argv[i];
+        if (arg == "--seconds") {
+            if (i + 1 >= argc)
+                throw std::invalid_argument("--seconds requires a value");
+            options.seconds = parse_positive_int(argv[++i]);
+        } else {
+            coins.push_back(arg);
+        }
+    }
+
+    if (!coins.empty())
+        options.coins = std::move(coins);
+    return options;
+}
+
+void print_top_of_book(const nlohmann::json& msg, const std::string& coin) {
+    if (!msg.contains("data"))
+        return;
+
+    const auto& data = msg["data"];
+    if (!data.contains("levels") || !data["levels"].is_array() || data["levels"].size() < 2)
+        return;
+
+    const auto& bids = data["levels"][0];
+    const auto& asks = data["levels"][1];
+    const std::string bid = (!bids.empty() && bids[0].contains("px"))
+        ? bids[0]["px"].get<std::string>()
+        : "n/a";
+    const std::string ask = (!asks.empty() && asks[0].contains("px"))
+        ? asks[0]["px"].get<std::string>()
+        : "n/a";
+
+    std::cout << "[l2Book] " << coin
+              << " best_bid=" << bid
+              << " best_ask=" << ask << "\n";
+}
+
+std::string mid_price_from_message(const nlohmann::json& msg, const std::string& coin) {
+    if (!msg.contains("data") || !msg["data"].is_object())
+        return {};
+
+    const auto& data = msg["data"];
+    if (data.contains(coin) && data[coin].is_string())
+        return data[coin].get<std::string>();
+
+    if (data.contains("mids") && data["mids"].is_object() &&
+        data["mids"].contains(coin) && data["mids"][coin].is_string())
+        return data["mids"][coin].get<std::string>();
+
+    return {};
+}
+
+} // namespace
+
+int main(int argc, char* argv[]) {
+    Options options;
+    try {
+        options = parse_options(argc, argv);
+    } catch (const std::exception& ex) {
+        std::cerr << "Invalid arguments: " << ex.what() << "\n"
+                  << "Usage: market_data_websocket [coin ...] [--seconds N]\n";
+        return 1;
+    }
+
+    hyperliquid::Info info(hyperliquid::TESTNET_API_URL, /*skip_ws=*/false);
+
+    std::mutex cout_mutex;
+    std::atomic<int> all_mids_updates{0};
+    std::vector<std::shared_ptr<std::atomic<int>>> l2_book_updates;
+    l2_book_updates.reserve(options.coins.size());
+    for (std::size_t i = 0; i < options.coins.size(); ++i)
+        l2_book_updates.push_back(std::make_shared<std::atomic<int>>(0));
+
+    const nlohmann::json all_mids_sub{{"type", "allMids"}};
+
+    const int all_mids_id = info.subscribe(all_mids_sub, [&](const nlohmann::json& msg) {
+        const int update_count = all_mids_updates.fetch_add(1, std::memory_order_relaxed) + 1;
+
+        std::lock_guard lock(cout_mutex);
+        std::cout << "[allMids] update #" << update_count;
+        for (const auto& coin : options.coins) {
+            const std::string mid_price = mid_price_from_message(msg, coin);
+            if (!mid_price.empty())
+                std::cout << " " << coin << "=" << mid_price;
+        }
+        std::cout << "\n";
+    });
+
+    std::vector<std::pair<nlohmann::json, int>> l2_book_subscriptions;
+    l2_book_subscriptions.reserve(options.coins.size());
+
+    for (std::size_t i = 0; i < options.coins.size(); ++i) {
+        const std::string coin = options.coins[i];
+        const nlohmann::json subscription{{"type", "l2Book"}, {"coin", coin}};
+        const int id = info.subscribe(subscription, [&, i, coin](const nlohmann::json& msg) {
+            l2_book_updates[i]->fetch_add(1, std::memory_order_relaxed);
+
+            std::lock_guard lock(cout_mutex);
+            print_top_of_book(msg, coin);
+        });
+        l2_book_subscriptions.emplace_back(subscription, id);
+    }
+
+    {
+        std::lock_guard lock(cout_mutex);
+        std::cout << "Listening for";
+        for (const auto& coin : options.coins)
+            std::cout << " " << coin;
+        std::cout << " market data on testnet for " << options.seconds << " seconds...\n";
+    }
+
+    std::this_thread::sleep_for(std::chrono::seconds(options.seconds));
+
+    info.unsubscribe(all_mids_sub, all_mids_id);
+    for (const auto& [subscription, id] : l2_book_subscriptions)
+        info.unsubscribe(subscription, id);
+
+    std::cout << "Done. Received "
+              << all_mids_updates.load(std::memory_order_relaxed)
+              << " allMids updates";
+    for (std::size_t i = 0; i < options.coins.size(); ++i) {
+        std::cout << ", " << l2_book_updates[i]->load(std::memory_order_relaxed)
+                  << " " << options.coins[i] << " l2Book updates";
+    }
+    std::cout << ".\n";
+
+    return 0;
+}

tests/CMakeLists.txt

@@ -17,6 +17,8 @@ target_link_libraries(hyperliquid_tests PRIVATE
 
 gtest_discover_tests(hyperliquid_tests
     TEST_PREFIX unit.
+    DISCOVERY_MODE PRE_TEST
+    DISCOVERY_TIMEOUT 60
     PROPERTIES
         LABELS unit
 )
@@ -34,6 +36,8 @@ target_link_libraries(hyperliquid_integration_tests PRIVATE
 
 gtest_discover_tests(hyperliquid_integration_tests
     TEST_PREFIX integration.
+    DISCOVERY_MODE PRE_TEST
+    DISCOVERY_TIMEOUT 60
     PROPERTIES
         LABELS integration
 )