risq 0.4.1

Re-implementation of Bisq (https://github.com/bisq-network/bisq) in rust
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

use crate::{api::WithQueryFields, domain::market::Market};
use serde::Deserialize;
use std::{collections::HashMap, fmt, iter::Chain, vec::IntoIter};

#[derive(Deserialize)]
pub struct Offers {
    buys_and_sells: BuysAndSells,
}
#[derive(Deserialize)]
pub struct BuysAndSells {
    buys: Vec<Offer>,
    sells: Vec<Offer>,
}
impl Offers {
    pub fn add_variables(market: &Market, args: &mut HashMap<String, String>) {
        args.insert("market".to_string(), market.pair.clone());
    }
    fn buys(&self) -> &Vec<Offer> {
        &self.buys_and_sells.buys
    }
    fn sells(&self) -> &Vec<Offer> {
        &self.buys_and_sells.sells
    }
    pub fn len(&self) -> usize {
        self.buys().len() + self.sells().len()
    }
}
impl IntoIterator for Offers {
    type Item = Offer;
    type IntoIter = Chain<IntoIter<Offer>, IntoIter<Offer>>;

    fn into_iter(self) -> Self::IntoIter {
        let BuysAndSells { buys, sells } = self.buys_and_sells;
        buys.into_iter().chain(sells.into_iter())
    }
}
impl WithQueryFields for Offers {
    fn get_fields() -> String {
        format!(
            r#"query Offers($market: MarketPair = "all") {{
                 buys_and_sells: offers(market: $market) {{
                   buys {}
                   sells {}
               }} }}"#,
            Offer::get_fields(),
            Offer::get_fields()
        )
    }
}

#[derive(Deserialize)]
pub struct Offer {
    pub id: String,
    pub market: String,
    pub direction: String,
    pub price: String,
    pub amount: String,
    pub min_amount: String,
    pub volume: String,
    pub payment_method: String,
}
impl fmt::Display for Offer {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "{} - {} {} {}({}) {} {}",
            self.id,
            self.direction,
            self.price,
            self.amount,
            self.min_amount,
            self.volume,
            self.payment_method
        )
    }
}

impl WithQueryFields for Offer {
    fn get_fields() -> String {
        r#"{ id
             market: marketPair
             direction
             price: formattedPrice
             amount: formattedAmount
             min_amount: formattedMinAmount
             volume: formattedVolume
             payment_method: paymentMethodId
           }"#
        .to_string()
    }
}