Initial commit

demos/rtx-algoarena-demo/src/lib.rs

@@ -0,0 +1,173 @@
+//! AlgoArena - Strategy Backtesting Battleground.
+//!
+//! This demo showcases multi-agent trading simulation where different strategies
+//! compete head-to-head in a simulated market environment.
+
+pub mod agents;
+pub mod arena;
+pub mod market;
+pub mod sample_data;
+
+use algoarena_shared::{TournamentConfig, TournamentResult};
+use thiserror::Error;
+
+use arena::TradingArena;
+
+/// Errors that can occur during tournament simulation.
+#[derive(Debug, Error)]
+pub enum AlgoArenaError {
+    /// No agents provided.
+    #[error("No agents provided for tournament")]
+    NoAgents,
+
+    /// No assets provided.
+    #[error("No assets provided for simulation")]
+    NoAssets,
+
+    /// Invalid configuration.
+    #[error("Invalid configuration: {0}")]
+    InvalidConfig(String),
+
+    /// Simulation failed.
+    #[error("Simulation failed: {0}")]
+    SimulationFailed(String),
+}
+
+/// Main AlgoArena system.
+#[derive(Debug)]
+pub struct AlgoArena {
+    /// Trading arena.
+    arena: TradingArena,
+}
+
+impl Default for AlgoArena {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl AlgoArena {
+    /// Create a new AlgoArena.
+    #[must_use]
+    pub fn new() -> Self {
+        Self {
+            arena: TradingArena::new(),
+        }
+    }
+
+    /// Run a tournament.
+    pub fn run_tournament(
+        &mut self,
+        config: &TournamentConfig,
+    ) -> Result<TournamentResult, AlgoArenaError> {
+        // Validate config
+        if config.agents.is_empty() {
+            return Err(AlgoArenaError::NoAgents);
+        }
+
+        if config.assets.is_empty() {
+            return Err(AlgoArenaError::NoAssets);
+        }
+
+        if config.num_steps == 0 {
+            return Err(AlgoArenaError::InvalidConfig(
+                "num_steps must be > 0".to_string(),
+            ));
+        }
+
+        // Run simulation
+        self.arena.run(config)
+    }
+
+    /// Get the trading arena.
+    #[must_use]
+    pub fn arena(&self) -> &TradingArena {
+        &self.arena
+    }
+}
+
+/// Run the full demo.
+pub fn run_demo() -> Result<TournamentResult, AlgoArenaError> {
+    let mut arena = AlgoArena::new();
+    let config = sample_data::create_sample_tournament();
+    arena.run_tournament(&config)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use algoarena_shared::{
+        AgentConfig, AgentParameters, AssetConfig, StrategyType, sample_tournament,
+    };
+
+    #[test]
+    fn test_algoarena_creation() {
+        let arena = AlgoArena::new();
+        assert!(std::mem::size_of_val(&arena) > 0);
+    }
+
+    #[test]
+    fn test_run_tournament() {
+        let mut arena = AlgoArena::new();
+        let config = sample_tournament();
+
+        let result = arena.run_tournament(&config);
+        assert!(result.is_ok());
+
+        let tournament = result.unwrap();
+        assert!(!tournament.rankings.is_empty());
+        assert_eq!(tournament.rankings[0].rank, 1);
+    }
+
+    #[test]
+    fn test_no_agents_error() {
+        let mut arena = AlgoArena::new();
+        let config = TournamentConfig {
+            name: "Empty".to_string(),
+            num_steps: 100,
+            assets: vec![AssetConfig {
+                symbol: "TEST".to_string(),
+                initial_price: 100.0,
+                volatility: 0.01,
+                drift: 0.0,
+            }],
+            agents: vec![],
+            transaction_cost_bps: 10.0,
+            seed: Some(42),
+        };
+
+        let result = arena.run_tournament(&config);
+        assert!(matches!(result, Err(AlgoArenaError::NoAgents)));
+    }
+
+    #[test]
+    fn test_no_assets_error() {
+        let mut arena = AlgoArena::new();
+        let config = TournamentConfig {
+            name: "Empty".to_string(),
+            num_steps: 100,
+            assets: vec![],
+            agents: vec![AgentConfig {
+                id: "test".to_string(),
+                name: "Test".to_string(),
+                strategy: StrategyType::BuyAndHold,
+                initial_capital: 100_000.0,
+                parameters: AgentParameters::default(),
+            }],
+            transaction_cost_bps: 10.0,
+            seed: Some(42),
+        };
+
+        let result = arena.run_tournament(&config);
+        assert!(matches!(result, Err(AlgoArenaError::NoAssets)));
+    }
+
+    #[test]
+    fn test_run_demo() {
+        let result = run_demo();
+        assert!(result.is_ok());
+
+        let tournament = result.unwrap();
+        assert!(tournament.rankings.len() >= 3);
+    }
+}