style: format futures paper files

Author: kdkiss

src/commands/futures_paper.rs

@@ -310,7 +310,12 @@ pub async fn run(
             size,
             price,
             stop_price,
-        } => cmd_edit_order(&order_id, size.as_deref(), price.as_deref(), stop_price.as_deref())?,
+        } => cmd_edit_order(
+            &order_id,
+            size.as_deref(),
+            price.as_deref(),
+            stop_price.as_deref(),
+        )?,
 
         FuturesPaperCommand::Cancel {
             order_id,
@@ -486,8 +491,8 @@ async fn cmd_place_order(
         .parse()
         .map_err(|_| BybitError::Paper(format!("Invalid size: {size_str}")))?;
 
-    let order_type = FuturesOrderType::from_str(order_type_str)
-        .map_err(|e| BybitError::Paper(e))?;
+    let order_type =
+        FuturesOrderType::from_str(order_type_str).map_err(|e| BybitError::Paper(e))?;
 
     let price = price_str
         .map(|s| s.parse::<f64>())
@@ -497,7 +502,12 @@ async fn cmd_place_order(
     let stop_price = stop_price_str
         .map(|s| s.parse::<f64>())
         .transpose()
-        .map_err(|_| BybitError::Paper(format!("Invalid stop_price: {}", stop_price_str.unwrap_or(""))))?;
+        .map_err(|_| {
+            BybitError::Paper(format!(
+                "Invalid stop_price: {}",
+                stop_price_str.unwrap_or("")
+            ))
+        })?;
 
     let trigger_signal = trigger_signal_str
         .map(|s| TriggerSignal::from_str(s))
@@ -507,7 +517,9 @@ async fn cmd_place_order(
     let leverage = leverage_str
         .map(|s| s.parse::<f64>())
         .transpose()
-        .map_err(|_| BybitError::Paper(format!("Invalid leverage: {}", leverage_str.unwrap_or(""))))?;
+        .map_err(|_| {
+            BybitError::Paper(format!("Invalid leverage: {}", leverage_str.unwrap_or("")))
+        })?;
 
     let trailing_max_dev = trailing_max_dev_str
         .map(|s| s.parse::<f64>())
@@ -613,7 +625,12 @@ fn cmd_edit_order(
     let stop_price = stop_price_str
         .map(|s| s.parse::<f64>())
         .transpose()
-        .map_err(|_| BybitError::Paper(format!("Invalid stop_price: {}", stop_price_str.unwrap_or(""))))?;
+        .map_err(|_| {
+            BybitError::Paper(format!(
+                "Invalid stop_price: {}",
+                stop_price_str.unwrap_or("")
+            ))
+        })?;
 
     let _lock = futures_paper::StateLock::acquire()?;
     let mut state = futures_paper::load_state()?;
@@ -733,9 +750,7 @@ async fn cmd_batch_order(client: &BybitClient, orders_json: &str) -> BybitResult
     let state_category = futures_paper::load_state()?.category.clone();
     let mut snapshots: HashMap<String, MarketSnapshot> = HashMap::new();
     for sym in &symbols {
-        if let Ok(snap) =
-            futures_paper::fetch_market_snapshot(client, &state_category, sym).await
-        {
+        if let Ok(snap) = futures_paper::fetch_market_snapshot(client, &state_category, sym).await {
             snapshots.insert(sym.clone(), snap);
         }
     }

src/futures_paper.rs

@@ -362,9 +362,8 @@ pub fn load_state() -> BybitResult<FuturesPaperState> {
         ));
     }
     let contents = fs::read_to_string(&path)?;
-    let state: FuturesPaperState = serde_json::from_str(&contents).map_err(|e| {
-        BybitError::Parse(format!("Failed to parse futures paper state: {e}"))
-    })?;
+    let state: FuturesPaperState = serde_json::from_str(&contents)
+        .map_err(|e| BybitError::Parse(format!("Failed to parse futures paper state: {e}")))?;
     Ok(state)
 }
 
@@ -469,11 +468,7 @@ impl FuturesPaperState {
         (self.collateral + self.unrealized_pnl(mark_prices) - self.used_margin()).max(0.0)
     }
 
-    pub fn resolve_leverage(
-        &self,
-        order_leverage: Option<f64>,
-        symbol: &str,
-    ) -> BybitResult<f64> {
+    pub fn resolve_leverage(&self, order_leverage: Option<f64>, symbol: &str) -> BybitResult<f64> {
         let lev = order_leverage
             .or_else(|| self.leverage_preferences.get(symbol).copied())
             .unwrap_or(DEFAULT_LEVERAGE);
@@ -575,9 +570,9 @@ impl FuturesPaperState {
         market: &MarketSnapshot,
         mark_prices: &HashMap<String, f64>,
     ) -> BybitResult<OrderPlacementResult> {
-        let price = params.price.ok_or_else(|| {
-            BybitError::Paper("Limit orders require --price".to_string())
-        })?;
+        let price = params
+            .price
+            .ok_or_else(|| BybitError::Paper("Limit orders require --price".to_string()))?;
         validate_finite_positive(price, "price")?;
 
         // Check if immediately fillable
@@ -682,9 +677,9 @@ impl FuturesPaperState {
         leverage: f64,
         market: &MarketSnapshot,
     ) -> BybitResult<OrderPlacementResult> {
-        let price = params.price.ok_or_else(|| {
-            BybitError::Paper("Post orders require --price".to_string())
-        })?;
+        let price = params
+            .price
+            .ok_or_else(|| BybitError::Paper("Post orders require --price".to_string()))?;
         validate_finite_positive(price, "price")?;
 
         // Post-only: cancel if would immediately cross
@@ -699,13 +694,16 @@ impl FuturesPaperState {
                 order_id,
                 status: OrderStatus::Cancelled,
                 fills: vec![],
-                message: Some("Post-only order would cross the spread and was cancelled.".to_string()),
+                message: Some(
+                    "Post-only order would cross the spread and was cancelled.".to_string(),
+                ),
             });
         }
 
         let reserved_margin = params.size * price / leverage;
-        let mark_prices: HashMap<String, f64> =
-            [(params.symbol.to_uppercase(), market.mark)].into_iter().collect();
+        let mark_prices: HashMap<String, f64> = [(params.symbol.to_uppercase(), market.mark)]
+            .into_iter()
+            .collect();
         let available = self.available_margin(&mark_prices);
         if !params.reduce_only && available < reserved_margin {
             return Err(BybitError::Paper(format!(
@@ -753,9 +751,9 @@ impl FuturesPaperState {
         leverage: f64,
         market: &MarketSnapshot,
     ) -> BybitResult<OrderPlacementResult> {
-        let price = params.price.ok_or_else(|| {
-            BybitError::Paper("IOC orders require --price".to_string())
-        })?;
+        let price = params
+            .price
+            .ok_or_else(|| BybitError::Paper("IOC orders require --price".to_string()))?;
         validate_finite_positive(price, "price")?;
 
         let fillable = match params.side {
@@ -769,7 +767,9 @@ impl FuturesPaperState {
                 order_id,
                 status: OrderStatus::Cancelled,
                 fills: vec![],
-                message: Some("IOC order could not fill immediately and was cancelled.".to_string()),
+                message: Some(
+                    "IOC order could not fill immediately and was cancelled.".to_string(),
+                ),
             });
         }
 
@@ -778,8 +778,9 @@ impl FuturesPaperState {
             Side::Short => market.bid.max(price),
         };
 
-        let mark_prices: HashMap<String, f64> =
-            [(params.symbol.to_uppercase(), market.mark)].into_iter().collect();
+        let mark_prices: HashMap<String, f64> = [(params.symbol.to_uppercase(), market.mark)]
+            .into_iter()
+            .collect();
         let available = self.available_margin(&mark_prices);
         let required_margin = params.size * fill_price / leverage;
         if !params.reduce_only && available < required_margin {
@@ -820,9 +821,9 @@ impl FuturesPaperState {
         leverage: f64,
         market: &MarketSnapshot,
     ) -> BybitResult<OrderPlacementResult> {
-        let price = params.price.ok_or_else(|| {
-            BybitError::Paper("FOK orders require --price".to_string())
-        })?;
+        let price = params
+            .price
+            .ok_or_else(|| BybitError::Paper("FOK orders require --price".to_string()))?;
         validate_finite_positive(price, "price")?;
 
         let fillable = match params.side {
@@ -836,7 +837,9 @@ impl FuturesPaperState {
                 order_id,
                 status: OrderStatus::Cancelled,
                 fills: vec![],
-                message: Some("FOK order could not fill in full immediately and was cancelled.".to_string()),
+                message: Some(
+                    "FOK order could not fill in full immediately and was cancelled.".to_string(),
+                ),
             });
         }
 
@@ -869,8 +872,9 @@ impl FuturesPaperState {
             Side::Short => market.bid.max(price),
         };
 
-        let mark_prices: HashMap<String, f64> =
-            [(params.symbol.to_uppercase(), market.mark)].into_iter().collect();
+        let mark_prices: HashMap<String, f64> = [(params.symbol.to_uppercase(), market.mark)]
+            .into_iter()
+            .collect();
         let available = self.available_margin(&mark_prices);
         let required_margin = params.size * fill_price / leverage;
         if !params.reduce_only && available < required_margin {
@@ -912,10 +916,7 @@ impl FuturesPaperState {
         mark_prices: &HashMap<String, f64>,
     ) -> BybitResult<OrderPlacementResult> {
         let stop_price = params.stop_price.ok_or_else(|| {
-            BybitError::Paper(format!(
-                "{} orders require --stop-price",
-                params.order_type
-            ))
+            BybitError::Paper(format!("{} orders require --stop-price", params.order_type))
         })?;
         validate_finite_positive(stop_price, "stop_price")?;
 
@@ -933,7 +934,8 @@ impl FuturesPaperState {
                 .unwrap_or("percent");
             if unit != "percent" && unit != "quote_currency" {
                 return Err(BybitError::Paper(
-                    "trailing_stop_deviation_unit must be 'percent' or 'quote_currency'".to_string(),
+                    "trailing_stop_deviation_unit must be 'percent' or 'quote_currency'"
+                        .to_string(),
                 ));
             }
         }
@@ -1080,8 +1082,7 @@ impl FuturesPaperState {
             .iter()
             .position(|o| {
                 order_id.is_some_and(|id| o.id == id)
-                    || client_order_id
-                        .is_some_and(|cid| o.client_order_id.as_deref() == Some(cid))
+                    || client_order_id.is_some_and(|cid| o.client_order_id.as_deref() == Some(cid))
             })
             .ok_or_else(|| {
                 BybitError::Paper(
@@ -1203,9 +1204,7 @@ impl FuturesPaperState {
                 event_type: "realized_pnl".to_string(),
                 symbol: Some(symbol.to_string()),
                 amount: pnl,
-                details: format!(
-                    "Closed {side} position: {size} @ {price:.4}, PnL = {pnl:.4}"
-                ),
+                details: format!("Closed {side} position: {size} @ {price:.4}, PnL = {pnl:.4}"),
                 timestamp: now_rfc3339(),
             };
             self.history.push(event);
@@ -1299,12 +1298,7 @@ impl FuturesPaperState {
         });
     }
 
-    fn validate_reduce_only(
-        &self,
-        symbol: &str,
-        side: Side,
-        size: f64,
-    ) -> BybitResult<()> {
+    fn validate_reduce_only(&self, symbol: &str, side: Side, size: f64) -> BybitResult<()> {
         let pos = self
             .positions
             .iter()
@@ -1339,17 +1333,8 @@ impl FuturesPaperState {
         let mut result = ReconcileResult::default();
 
         self.reconcile_limit_orders(last_prices, mark_prices, &mut result.fills);
-        self.reconcile_triggered_orders(
-            mark_prices,
-            last_prices,
-            index_prices,
-            &mut result.fills,
-        );
-        self.reconcile_liquidations(
-            mark_prices,
-            maintenance_rates,
-            &mut result.liquidations,
-        );
+        self.reconcile_triggered_orders(mark_prices, last_prices, index_prices, &mut result.fills);
+        self.reconcile_liquidations(mark_prices, maintenance_rates, &mut result.liquidations);
         self.reconcile_funding(funding_rates, mark_prices, &mut result.funding_events);
 
         self.last_reconciled_at = Some(now_rfc3339());
@@ -1711,10 +1696,7 @@ pub fn compute_unrealized_pnl(pos: &FuturesPaperPosition, mark_price: f64) -> f6
     compute_realized_pnl(pos.side, pos.entry_price, mark_price, pos.size)
 }
 
-pub fn compute_liquidation_price(
-    pos: &FuturesPaperPosition,
-    maintenance_margin_rate: f64,
-) -> f64 {
+pub fn compute_liquidation_price(pos: &FuturesPaperPosition, maintenance_margin_rate: f64) -> f64 {
     if pos.entry_price <= 0.0 || pos.leverage <= 0.0 {
         return f64::INFINITY;
     }
@@ -1835,9 +1817,7 @@ pub async fn fetch_market_snapshot(
         .as_array()
         .and_then(|a| a.first())
         .cloned()
-        .ok_or_else(|| {
-            BybitError::Paper(format!("No ticker data for symbol {symbol_upper}"))
-        })?;
+        .ok_or_else(|| BybitError::Paper(format!("No ticker data for symbol {symbol_upper}")))?;
 
     let parse_f = |v: &Value| -> f64 {
         v.as_str()

src/lib.rs

@@ -3,9 +3,9 @@ pub mod client;
 pub mod commands;
 pub mod config;
 pub mod errors;
+pub mod futures_paper;
 pub mod mcp;
 pub mod output;
-pub mod futures_paper;
 pub mod paper;
 pub mod shell;
 pub mod telemetry;
@@ -196,7 +196,11 @@ pub enum Command {
     /// Start MCP server for AI tool use
     Mcp {
         /// Comma-separated service groups to expose, or "all"
-        #[arg(short = 's', long, default_value = "market,account,paper,futures-paper")]
+        #[arg(
+            short = 's',
+            long,
+            default_value = "market,account,paper,futures-paper"
+        )]
         services: String,
         /// Skip per-call confirmation for dangerous tools
         #[arg(long)]

src/mcp/registry.rs

@@ -3532,8 +3532,16 @@ pub fn tool_to_args(name: &str, p: &Value) -> Option<Vec<String>> {
             opt!(args, "--trigger-signal", gs("trigger_signal"));
             opt!(args, "--client-order-id", gs("client_order_id"));
             opt!(args, "--leverage", gs("leverage"));
-            opt!(args, "--trailing-stop-max-deviation", gs("trailing_stop_max_deviation"));
-            opt!(args, "--trailing-stop-deviation-unit", gs("trailing_stop_deviation_unit"));
+            opt!(
+                args,
+                "--trailing-stop-max-deviation",
+                gs("trailing_stop_max_deviation")
+            );
+            opt!(
+                args,
+                "--trailing-stop-deviation-unit",
+                gs("trailing_stop_deviation_unit")
+            );
             opt!(args, "--category", gs("category"));
             if gb("reduce_only") {
                 args.push("--reduce-only".to_string());
@@ -3553,8 +3561,16 @@ pub fn tool_to_args(name: &str, p: &Value) -> Option<Vec<String>> {
             opt!(args, "--trigger-signal", gs("trigger_signal"));
             opt!(args, "--client-order-id", gs("client_order_id"));
             opt!(args, "--leverage", gs("leverage"));
-            opt!(args, "--trailing-stop-max-deviation", gs("trailing_stop_max_deviation"));
-            opt!(args, "--trailing-stop-deviation-unit", gs("trailing_stop_deviation_unit"));
+            opt!(
+                args,
+                "--trailing-stop-max-deviation",
+                gs("trailing_stop_max_deviation")
+            );
+            opt!(
+                args,
+                "--trailing-stop-deviation-unit",
+                gs("trailing_stop_deviation_unit")
+            );
             opt!(args, "--category", gs("category"));
             if gb("reduce_only") {
                 args.push("--reduce-only".to_string());