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

use crate::{
    bisq::PersistentMessageHash,
    domain::{
        amount::*,
        market::Market,
        offer::{OfferDirection, OfferId},
    },
};
use std::time::SystemTime;

#[derive(Clone)]
pub struct Trade {
    pub market: &'static Market,
    pub direction: OfferDirection,
    pub offer_id: OfferId,
    pub price: NumberWithPrecision,
    pub amount: NumberWithPrecision,
    pub volume: NumberWithPrecision,
    pub payment_method_id: String,
    pub timestamp: SystemTime,
    pub hash: PersistentMessageHash,
}
#[cfg(feature = "statistics")]
impl Trade {
    pub fn new(
        market: &'static Market,
        mut direction: OfferDirection,
        offer_id: OfferId,
        price: NumberWithPrecision,
        mut amount: NumberWithPrecision,
        payment_method_id: String,
        timestamp: SystemTime,
        hash: PersistentMessageHash,
    ) -> Self {
        let volume = if market.non_btc_side().is_crypto() {
            direction = direction.oposite();
            let volume = amount;
            amount = volume / price;
            volume
        } else {
            (price * amount).with_precision(market.right.bisq_internal_precision())
        };
        Self {
            market,
            direction,
            offer_id,
            price,
            amount,
            volume,
            payment_method_id,
            timestamp,
            hash,
        }
    }
}

#[cfg(feature = "statistics")]
pub struct TradeHistory {
    inner: Vec<Trade>,
}
#[cfg(feature = "statistics")]
impl TradeHistory {
    pub(super) fn new() -> Self {
        Self {
            inner: Vec::with_capacity(60000),
        }
    }
    pub(super) fn insert(&mut self, trade: Trade) {
        for n in (0..=self.inner.len()).rev() {
            if n == 0 || trade.timestamp > self.inner[n - 1].timestamp {
                self.inner.insert(n, trade);
                break;
            }
        }
    }
    pub(super) fn insert_all(&mut self, trades: impl IntoIterator<Item = Trade>) {
        self.inner.extend(trades.into_iter());
        self.inner
            .sort_unstable_by(|a, b| a.timestamp.cmp(&b.timestamp));
    }
    pub fn iter(&self) -> impl DoubleEndedIterator<Item = &Trade> {
        self.inner.iter()
    }
    pub fn first_trade_time(&self) -> Option<SystemTime> {
        self.inner.get(0).map(|t| t.timestamp)
    }
}