chore: add base clap interface

Author: valeratrades

.pre-commit-config.yaml

@@ -1 +1 @@
-/nix/store/wnzsd16man9civsdvahfpklfkprzw9x4-pre-commit-config.json
+/nix/store/bydqjjc5cihzr4k1ws1wl0kjl4r106x9-pre-commit-config.json

Cargo.lock

@@ -21,12 +21,12 @@ tabs_in_doc_comments = "allow"
 clap = { version = "^4.5.53", features = ["derive"] }
 color-eyre = "^0.6.5"
 insta = { version = "1.45.0", features = ["json"] }
-jiff = "^0.2.16"
+jiff = "^0.2.17"
 secrecy = { version = "0.10.3", features = ["serde"] }
 snapshot_fonts = "1.2.0"
 strum = { version = "0.27", features = ["derive"] }
-tracing = { version = "^0.1.41", features = ["log", "std", "async-await"] }
-v_exchanges = { version = "^0.16.3", features = ["full"] }
+tracing = { version = "^0.1.44", features = ["log", "std", "async-await"] }
+v_exchanges = { version = "^0.16.7", features = ["full"] }
 v_utils = { version = "2.15.9", features = ["full"] }
 
 #[patch.crates-io]

Cargo.toml

@@ -10,16 +10,21 @@
 //! - **Strategy Layer** (`strategy.rs`): Exchange-agnostic strategy implementations that only
 //!   work with Nautilus types (`TradeTick`, `QuoteTick`, `Bar`, etc.).
 //!
+//! - **Protocols** (`protocols/`): Protocol definitions and deserialization.
+//!
 //! This separation ensures:
 //! 1. Strategies can be easily tested with mock data
 //! 2. Strategies can switch between exchanges without code changes
 //! 3. The same strategy code works for backtesting and live trading
 
 pub mod data;
+pub mod protocols;
 pub mod strategy;
 
 mod start;
 
 use clap as _;
+#[cfg(test)]
+use insta as _;
 pub use start::start;
 use tracing_subscriber as _;

discretionary_engine_strategy/src/lib.rs

@@ -1,5 +1,6 @@
-use clap::{Parser, Subcommand};
+use clap::{Args, Parser, Subcommand};
 use color_eyre::eyre::Result;
+use discretionary_engine_strategy::protocols::interpret_protocol_specs;
 use futures_util as _;
 use nautilus_bybit as _;
 use nautilus_model as _;
@@ -10,14 +11,35 @@ use tracing::level_filters::LevelFilter;
 struct Cli {
 	#[command(subcommand)]
 	command: Commands,
+	/// Use testnet instead of mainnet
+	#[arg(long, global = true)]
+	testnet: bool,
 }
 
 #[derive(Subcommand)]
 enum Commands {
-	/// Start the strategy with live market data
+	/// Submit a position request
+	Submit(PositionArgs),
+	/// Start the strategy with live market data (legacy)
 	Start,
 }
 
