Improve validations for LimitIfTouchedOrder (#2533)

Author: nicolad

crates/model/src/orders/limit_if_touched.rs

@@ -13,15 +13,21 @@
 //  limitations under the License.
 // -------------------------------------------------------------------------------------------------
 
-use std::ops::{Deref, DerefMut};
+use std::{
+    fmt::Display,
+    ops::{Deref, DerefMut},
+};
 
 use indexmap::IndexMap;
-use nautilus_core::{UUID4, UnixNanos};
+use nautilus_core::{
+    UUID4, UnixNanos,
+    correctness::{FAILED, check_predicate_false},
+};
 use rust_decimal::Decimal;
 use serde::{Deserialize, Serialize};
 use ustr::Ustr;
 
-use super::{Order, OrderAny, OrderCore, OrderError};
+use super::{Order, OrderAny, OrderCore};
 use crate::{
     enums::{
         ContingencyType, LiquiditySide, OrderSide, OrderStatus, OrderType, PositionSide,
@@ -32,7 +38,11 @@ use crate::{
         AccountId, ClientOrderId, ExecAlgorithmId, InstrumentId, OrderListId, PositionId,
         StrategyId, Symbol, TradeId, TraderId, Venue, VenueOrderId,
     },
-    types::{Currency, Money, Price, Quantity},
+    orders::OrderError,
+    types::{
+        Currency, Money, Price, Quantity, price::check_positive_price,
+        quantity::check_positive_quantity,
+    },
 };
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
@@ -53,6 +63,7 @@ pub struct LimitIfTouchedOrder {
     core: OrderCore,
 }
 
+#[allow(clippy::too_many_arguments)]
 impl LimitIfTouchedOrder {
     /// Creates a new [`LimitIfTouchedOrder`] instance.
     ///
@@ -90,7 +101,94 @@ impl LimitIfTouchedOrder {
         init_id: UUID4,
         ts_init: UnixNanos,
     ) -> Self {
-        // TODO: Implement new_checked and check quantity positive, add error docs.
+        Self::new_checked(
+            trader_id,
+            strategy_id,
+            instrument_id,
+            client_order_id,
+            order_side,
+            quantity,
+            price,
+            trigger_price,
+            trigger_type,
+            time_in_force,
+            expire_time,
+            post_only,
+            reduce_only,
+            quote_quantity,
+            display_qty,
+            emulation_trigger,
+            trigger_instrument_id,
+            contingency_type,
+            order_list_id,
+            linked_order_ids,
+            parent_order_id,
+            exec_algorithm_id,
+            exec_algorithm_params,
+            exec_spawn_id,
+            tags,
+            init_id,
+            ts_init,
+        )
+        .expect(FAILED)
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn new_checked(
+        trader_id: TraderId,
+        strategy_id: StrategyId,
+        instrument_id: InstrumentId,
+        client_order_id: ClientOrderId,
+        order_side: OrderSide,
+        quantity: Quantity,
+        price: Price,
+        trigger_price: Price,
+        trigger_type: TriggerType,
+        time_in_force: TimeInForce,
+        expire_time: Option<UnixNanos>,
+        post_only: bool,
+        reduce_only: bool,
+        quote_quantity: bool,
+        display_qty: Option<Quantity>,
+        emulation_trigger: Option<TriggerType>,
+        trigger_instrument_id: Option<InstrumentId>,
+        contingency_type: Option<ContingencyType>,
+        order_list_id: Option<OrderListId>,
+        linked_order_ids: Option<Vec<ClientOrderId>>,
+        parent_order_id: Option<ClientOrderId>,
+        exec_algorithm_id: Option<ExecAlgorithmId>,
+        exec_algorithm_params: Option<IndexMap<Ustr, Ustr>>,
+        exec_spawn_id: Option<ClientOrderId>,
+        tags: Option<Vec<Ustr>>,
+        init_id: UUID4,
+        ts_init: UnixNanos,
+    ) -> anyhow::Result<Self> {
+        check_positive_quantity(quantity, "quantity")?;
+        check_positive_price(price, "price")?;
+        check_positive_price(trigger_price, "trigger_price")?;
+
+        if let Some(disp) = display_qty {
+            check_positive_quantity(disp, "display_qty")?;
+            check_predicate_false(disp > quantity, "`display_qty` may not exceed `quantity`")?;
+        }
+
+        if time_in_force == TimeInForce::Gtd {
+            check_predicate_false(
+                expire_time.unwrap_or_default() == 0,
+                "Condition failed: `expire_time` is required for `GTD` order",
+            )?;
+        }
+
+        match order_side {
+            OrderSide::Buy if trigger_price > price => {
+                anyhow::bail!("BUY Limit-If-Touched must have `trigger_price` <= `price`")
+            }
+            OrderSide::Sell if trigger_price < price => {
+                anyhow::bail!("SELL Limit-If-Touched must have `trigger_price` >= `price`")
+            }
+            _ => {}
+        }
+
         let init_order = OrderInitialized::new(
             trader_id,
             strategy_id,
@@ -126,8 +224,8 @@ impl LimitIfTouchedOrder {
             exec_spawn_id,
             tags,
         );
-        Self {
-            core: OrderCore::new(init_order),
+
+        Ok(Self {
             price,
             trigger_price,
             trigger_type,
@@ -137,7 +235,8 @@ impl LimitIfTouchedOrder {
             trigger_instrument_id,
             is_triggered: false,
             ts_triggered: None,
-        }
+            core: OrderCore::new(init_order),
+        })
     }
 }
 
@@ -421,7 +520,7 @@ impl Order for LimitIfTouchedOrder {
     }
 
     fn set_liquidity_side(&mut self, liquidity_side: LiquiditySide) {
-        self.liquidity_side = Some(liquidity_side)
+        self.liquidity_side = Some(liquidity_side);
     }
 
     fn would_reduce_only(&self, side: PositionSide, position_qty: Quantity) -> bool {
@@ -433,6 +532,23 @@ impl Order for LimitIfTouchedOrder {
     }
 }
 
+impl Display for LimitIfTouchedOrder {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "LimitIfTouchedOrder({} {} {} @ {} / trigger {} ({:?}) {}, status={})",
+            self.side,
+            self.quantity.to_formatted_string(),
+            self.instrument_id,
+            self.price,
+            self.trigger_price,
+            self.trigger_type,
+            self.time_in_force,
+            self.status
+        )
+    }
+}
+
 impl From<OrderInitialized> for LimitIfTouchedOrder {
     fn from(event: OrderInitialized) -> Self {
         Self::new(
@@ -474,3 +590,85 @@ impl From<OrderInitialized> for LimitIfTouchedOrder {
         )
     }
 }
+
+////////////////////////////////////////////////////////////////////////////////
+// Tests
+////////////////////////////////////////////////////////////////////////////////
+#[cfg(test)]
+mod tests {
+    use rstest::rstest;
+
+    use crate::{
+        enums::{OrderSide, OrderType, TimeInForce, TriggerType},
+        instruments::{CurrencyPair, stubs::*},
+        orders::builder::OrderTestBuilder,
+        types::{Price, Quantity},
+    };
+
+    #[rstest]
+    fn ok(audusd_sim: CurrencyPair) {
+        let _ = OrderTestBuilder::new(OrderType::LimitIfTouched)
+            .instrument_id(audusd_sim.id)
+            .side(OrderSide::Buy)
+            .trigger_price(Price::from("30200"))
+            .price(Price::from("30200"))
+            .trigger_type(TriggerType::LastPrice)
+            .quantity(Quantity::from(1))
+            .build();
+    }
+
+    #[rstest]
+    #[should_panic(
+        expected = "Condition failed: invalid `Quantity` for 'quantity' not positive, was 0"
+    )]
+    fn quantity_zero(audusd_sim: CurrencyPair) {
+        let _ = OrderTestBuilder::new(OrderType::LimitIfTouched)
+            .instrument_id(audusd_sim.id)
+            .side(OrderSide::Buy)
+            .price(Price::from("30000"))
+            .trigger_price(Price::from("30200"))
+            .trigger_type(TriggerType::LastPrice)
+            .quantity(Quantity::from(0))
+            .build();
+    }
+
+    #[rstest]
+    #[should_panic(expected = "Condition failed: `expire_time` is required for `GTD` order")]
+    fn gtd_without_expire(audusd_sim: CurrencyPair) {
+        let _ = OrderTestBuilder::new(OrderType::LimitIfTouched)
+            .instrument_id(audusd_sim.id)
+            .side(OrderSide::Buy)
+            .price(Price::from("30000"))
+            .trigger_price(Price::from("30200"))
+            .trigger_type(TriggerType::LastPrice)
+            .quantity(Quantity::from(1))
+            .time_in_force(TimeInForce::Gtd)
+            .build();
+    }
+
+    #[rstest]
+    #[should_panic(expected = "BUY Limit-If-Touched must have `trigger_price` <= `price`")]
+    fn buy_trigger_gt_price(audusd_sim: CurrencyPair) {
+        OrderTestBuilder::new(OrderType::LimitIfTouched)
+            .instrument_id(audusd_sim.id)
+            .side(OrderSide::Buy)
+            .trigger_price(Price::from("30300")) // Invalid trigger > price
+            .price(Price::from("30200"))
+            .trigger_type(TriggerType::LastPrice)
+            .quantity(Quantity::from(1))
+            .build();
+    }
+
+    #[rstest]
+    #[should_panic(expected = "SELL Limit-If-Touched must have `trigger_price` >= `price`")]
+    fn sell_trigger_lt_price(audusd_sim: CurrencyPair) {
+        OrderTestBuilder::new(OrderType::LimitIfTouched)
+            .instrument_id(audusd_sim.id)
+            .side(OrderSide::Sell)
+            .trigger_price(Price::from("30100")) // Invalid trigger < price
+            .price(Price::from("30200"))
+            .trigger_type(TriggerType::LastPrice)
+            .quantity(Quantity::from(1))
+            .build();
+    }
+}