Skip to main content

cripsy_binary_api/domain/
operation.rs

1//! Órdenes, operaciones y resultados.
2
3use serde::{Deserialize, Serialize};
4
5#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
6pub enum Direction {
7    Call,
8    Put,
9}
10
11#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
12pub enum OptionType {
13    Binary,
14    Digital,
15    /// BLITZ: duraciones en segundos (protocolo v2, `option_type_id: 12`).
16    Blitz,
17}
18
19/// Compra de binaria/turbo clásica.
20#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
21pub struct BuyBinaryRequest {
22    pub symbol: String,
23    pub amount: f64,
24    pub direction: Direction,
25    /// Duración en minutos; el adaptador decide turbo (≤5) vs binary (>5).
26    pub expiration_minutes: u64,
27    pub option_type: OptionType,
28}
29
30/// Compra digital por strike explícito (elegido de una `StrikeList`).
31#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
32pub struct BuyDigitalRequest {
33    pub symbol: String,
34    pub amount: f64,
35    pub direction: Direction,
36    pub duration_minutes: u64,
37    /// Precio de strike elegido de la `StrikeList`.
38    pub strike: f64,
39}
40
41/// Compra BLITZ (protocolo v2): duración en segundos y payout explícito.
42#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
43pub struct BuyBlitzRequest {
44    pub symbol: String,
45    pub amount: f64,
46    pub direction: Direction,
47    /// Duración en segundos (admitidas por el activo: `option.expiration_times`).
48    pub expiration_size_secs: u64,
49    /// Payout en porcentaje (100 - comisión), del catálogo.
50    pub profit_percent: f64,
51}
52
53/// Parámetros de rollover automático de una orden BLITZ.
54#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
55pub struct RolloverParams {
56    pub deadtime: u32,
57    pub limit: u32,
58    pub offset: u32,
59    pub offset_from_expiration: u32,
60    pub expiration_size: u32,
61}
62
63/// Identificador de orden opaco (el formato es del bróker).
64pub type OrderId = String;
65
66#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
67pub enum OperationStatus {
68    Open,
69    Closed,
70    Cancelled,
71    Rejected,
72}
73
74#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
75pub enum OperationResult {
76    /// Ganancia neta (ya descontada la inversión).
77    Win(f64),
78    /// Pérdida igual al monto invertido.
79    Loss(f64),
80    /// Empate: devolución del monto.
81    Equal(f64),
82    /// La operación sigue abierta.
83    Pending,
84}
85
86impl OperationResult {
87    /// Resultado neto contable: win/equal → delta positivo o cero; loss → negativo.
88    pub fn net(&self) -> Option<f64> {
89        match self {
90            OperationResult::Win(n) => Some(*n),
91            OperationResult::Loss(amount) => Some(-*amount),
92            OperationResult::Equal(_) => Some(0.0),
93            OperationResult::Pending => None,
94        }
95    }
96}
97
98#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
99pub struct Operation {
100    pub id: OrderId,
101    pub symbol: String,
102    pub amount: f64,
103    pub direction: Direction,
104    pub option_type: OptionType,
105    pub status: OperationStatus,
106    pub result: Option<OperationResult>,
107    pub payout_percent: Option<f64>,
108    pub opened_at: i64,
109    pub closed_at: Option<i64>,
110}
111
112#[cfg(test)]
113mod tests {
114    use super::*;
115
116    #[test]
117    fn net_de_resultados() {
118        assert_eq!(OperationResult::Win(8.2).net(), Some(8.2));
119        assert_eq!(OperationResult::Loss(10.0).net(), Some(-10.0));
120        assert_eq!(OperationResult::Equal(10.0).net(), Some(0.0));
121        assert_eq!(OperationResult::Pending.net(), None);
122    }
123
124    #[test]
125    fn request_binaria_serializa() {
126        let r = BuyBinaryRequest {
127            symbol: "EURUSD".into(),
128            amount: 10.0,
129            direction: Direction::Call,
130            expiration_minutes: 1,
131            option_type: OptionType::Binary,
132        };
133        let json = serde_json::to_string(&r).unwrap();
134        assert!(json.contains("\"direction\":\"Call\""));
135        assert!(json.contains("\"expiration_minutes\":1"));
136    }
137}