ethereal_rust_sdk 0.1.5

Trading client for Ethereal exchange
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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

/*
 * Ethereal Exchange API
 *
 * Ethereal HTTP API for real-time trading, order management, and market data access.
 *
 * The version of the OpenAPI document: 0.1.0
 *
 * Generated by: https://openapi-generator.tech
 */

use crate::models;
use serde::{Deserialize, Serialize};

#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct SubmitOrderLimitDtoData {
    /// Bytes32 encoded subaccount name (0x prefix, zero padded)
    #[serde(rename = "subaccount")]
    pub subaccount: String,
    /// Address of account
    #[serde(rename = "sender")]
    pub sender: String,
    /// Message nonce timestamp (nanoseconds since Unix Epoch)
    #[serde(rename = "nonce")]
    pub nonce: String,
    #[serde(rename = "type")]
    pub r#type: models::OrderType,
    /// Non-directional quantity of product in native units expressed as a decimal (precision: 9)
    #[serde(rename = "quantity")]
    pub quantity: String,
    #[serde(rename = "side")]
    pub side: models::OrderSide,
    /// Onchain generated productId from prior product registration
    #[serde(rename = "onchainId")]
    pub onchain_id: i32,
    #[serde(rename = "engineType")]
    pub engine_type: models::EngineType,
    /// A subaccount scoped unique client-generated order id (either a UUID or alphanumeric string up to 32 characters)
    #[serde(rename = "clientOrderId", skip_serializing_if = "Option::is_none")]
    pub client_order_id: Option<String>,
    /// Whether this should be a reduce-only order, required for close
    #[serde(rename = "reduceOnly", skip_serializing_if = "Option::is_none")]
    pub reduce_only: Option<bool>,
    /// Order closes the entire current position, requires zero quantity and reduceOnly
    #[serde(rename = "close", skip_serializing_if = "Option::is_none")]
    pub close: Option<bool>,
    /// Stop price expressed as a decimal (precision: 9), requires stopType
    #[serde(rename = "stopPrice", skip_serializing_if = "Option::is_none")]
    pub stop_price: Option<String>,
    /// Stop type, either 0 (take-profit) or 1 (stop-loss), requires non-zero stopPrice
    #[serde(rename = "stopType", skip_serializing_if = "Option::is_none")]
    pub stop_type: Option<StopType>,
    /// Message signedAt current timestamp (seconds since Unix Epoch)
    #[serde(rename = "signedAt")]
    pub signed_at: i64,
    /// Order expiry timestamp (seconds since Unix Epoch), defaults to the maximum allowed value: signedAt + 6652800
    #[serde(rename = "expiresAt", skip_serializing_if = "Option::is_none")]
    pub expires_at: Option<i64>,
    /// Group Id (UUID) for linking orders together in OCO/OTO relationships
    #[serde(rename = "groupId", skip_serializing_if = "Option::is_none")]
    pub group_id: Option<uuid::Uuid>,
    /// Contingency type for order groups: OTO (Order-Triggers-Order) or OCO (One-Cancels-Other)
    #[serde(
        rename = "groupContingencyType",
        skip_serializing_if = "Option::is_none"
    )]
    pub group_contingency_type: Option<GroupContingencyType>,
    /// Limit price expressed as a decimal (precision: 9)
    #[serde(rename = "price")]
    pub price: String,
    /// How long an order will remain until executed/expired
    #[serde(rename = "timeInForce")]
    pub time_in_force: TimeInForce,
    /// Only add order if it does not immediately fill
    #[serde(rename = "postOnly")]
    pub post_only: bool,
}

impl SubmitOrderLimitDtoData {
    pub fn new(
        subaccount: String,
        sender: String,
        nonce: String,
        r#type: models::OrderType,
        quantity: String,
        side: models::OrderSide,
        onchain_id: i32,
        engine_type: models::EngineType,
        signed_at: i64,
        price: String,
        time_in_force: TimeInForce,
        post_only: bool,
    ) -> SubmitOrderLimitDtoData {
        SubmitOrderLimitDtoData {
            subaccount,
            sender,
            nonce,
            r#type,
            quantity,
            side,
            onchain_id,
            engine_type,
            client_order_id: None,
            reduce_only: None,
            close: None,
            stop_price: None,
            stop_type: None,
            signed_at,
            expires_at: None,
            group_id: None,
            group_contingency_type: None,
            price,
            time_in_force,
            post_only,
        }
    }
}
/// Stop type, either 0 (take-profit) or 1 (stop-loss), requires non-zero stopPrice
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum StopType {
    #[serde(rename = "0")]
    GAIN,
    #[serde(rename = "1")]
    LOSS,
}

impl Default for StopType {
    fn default() -> StopType {
        Self::GAIN
    }
}
/// Contingency type for order groups: OTO (Order-Triggers-Order) or OCO (One-Cancels-Other)
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum GroupContingencyType {
    #[serde(rename = "0")]
    OTO,
    #[serde(rename = "1")]
    OCO,
}

impl Default for GroupContingencyType {
    fn default() -> GroupContingencyType {
        Self::OTO
    }
}
/// How long an order will remain until executed/expired
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum TimeInForce {
    #[serde(rename = "GTD")]
    Gtd,
    #[serde(rename = "IOC")]
    Ioc,
    #[serde(rename = "FOK")]
    Fok,
}

impl Default for TimeInForce {
    fn default() -> TimeInForce {
        Self::Gtd
    }
}