kucoin 0.7.4

A robust and asynchronous Rust client for the KuCoin exchange API.
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

#[derive(Debug)]
pub struct Candle {
    pub time: i64,
    pub open: f64,
    pub close: f64,
    pub high: f64,
    pub low: f64,
    pub volume: f64,
    pub turnover: f64,
}

use chrono::Utc;
use reqwest::Client;

pub async fn get_candles(
    client: &Client,
    symbol: &str,
    interval: &str,
    count: usize,
) -> Result<Vec<Candle>, Box<dyn std::error::Error>> {
    // Estimate duration per candle
    let seconds_per_candle = match interval {
        "1min" => 60,
        "5min" => 300,
        "15min" => 900,
        "1hour" => 3600,
        "4hour" => 14400,
        "1day" => 86400,
        "1week" => 604800,
        _ => return Err("Unsupported interval".into()),
    };

    // End at last fully closed candle
    let end_at = Utc::now().timestamp() - seconds_per_candle;
    let start_at = end_at - (seconds_per_candle * count as i64);

    let url = "https://api.kucoin.com/api/v1/market/candles";
    let res = client
        .get(url)
        .query(&[
            ("symbol", symbol),
            ("type", interval),
            ("startAt", &start_at.to_string()),
        ])
        .send()
        .await?
        .json::<serde_json::Value>()
        .await?;

    let data = res["data"]
        .as_array()
        .ok_or(format!("Invalid KuCoin response for symbol {}", symbol))?;

    let mut candles = Vec::with_capacity(count);

    // KuCoin returns newest → oldest
    for entry in data.iter().take(count) {
        let c = Candle {
            time: entry[0].as_str().unwrap().parse()?,
            open: entry[1].as_str().unwrap().parse()?,
            close: entry[2].as_str().unwrap().parse()?,
            high: entry[3].as_str().unwrap().parse()?,
            low: entry[4].as_str().unwrap().parse()?,
            volume: entry[5].as_str().unwrap().parse()?,
            turnover: entry[6].as_str().unwrap().parse()?,
        };
        candles.push(c);
    }

    Ok(candles)
}

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

    #[tokio::test]
    async fn test_get_weekly_candles_btc() {
        let client = Client::new();

        let count = 5;
        let candles = get_candles(&client, "BTC-USDT", "1week", count)
            .await
            .expect("Failed to fetch candles");

        // 1. Correct number of candles
        assert_eq!(
            candles.len(),
            count,
            "Expected {} candles, got {}",
            count,
            candles.len()
        );

        // 2. Candles are ordered oldest → newest
        for i in 1..candles.len() {
            assert!(
                candles[i].time > candles[i - 1].time,
                "Candles are not time-ordered"
            );
        }

        // 3. Candle values are sane
        for candle in &candles {
            assert!(candle.open > 0.0);
            assert!(candle.close > 0.0);
            assert!(candle.high >= candle.low);
            assert!(candle.volume >= 0.0);
        }

        // 4. Last candle is fully closed (not in the future)
        let now = chrono::Utc::now().timestamp();
        assert!(
            candles.last().unwrap().time < now,
            "Last candle appears to be unfinished"
        );
    }
}