kraky 0.1.2

Lightweight, production-ready Rust SDK for Kraken Exchange WebSocket API v2 with unique orderbook imbalance detection and WebSocket trading
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

//! Trade data types

use serde::{Deserialize, Serialize};

/// Deserialize a value that could be either a number or a string representation of a number
fn deserialize_number<'de, D>(deserializer: D) -> Result<f64, D::Error>
where
    D: serde::Deserializer<'de>,
{
    use serde::de::{self, Visitor};

    struct NumberVisitor;

    impl<'de> Visitor<'de> for NumberVisitor {
        type Value = f64;

        fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
            formatter.write_str("a number or string representation of a number")
        }

        fn visit_f64<E>(self, value: f64) -> Result<f64, E> {
            Ok(value)
        }

        fn visit_i64<E>(self, value: i64) -> Result<f64, E> {
            Ok(value as f64)
        }

        fn visit_u64<E>(self, value: u64) -> Result<f64, E> {
            Ok(value as f64)
        }

        fn visit_str<E>(self, value: &str) -> Result<f64, E>
        where
            E: de::Error,
        {
            value.parse::<f64>().map_err(de::Error::custom)
        }
    }

    deserializer.deserialize_any(NumberVisitor)
}

/// Trade side (buy or sell)
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "lowercase")]
pub enum TradeSide {
    /// Buy order (taker bought)
    Buy,
    /// Sell order (taker sold)
    Sell,
}

impl std::fmt::Display for TradeSide {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            TradeSide::Buy => write!(f, "buy"),
            TradeSide::Sell => write!(f, "sell"),
        }
    }
}

/// Order type for a trade (market or limit)
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "lowercase")]
pub enum TradeOrderType {
    /// Market order
    Market,
    /// Limit order
    Limit,
}

/// A single trade event
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Trade {
    /// Trading pair symbol
    pub symbol: String,
    /// Trade side (buy/sell from taker's perspective)
    pub side: TradeSide,
    /// Trade price
    pub price: f64,
    /// Trade quantity
    pub qty: f64,
    /// Order type
    pub ord_type: TradeOrderType,
    /// Trade ID
    pub trade_id: i64,
    /// Timestamp
    pub timestamp: String,
}

/// Raw trade data from Kraken API
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TradeDataRaw {
    /// Trading pair symbol
    pub symbol: String,
    /// Trade side
    pub side: TradeSide,
    /// Price (can be number or string from API)
    #[serde(deserialize_with = "deserialize_number")]
    pub price: f64,
    /// Quantity (can be number or string from API)
    #[serde(deserialize_with = "deserialize_number")]
    pub qty: f64,
    /// Order type
    pub ord_type: TradeOrderType,
    /// Trade ID
    pub trade_id: i64,
    /// Timestamp
    pub timestamp: String,
}

impl TradeDataRaw {
    /// Convert to typed Trade
    pub fn to_trade(&self) -> Trade {
        Trade {
            symbol: self.symbol.clone(),
            side: self.side,
            price: self.price,
            qty: self.qty,
            ord_type: self.ord_type,
            trade_id: self.trade_id,
            timestamp: self.timestamp.clone(),
        }
    }
}

/// Trade update message from Kraken
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TradeUpdate {
    /// Channel name
    #[serde(default)]
    pub channel: String,
    /// Update type
    #[serde(rename = "type")]
    pub update_type: String,
    /// Trade data
    pub data: Vec<TradeDataRaw>,
}