rust-okx 0.5.1

Async Rust client for the OKX v5 REST API
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

//! Common WebSocket request envelopes.

use serde::Serialize;

use crate::ws::Arg;

/// Subscribe or unsubscribe request body.
///
/// OKX docs: <https://www.okx.com/docs-v5/en/#overview-websocket-subscribe>
#[derive(Debug, Serialize)]
#[non_exhaustive]
pub struct ChannelRequest<'a> {
    /// Optional client message ID (up to 32 case-sensitive alphanumeric characters).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<&'a str>,
    /// `subscribe` or `unsubscribe`.
    pub op: &'a str,
    /// Channel arguments.
    pub args: &'a [Arg],
}

impl<'a> ChannelRequest<'a> {
    /// Build a subscription request.
    pub fn subscribe(args: &'a [Arg]) -> Self {
        Self {
            id: None,
            op: "subscribe",
            args,
        }
    }

    /// Build an unsubscription request.
    pub fn unsubscribe(args: &'a [Arg]) -> Self {
        Self {
            id: None,
            op: "unsubscribe",
            args,
        }
    }

    /// Attach a client message ID.
    pub fn id(mut self, id: &'a str) -> Self {
        self.id = Some(id);
        self
    }
}

/// Private WebSocket login request body.
///
/// OKX docs: <https://www.okx.com/docs-v5/en/#overview-websocket-login>
#[derive(Debug, Serialize)]
#[non_exhaustive]
pub struct LoginRequest<'a> {
    /// Always `login`.
    pub op: &'static str,
    /// OKX requires exactly one login argument.
    pub args: [LoginArg<'a>; 1],
}

impl<'a> LoginRequest<'a> {
    /// Build a login request from one authentication argument.
    pub fn new(arg: LoginArg<'a>) -> Self {
        Self {
            op: "login",
            args: [arg],
        }
    }
}

/// Authentication argument inside [`LoginRequest`].
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct LoginArg<'a> {
    /// API key.
    pub api_key: &'a str,
    /// API key passphrase.
    pub passphrase: &'a str,
    /// Unix timestamp in seconds used for signing.
    pub timestamp: &'a str,
    /// Base64-encoded HMAC-SHA256 signature.
    pub sign: String,
}

impl<'a> LoginArg<'a> {
    /// Build a login argument from already-computed authentication values.
    pub fn new(
        api_key: &'a str,
        passphrase: &'a str,
        timestamp: &'a str,
        sign: impl Into<String>,
    ) -> Self {
        Self {
            api_key,
            passphrase,
            timestamp,
            sign: sign.into(),
        }
    }
}

/// Generic WebSocket trade-operation envelope.
///
/// OKX docs: <https://www.okx.com/docs-v5/en/#overview-websocket>
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct OperationRequest<'a, A> {
    /// Client-provided request ID.
    pub id: String,
    /// OKX operation name.
    pub op: String,
    /// Optional request effective deadline in Unix milliseconds.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub exp_time: Option<String>,
    /// Operation arguments.
    pub args: &'a [A],
}

impl<'a, A> OperationRequest<'a, A> {
    /// Build an operation request without an expiration deadline.
    pub fn new(id: impl Into<String>, op: impl Into<String>, args: &'a [A]) -> Self {
        Self {
            id: id.into(),
            op: op.into(),
            exp_time: None,
            args,
        }
    }

    /// Set the request effective deadline in Unix milliseconds.
    pub fn exp_time(mut self, exp_time: impl Into<String>) -> Self {
        self.exp_time = Some(exp_time.into());
        self
    }
}