deribit-http 0.7.0

HTTP REST API client for Deribit trading platform
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

//! Portfolio simulation models for Deribit API
//!
//! This module contains types for portfolio margin simulation.

use serde::{Deserialize, Serialize};
use std::collections::HashMap;

/// Request for simulate_portfolio endpoint
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SimulatePortfolioRequest {
    /// Currency for the simulation (e.g., "BTC", "ETH")
    pub currency: String,
    /// Whether to add simulated positions to existing positions
    #[serde(skip_serializing_if = "Option::is_none")]
    pub add_positions: Option<bool>,
    /// Map of instrument names to simulated position sizes
    #[serde(skip_serializing_if = "Option::is_none")]
    pub simulated_positions: Option<HashMap<String, f64>>,
}

impl SimulatePortfolioRequest {
    /// Creates a new simulation request for the specified currency
    #[must_use]
    pub fn new(currency: impl Into<String>) -> Self {
        Self {
            currency: currency.into(),
            add_positions: None,
            simulated_positions: None,
        }
    }

    /// Sets whether to add positions to existing ones
    #[must_use]
    pub fn with_add_positions(mut self, add: bool) -> Self {
        self.add_positions = Some(add);
        self
    }

    /// Sets the simulated positions
    #[must_use]
    pub fn with_simulated_positions(mut self, positions: HashMap<String, f64>) -> Self {
        self.simulated_positions = Some(positions);
        self
    }
}

/// Response for simulate_portfolio endpoint
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SimulatePortfolioResponse {
    /// Projected initial margin
    #[serde(skip_serializing_if = "Option::is_none")]
    pub projected_initial_margin: Option<f64>,
    /// Projected maintenance margin
    #[serde(skip_serializing_if = "Option::is_none")]
    pub projected_maintenance_margin: Option<f64>,
    /// Projected delta total
    #[serde(skip_serializing_if = "Option::is_none")]
    pub projected_delta_total: Option<f64>,
    /// Change in margin
    #[serde(skip_serializing_if = "Option::is_none")]
    pub margin_change: Option<f64>,
    /// Available funds after simulation
    #[serde(skip_serializing_if = "Option::is_none")]
    pub available_funds: Option<f64>,
    /// Additional margin data
    #[serde(flatten)]
    pub additional: HashMap<String, serde_json::Value>,
}

/// Response for PME (Portfolio Margin Engine) simulation
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PmeSimulateResponse {
    /// Total projected margin
    #[serde(skip_serializing_if = "Option::is_none")]
    pub projected_margin: Option<f64>,
    /// Liquidation price estimate
    #[serde(skip_serializing_if = "Option::is_none")]
    pub liquidation_price: Option<f64>,
    /// Risk metrics
    #[serde(skip_serializing_if = "Option::is_none")]
    pub risk_value: Option<f64>,
    /// Additional PME data
    #[serde(flatten)]
    pub additional: HashMap<String, serde_json::Value>,
}

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

    #[test]
    fn test_simulate_portfolio_request_builder() {
        let mut positions = HashMap::new();
        positions.insert("BTC-PERPETUAL".to_string(), 1.0);

        let request = SimulatePortfolioRequest::new("BTC")
            .with_add_positions(true)
            .with_simulated_positions(positions);

        assert_eq!(request.currency, "BTC");
        assert_eq!(request.add_positions, Some(true));
        assert!(request.simulated_positions.is_some());
    }

    #[test]
    fn test_simulate_portfolio_response_deserialization() {
        let json = r#"{
            "projected_initial_margin": 0.05,
            "projected_maintenance_margin": 0.03,
            "projected_delta_total": 1.5,
            "margin_change": 0.01,
            "available_funds": 0.95
        }"#;

        let response: SimulatePortfolioResponse =
            serde_json::from_str(json).expect("Failed to parse");
        assert_eq!(response.projected_initial_margin, Some(0.05));
        assert_eq!(response.projected_maintenance_margin, Some(0.03));
    }

    #[test]
    fn test_pme_simulate_response_deserialization() {
        let json = r#"{
            "projected_margin": 0.1,
            "liquidation_price": 50000.0,
            "risk_value": 0.05
        }"#;

        let response: PmeSimulateResponse = serde_json::from_str(json).expect("Failed to parse");
        assert_eq!(response.projected_margin, Some(0.1));
        assert_eq!(response.liquidation_price, Some(50000.0));
    }
}