Better formatting

src/terminal/formatting.rs

@@ -1,6 +1,6 @@
 use pulse_sdk::prelude::*;
 
-use hypersdk::hypercore::Side;
+use hypersdk::{Decimal, hypercore::Side};
 
 pub trait Formatted {
     fn get_formatted(&self) -> Vec<String>;
@@ -68,12 +68,12 @@ impl Formatted for SignalStatus {
                         format!("\x1b[31mSELL\x1b[0m")
                     },
                     format_symbol(&signal.symbol),
-                    format_usd(signal.entry_price.as_f64()),
+                    format_usd(signal.entry_price),
-                    format_usd(signal.take_profit.as_f64()),
+                    format_usd(signal.take_profit),
                 ];
 
                 if let Some(order) = order {
-                    base.extend(vec![format_usd_reverse(order.stop_loss.as_f64())]);
+                    base.extend(vec![format_usd_reverse(order.stop_loss)]);
                 }
 
                 base
@@ -86,8 +86,8 @@ impl Formatted for MarketItem {
     fn get_formatted(&self) -> Vec<String> {
         vec![
             format_symbol(&self.symbol),
-            format_usd(self.price.as_f64()),
+            format_usd(self.price),
-            format_usd(self.volume_24h.as_f64()),
+            format_usd(self.volume_24h),
             format!(
                 "{} {}%",
                 if self.trend.is_sign_positive() {
@@ -95,7 +95,7 @@ impl Formatted for MarketItem {
                 } else {
                     "\x1b[31m▼\x1b[0m"
                 },
-                format_f64(self.trend.as_f64().abs())
+                format_decimal(self.trend.abs())
             ),
         ]
     }
@@ -105,17 +105,9 @@ impl Formatted for Position {
     fn get_formatted(&self) -> Vec<String> {
         vec![
             format_symbol(&self.symbol),
-            format_f64(self.size.as_f64()),
+            format_decimal(self.size),
             self.entry_price.to_string(),
-            format!(
+            format_usd(self.pnl),
-                "{}{}\x1b[0m",
-                if self.pnl.is_sign_positive() {
-                    "\x1b[32m"
-                } else {
-                    "\x1b[31m"
-                },
-                self.pnl,
-            ),
         ]
     }
 }
@@ -201,7 +193,7 @@ impl Formatted for EngineStatus {
                 "\x1b[2mStrategy Mode\x1b[0m",
             ),
             Triple(
-                &format_usd(self.perps_equity.as_f64()),
+                &format_usd(self.perps_equity),
                 &self.strategy_state.to_string(),
                 &self.strategy_mode.to_string(),
             ),
@@ -248,8 +240,8 @@ pub fn apply_padding(mut items: Vec<String>) -> Vec<String> {
 
 pub fn format_inspect_item(item: &InspectItem) -> String {
     match item {
-        InspectItem::F64(v) => format_f64(v.as_f64()),
+        InspectItem::F64(v) => format_decimal(*v),
-        InspectItem::USD(v) => format!("${}", format_f64(v.as_f64())),
+        InspectItem::USD(v) => format!("${}", format_decimal(*v)),
         InspectItem::Symbol(v) => format!("\x1b[35m{v}\x1b[0m"),
         InspectItem::Name(v) => v.clone(),
     }
@@ -259,73 +251,36 @@ pub fn format_symbol(value: &str) -> String {
     format!("\x1b[35m{value}\x1b[0m")
 }
 
-pub fn format_usd(value: f64) -> String {
+pub fn format_usd(value: Decimal) -> String {
     if value.is_sign_positive() {
-        format!("\x1b[32m${}\x1b[0m", format_f64(value))
+        format!("\x1b[32m${}\x1b[0m", format_decimal(value))
     } else {
-        format!("\x1b[31m${}\x1b[0m", format_f64(value))
+        format!("\x1b[31m-${}\x1b[0m", format_decimal(value.abs()))
     }
 }
 
-pub fn format_usd_reverse(value: f64) -> String {
+pub fn format_usd_reverse(value: Decimal) -> String {
     if value.is_sign_positive() {
-        format!("\x1b[31m${}\x1b[0m", format_f64(value))
+        format!("\x1b[31m${}\x1b[0m", format_decimal(value))
     } else {
-        format!("\x1b[32m${}\x1b[0m", format_f64(value))
+        format!("\x1b[32m-${}\x1b[0m", format_decimal(value.abs()))
     }
 }
 
-pub fn format_f64(value: f64) -> String {
+pub fn format_decimal(value: Decimal) -> String {
     let abs = value.abs();
 
-    let (divisor, suffix) = if abs >= 1_000_000_000.0 {
+    let (divisor, suffix) = if abs >= Decimal::from(1_000_000_000u64) {
-        (1_000_000_000.0, "B")
+        (Decimal::from(1_000_000_000u64), "B")
-    } else if abs >= 1_000_000.0 {
+    } else if abs >= Decimal::from(1_000_000u64) {
-        (1_000_000.0, "M")
+        (Decimal::from(1_000_000u64), "M")
-    } else if abs >= 1_000.0 {
+    } else if abs >= Decimal::from(1_000u64) {
-        (1_000.0, "K")
+        (Decimal::from(1_000u64), "K")
     } else {
-        (1.0, "")
+        return value.round_dp(3).normalize().to_string();
     };
 
-    if divisor != 1.0 {
+    let formatted = (value / divisor).round_dp(3).normalize();
-        let formatted = value / divisor;
 
-        // Remove unnecessary trailing zeros
+    format!("{formatted}{suffix}")
-        let s = format!("{:.2}", formatted)
-            .trim_end_matches('0')
-            .trim_end_matches('.')
-            .to_string();
-
-        return format!("{}{}", s, suffix);
-    }
-
-    let val = format!("{:.3}", value);
-    let parts: Vec<&str> = val.split('.').collect();
-
-    let int = parts[0].to_string();
-    let negative = int.starts_with('-');
-
-    let start = if negative { 1 } else { 0 };
-    let mut result = String::new();
-
-    for (i, c) in int[start..].chars().rev().enumerate() {
-        if i > 0 && i % 3 == 0 {
-            result.push(',');
-        }
-        result.push(c);
-    }
-
-    let mut formatted: String = result.chars().rev().collect();
-
-    if negative {
-        formatted.insert(0, '-');
-    }
-
-    if parts.len() > 1 {
-        formatted.push('.');
-        formatted.push_str(parts[1]);
-    }
-
-    formatted
 }