kraapi 0.2.1

Asynchronous HTTP client for the Kraken Cryptocurrency 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

use indexmap::map::IndexMap;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

use crate::auth::KrakenAuth;
// Structs/Enums
use super::{EndpointInfo, KAssetPair, KrakenInput, MethodType};

// Traits
use super::{Input, InputList, InputListItem, IntoInputList, MutateInput, Output, UpdateInput};

/// Request builder for the Get Trade Volume endpoint
pub struct KITradeVolume {
    params: IndexMap<String, String>,
}

impl KITradeVolume {
    /// Constructor returning a [KrakenInput] builder for the get trade volume endpoint.
    pub fn build() -> Self {
        KITradeVolume {
            params: IndexMap::new(),
        }
    }

    /// An asset pair is not required for the get trade volume endpoint. 
    /// This method clears a currently populated asset pair list.
    /// Useful for templating
    pub fn clear_pair_list(self) -> Self {
        self.update_input("pair", String::from(""))
    }

    /// Update the list of asset pairs to query fee info for
    pub fn with_pair(self, pair: KAssetPair) -> Self {
        self.with_item(pair)
    }

    /// Update the list of asset pairs to query fee info for
    pub fn with_pair_list<T>(self, pairs: T) -> Self
    where
        T: IntoIterator<Item = KAssetPair>,
    {
        self.with_item_list(pairs)
    }

    /// Should fee info be included in the results?
    pub fn with_fee_info(self, feeinfo: bool) -> Self {
        self.update_input("fee-info", feeinfo.to_string())
    }

    fn with_nonce(self) -> Self {
        self.update_input("nonce", KrakenAuth::nonce())
    }
}

impl MutateInput for KITradeVolume {
    fn list_mut(&mut self) -> &mut IndexMap<String, String> {
        &mut self.params
    }
}

impl UpdateInput for KITradeVolume {}

impl IntoInputList for KITradeVolume {
    fn list_name(&self) -> String {
        String::from("pair")
    }
}

impl InputListItem for KITradeVolume {
    type ListItem = KAssetPair;
}

impl InputList for KITradeVolume {}

impl Input for KITradeVolume {
    fn finish(self) -> KrakenInput {
        KrakenInput {
            info: EndpointInfo {
                methodtype: MethodType::Private,
                endpoint: String::from("TradeVolume"),
            },
            params: Some(self.with_nonce().params),
        }
    }

    fn finish_clone(self) -> (KrakenInput, Self) {
        let newself = self.with_nonce();
        (
            KrakenInput {
                info: EndpointInfo {
                    methodtype: MethodType::Private,
                    endpoint: String::from("TradeVolume"),
                },
                params: Some(newself.params.clone()),
            },
            newself,
        )
    }
}

/// Fee info
#[derive(Deserialize, Serialize, Debug)]
pub struct KOFeeInfo {
    pub fee: String,
    pub minfee: Option<String>,
    pub maxfee: Option<String>,
    pub nextfee: Option<String>,
    pub nextvolume: Option<String>,
}

/// Maker fee info
#[derive(Deserialize, Serialize, Debug)]
pub struct KOMakerFeeInfo {
    pub fee: String,
    pub minfee: Option<String>,
    pub maxfee: Option<String>,
    pub nextfee: Option<String>,
    pub nextvolume: Option<String>,
    pub tiervolume: Option<String>,
}

/// Response from the Get Trade Volume endpoint
#[derive(Deserialize, Serialize, Debug)]
pub struct KOTradeVolume {
    pub currency: String,
    pub volume: String,
    pub fees: Option<HashMap<String, KOFeeInfo>>,
    pub fees_maker: Option<HashMap<String, KOMakerFeeInfo>>,
}

impl Output for KOTradeVolume {}