Skip to main content

bulk_client/common/
order_status.rs

1use serde::{Deserialize};
2
3/// Various order status
4#[derive(Debug, Clone, Copy, Eq, PartialEq)]
5#[repr(u8)]
6pub enum OrderStatus {
7    // order state preplacement (would not be seen in events)
8    Pending,
9    // order has been placed
10    Placed,
11    // order is resting in the book
12    Resting,
13    // order is in book and has received some fills
14    Working,
15    // order was just modified
16    Modified,
17    // order fully filled and terminal
18    Filled,
19    // order partially filled and terminal
20    PartiallyFilled,
21    // order cancelled
22    Cancelled,
23    // order cancelled due to risk limit
24    CancelledRiskLimit,
25    // order was self crossing
26    CancelledSelfCrossing,
27    // order would not reduce position
28    CancelledReduceOnly,
29    // order expired without fill (IOC)
30    CancelledIOC,
31    // order is invalid
32    RejectedInvalid,
33    // order immediately rejected due to limits
34    RejectedRiskLimit,
35    // post-only order rejected due to crossing
36    RejectedCrossing,
37    // order rejected due to being a duplicate
38    RejectedDuplicate,
39    // notify that order triggered
40    Triggered,
41    // notify that sibling conditional order cancelled
42    SiblingCancelled,
43    // notify that trigger failed
44    TriggerFailed,
45}
46
47#[allow(unused)]
48impl OrderStatus {
49    /// Determine if order status is terminal
50    pub fn is_terminal(&self) -> bool {
51        match self {
52            OrderStatus::Pending => false,
53            OrderStatus::Placed => false,
54            OrderStatus::Resting => false,
55            OrderStatus::Working => false,
56            OrderStatus::Modified => true,
57            OrderStatus::Filled => true,
58            OrderStatus::PartiallyFilled => true,
59            OrderStatus::Cancelled => true,
60            OrderStatus::CancelledRiskLimit => true,
61            OrderStatus::CancelledSelfCrossing => true,
62            OrderStatus::CancelledReduceOnly => true,
63            OrderStatus::CancelledIOC => true,
64            OrderStatus::RejectedInvalid => true,
65            OrderStatus::RejectedRiskLimit => true,
66            OrderStatus::RejectedCrossing => true,
67            OrderStatus::RejectedDuplicate => true,
68            OrderStatus::Triggered => true,
69            OrderStatus::SiblingCancelled => true,
70            OrderStatus::TriggerFailed => true,
71        }
72    }
73
74    /// Indicate whether is a reject
75    pub fn is_rejected(&self) -> bool {
76        match self {
77            OrderStatus::RejectedInvalid => true,
78            OrderStatus::RejectedRiskLimit => true,
79            OrderStatus::RejectedCrossing => true,
80            OrderStatus::RejectedDuplicate => true,
81            _ => false,
82        }
83    }
84}
85
86impl TryFrom<&str> for OrderStatus {
87    type Error = String;
88
89    fn try_from(status: &str) -> Result<Self, Self::Error> {
90        match status {
91            "pending" => Ok(OrderStatus::Pending),
92            "placed" => Ok(OrderStatus::Placed),
93            "resting" => Ok(OrderStatus::Resting),
94            "working" => Ok(OrderStatus::Working),
95            "modified" => Ok(OrderStatus::Modified),
96            "filled" => Ok(OrderStatus::Filled),
97            "partiallyFilled" => Ok(OrderStatus::PartiallyFilled),
98            "cancelled" => Ok(OrderStatus::Cancelled),
99            "canceled" => Ok(OrderStatus::Cancelled),
100            "canceledRiskLimit" => Ok(OrderStatus::CancelledRiskLimit),
101            "cancelledRiskLimit" => Ok(OrderStatus::CancelledRiskLimit),
102            "canceledSelfCrossing" => Ok(OrderStatus::CancelledSelfCrossing),
103            "cancelledSelfCrossing" => Ok(OrderStatus::CancelledSelfCrossing),
104            "canceledReduceOnly" => Ok(OrderStatus::CancelledReduceOnly),
105            "cancelledReduceOnly" => Ok(OrderStatus::CancelledReduceOnly),
106            "canceledIOC" => Ok(OrderStatus::CancelledIOC),
107            "cancelledIOC" => Ok(OrderStatus::CancelledIOC),
108            "rejectedInvalid" => Ok(OrderStatus::RejectedInvalid),
109            "rejectedRiskLimit" => Ok(OrderStatus::RejectedRiskLimit),
110            "rejectedCrossing" => Ok(OrderStatus::RejectedCrossing),
111            "rejectedDuplicate" => Ok(OrderStatus::RejectedDuplicate),
112            "triggered" => Ok(OrderStatus::Triggered),
113            "siblingCancelled" => Ok(OrderStatus::SiblingCancelled),
114            "triggerFailed" => Ok(OrderStatus::TriggerFailed),
115            _ => Err(format!("Unknown OrderStatus: {}", status)),
116        }
117    }
118}
119
120impl TryFrom<String> for OrderStatus {
121    type Error = String;
122
123    fn try_from(status: String) -> Result<Self, Self::Error> {
124        Self::try_from(status.as_str())
125    }
126}
127
128impl<'de> Deserialize<'de> for OrderStatus {
129    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
130    where
131        D: serde::Deserializer<'de>,
132    {
133        let s = String::deserialize(deserializer)?;
134        OrderStatus::try_from(s).map_err(serde::de::Error::custom)
135    }
136}