bitculator 1.1.0

Official Rust SDK for the Bitculator Data 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

use std::fmt::Display;
use std::sync::Arc;

use serde::de::DeserializeOwned;

use crate::error::Error;
use crate::http::{enc, HttpClient};
use crate::pagination::Page;
use crate::params::Params;

/// Markets, tickers, and trading pairs.
pub struct Markets {
    http: Arc<HttpClient>,
}

impl Markets {
    pub(crate) fn new(http: Arc<HttpClient>) -> Self {
        Self { http }
    }

    /// Markets (tickers) for a coin (paginated). Params: page, per_page,
    /// exchange, pair, instrument, search, min_volume, max_volume, min_change,
    /// max_change, sort.
    pub fn coin_markets<T: DeserializeOwned>(&self, slug: &str, params: Params) -> Result<Page<T>, Error> {
        Page::fetch(self.http.clone(), &format!("/api/v1/coins/{}/markets", enc(slug)), params)
    }

    /// Trading symbols for a coin.
    pub fn coin_symbols<T: DeserializeOwned>(&self, slug: &str) -> Result<T, Error> {
        self.http.get(&format!("/api/v1/coins/{}/symbols", enc(slug)), &Params::new())
    }

    /// List tickers across the market (paginated).
    pub fn tickers<T: DeserializeOwned>(&self, params: Params) -> Result<Page<T>, Error> {
        Page::fetch(self.http.clone(), "/api/v1/tickers", params)
    }

    /// List trading pairs (paginated). Params: page, per_page, search, coin,
    /// min_volume, max_volume, sort.
    pub fn pairs<T: DeserializeOwned>(&self, params: Params) -> Result<Page<T>, Error> {
        Page::fetch(self.http.clone(), "/api/v1/pairs", params)
    }

    /// Get a single trading pair by id.
    pub fn pair<T: DeserializeOwned>(&self, id: impl Display) -> Result<T, Error> {
        self.http.get(&format!("/api/v1/pairs/{}", enc(&id.to_string())), &Params::new())
    }
}

/// Exchanges: listings, trust score, history, markets, and listed assets.
pub struct Exchanges {
    http: Arc<HttpClient>,
}

impl Exchanges {
    pub(crate) fn new(http: Arc<HttpClient>) -> Self {
        Self { http }
    }

    /// List exchanges (paginated). Params: page, per_page, type, search,
    /// min_pairs, max_pairs, min_assets, max_assets, min_volume, max_volume,
    /// ids, slugs, sort.
    pub fn list<T: DeserializeOwned>(&self, params: Params) -> Result<Page<T>, Error> {
        Page::fetch(self.http.clone(), "/api/v1/exchanges", params)
    }

    /// Get a single exchange by slug.
    pub fn get<T: DeserializeOwned>(&self, slug: &str) -> Result<T, Error> {
        self.http.get(&format!("/api/v1/exchanges/{}", enc(slug)), &Params::new())
    }

    /// Get an exchange's trust score.
    pub fn trust_score<T: DeserializeOwned>(&self, slug: &str) -> Result<T, Error> {
        self.http.get(&format!("/api/v1/exchanges/{}/trust-score", enc(slug)), &Params::new())
    }

    /// Volume/history for an exchange. Params: interval, start, end, limit.
    pub fn history<T: DeserializeOwned>(&self, slug: &str, params: Params) -> Result<T, Error> {
        self.http.get(&format!("/api/v1/exchanges/{}/history", enc(slug)), &params)
    }

    /// Sparkline for an exchange. Params: period.
    pub fn sparkline<T: DeserializeOwned>(&self, slug: &str, params: Params) -> Result<T, Error> {
        self.http.get(&format!("/api/v1/exchanges/{}/sparkline", enc(slug)), &params)
    }

    /// Markets (tickers) on an exchange (paginated).
    pub fn tickers<T: DeserializeOwned>(&self, slug: &str, params: Params) -> Result<Page<T>, Error> {
        Page::fetch(self.http.clone(), &format!("/api/v1/exchanges/{}/tickers", enc(slug)), params)
    }

    /// Coins listed on an exchange (paginated).
    pub fn assets<T: DeserializeOwned>(&self, slug: &str, params: Params) -> Result<Page<T>, Error> {
        Page::fetch(self.http.clone(), &format!("/api/v1/exchanges/{}/assets", enc(slug)), params)
    }
}

/// Wallets: listings, release timeline, comparison, and supported coins.
pub struct Wallets {
    http: Arc<HttpClient>,
}

impl Wallets {
    pub(crate) fn new(http: Arc<HttpClient>) -> Self {
        Self { http }
    }

    /// List wallets (paginated). Params: page, per_page, search, min_score,
    /// max_score, tags, ids, slugs, sort.
    pub fn list<T: DeserializeOwned>(&self, params: Params) -> Result<Page<T>, Error> {
        Page::fetch(self.http.clone(), "/api/v1/wallets", params)
    }

    /// Wallet release timeline (paginated).
    pub fn timeline<T: DeserializeOwned>(&self, params: Params) -> Result<Page<T>, Error> {
        Page::fetch(self.http.clone(), "/api/v1/wallets/timeline", params)
    }

    /// Compare a set of wallets side by side. Params: slugs.
    pub fn compare<T: DeserializeOwned>(&self, params: Params) -> Result<T, Error> {
        self.http.get("/api/v1/wallets/compare", &params)
    }

    /// Get a single wallet by slug.
    pub fn get<T: DeserializeOwned>(&self, slug: &str) -> Result<T, Error> {
        self.http.get(&format!("/api/v1/wallets/{}", enc(slug)), &Params::new())
    }

    /// Coins supported by a wallet (paginated).
    pub fn assets<T: DeserializeOwned>(&self, slug: &str, params: Params) -> Result<Page<T>, Error> {
        Page::fetch(self.http.clone(), &format!("/api/v1/wallets/{}/assets", enc(slug)), params)
    }
}