mkt-core 0.1.0

Core traits, errors, and configuration for the mkt exchange client ecosystem.
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

use std::fmt;

use secrecy::ExposeSecret;
pub use secrecy::SecretString;

use mkt_types::ExchangeId;

pub struct ApiCredentials {
    api_key: SecretString,
    secret: SecretString,
    passphrase: Option<SecretString>,
}

impl PartialEq for ApiCredentials {
    fn eq(&self, other: &Self) -> bool {
        self.api_key.expose_secret() == other.api_key.expose_secret()
            && self.secret.expose_secret() == other.secret.expose_secret()
            && self.passphrase.as_ref().map(|value| value.expose_secret())
                == other.passphrase.as_ref().map(|value| value.expose_secret())
    }
}

impl Eq for ApiCredentials {}

impl ApiCredentials {
    pub fn new(api_key: impl Into<String>, secret: impl Into<String>) -> Self {
        Self {
            api_key: SecretString::from(api_key.into()),
            secret: SecretString::from(secret.into()),
            passphrase: None,
        }
    }

    pub fn with_passphrase(mut self, passphrase: impl Into<String>) -> Self {
        self.passphrase = Some(SecretString::from(passphrase.into()));
        self
    }

    pub fn api_key(&self) -> &SecretString {
        &self.api_key
    }

    pub fn secret(&self) -> &SecretString {
        &self.secret
    }

    pub fn passphrase(&self) -> Option<&SecretString> {
        self.passphrase.as_ref()
    }
}

impl fmt::Debug for ApiCredentials {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("ApiCredentials")
            .field("api_key", &self.api_key)
            .field("secret", &self.secret)
            .field("passphrase", &self.passphrase)
            .finish()
    }
}

#[derive(Debug, PartialEq, Eq)]
pub struct ExchangeConfig {
    pub exchange_id: ExchangeId,
    pub rest_base_url: Option<String>,
    pub websocket_base_url: Option<String>,
    pub credentials: Option<ApiCredentials>,
}

impl ExchangeConfig {
    pub fn new(exchange_id: ExchangeId) -> Self {
        Self {
            exchange_id,
            rest_base_url: None,
            websocket_base_url: None,
            credentials: None,
        }
    }

    pub fn with_rest_base_url(mut self, url: impl Into<String>) -> Self {
        self.rest_base_url = Some(url.into());
        self
    }

    pub fn with_websocket_base_url(mut self, url: impl Into<String>) -> Self {
        self.websocket_base_url = Some(url.into());
        self
    }

    pub fn with_credentials(mut self, credentials: ApiCredentials) -> Self {
        self.credentials = Some(credentials);
        self
    }
}