rw: strategy: proper types for protocols (some v_exchanges typing use)

Author: valeratrades

Cargo.lock

@@ -31,9 +31,12 @@ tracing = { version = "^0.1.44", features = ["log", "std", "async-await"] }
 v_exchanges = { version = "^0.16.7", features = ["full"] }
 v_utils = { version = "2.15.11", features = ["full"] }
 
-#[patch.crates-io]
-#v_utils = { path = "../v_utils/v_utils" }
-#v_utils_macros = { path = "../v_utils/v_utils_macros" }
+[patch.crates-io]
+v_exchanges = { path = "../v_exchanges/v_exchanges" }
+v_exchanges_adapters = { path = "../v_exchanges/v_exchanges_adapters" }
+v_exchanges_api_generics = { path = "../v_exchanges/v_exchanges_api_generics" }
+v_utils = { path = "../v_utils/v_utils" }
+v_utils_macros = { path = "../v_utils/v_utils_macros" }
 
 [profile.dev]
 # codegen-backend = "cranelift"  # disabled due to aws-lc-rs incompatibility

Cargo.toml

@@ -16,13 +16,18 @@ cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]
 [dependencies]
 clap = { workspace = true }
 color-eyre = { workspace = true }
+derive-new = "0.7"
+discretionary_engine_macros = { path = "../discretionary_engine_macros" }
+eyre = "0.6"
 futures-util = "0.3.31"
 nautilus-bybit = { path = "../libs/nautilus_trader/crates/adapters/bybit", default-features = false }
 nautilus-model = { path = "../libs/nautilus_trader/crates/model" }
 redis = { version = "0.27", features = ["tokio-comp", "streams"] }
+serde = { workspace = true }
 tokio = { version = "^1.48.0", features = ["full", "signal"] }
 tracing = { workspace = true }
 tracing-subscriber = { version = "^0.3.20", features = ["fmt", "env-filter"] }
+v_exchanges = { workspace = true }
 v_utils = { workspace = true }
 
 [dev-dependencies]

discretionary_engine_strategy/Cargo.toml

@@ -22,6 +22,7 @@
 pub mod commands;
 pub mod config;
 pub mod data;
+pub mod order_types;
 pub mod protocols;
 pub mod redis_bus;
 pub mod strategy;

discretionary_engine_strategy/src/lib.rs

@@ -120,11 +120,11 @@ async fn main() -> Result<()> {
 
 			// Build CLI string and publish to Redis
 			let cli_string = build_cli_string(&args, cli.testnet);
-			println!("Publishing command: {}", cli_string);
+			println!("Publishing command: {cli_string}");
 
 			let mut conn = redis_bus::connect(cli.redis_port).await?;
 			let id = redis_bus::publish_command(&mut conn, &cli_string).await?;
-			println!("Command published with ID: {}", id);
+			println!("Command published with ID: {id}");
 		}
 		Commands::Adjust(args) => {
 			//Q: think logic should be very similar right, - we just validate, then submit over into the actual execution. Just slightly different set of commands that could be passed here

discretionary_engine_strategy/src/main.rs

@@ -0,0 +1,114 @@
+//! Order type definitions for the strategy engine.
+
+use std::hash::Hash;
+
+use color_eyre::eyre::{Result, bail};
+use derive_new::new;
+use serde::{Deserialize, Serialize};
+use v_exchanges::core::Symbol;
+use v_utils::{Percent, trades::Side};
+
+pub trait IdRequirements: Hash + Clone + PartialEq + Default + std::fmt::Debug {}
+impl<T: Hash + Clone + PartialEq + Default + std::fmt::Debug> IdRequirements for T {}
+
+#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize, new)]
+pub struct Order<Id: IdRequirements> {
+	pub id: Id,
+	pub order_type: OrderType,
+	pub symbol: Symbol,
+	pub side: Side,
+	pub qty_notional: f64,
+}
+
+#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
+pub enum OrderType {
+	#[default]
+	Market,
+	StopMarket(StopMarketOrder),
+}
+
+#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize, new)]
+pub struct StopMarketOrder {
+	pub price: f64,
+}
+
+//=============================================================================
+// Conceptual Orders
+//=============================================================================
+
+#[derive(Clone, Debug, Default, Deserialize, Hash, PartialEq, Serialize, new)]
+pub struct ProtocolOrderId {
+	pub protocol_signature: String,
+	pub ordinal: usize,
+}
+
+#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize, new)]
+pub struct ConceptualOrder<Id: IdRequirements> {
+	pub id: Id,
+	pub order_type: ConceptualOrderType,
+	pub symbol: Symbol,
+	pub side: Side,
+	pub qty_notional: f64,
+}
+
+impl<Id: IdRequirements> ConceptualOrder<Id> {
+	pub fn price(&self) -> Result<f64> {
+		match &self.order_type {
+			ConceptualOrderType::Market(_) => bail!("Market orders don't have a price"),
+			ConceptualOrderType::Limit(l) => Ok(l.price),
+			ConceptualOrderType::StopMarket(s) => Ok(s.price),
+		}
+	}
+}
+
+/// Generics for defining order types and their whereabouts. Details of execution do not concern us here.
+#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize)]
+pub enum ConceptualOrderType {
+	Market(ConceptualMarket),
+	Limit(ConceptualLimit),
+	StopMarket(ConceptualStopMarket),
+}
+
+impl Default for ConceptualOrderType {
+	fn default() -> Self {
+		ConceptualOrderType::Market(ConceptualMarket::default())
+	}
+}
+
+/// Will be executed via above-the-price limits most of the time to prevent excessive slippages.
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, new)]
+pub struct ConceptualMarket {
+	/// 1.0 will be translated into an actual Market order. Others, most of the time, will be expressed via limit orders.
+	pub maximum_slippage_percent: Percent,
+}
+
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, new)]
+pub struct ConceptualStopMarket {
+	pub price: f64,
+}
+
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize, new)]
+pub struct ConceptualLimit {
+	pub price: f64,
+	pub limit_only: bool,
+}
+
+#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize, new)]
+pub struct ConceptualOrderPercents {
+	pub order_type: ConceptualOrderType,
+	pub symbol: Symbol,
+	pub side: Side,
+	pub qty_percent_of_controlled: Percent,
+}
+
+impl ConceptualOrderPercents {
+	pub fn to_exact<Id: IdRequirements>(self, total_controlled_size: f64, id: Id) -> ConceptualOrder<Id> {
+		ConceptualOrder {
+			id,
+			order_type: self.order_type,
+			symbol: self.symbol,
+			side: self.side,
+			qty_notional: total_controlled_size * *self.qty_percent_of_controlled,
+		}
+	}
+}

