_

Author: valeratrades

Cargo.lock

@@ -112,7 +112,7 @@ pub(crate) async fn main(args: AdjustPosArgs, live_settings: Arc<LiveSettings>,
 	// Get current ticker price first
 	let symbol_raw = args.ticker.symbol.to_string();
 	let symbol = convert_symbol_to_bybit(&symbol_raw);
-	info!("Fetching current price for {} (converted from {})", symbol, symbol_raw);
+	info!("Fetching current price for {symbol} (converted from {symbol_raw})");
 
 	let ticker_params = BybitTickersParamsBuilder::default()
 		.category(BybitProductType::Linear)
@@ -128,7 +128,7 @@ pub(crate) async fn main(args: AdjustPosArgs, live_settings: Arc<LiveSettings>,
 	let ticker = ticker_response.result.list.get(0).ok_or_else(|| color_eyre::eyre::eyre!("No ticker data found for {}", symbol))?;
 
 	let current_price: f64 = ticker.last_price.parse().context("Failed to parse price as float")?;
-	info!("Current price: ${}", current_price);
+	info!("Current price: ${current_price}");
 
 	// Fetch instrument info to get lot size filter
 	let instruments_params = BybitInstrumentsInfoParamsBuilder::default()
@@ -156,10 +156,7 @@ pub(crate) async fn main(args: AdjustPosArgs, live_settings: Arc<LiveSettings>,
 	let price_filter = &instrument.price_filter;
 	let tick_size: f64 = price_filter.tick_size.parse().context("Failed to parse tickSize")?;
 
-	info!(
-		"Instrument info - qtyStep: {}, tickSize: {}, minOrderQty: {}, maxOrderQty: {}",
-		qty_step, tick_size, min_order_qty, max_order_qty
-	);
+	info!("Instrument info - qtyStep: {qty_step}, tickSize: {tick_size}, minOrderQty: {min_order_qty}, maxOrderQty: {max_order_qty}");
 
 	// Calculate quantity based on size type, extracting sign for order side
 	let (raw_quantity, side) = match size_type {
@@ -196,7 +193,7 @@ pub(crate) async fn main(args: AdjustPosArgs, live_settings: Arc<LiveSettings>,
 
 		// Create InstrumentId for ticker subscription
 		// Format: "SYMBOL.VENUE" e.g., "BTCUSDT.BYBIT"
-		let instrument_id = InstrumentId::from(format!("{}.BYBIT", symbol).as_str());
+		let instrument_id = InstrumentId::from(format!("{symbol}.BYBIT").as_str());
 
 		let filled_qty = crate::ws_chase_limit::execute_ws_chase_limit(
 			&raw_client, api_key, api_secret, environment, &symbol, instrument_id, side, quantity, qty_step, tick_size, args.duration,
@@ -217,7 +214,7 @@ pub(crate) async fn main(args: AdjustPosArgs, live_settings: Arc<LiveSettings>,
 		} else if qty_step >= 0.01 {
 			format!("{:.2}", quantity)
 		} else {
-			format!("{}", quantity)
+			format!("{quantity}")
 		};
 
 		// Prepare order request
@@ -232,7 +229,7 @@ pub(crate) async fn main(args: AdjustPosArgs, live_settings: Arc<LiveSettings>,
 			"reduceOnly": args.reduce,
 		});
 
-		info!("Submitting market {} order for {} {}", side, quantity, symbol);
+		info!("Submitting market {side} order for {quantity} {symbol}");
 
 		// Submit order
 		let order_response = client.place_order(&order_request).await.context("Failed to place order")?;
@@ -241,7 +238,7 @@ pub(crate) async fn main(args: AdjustPosArgs, live_settings: Arc<LiveSettings>,
 			println!("✅ Order submitted successfully!");
 			info!("Order submitted successfully!");
 			if let Some(order_id) = order_response.result.order_id {
-				println!("   Order ID: {}", order_id);
+				println!("   Order ID: {order_id}");
 			}
 			println!("   Quantity: {} {} (notional: ${:.2})", qty_str, symbol, actual_notional);
 			Ok(())

discretionary_engine/src/adjust_pos.rs

@@ -97,7 +97,7 @@ impl BybitAmendClient {
 		let param_str = serde_json::to_string(&params)?;
 
 		// Bybit signature: timestamp + api_key + recv_window + param_str
-		let sign_str = format!("{}{}{}{}", timestamp, self.api_key, recv_window, param_str);
+		let sign_str = format!("{timestamp}{}{recv_window}{param_str}", self.api_key);
 
 		let mut mac = Hmac::<Sha256>::new_from_slice(self.api_secret.as_bytes()).map_err(|e| color_eyre::eyre::eyre!("Invalid secret key: {}", e))?;
 		mac.update(sign_str.as_bytes());
@@ -139,7 +139,7 @@ impl BybitAmendClient {
 		let param_str = serde_json::to_string(&params)?;
 
 		// Bybit signature: timestamp + api_key + recv_window + param_str
-		let sign_str = format!("{}{}{}{}", timestamp, self.api_key, recv_window, param_str);
+		let sign_str = format!("{timestamp}{}{recv_window}{param_str}", self.api_key);
 
 		let mut mac = Hmac::<Sha256>::new_from_slice(self.api_secret.as_bytes()).map_err(|e| color_eyre::eyre::eyre!("Invalid secret key: {}", e))?;
 		mac.update(sign_str.as_bytes());

discretionary_engine/src/bybit_common.rs

@@ -23,7 +23,6 @@ use v_utils::{log, trades::Timeframe};
 /// * `symbol` - Trading symbol (Bybit format, e.g., "BTCUSDT")
 /// * `side` - Order side ("Buy" or "Sell")
 /// * `target_qty` - Total quantity to execute
-/// * `qty_step` - Minimum quantity increment for the instrument
 /// * `price_tick` - Minimum price increment for the instrument
 /// * `duration` - Optional duration to spread the execution over
 pub async fn execute_chase_limit(
@@ -32,11 +31,10 @@ pub async fn execute_chase_limit(
 	symbol: &str,
 	side: &str,
 	target_qty: f64,
-	qty_step: f64,
 	price_tick: f64,
 	duration: Option<Timeframe>,
 ) -> Result<f64> {
-	log!("Starting chase-limit execution for {} {} {}", side, target_qty, symbol);
+	log!("Starting chase-limit execution for {side} {target_qty} {symbol}");
 
 	// Calculate execution parameters based on duration
 	let (sleep_interval, end_time) = if let Some(duration_tf) = duration {
@@ -56,6 +54,7 @@ pub async fn execute_chase_limit(
 	let mut last_order_price: Option<f64> = None;
 	let mut iteration = 0;
 
+	//LOOP: very bad interface from the old implementation. Shouldn't be done this way, - will transfer to implementation through protocol primitives
 	loop {
 		iteration += 1;
 
@@ -134,7 +133,7 @@ pub async fn execute_chase_limit(
 			_ => bail!("Invalid side: {}", side),
 		};
 
-		info!("[{}] Market: bid={}, ask={}, target {} limit @ {}", iteration, bid_price, ask_price, side, limit_price);
+		info!("[{iteration}] Market: bid={bid_price}, ask={ask_price}, target {side} limit @ {limit_price}");
 
 		// Check if we should update the order
 		// Only update if price changed significantly (to avoid unnecessary cancel-replace)
@@ -146,7 +145,7 @@ pub async fn execute_chase_limit(
 		if should_update {
 			// Cancel existing order if there is one
 			if let Some(ref old_order_link_id) = current_order_link_id {
-				log!("[{}] Cancelling previous order to update price", iteration);
+				log!("[{iteration}] Cancelling previous order to update price");
 
 				let cancel_request = serde_json::json!({
 					"category": "linear",
@@ -162,10 +161,10 @@ pub async fn execute_chase_limit(
 			}
 
 			// Create new orderLinkId for this order
-			let new_order_link_id = format!("{}-{}", base_order_link_id, iteration);
+			let new_order_link_id = format!("{base_order_link_id}-{iteration}");
 
 			// Place new order at updated price
-			log!("[{}] Placing {} limit order: {} @ {}", iteration, side, target_qty, limit_price);
+			log!("[{iteration}] Placing {side} limit order: {target_qty} @ {limit_price}");
 
 			let order_request = serde_json::json!({
 				"category": "linear",
@@ -183,15 +182,15 @@ pub async fn execute_chase_limit(
 			if order_response.ret_code == 0 {
 				current_order_link_id = Some(new_order_link_id);
 				last_order_price = Some(limit_price);
-				info!("[{}] Order placed successfully", iteration);
+				info!("[{iteration}] Order placed successfully");
 			} else if order_response.ret_code == 10001 || order_response.ret_msg.contains("post only") || order_response.ret_msg.contains("would cross") {
-				info!("[{}] PostOnly rejected (would cross spread): {}, will retry", iteration, order_response.ret_msg);
+				info!("[{iteration}] PostOnly rejected (would cross spread): {}, will retry", order_response.ret_msg);
 				// Don't update last_order_price or current_order_link_id, will retry next iteration
 			} else {
 				log!("Order placement warning: {} (code: {})", order_response.ret_msg, order_response.ret_code);
 			}
 		} else {
-			info!("[{}] Price unchanged, keeping order at {}", iteration, last_order_price.unwrap_or(0.0));
+			info!("[{iteration}] Price unchanged, keeping order at {}", last_order_price.unwrap_or(0.0));
 		}
 
 		// Sleep before next iteration
@@ -204,6 +203,6 @@ pub async fn execute_chase_limit(
 		}
 	}
 
-	log!("Chase-limit execution completed for {} {}", target_qty, symbol);
+	log!("Chase-limit execution completed for {target_qty} {symbol}");
 	Ok(target_qty)
 }

discretionary_engine/src/chase_limit.rs

@@ -108,7 +108,7 @@ pub async fn signed_request<S: AsRef<str>>(http_method: reqwest::Method, endpoin
 
 	for attempt in 0..max_retries {
 		let time_ms = Utc::now().timestamp_millis();
-		params.insert("timestamp", format!("{}", time_ms));
+		params.insert("timestamp", format!("{time_ms}"));
 
 		let query_string = serde_urlencoded::to_string(&params)?;
 
@@ -117,7 +117,7 @@ pub async fn signed_request<S: AsRef<str>>(http_method: reqwest::Method, endpoin
 		let mac_bytes = mac.finalize().into_bytes();
 		let signature = hex::encode(mac_bytes);
 
-		let url = format!("{}?{}&signature={}", endpoint_str, query_string, signature);
+		let url = format!("{endpoint_str}?{query_string}&signature={signature}");
 		let r = client.request(http_method.clone(), &url).send().await?;
 
 		if r.status().is_success() {

discretionary_engine/src/exchange_apis/binance/mod.rs

@@ -131,7 +131,7 @@ async fn main() -> Result<()> {
 	let live_settings = match LiveSettings::new(cli.settings, Duration::from_secs(5)) {
 		Ok(ls) => Arc::new(ls),
 		Err(e) => {
-			eprintln!("Loading config failed: {}", e);
+			eprintln!("Loading config failed: {e}");
 			std::process::exit(1);
 		}
 	};
@@ -199,12 +199,12 @@ async fn command_new(position_args: PositionArgs, live_settings: Arc<LiveSetting
 	let balance = match Exchanges::compile_total_balance(exchanges_arc.clone(), live_settings.clone()).await {
 		Ok(b) => b,
 		Err(e) => {
-			eprintln!("Failed to get balance: {}", e);
+			eprintln!("Failed to get balance: {e}");
 			std::process::exit(1);
 		}
 	};
-	info!("Total balance: {}", balance);
-	println!("Current total available balance: {}", balance);
+	info!("Total balance: {balance}");
+	println!("Current total available balance: {balance}");
 
 	let (side, target_size) = match position_args.size_usdt {
 		s if s > 0.0 => (Side::Buy, s),