Stop loss order management

src/engine/engine/execution.rs

@@ -3,7 +3,7 @@ use hypersdk::hypercore::{
 };
 use pulse_sdk::prelude::*;
 
-use crate::engine::{Engine, risk::OrderIds};
+use crate::engine::Engine;
 
 impl Engine {
     pub async fn execute_signal(&self, signal: &Signal) -> tokio::io::Result<()> {
@@ -32,7 +32,7 @@ impl Engine {
                 return Ok(());
             };
 
-            let order_ids = OrderIds::new();
+            let order_ids = self.risk_engine.create_order().await?;
 
             let order = BatchOrder {
                 orders: vec![

src/engine/engine/risk.rs

@@ -18,21 +18,23 @@ pub struct OrderIds {
     pub entry: Cloid,
     pub take_profit: Cloid,
     pub stop_loss: Cloid,
+    pub risk_equity: Decimal,
 }
 
 impl OrderIds {
-    pub fn new() -> Self {
+    pub fn new(risk_equity: Decimal) -> Self {
         Self {
             entry: Cloid::random(),
             take_profit: Cloid::random(),
             stop_loss: Cloid::random(),
+            risk_equity,
         }
     }
 }
 
 pub struct RiskState {
     pub starting_equity: Decimal,
-    pub realized_pnl_today: Decimal,
+    pub pnl: Decimal,
     pub open_positions: usize,
 }
 
@@ -51,7 +53,7 @@ impl RiskEngine {
             handle: Mutex::new(handle),
             state: Mutex::new(RiskState {
                 starting_equity: 0.into(),
-                realized_pnl_today: 0.into(),
+                pnl: 0.into(),
                 open_positions: 0,
             }),
             engine,
@@ -101,7 +103,9 @@ impl RiskEngine {
                             }
 
                             for r in rm {
-                                self.orders.lock().await.remove(r);
+                                let order = self.orders.lock().await.remove(r);
+
+                                self.state.lock().await.pnl -= order.risk_equity;
                             }
                         }
                     }
@@ -140,6 +144,21 @@ impl RiskEngine {
         true
     }
 
+    pub async fn create_order(&self) -> tokio::io::Result<OrderIds> {
+        let state = self.state.lock().await;
+
+        Ok(OrderIds::new(
+            self.get_engine()
+                .config
+                .lock()
+                .await
+                .get_ref()?
+                .risk
+                .risk_per_trade
+                .get(state.starting_equity),
+        ))
+    }
+
     pub async fn order_placed(&self, order: OrderIds) {
         self.orders.lock().await.push(order);
     }