bulk-client 0.1.0

High-performance Rust SDK for BULK (HTTP + WebSocket)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

use serde::{Deserialize};

/// Various order status
#[derive(Debug, Clone, Copy, Eq, PartialEq)]
#[repr(u8)]
pub enum OrderStatus {
    // order state preplacement (would not be seen in events)
    Pending,
    // order has been placed
    Placed,
    // order is resting in the book
    Resting,
    // order is in book and has received some fills
    Working,
    // order was just modified
    Modified,
    // order fully filled and terminal
    Filled,
    // order partially filled and terminal
    PartiallyFilled,
    // order cancelled
    Cancelled,
    // order cancelled due to risk limit
    CancelledRiskLimit,
    // order was self crossing
    CancelledSelfCrossing,
    // order would not reduce position
    CancelledReduceOnly,
    // order expired without fill (IOC)
    CancelledIOC,
    // order is invalid
    RejectedInvalid,
    // order immediately rejected due to limits
    RejectedRiskLimit,
    // post-only order rejected due to crossing
    RejectedCrossing,
    // order rejected due to being a duplicate
    RejectedDuplicate,
    // notify that order triggered
    Triggered,
    // notify that sibling conditional order cancelled
    SiblingCancelled,
    // notify that trigger failed
    TriggerFailed,
}

#[allow(unused)]
impl OrderStatus {
    /// Determine if order status is terminal
    pub fn is_terminal(&self) -> bool {
        match self {
            OrderStatus::Pending => false,
            OrderStatus::Placed => false,
            OrderStatus::Resting => false,
            OrderStatus::Working => false,
            OrderStatus::Modified => true,
            OrderStatus::Filled => true,
            OrderStatus::PartiallyFilled => true,
            OrderStatus::Cancelled => true,
            OrderStatus::CancelledRiskLimit => true,
            OrderStatus::CancelledSelfCrossing => true,
            OrderStatus::CancelledReduceOnly => true,
            OrderStatus::CancelledIOC => true,
            OrderStatus::RejectedInvalid => true,
            OrderStatus::RejectedRiskLimit => true,
            OrderStatus::RejectedCrossing => true,
            OrderStatus::RejectedDuplicate => true,
            OrderStatus::Triggered => true,
            OrderStatus::SiblingCancelled => true,
            OrderStatus::TriggerFailed => true,
        }
    }

    /// Indicate whether is a reject
    pub fn is_rejected(&self) -> bool {
        match self {
            OrderStatus::RejectedInvalid => true,
            OrderStatus::RejectedRiskLimit => true,
            OrderStatus::RejectedCrossing => true,
            OrderStatus::RejectedDuplicate => true,
            _ => false,
        }
    }
}

impl TryFrom<&str> for OrderStatus {
    type Error = String;

    fn try_from(status: &str) -> Result<Self, Self::Error> {
        match status {
            "pending" => Ok(OrderStatus::Pending),
            "placed" => Ok(OrderStatus::Placed),
            "resting" => Ok(OrderStatus::Resting),
            "working" => Ok(OrderStatus::Working),
            "modified" => Ok(OrderStatus::Modified),
            "filled" => Ok(OrderStatus::Filled),
            "partiallyFilled" => Ok(OrderStatus::PartiallyFilled),
            "cancelled" => Ok(OrderStatus::Cancelled),
            "canceled" => Ok(OrderStatus::Cancelled),
            "canceledRiskLimit" => Ok(OrderStatus::CancelledRiskLimit),
            "cancelledRiskLimit" => Ok(OrderStatus::CancelledRiskLimit),
            "canceledSelfCrossing" => Ok(OrderStatus::CancelledSelfCrossing),
            "cancelledSelfCrossing" => Ok(OrderStatus::CancelledSelfCrossing),
            "canceledReduceOnly" => Ok(OrderStatus::CancelledReduceOnly),
            "cancelledReduceOnly" => Ok(OrderStatus::CancelledReduceOnly),
            "canceledIOC" => Ok(OrderStatus::CancelledIOC),
            "cancelledIOC" => Ok(OrderStatus::CancelledIOC),
            "rejectedInvalid" => Ok(OrderStatus::RejectedInvalid),
            "rejectedRiskLimit" => Ok(OrderStatus::RejectedRiskLimit),
            "rejectedCrossing" => Ok(OrderStatus::RejectedCrossing),
            "rejectedDuplicate" => Ok(OrderStatus::RejectedDuplicate),
            "triggered" => Ok(OrderStatus::Triggered),
            "siblingCancelled" => Ok(OrderStatus::SiblingCancelled),
            "triggerFailed" => Ok(OrderStatus::TriggerFailed),
            _ => Err(format!("Unknown OrderStatus: {}", status)),
        }
    }
}

impl TryFrom<String> for OrderStatus {
    type Error = String;

    fn try_from(status: String) -> Result<Self, Self::Error> {
        Self::try_from(status.as_str())
    }
}

impl<'de> Deserialize<'de> for OrderStatus {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let s = String::deserialize(deserializer)?;
        OrderStatus::try_from(s).map_err(serde::de::Error::custom)
    }
}