hyper_playbook/

executor.rs

use serde::{Deserialize, Serialize};

/// Order params for playbook-driven trades.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PlaybookOrderParams {
    pub symbol: String,
    pub side: String,
    pub size: f64,
    pub price: Option<f64>,
    pub reduce_only: bool,
}

/// Result of a filled order.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OrderFill {
    pub order_id: String,
    pub fill_price: f64,
    pub filled: bool,
}

/// Errors that can occur during order execution.
#[derive(Debug, Clone)]
pub enum ExecutionError {
    OrderRejected(String),
    NetworkError(String),
    NotFound(String),
}

impl std::fmt::Display for ExecutionError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::OrderRejected(msg) => write!(f, "Order rejected: {}", msg),
            Self::NetworkError(msg) => write!(f, "Network error: {}", msg),
            Self::NotFound(msg) => write!(f, "Not found: {}", msg),
        }
    }
}

/// Trait abstracting order execution for playbooks.
///
/// Implementations include paper trading (instant fill) and live exchange
/// execution.
#[async_trait::async_trait]
pub trait OrderExecutor: Send + Sync {
    async fn place_order(&self, params: &PlaybookOrderParams) -> Result<String, ExecutionError>;
    async fn cancel_order(&self, order_id: &str) -> Result<(), ExecutionError>;
    async fn is_filled(&self, order_id: &str) -> Result<bool, ExecutionError>;
    async fn close_position(
        &self,
        position_id: &str,
        reason: &str,
    ) -> Result<String, ExecutionError>;
}

/// Paper executor: instant fill at given price, no real exchange interaction.
pub struct PaperOrderExecutor {
    counter: std::sync::atomic::AtomicU64,
}

impl PaperOrderExecutor {
    pub fn new() -> Self {
        Self {
            counter: std::sync::atomic::AtomicU64::new(1),
        }
    }

    fn next_id(&self, prefix: &str) -> String {
        let n = self
            .counter
            .fetch_add(1, std::sync::atomic::Ordering::Relaxed);
        format!("{}-{}", prefix, n)
    }
}

impl Default for PaperOrderExecutor {
    fn default() -> Self {
        Self::new()
    }
}

#[async_trait::async_trait]
impl OrderExecutor for PaperOrderExecutor {
    async fn place_order(&self, params: &PlaybookOrderParams) -> Result<String, ExecutionError> {
        let id = self.next_id("paper-order");
        tracing::info!(
            order_id = %id,
            symbol = %params.symbol,
            side = %params.side,
            size = params.size,
            "Paper order placed (instant fill)"
        );
        Ok(id)
    }

    async fn cancel_order(&self, order_id: &str) -> Result<(), ExecutionError> {
        tracing::info!(order_id = %order_id, "Paper order cancelled");
        Ok(())
    }

    async fn is_filled(&self, _order_id: &str) -> Result<bool, ExecutionError> {
        Ok(true)
    }

    async fn close_position(
        &self,
        position_id: &str,
        reason: &str,
    ) -> Result<String, ExecutionError> {
        let id = self.next_id("paper-close");
        tracing::info!(
            position_id = %position_id,
            reason = %reason,
            close_id = %id,
            "Paper position closed"
        );
        Ok(id)
    }
}

// ---------------------------------------------------------------------------
// Risk-checked executor (decorator)
// ---------------------------------------------------------------------------

use hyper_risk::risk::{
    get_risk_config_sync, record_risk_alert, AccountState, OrderRequest, RiskConfig, RiskGuard,
};

/// An [`OrderExecutor`] decorator that enforces pre-trade risk checks before
/// delegating to an inner executor.
///
/// If the risk check fails the order is rejected with [`ExecutionError::OrderRejected`]
/// and the violation is recorded to the alert history. Cancel, fill-check, and
/// close operations are passed through without additional checks.
pub struct RiskCheckedOrderExecutor {
    inner: Box<dyn OrderExecutor>,
    risk_guard: RiskGuard,
    account_state: std::sync::Mutex<AccountState>,
}

