lightcone-sdk 0.1.9

Rust SDK for the Lightcone Protcol
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

//! WebSocket-specific error types for the Lightcone SDK.

use thiserror::Error;

/// WebSocket-specific errors
#[derive(Debug, Clone, Error)]
pub enum WebSocketError {
    /// Initial connection failure
    #[error("Connection failed: {0}")]
    ConnectionFailed(String),

    /// Unexpected connection close
    #[error("Connection closed unexpectedly: code {code}, reason: {reason}")]
    ConnectionClosed { code: u16, reason: String },

    /// Rate limited (close code 1008)
    #[error("Rate limited: too many connections from this IP")]
    RateLimited,

    /// JSON deserialization failure
    #[error("Failed to parse message: {0}")]
    MessageParseError(String),

    /// Detected sequence gap in book updates
    #[error("Sequence gap detected: expected {expected}, received {received}")]
    SequenceGap { expected: u64, received: u64 },

    /// Server requested resync
    #[error("Resync required for orderbook: {orderbook_id}")]
    ResyncRequired { orderbook_id: String },

    /// Subscription error from server
    #[error("Subscription failed: {0}")]
    SubscriptionFailed(String),

    /// Client ping not responded
    #[error("Ping timeout: no pong response received")]
    PingTimeout,

    /// WebSocket protocol error
    #[error("WebSocket protocol error: {0}")]
    Protocol(String),

    /// Server returned an error
    #[error("Server error: {message} (code: {code})")]
    ServerError { code: String, message: String },

    /// Not connected
    #[error("Not connected to WebSocket server")]
    NotConnected,

    /// Already connected
    #[error("Already connected to WebSocket server")]
    AlreadyConnected,

    /// Send failed
    #[error("Failed to send message: {0}")]
    SendFailed(String),

    /// Channel closed
    #[error("Internal channel closed")]
    ChannelClosed,

    /// Invalid URL
    #[error("Invalid WebSocket URL: {0}")]
    InvalidUrl(String),

    /// Timeout
    #[error("Operation timed out")]
    Timeout,

    /// IO error
    #[error("IO error: {0}")]
    Io(String),

    /// Authentication failed
    #[error("Authentication failed: {0}")]
    AuthenticationFailed(String),

    /// Authentication required for user stream
    #[error("Authentication required for user stream")]
    AuthRequired,

    /// HTTP request error
    #[error("HTTP request error: {0}")]
    HttpError(String),

    /// Invalid auth token
    #[error("Invalid auth token: {0}")]
    InvalidAuthToken(String),
}

impl From<tokio_tungstenite::tungstenite::Error> for WebSocketError {
    fn from(err: tokio_tungstenite::tungstenite::Error) -> Self {
        use tokio_tungstenite::tungstenite::Error;
        match err {
            Error::ConnectionClosed => WebSocketError::ConnectionClosed {
                code: 1000,
                reason: "Connection closed normally".to_string(),
            },
            Error::AlreadyClosed => WebSocketError::NotConnected,
            Error::Io(e) => WebSocketError::Io(e.to_string()),
            Error::Protocol(e) => WebSocketError::Protocol(e.to_string()),
            Error::Url(e) => WebSocketError::InvalidUrl(e.to_string()),
            Error::Http(resp) => {
                WebSocketError::ConnectionFailed(format!("HTTP error: {:?}", resp.status()))
            }
            Error::HttpFormat(e) => WebSocketError::ConnectionFailed(e.to_string()),
            other => WebSocketError::Protocol(other.to_string()),
        }
    }
}

impl From<serde_json::Error> for WebSocketError {
    fn from(err: serde_json::Error) -> Self {
        WebSocketError::MessageParseError(err.to_string())
    }
}

impl From<reqwest::Error> for WebSocketError {
    fn from(err: reqwest::Error) -> Self {
        WebSocketError::HttpError(err.to_string())
    }
}

impl From<crate::auth::AuthError> for WebSocketError {
    fn from(err: crate::auth::AuthError) -> Self {
        match err {
            crate::auth::AuthError::SystemTime(msg) => WebSocketError::Protocol(msg),
            crate::auth::AuthError::HttpError(msg) => WebSocketError::HttpError(msg),
            crate::auth::AuthError::AuthenticationFailed(msg) => {
                WebSocketError::AuthenticationFailed(msg)
            }
        }
    }
}

impl<T> From<tokio::sync::mpsc::error::SendError<T>> for WebSocketError {
    fn from(_: tokio::sync::mpsc::error::SendError<T>) -> Self {
        WebSocketError::ChannelClosed
    }
}

/// Result type alias for WebSocket operations
pub type WsResult<T> = Result<T, WebSocketError>;