atelier_data 0.0.15

Data Artifacts and I/O for the atelier-rs engine
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

use crate::orderbooks::delta::NormalizedDelta;
use serde::Deserialize;

/// Diff depth stream event from `<symbol>@depth@100ms`.
///
/// Binance WebSocket payload (single-letter field names):
///
/// ```json
/// {
///   "e": "depthUpdate",
///   "E": 1672304484978,
///   "s": "BTCUSDT",
///   "U": 18521288,
///   "u": 18521290,
///   "b": [["21921.73","0.063"]],
///   "a": [["21922.00","0.500"]]
/// }
/// ```
#[derive(Deserialize, Debug, Clone)]
pub struct BinanceDepthUpdate {
    /// Event type — always `"depthUpdate"`.
    #[serde(rename = "e")]
    pub event_type: String,

    /// Event time (Unix ms).
    #[serde(rename = "E")]
    pub event_time: u64,

    /// Symbol (e.g. `"BTCUSDT"`).
    #[serde(rename = "s")]
    pub symbol: String,

    /// First update ID in this event.
    #[serde(rename = "U")]
    pub first_update_id: u64,

    /// Final update ID in this event.
    #[serde(rename = "u")]
    pub last_update_id: u64,

    /// Bid levels to update: `[[price, qty], ...]`.
    #[serde(rename = "b")]
    pub bids: Vec<[String; 2]>,

    /// Ask levels to update: `[[price, qty], ...]`.
    #[serde(rename = "a")]
    pub asks: Vec<[String; 2]>,
}

impl BinanceDepthUpdate {
    /// Convert to exchange-agnostic [`NormalizedDelta`].
    pub fn to_normalized(&self) -> NormalizedDelta {
        NormalizedDelta {
            symbol: self.symbol.clone(),
            bids: self
                .bids
                .iter()
                .map(|l| (l[0].clone(), l[1].clone()))
                .collect(),
            asks: self
                .asks
                .iter()
                .map(|l| (l[0].clone(), l[1].clone()))
                .collect(),
            update_id: self.last_update_id,
            sequence: self.first_update_id,
            is_snapshot: false,
        }
    }
}

/// Full depth snapshot from REST `GET /api/v3/depth?symbol=...&limit=5000`.
///
/// ```json
/// {
///   "lastUpdateId": 18521290,
///   "bids": [["21921.73","0.063"], ...],
///   "asks": [["21922.00","0.500"], ...]
/// }
/// ```
#[derive(Deserialize, Debug, Clone)]
pub struct BinanceDepthSnapshot {
    /// Sequence marker for delta reconciliation.
    #[serde(rename = "lastUpdateId")]
    pub last_update_id: u64,

    /// Full bid book: `[[price, qty], ...]` (descending by price).
    pub bids: Vec<[String; 2]>,

    /// Full ask book: `[[price, qty], ...]` (ascending by price).
    pub asks: Vec<[String; 2]>,
}

impl BinanceDepthSnapshot {
    /// Convert to exchange-agnostic [`NormalizedDelta`] (as a snapshot).
    pub fn to_normalized(&self, symbol: &str) -> NormalizedDelta {
        NormalizedDelta {
            symbol: symbol.to_string(),
            bids: self
                .bids
                .iter()
                .map(|l| (l[0].clone(), l[1].clone()))
                .collect(),
            asks: self
                .asks
                .iter()
                .map(|l| (l[0].clone(), l[1].clone()))
                .collect(),
            update_id: self.last_update_id,
            sequence: self.last_update_id,
            is_snapshot: true,
        }
    }
}