impl RiskCheckedOrderExecutor {
    /// Wrap an existing executor with risk enforcement using the on-disk config.
    pub fn new(inner: Box<dyn OrderExecutor>) -> Self {
        let config = get_risk_config_sync();
        Self {
            inner,
            risk_guard: RiskGuard::new(config),
            account_state: std::sync::Mutex::new(AccountState::default()),
        }
    }

    /// Wrap an existing executor with a specific risk config.
    pub fn with_config(inner: Box<dyn OrderExecutor>, config: RiskConfig) -> Self {
        Self {
            inner,
            risk_guard: RiskGuard::new(config),
            account_state: std::sync::Mutex::new(AccountState::default()),
        }
    }

    /// Update the account state snapshot used for risk evaluation.
    pub fn update_account_state(&self, state: AccountState) {
        let mut current = self.account_state.lock().unwrap();
        *current = state;
    }
}

#[async_trait::async_trait]
impl OrderExecutor for RiskCheckedOrderExecutor {
    async fn place_order(&self, params: &PlaybookOrderParams) -> Result<String, ExecutionError> {
        let order_req = OrderRequest {
            symbol: params.symbol.clone(),
            side: params.side.clone(),
            size: params.size,
            price: params.price.unwrap_or(0.0),
        };

        let account_state = self.account_state.lock().unwrap().clone();
        if let Err(violation) = self.risk_guard.check_order(&order_req, &account_state) {
            record_risk_alert(&violation);
            return Err(ExecutionError::OrderRejected(format!(
                "Risk violation: {}",
                violation
            )));
        }

        self.inner.place_order(params).await
    }

    async fn cancel_order(&self, order_id: &str) -> Result<(), ExecutionError> {
        self.inner.cancel_order(order_id).await
    }

    async fn is_filled(&self, order_id: &str) -> Result<bool, ExecutionError> {
        self.inner.is_filled(order_id).await
    }

