bat-markets-core 0.3.4

Core domain contracts and in-memory state engine for bat-markets
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
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

use serde::{Deserialize, Serialize};

/// Market-data capabilities for a venue adapter.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct MarketCapabilities {
    pub ticker: bool,
    pub recent_trades: bool,
    pub book_top: bool,
    pub order_book: bool,
    pub klines: bool,
    pub mark_price: bool,
    pub funding_rate: bool,
    pub open_interest: bool,
    pub liquidations: bool,
    pub public_streams: bool,
    pub multi_symbol_streams: bool,
}

/// Trade capabilities for a venue adapter.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct TradeCapabilities {
    pub create: bool,
    pub batch_create: bool,
    pub amend: bool,
    pub cancel: bool,
    pub batch_cancel: bool,
    pub cancel_all: bool,
    pub get: bool,
    pub list_open: bool,
    pub history: bool,
    pub validate: bool,
}

/// Position capabilities for a venue adapter.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct PositionCapabilities {
    pub read: bool,
    pub leverage_set: bool,
    pub margin_mode_set: bool,
    pub position_mode_set: bool,
    pub hedge_mode: bool,
}

/// Account capabilities for a venue adapter.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct AccountCapabilities {
    pub read_balances: bool,
    pub read_summary: bool,
    pub private_streams: bool,
}

/// Asset capabilities remain intentionally narrow in `0.1.x`.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct AssetCapabilities {
    pub read: bool,
    pub transfer: bool,
    pub withdraw: bool,
    pub convert: bool,
}

/// Native-only capabilities.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct NativeCapabilities {
    pub fast_stream: bool,
    pub special_orders: bool,
    pub ws_order_entry: bool,
}

/// Complete capability set exposed by a single venue/product adapter.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct CapabilitySet {
    pub market: MarketCapabilities,
    pub trade: TradeCapabilities,
    pub position: PositionCapabilities,
    pub account: AccountCapabilities,
    pub asset: AssetCapabilities,
    pub native: NativeCapabilities,
}

impl CapabilitySet {
    /// Standard capability profile shared by current linear futures adapters.
    #[must_use]
    pub const fn linear_futures_defaults() -> Self {
        Self {
            market: MarketCapabilities {
                ticker: true,
                recent_trades: true,
                book_top: true,
                order_book: true,
                klines: true,
                mark_price: true,
                funding_rate: true,
                open_interest: true,
                liquidations: false,
                public_streams: true,
                multi_symbol_streams: true,
            },
            trade: TradeCapabilities {
                create: true,
                batch_create: true,
                amend: true,
                cancel: true,
                batch_cancel: true,
                cancel_all: true,
                get: true,
                list_open: true,
                history: true,
                validate: true,
            },
            position: PositionCapabilities {
                read: true,
                leverage_set: true,
                margin_mode_set: true,
                position_mode_set: true,
                hedge_mode: true,
            },
            account: AccountCapabilities {
                read_balances: true,
                read_summary: true,
                private_streams: true,
            },
            asset: AssetCapabilities {
                read: false,
                transfer: false,
                withdraw: false,
                convert: false,
            },
            native: NativeCapabilities {
                fast_stream: true,
                special_orders: true,
                ws_order_entry: true,
            },
        }
    }

    #[must_use]
    pub fn supports_private_trading(self) -> bool {
        self.trade.create && self.account.private_streams
    }
}

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

    #[test]
    fn linear_futures_defaults_cover_current_adapter_contract() {
        let capabilities = CapabilitySet::linear_futures_defaults();

        assert!(capabilities.supports_private_trading());
        assert!(capabilities.market.ticker);
        assert!(capabilities.market.multi_symbol_streams);
        assert!(!capabilities.market.liquidations);
        assert!(capabilities.trade.batch_create);
        assert!(capabilities.position.hedge_mode);
        assert!(capabilities.account.private_streams);
        assert_eq!(capabilities.asset, AssetCapabilities::default());
        assert!(capabilities.native.ws_order_entry);
    }
}