discretionary_engine_strategy/src/order_types.rs

@@ -1,70 +1,80 @@
 //! DummyMarket protocol - sends a single market order.
 
-use std::{fmt, str::FromStr};
+use color_eyre::eyre::Result;
+use discretionary_engine_macros::ProtocolWrapper;
+use tokio::{sync::mpsc, task::JoinSet};
+use v_exchanges::core::{Instrument, Symbol};
+use v_utils::{
+	Percent,
+	macros::CompactFormat,
+	trades::{Pair, Side},
+};
 
-use color_eyre::eyre::{Result, bail};
+use super::{ProtocolOrders, ProtocolTrait, ProtocolType};
+use crate::order_types::{ConceptualMarket, ConceptualOrderPercents, ConceptualOrderType};
 
-/// A protocol that simply sends one market order.
-///
-/// This is the simplest possible protocol, used for testing and debugging.
-#[derive(Clone, Debug, Default)]
-pub struct DummyMarket;
+/// Literally just sends one market order.
+#[derive(Clone, CompactFormat, Debug, Default, ProtocolWrapper, derive_new::new)]
+pub struct DummyMarket {}
 
-impl DummyMarket {
-	/// Protocol prefix used for parsing.
-	pub const PREFIX: &'static str = "dm";
-}
+impl ProtocolTrait for DummyMarketWrapper {
+	type Params = DummyMarket;
+
+	fn attach(&self, set: &mut JoinSet<Result<()>>, tx_orders: mpsc::Sender<ProtocolOrders>, asset: String, protocol_side: Side) -> Result<()> {
+		let symbol = Symbol::new(Pair::new(asset, "USDT".to_string()), Instrument::Perp);
+		let m = ConceptualMarket::new(Percent(1.0));
+		let order = ConceptualOrderPercents::new(ConceptualOrderType::Market(m), symbol, protocol_side, Percent::new(1.0));
 
-impl fmt::Display for DummyMarket {
-	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-		write!(f, "{}", Self::PREFIX)
+		let protocol_spec = self.0.read().unwrap().to_string();
+		let protocol_orders = ProtocolOrders::new(protocol_spec, vec![Some(order)]);
+		set.spawn(async move {
+			tx_orders.send(protocol_orders).await.unwrap();
+			// LOOP: it's a dummy protocol, relax
+			loop {
+				tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
+			}
+			#[expect(unreachable_code)]
+			Ok(())
+		});
+		Ok(())
 	}
-}
 
-impl FromStr for DummyMarket {
-	type Err = color_eyre::eyre::Report;
+	fn update_params(&self, _params: Self::Params) -> Result<()> {
+		unimplemented!()
+	}
 
-	fn from_str(spec: &str) -> Result<Self> {
-		// Accept "dm" or "dm:" with no additional params
-		let trimmed = spec.trim();
-		if trimmed == Self::PREFIX || trimmed.starts_with(&format!("{}:", Self::PREFIX)) {
-			// For now, DummyMarket has no parameters
-			let after_prefix = trimmed.strip_prefix(Self::PREFIX).unwrap_or("");
-			let after_colon = after_prefix.strip_prefix(':').unwrap_or(after_prefix);
-			if after_colon.is_empty() {
-				return Ok(DummyMarket);
-			}
-			bail!("DummyMarket does not accept parameters, got: {after_colon}");
-		}
-		bail!("Expected protocol spec starting with '{}', got: {spec}", Self::PREFIX)
+	fn get_type(&self) -> ProtocolType {
+		ProtocolType::StopEntry
 	}
 }
 
 #[cfg(test)]
 mod tests {
+	use std::str::FromStr;
+
 	use super::*;
 
 	#[test]
 	fn parse_dm() {
-		let dm = DummyMarket::from_str("dm").unwrap();
-		assert_eq!(dm.to_string(), "dm");
+		let dm = DummyMarketWrapper::from_str("dm").unwrap();
+		assert_eq!(dm.signature(), "dm");
 	}
 
 	#[test]
 	fn parse_dm_with_colon() {
-		let dm = DummyMarket::from_str("dm:").unwrap();
-		assert_eq!(dm.to_string(), "dm");
+		let dm = DummyMarketWrapper::from_str("dm:").unwrap();
+		assert_eq!(dm.signature(), "dm");
 	}
 
 	#[test]
 	fn parse_dm_with_params_fails() {
-		let result = DummyMarket::from_str("dm:p0.5");
+		let result = DummyMarketWrapper::from_str("dm:p0.5");
 		assert!(result.is_err());
 	}
 
 	#[test]
 	fn parse_wrong_prefix_fails() {
-		let result = DummyMarket::from_str("ts:p0.5");
+		let result = DummyMarketWrapper::from_str("ts:p0.5");
 		assert!(result.is_err());
 	}
 }