    async fn close_position(
        &self,
        position_id: &str,
        reason: &str,
    ) -> Result<String, ExecutionError> {
        self.inner.close_position(position_id, reason).await
    }
}

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

    fn make_params() -> PlaybookOrderParams {
        PlaybookOrderParams {
            symbol: "BTC-USDT".to_string(),
            side: "buy".to_string(),
            size: 0.1,
            price: Some(60000.0),
            reduce_only: false,
        }
    }

    #[tokio::test]
    async fn place_order_returns_unique_ids() {
        let executor = PaperOrderExecutor::new();
        let id1 = executor.place_order(&make_params()).await.unwrap();
        let id2 = executor.place_order(&make_params()).await.unwrap();
        assert_ne!(id1, id2);
        assert!(id1.starts_with("paper-order-"));
        assert!(id2.starts_with("paper-order-"));
    }

    #[tokio::test]
    async fn is_filled_always_true() {
        let executor = PaperOrderExecutor::new();
        assert!(executor.is_filled("any-id").await.unwrap());
    }

    #[tokio::test]
    async fn cancel_order_succeeds() {
        let executor = PaperOrderExecutor::new();
        assert!(executor.cancel_order("order-1").await.is_ok());
    }

    #[tokio::test]
    async fn close_position_returns_unique_id() {
        let executor = PaperOrderExecutor::new();
        let id1 = executor
            .close_position("pos-1", "take-profit")
            .await
            .unwrap();
        let id2 = executor.close_position("pos-2", "stop-loss").await.unwrap();
        assert_ne!(id1, id2);
        assert!(id1.starts_with("paper-close-"));
    }

    #[test]
    fn order_params_serde_roundtrip() {
        let params = make_params();
        let json = serde_json::to_string(&params).unwrap();
        let back: PlaybookOrderParams = serde_json::from_str(&json).unwrap();
        assert_eq!(back.symbol, params.symbol);
        assert_eq!(back.side, params.side);
        assert_eq!(back.size, params.size);
        assert_eq!(back.price, params.price);
        assert_eq!(back.reduce_only, params.reduce_only);
    }

    #[test]
    fn execution_error_display() {
        let e1 = ExecutionError::OrderRejected("insufficient funds".to_string());
        assert_eq!(e1.to_string(), "Order rejected: insufficient funds");

        let e2 = ExecutionError::NetworkError("timeout".to_string());
        assert_eq!(e2.to_string(), "Network error: timeout");

        let e3 = ExecutionError::NotFound("order-999".to_string());
        assert_eq!(e3.to_string(), "Not found: order-999");
    }

    // -- RiskCheckedOrderExecutor tests --

    use hyper_risk::risk::{
        AnomalyDetection, CircuitBreaker, DailyLossLimits, PositionLimits, RiskConfig,
    };

    fn permissive_risk_config() -> RiskConfig {
        RiskConfig {
            position_limits: PositionLimits {
                enabled: true,
                max_total_position: 1_000_000.0,
                max_per_symbol: 500_000.0,
            },
            daily_loss_limits: DailyLossLimits {
                enabled: false,
                max_daily_loss: 100_000.0,
                max_daily_loss_percent: 50.0,
            },
            anomaly_detection: AnomalyDetection {
                enabled: true,
                max_order_size: 1_000_000.0,
                max_orders_per_minute: 100,
                block_duplicate_orders: false,
            },
            circuit_breaker: CircuitBreaker {
                enabled: false,
                trigger_loss: 100_000.0,
                trigger_window_minutes: 60,
                action: "pause_all".to_string(),
                cooldown_minutes: 30,
            },
        }
    }

    fn restrictive_risk_config() -> RiskConfig {
        RiskConfig {
            position_limits: PositionLimits {
                enabled: true,
                max_total_position: 100.0,
                max_per_symbol: 50.0,
            },
            daily_loss_limits: DailyLossLimits {
                enabled: false,
                max_daily_loss: 100_000.0,
                max_daily_loss_percent: 50.0,
            },
            anomaly_detection: AnomalyDetection {
                enabled: true,
                max_order_size: 100.0,
                max_orders_per_minute: 100,
                block_duplicate_orders: false,
            },
            circuit_breaker: CircuitBreaker {
                enabled: false,
                trigger_loss: 100_000.0,
                trigger_window_minutes: 60,
                action: "pause_all".to_string(),
                cooldown_minutes: 30,
            },
        }
    }

    #[tokio::test]
    async fn risk_checked_executor_passes_small_order() {
        let inner = Box::new(PaperOrderExecutor::new());
        let executor = RiskCheckedOrderExecutor::with_config(inner, permissive_risk_config());

        let params = PlaybookOrderParams {
            symbol: "BTC-PERP".to_string(),
            side: "buy".to_string(),
            size: 0.01,
            price: Some(60000.0),
            reduce_only: false,
        };

        let result = executor.place_order(&params).await;
        assert!(result.is_ok(), "Small order should pass risk checks");
        assert!(result.unwrap().starts_with("paper-order-"));
    }

    #[tokio::test]
    async fn risk_checked_executor_blocks_oversized_order() {
        let inner = Box::new(PaperOrderExecutor::new());
        let executor = RiskCheckedOrderExecutor::with_config(inner, restrictive_risk_config());

        // $60,000 notional > $100 max_order_size
        let params = PlaybookOrderParams {
            symbol: "BTC-PERP".to_string(),
            side: "buy".to_string(),
            size: 1.0,
            price: Some(60000.0),
            reduce_only: false,
        };

        let result = executor.place_order(&params).await;
        assert!(result.is_err(), "Oversized order should be blocked");
        match result.unwrap_err() {
            ExecutionError::OrderRejected(msg) => {
                assert!(
                    msg.contains("Risk violation"),
                    "Error should mention risk: {}",
                    msg
                );
            }
            other => panic!("Expected OrderRejected, got: {:?}", other),
        }
    }

    #[tokio::test]
    async fn risk_checked_executor_blocks_position_limit_exceeded() {
        let inner = Box::new(PaperOrderExecutor::new());
        let executor = RiskCheckedOrderExecutor::with_config(inner, restrictive_risk_config());

        // Set account state with existing position near limit
        executor.update_account_state(AccountState {
            total_position_value: 90.0,
            ..AccountState::default()
        });

        // $20 notional would push total to $110 > $100 limit
        let params = PlaybookOrderParams {
            symbol: "ETH-PERP".to_string(),
            side: "buy".to_string(),
            size: 1.0,
            price: Some(20.0),
            reduce_only: false,
        };

        let result = executor.place_order(&params).await;
        assert!(result.is_err(), "Should block when position limit exceeded");
    }

    #[tokio::test]
    async fn risk_checked_executor_cancel_passes_through() {
        let inner = Box::new(PaperOrderExecutor::new());
        let executor = RiskCheckedOrderExecutor::with_config(inner, restrictive_risk_config());

        // Cancel should always pass through regardless of risk config
        let result = executor.cancel_order("order-123").await;
        assert!(result.is_ok());
    }

    #[tokio::test]
    async fn risk_checked_executor_close_position_passes_through() {
        let inner = Box::new(PaperOrderExecutor::new());
        let executor = RiskCheckedOrderExecutor::with_config(inner, restrictive_risk_config());

        let result = executor.close_position("pos-1", "stop-loss").await;
        assert!(result.is_ok());
    }

    #[tokio::test]
    async fn risk_checked_executor_is_filled_passes_through() {
        let inner = Box::new(PaperOrderExecutor::new());
        let executor = RiskCheckedOrderExecutor::with_config(inner, permissive_risk_config());

        let result = executor.is_filled("any-order").await;
        assert!(result.is_ok());
        assert!(result.unwrap());
    }

    #[tokio::test]
    async fn risk_checked_executor_market_order_no_price() {
        let inner = Box::new(PaperOrderExecutor::new());
        let executor = RiskCheckedOrderExecutor::with_config(inner, permissive_risk_config());

        // Market order with no price (price defaults to 0.0, so notional = 0)
        let params = PlaybookOrderParams {
            symbol: "SOL-PERP".to_string(),
            side: "buy".to_string(),
            size: 100.0,
            price: None,
            reduce_only: false,
        };

        let result = executor.place_order(&params).await;
        assert!(
            result.is_ok(),
            "Market order with no price should pass (notional=0)"
        );
    }

    #[tokio::test]
    async fn risk_checked_executor_all_disabled_passes_everything() {
        let config = RiskConfig {
            position_limits: PositionLimits {
                enabled: false,
                max_total_position: 1.0,
                max_per_symbol: 1.0,
            },
            daily_loss_limits: DailyLossLimits {
                enabled: false,
                max_daily_loss: 1.0,
                max_daily_loss_percent: 0.01,
            },
            anomaly_detection: AnomalyDetection {
                enabled: false,
                max_order_size: 1.0,
                max_orders_per_minute: 1,
                block_duplicate_orders: true,
            },
            circuit_breaker: CircuitBreaker {
                enabled: false,
                trigger_loss: 1.0,
                trigger_window_minutes: 1,
                action: "pause_all".to_string(),
                cooldown_minutes: 1,
            },
        };

        let inner = Box::new(PaperOrderExecutor::new());
        let executor = RiskCheckedOrderExecutor::with_config(inner, config);

        // Huge order should pass when all checks are disabled
        let params = PlaybookOrderParams {
            symbol: "BTC-PERP".to_string(),
            side: "buy".to_string(),
            size: 999_999.0,
            price: Some(999_999.0),
            reduce_only: false,
        };

        let result = executor.place_order(&params).await;
        assert!(result.is_ok(), "All checks disabled should pass any order");
    }
}