+#[derive(Args, Clone, Debug)]
+struct PositionArgs {
+	/// Target change in exposure. So positive for buying, negative for selling.
+	#[arg(short, long, allow_hyphen_values = true)]
+	size_usdt: f64,
+	/// _only_ the coin name itself. e.g. "BTC" or "ETH". Providing full symbol currently will error on the stage of making price requests for the coin.
+	#[arg(short, long)]
+	coin: String,
+	/// acquisition protocols parameters, in the format of "<protocol>-<params>", e.g. "ts:p0.5". Params consist of their starting letter followed by the value, e.g. "p0.5" for 0.5% offset. If multiple params are required, they are separated by '-'.
+	#[arg(short, long)]
+	acquisition_protocols: Vec<String>,
+	/// followup protocols parameters, in the format of "<protocol>-<params>", e.g. "ts:p0.5". Params consist of their starting letter followed by the value, e.g. "p0.5" for 0.5% offset. If multiple params are required, they are separated by '-'.
+	#[arg(short, long)]
+	followup_protocols: Vec<String>,
+}
+
 #[tokio::main]
 async fn main() -> Result<()> {
 	color_eyre::install()?;
@@ -27,6 +49,24 @@ async fn main() -> Result<()> {
 	let cli = Cli::parse();
 
 	match cli.command {
+		Commands::Submit(args) => {
+			// Parse and validate protocols (no execution yet)
+			let acquisition_protocols = interpret_protocol_specs(args.acquisition_protocols)?;
+			let followup_protocols = interpret_protocol_specs(args.followup_protocols)?;
+
+			println!("Position: {} USDT of {}", args.size_usdt, args.coin);
+			println!("Testnet: {}", cli.testnet);
+			println!();
+			println!("Acquisition protocols ({}):", acquisition_protocols.len());
+			for (i, protocol) in acquisition_protocols.iter().enumerate() {
+				println!("  [{}] {:?} -> {}", i, protocol, protocol.signature());
+			}
+			println!();
+			println!("Followup protocols ({}):", followup_protocols.len());
+			for (i, protocol) in followup_protocols.iter().enumerate() {
+				println!("  [{}] {:?} -> {}", i, protocol, protocol.signature());
+			}
+		}
 		Commands::Start => discretionary_engine_strategy::start().await?,
 	}
 

discretionary_engine_strategy/src/main.rs

@@ -0,0 +1,70 @@
+//! DummyMarket protocol - sends a single market order.
+
+use std::{fmt, str::FromStr};
+
+use color_eyre::eyre::{Result, bail};
+
+/// 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;
+
+impl DummyMarket {
+	/// Protocol prefix used for parsing.
+	pub const PREFIX: &'static str = "dm";
+}
+
+impl fmt::Display for DummyMarket {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		write!(f, "{}", Self::PREFIX)
+	}
+}
+
+impl FromStr for DummyMarket {
+	type Err = color_eyre::eyre::Report;
+
+	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)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn parse_dm() {
+		let dm = DummyMarket::from_str("dm").unwrap();
+		assert_eq!(dm.to_string(), "dm");
+	}
+
+	#[test]
+	fn parse_dm_with_colon() {
+		let dm = DummyMarket::from_str("dm:").unwrap();
+		assert_eq!(dm.to_string(), "dm");
+	}
+
+	#[test]
+	fn parse_dm_with_params_fails() {
+		let result = DummyMarket::from_str("dm:p0.5");
+		assert!(result.is_err());
+	}
+
+	#[test]
+	fn parse_wrong_prefix_fails() {
+		let result = DummyMarket::from_str("ts:p0.5");
+		assert!(result.is_err());
+	}
+}

discretionary_engine_strategy/src/protocols/dummy_market.rs

@@ -0,0 +1,52 @@
+//! Protocol module for discretionary_engine_strategy.
+//!
+//! This is a simplified version focused only on protocol deserialization,
+//! without execution logic.
+
+mod dummy_market;
+
+use std::str::FromStr;
+
+use color_eyre::eyre::{Result, bail};
+pub use dummy_market::DummyMarket;
+
+/// Protocol types supported by the strategy engine.
+#[derive(Clone, Debug)]
+pub enum Protocol {
+	DummyMarket(DummyMarket),
+}
+
+impl FromStr for Protocol {
+	type Err = color_eyre::eyre::Report;
+
+	fn from_str(spec: &str) -> Result<Self> {
+		if let Ok(dm) = DummyMarket::from_str(spec) {
+			Ok(Protocol::DummyMarket(dm))
+		} else {
+			bail!("Could not convert string to any Protocol\nString: {spec}")
+		}
+	}
+}
+
+impl Protocol {
+	/// Get the protocol signature (its string representation).
+	pub fn signature(&self) -> String {
+		match self {
+			Protocol::DummyMarket(dm) => dm.to_string(),
+		}
+	}
+}
+
+/// Parse protocol specs from command line arguments.
+pub fn interpret_protocol_specs(protocol_specs: Vec<String>) -> Result<Vec<Protocol>> {
+	let protocol_specs: Vec<String> = protocol_specs.into_iter().filter(|s| !s.is_empty()).collect();
+	if protocol_specs.is_empty() {
+		bail!("No protocols specified");
+	}
+	let mut protocols = Vec::new();
+	for spec in protocol_specs {
+		let protocol = Protocol::from_str(&spec)?;
+		protocols.push(protocol);
+	}
+	Ok(protocols)
+}