use serde::{Deserialize, Serialize};
use crate::broker::config::{AccountSelection, TransportConfig};
use crate::broker::error::BrokerError;
#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub struct LimitesTasa {
pub porcentaje: f64,
pub trading_por_min: u32,
pub trading_por_hora: u32,
pub balance_por_min: u32,
pub balance_por_hora: u32,
pub cartera_por_min: u32,
pub cartera_por_hora: u32,
pub resto_por_min: u32,
pub resto_por_hora: u32,
}
impl Default for LimitesTasa {
fn default() -> Self {
let p = 0.8;
Self {
porcentaje: p,
trading_por_min: (360.0 * p) as u32,
trading_por_hora: (14_400.0 * p) as u32,
balance_por_min: (100.0 * p) as u32,
balance_por_hora: (2_000.0 * p) as u32,
cartera_por_min: (30.0 * p) as u32,
cartera_por_hora: (1_500.0 * p) as u32,
resto_por_min: (220.0 * p) as u32,
resto_por_hora: (14_400.0 * p) as u32,
}
}
}
#[derive(Clone, PartialEq, Serialize, Deserialize)]
pub struct DerivConfig {
#[serde(default, skip_serializing)]
pub token: Option<String>,
pub app_id: Option<String>,
pub account_id: Option<String>,
pub base_url: String,
pub public_ws_url: String,
pub account: AccountSelection,
pub currency: Option<String>,
pub stake_referencia: f64,
pub transport: TransportConfig,
pub limites: LimitesTasa,
}
impl Default for DerivConfig {
fn default() -> Self {
Self {
token: None,
app_id: None,
account_id: None,
base_url: "https://api.derivws.com".into(),
public_ws_url: "wss://api.derivws.com/trading/v1/options/ws/public".into(),
account: AccountSelection::Practice,
currency: None,
stake_referencia: 1.0,
transport: TransportConfig::default(),
limites: LimitesTasa::default(),
}
}
}
impl DerivConfig {
pub fn publico() -> Self {
Self::default()
}
pub fn es_publico(&self) -> bool {
self.token.is_none()
}
pub fn validar(&self) -> Result<(), BrokerError> {
if self.base_url.trim().is_empty() {
return Err(BrokerError::Internal("deriv: base_url vacía".into()));
}
if !self.public_ws_url.starts_with("wss://") {
return Err(BrokerError::Internal(
"deriv: public_ws_url debe ser wss://".into(),
));
}
if let Some(token) = &self.token {
if token.trim().is_empty() {
return Err(BrokerError::Authentication(
"deriv: token vacío; usa None para el modo público".into(),
));
}
}
if self.stake_referencia <= 0.0 {
return Err(BrokerError::Internal(
"deriv: stake_referencia debe ser positivo".into(),
));
}
if !(0.05..=1.0).contains(&self.limites.porcentaje) {
return Err(BrokerError::Internal(
"deriv: limites.porcentaje fuera de 0.05..=1.0".into(),
));
}
Ok(())
}
}
impl std::fmt::Debug for DerivConfig {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let token = match &self.token {
Some(t) if !t.is_empty() => format!("<redactado:{}chars>", t.len()),
Some(_) => "<vacío>".to_string(),
None => "<ninguno>".to_string(),
};
f.debug_struct("DerivConfig")
.field("token", &token)
.field("app_id", &self.app_id.as_deref().map(|_| "<presente>"))
.field("account_id", &self.account_id)
.field("base_url", &self.base_url)
.field("public_ws_url", &self.public_ws_url)
.field("account", &self.account)
.field("currency", &self.currency)
.field("stake_referencia", &self.stake_referencia)
.field("transport", &self.transport)
.field("limites", &self.limites)
.finish()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn debug_no_filtra_el_token() {
let cfg = DerivConfig {
token: Some("pat_secreto_123".into()),
app_id: Some("12345".into()),
..DerivConfig::default()
};
let texto = format!("{cfg:?}");
assert!(!texto.contains("pat_secreto_123"));
assert!(texto.contains("redactado"));
}
#[test]
fn serde_omite_el_token() {
let cfg = DerivConfig {
token: Some("pat_secreto_123".into()),
..DerivConfig::default()
};
let json = serde_json::to_string(&cfg).unwrap();
assert!(!json.contains("pat_secreto_123"));
assert!(!json.contains("token"));
}
#[test]
fn publico_no_requiere_token() {
assert!(DerivConfig::publico().es_publico());
assert!(DerivConfig::publico().validar().is_ok());
}
#[test]
fn token_vacio_es_error() {
let cfg = DerivConfig {
token: Some(" ".into()),
..DerivConfig::default()
};
assert!(matches!(cfg.validar(), Err(BrokerError::Authentication(_))));
}
#[test]
fn cupos_por_defecto_bajo_el_limite() {
let l = LimitesTasa::default();
assert!(l.trading_por_min < 360);
assert!(l.cartera_por_min < 30);
}
}