bybit-rust-api 0.4.0

Complete Rust SDK for Bybit API V5 with all endpoints, comprehensive type safety and full test coverage
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

//! Kline/Candlestick stream — real-time OHLCV updates.
//!
//! # Topic format
//! `kline.{interval}.{symbol}` — e.g. `kline.1.BTCUSDT`
//!
//! # Intervals
//! 1, 3, 5, 15, 30, 60, 120, 240, 360, 720, D, W, M
//!
//! Each message contains a single kline (the current candle being updated).

use serde::Deserialize;

/// A single kline/candlestick update.
#[derive(Debug, Clone, Deserialize)]
pub struct KlineData {
    /// Kline start timestamp in ms
    #[serde(rename = "start")]
    #[serde(default)]
    pub start: Option<i64>,
    /// Kline end timestamp in ms
    #[serde(rename = "end")]
    #[serde(default)]
    pub end: Option<i64>,
    /// Kline interval (e.g. "1", "5", "D")
    #[serde(rename = "interval")]
    #[serde(default)]
    pub interval: Option<String>,
    /// Open price
    #[serde(rename = "open")]
    #[serde(default)]
    pub open: Option<String>,
    /// Close price
    #[serde(rename = "close")]
    #[serde(default)]
    pub close: Option<String>,
    /// High price
    #[serde(rename = "high")]
    #[serde(default)]
    pub high: Option<String>,
    /// Low price
    #[serde(rename = "low")]
    #[serde(default)]
    pub low: Option<String>,
    /// Volume
    #[serde(rename = "volume")]
    #[serde(default)]
    pub volume: Option<String>,
    /// Turnover (USDT value)
    #[serde(rename = "turnover")]
    #[serde(default)]
    pub turnover: Option<String>,
    /// Whether this kline is confirmed (final) or still updating
    #[serde(rename = "confirm")]
    #[serde(default)]
    pub confirm: Option<bool>,
    /// Timestamp of this push
    #[serde(rename = "timestamp")]
    #[serde(default)]
    pub timestamp: Option<i64>,
}

/// Typed wrapper for kline stream data.
///
/// Bybit sends an array with a single kline per message.
pub struct KlineStream;

impl KlineStream {
    /// Parse raw WS data into a vector of klines (usually single-element).
    pub fn parse(data: &serde_json::Value) -> serde_json::Result<Vec<KlineData>> {
        serde_json::from_value(data.clone())
    }

    /// Parse and return the first kline (most common case).
    pub fn parse_single(data: &serde_json::Value) -> serde_json::Result<KlineData> {
        let mut klines: Vec<KlineData> = serde_json::from_value(data.clone())?;
        klines
            .pop()
            .ok_or_else(|| serde::de::Error::custom("empty kline array"))
    }

    /// Check if the given topic matches a kline channel.
    pub fn matches_topic(topic: &str) -> bool {
        topic.starts_with("kline.")
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_parse_kline() {
        let json = serde_json::json!([{
            "start": 1672828800000_i64,
            "end": 1672832400000_i64,
            "interval": "60",
            "open": "50000.00",
            "close": "50100.00",
            "high": "50200.00",
            "low": "49900.00",
            "volume": "150.5",
            "turnover": "7525000.00",
            "confirm": false,
            "timestamp": 1672832100000_i64
        }]);

        let kline = KlineStream::parse_single(&json).unwrap();
        assert_eq!(kline.open.as_deref(), Some("50000.00"));
        assert_eq!(kline.close.as_deref(), Some("50100.00"));
        assert_eq!(kline.confirm, Some(false));
    }

    #[test]
    fn test_matches_topic() {
        assert!(KlineStream::matches_topic("kline.1.BTCUSDT"));
        assert!(KlineStream::matches_topic("kline.D.ETHUSDT"));
        assert!(!KlineStream::matches_topic("tickers.BTCUSDT"));
    }
}