Order size

pulse-sdk/src/terminal.rs

@@ -4,7 +4,7 @@ use crate::{
 };
 use hypersdk::Decimal;
 
-pub type SignalStatus = Result<Signal, Signal>;
+pub type SignalStatus = Result<(Signal, Option<Decimal>), (Signal, Option<Decimal>)>;
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum TerminalServerMessage {

src/engine/engine/execution.rs

@@ -1,12 +1,19 @@
-use hypersdk::hypercore::{
+use hypersdk::{
-    self, BatchOrder, OrderRequest, OrderResponseStatus, OrderTypePlacement, Side, TimeInForce,
+    Decimal,
+    hypercore::{
+        self, BatchOrder, OrderRequest, OrderResponseStatus, OrderTypePlacement, Side, TimeInForce,
+    },
 };
 use pulse_sdk::prelude::*;
 
 use crate::engine::Engine;
 
 impl Engine {
-    pub async fn execute_signal(&self, signal: &Signal) -> anyhow::Result<()> {
+    pub async fn execute_signal(
+        &self,
+        size: &mut Option<Decimal>,
+        signal: &Signal,
+    ) -> anyhow::Result<()> {
         let client = hypercore::mainnet();
         let accounts = self.accounts.lock().await;
 
@@ -30,6 +37,8 @@ impl Engine {
 
         let engine_order = self.risk_engine.create_order(signal).await?;
 
+        *size = Some(engine_order.size);
+
         let order = BatchOrder {
             orders: vec![
                 OrderRequest {

src/engine/engine/strategy.rs

@@ -153,7 +153,7 @@ impl StrategyEngine {
 
                 Some(StrategyMessage::Signal(mut signal)) => {
                     if !engine.risk_engine.validate_signal(&mut signal).await? {
-                        engine.signals.lock().await.push(Err(signal));
+                        engine.signals.lock().await.push(Err((signal, None)));
 
                         engine
                             .terminal_server
@@ -163,15 +163,17 @@ impl StrategyEngine {
                         continue;
                     }
 
-                    let result = match engine.execute_signal(&signal).await {
+                    let mut size = None;
-                        Ok(_) => Ok(signal),
+
+                    let result = match engine.execute_signal(&mut size, &signal).await {
+                        Ok(_) => Ok((signal, size)),
                         Err(e) => {
                             engine
                                 .terminal_server
                                 .error("engine::order", &format!("Failed to execute signal: {e}"))
                                 .await?;
 
-                            Err(signal)
+                            Err((signal, size))
                         }
                     };
 

src/terminal/formatting.rs

@@ -55,7 +55,7 @@ impl Formatted for EventLog {
 impl Formatted for SignalStatus {
     fn get_formatted(&self) -> Vec<String> {
         match self {
-            Ok(signal) | Err(signal) => {
+            Ok((signal, size)) | Err((signal, size)) => {
                 vec![
                     if matches!(self, Ok(_)) {
                         format!("\x1b[34mOK\x1b[0m")
@@ -67,6 +67,7 @@ impl Formatted for SignalStatus {
                     } else {
                         format!("\x1b[31mSELL\x1b[0m")
                     },
+                    size.map(|v| format_f64(v.as_f64())).unwrap_or_default(),
                     format_symbol(&signal.symbol),
                     format_usd(signal.entry_price.as_f64()),
                     format_usd(signal.take_profit.as_f64()),