Pulse wire crate

pulse-wire/src/lib.rs

@@ -0,0 +1,85 @@
+pub mod terminal;
+
+pub trait PulseCom {
+    fn to_com(&self) -> Vec<u8>;
+    fn from_com(_com: &mut Vec<u8>) -> Self;
+}
+
+impl<T: PulseCom> PulseCom for Vec<T> {
+    fn to_com(&self) -> Vec<u8> {
+        let mut vec = Vec::new();
+
+        vec.extend_from_slice(&(self.len() as u32).to_le_bytes());
+
+        for item in self {
+            vec.extend(item.to_com());
+        }
+
+        vec
+    }
+
+    fn from_com(com: &mut Vec<u8>) -> Self {
+        let len_bytes: [u8; 4] = com.drain(..4).collect::<Vec<_>>().try_into().unwrap();
+
+        let len = u32::from_le_bytes(len_bytes) as usize;
+
+        let mut result = Vec::with_capacity(len);
+
+        for _ in 0..len {
+            result.push(T::from_com(com));
+        }
+
+        result
+    }
+}
+
+impl PulseCom for String {
+    fn to_com(&self) -> Vec<u8> {
+        let bytes = self.as_bytes();
+        let mut out = Vec::with_capacity(4 + bytes.len());
+
+        out.extend_from_slice(&(bytes.len() as u32).to_le_bytes());
+        out.extend_from_slice(bytes);
+
+        out
+    }
+
+    fn from_com(com: &mut Vec<u8>) -> Self {
+        let len = u32::from_le_bytes(com[..4].try_into().unwrap()) as usize;
+        com.drain(..4);
+
+        let bytes: Vec<u8> = com.drain(..len).collect();
+        String::from_utf8(bytes).unwrap()
+    }
+}
+
+macro_rules! int_com {
+    ($t:ty) => {
+        impl PulseCom for $t {
+            fn to_com(&self) -> Vec<u8> {
+                self.to_le_bytes().to_vec()
+            }
+
+            fn from_com(com: &mut Vec<u8>) -> Self {
+                const N: usize = std::mem::size_of::<$t>();
+                let bytes: [u8; N] = com.drain(..N).collect::<Vec<_>>().try_into().unwrap();
+                <$t>::from_le_bytes(bytes)
+            }
+        }
+    };
+}
+
+int_com!(i8);
+int_com!(i16);
+int_com!(i32);
+int_com!(i64);
+int_com!(isize);
+
+int_com!(u8);
+int_com!(u16);
+int_com!(u32);
+int_com!(u64);
+int_com!(usize);
+
+int_com!(f64);
+int_com!(f32);

pulse-wire/src/terminal.rs

@@ -0,0 +1,175 @@
+use crate::PulseCom;
+use pulse_macros::p_com;
+
+#[p_com]
+pub struct WatchListItem {
+    symbol: String,
+    price: f64,
+    trend: f64,
+}
+
+#[p_com]
+pub struct ActivePosition {
+    symbol: String,
+    profit: f64,
+    amount: f64,
+}
+
+#[p_com]
+pub enum MarketTrend {
+    Bullish,
+    Bearish,
+    Neutral,
+}
+
+#[p_com]
+pub enum Volatility {
+    Low,
+    Medium,
+    High,
+}
+
+#[p_com]
+pub struct MarketOverview {
+    trend: MarketTrend,
+    volatility: Volatility,
+    pressure: f64,
+
+    alerts: Vec<Alert>,
+}
+
+#[p_com]
+pub enum Feed {
+    Connected,
+    Disconnected,
+    Connecting,
+    Failed,
+}
+
+#[p_com]
+pub struct Status {
+    feed: Feed,
+    exchange: String,
+    dex: String,
+    latency: u16,
+}
+
+#[p_com]
+pub enum SignalKind {
+    Buy,
+    Sell,
+}
+
+#[p_com]
+pub enum SignalParameter {
+    Lim,
+    Stl,
+    Tap,
+    Chk,
+}
+
+#[p_com]
+pub struct Signal {
+    kind: SignalKind,
+    symbol: String,
+    param: SignalParameter,
+    price: f64,
+}
+
+#[p_com]
+pub enum LogKind {
+    Info,
+    Warn,
+    Err,
+    Debug,
+}
+
+#[p_com]
+pub struct EventLog {
+    kind: LogKind,
+    name: String,
+    message: String,
+}
+
+#[p_com]
+pub enum AlertLevel {
+    High,
+    Medium,
+    Low,
+}
+
+#[p_com]
+pub struct Alert {
+    level: AlertLevel,
+    message: String,
+}
+
+#[p_com]
+pub enum InspectTarget {
+    None,
+    Symbol(WatchListItem),
+    Position(ActivePosition),
+    Signal(Signal),
+    Alert(Alert),
+}
+
+impl std::fmt::Display for MarketTrend {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Bullish => write!(f, "Bullish"),
+            Self::Bearish => write!(f, "Bearish"),
+            Self::Neutral => write!(f, "Neutral"),
+        }
+    }
+}
+
+impl std::fmt::Display for AlertLevel {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::High => write!(f, "H"),
+            Self::Medium => write!(f, "M"),
+            Self::Low => write!(f, "L"),
+        }
+    }
+}
+
+impl std::fmt::Display for Volatility {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Low => write!(f, "Low"),
+            Self::Medium => write!(f, "Medium"),
+            Self::High => write!(f, "High"),
+        }
+    }
+}
+
+impl std::fmt::Display for LogKind {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Info => write!(f, "INFO"),
+            Self::Warn => write!(f, "WARN"),
+            Self::Err => write!(f, "ERR"),
+            Self::Debug => write!(f, "DEBUG"),
+        }
+    }
+}
+
+impl std::fmt::Display for SignalKind {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Buy => write!(f, "BUY"),
+            Self::Sell => write!(f, "SELL"),
+        }
+    }
+}
+
+impl std::fmt::Display for SignalParameter {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Lim => write!(f, "LIM"),
+            Self::Stl => write!(f, "STL"),
+            Self::Tap => write!(f, "TAP"),
+            Self::Chk => write!(f, "CHK"),
+        }
+    }
+}