websocket.hpp

Go to the documentation of this file.

#pragma once
 
#include "kalshi/environment.hpp"
#include "kalshi/error.hpp"
#include "kalshi/signer.hpp"
#include "kalshi/ws_models.hpp"
 
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
namespace kalshi {
 
using WsMessage = ws::Message;
 
struct WsError {
    std::int64_t code{0};
    std::string message;
    std::optional<std::int64_t> id;
    std::optional<std::int64_t> sid;
    std::optional<std::int64_t> seq;
    std::optional<ws::Subscription> subscription;
    std::optional<std::int64_t> sending_ts_ms;
};
 
enum class WsState : std::uint8_t { Disconnected, Connecting, Connected, Reconnecting };
 
[[nodiscard]] constexpr std::string_view to_string(WsState state) noexcept {
    switch (state) {
        case WsState::Disconnected:
            return "disconnected";
        case WsState::Connecting:
            return "connecting";
        case WsState::Connected:
            return "connected";
        case WsState::Reconnecting:
            return "reconnecting";
    }
    return "";
}
 
struct WsConfig {
    std::string url{websocket_url(Environment::Production)};
    std::chrono::milliseconds connect_timeout{std::chrono::seconds{10}};
    bool auto_reconnect{true};
    std::chrono::milliseconds reconnect_delay{std::chrono::milliseconds{500}};
    std::chrono::milliseconds max_reconnect_delay{std::chrono::seconds{30}};
    std::uint32_t max_reconnect_attempts{0};
    std::chrono::seconds ping_interval{std::chrono::seconds{15}};
    std::chrono::seconds idle_timeout{std::chrono::seconds{30}};
    bool resync_on_gap{true};
    std::size_t max_message_bytes{std::size_t{64} * 1024 * 1024};
 
    [[nodiscard]] static WsConfig for_environment(Environment environment) {
        WsConfig config;
        config.url = std::string(websocket_url(environment));
        return config;
    }
};
 
class WebSocketClient {
public:
    explicit WebSocketClient(Signer signer, WsConfig config = {});
    ~WebSocketClient();
 
    WebSocketClient(WebSocketClient&&) noexcept;
    WebSocketClient& operator=(WebSocketClient&&) noexcept;
    WebSocketClient(const WebSocketClient&) = delete;
    WebSocketClient& operator=(const WebSocketClient&) = delete;
 
    [[nodiscard]] Result<void> connect();
 
    void disconnect();
 
    [[nodiscard]] WsState state() const noexcept;
    [[nodiscard]] bool is_connected() const noexcept;
 
    [[nodiscard]] Result<ws::Subscription> subscribe(ws::Channel channel,
                                                     ws::SubscribeParams params = {});
    [[nodiscard]] Result<void> unsubscribe(ws::Subscription subscription);
    [[nodiscard]] Result<void> update_subscription(ws::Subscription subscription,
                                                   const ws::UpdateSubscriptionParams& params);
    [[nodiscard]] Result<void> add_markets(ws::Subscription subscription,
                                           std::vector<std::string> market_tickers);
    [[nodiscard]] Result<void> remove_markets(ws::Subscription subscription,
                                              std::vector<std::string> market_tickers);
    [[nodiscard]] Result<void> request_snapshot(ws::Subscription subscription,
                                                std::vector<std::string> market_tickers);
    [[nodiscard]] Result<std::int64_t> list_subscriptions();
    [[nodiscard]] std::vector<ws::Subscription> subscriptions() const;
 
    void on_message(std::function<void(const WsMessage&)> callback);
    void on_error(std::function<void(const WsError&)> callback);
    void on_state_change(std::function<void(WsState)> callback);
 
    [[nodiscard]] const WsConfig& config() const noexcept;
 
private:
    struct Impl;
    std::shared_ptr<Impl> impl_;
};
 
} // namespace kalshi