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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

use crate::domain::{amount::*, offer::*};

pub struct BtcOffer<'a> {
    inner: &'a OpenOffer,
}

impl<'a> BtcOffer<'a> {
    pub fn new(offer: &'a OpenOffer) -> Self {
        Self { inner: offer }
    }

    pub fn direction(&self) -> OfferDirection {
        if self.inner.market.non_btc_side().is_crypto() {
            self.inner.direction.oposite()
        } else {
            self.inner.direction
        }
    }

    pub fn volume(&self) -> NumberWithPrecision {
        if self.inner.market.non_btc_side().is_crypto() {
            self.inner.amount.total
        } else {
            self.inner.display_price * self.inner.amount.total
        }
    }

    pub fn amount(&self) -> NumberWithPrecision {
        if self.inner.market.non_btc_side().is_crypto() {
            self.inner.amount.total / self.inner.display_price
        } else {
            self.inner.amount.total
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{bisq::SequencedMessageHash, domain::market::*};
    use bitcoin_hashes::sha256;
    use std::{str::FromStr, time::UNIX_EPOCH};

    fn fiat_offer() -> OpenOffer {
        OpenOffer::new(
            SequencedMessageHash::new(
                sha256::Hash::from_str(
                    &"2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824",
                )
                .unwrap(),
            ),
            Market::from_pair("btc_eur").unwrap(),
            "fiat-offer".to_string().into(),
            OfferDirection::Buy,
            OfferPrice::Fixed(NumberWithPrecision::new(1000, 0)),
            OfferAmount {
                total: NumberWithPrecision::new(1, 0),
                min: NumberWithPrecision::new(5, 1),
            },
            "PAYMENT_METHOD".into(),
            "OFFER_FEE_TX_ID".into(),
            UNIX_EPOCH,
            0.into(),
        )
    }

    fn crypto_offer() -> OpenOffer {
        OpenOffer::new(
            SequencedMessageHash::new(
                sha256::Hash::from_str(
                    &"2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824",
                )
                .unwrap(),
            ),
            Market::from_pair("bsq_btc").unwrap(),
            "fiat-offer".to_string().into(),
            OfferDirection::Sell,
            OfferPrice::Fixed(NumberWithPrecision::new(7800, 8)),
            OfferAmount {
                total: NumberWithPrecision::new(5, 1),
                min: NumberWithPrecision::new(5, 1),
            },
            "PAYMENT_METHOD".into(),
            "OFFER_FEE_TX_ID".into(),
            UNIX_EPOCH,
            0.into(),
        )
    }

    #[test]
    fn test_fiat_offer() {
        let fiat_offer = fiat_offer();
        let btc_offer = BtcOffer::new(&fiat_offer);
        assert!(btc_offer.direction() == OfferDirection::Buy);
        assert!(btc_offer.volume() == NumberWithPrecision::new(1000, 0));
        assert!(btc_offer.amount() == NumberWithPrecision::new(1, 0));
    }

    #[test]
    fn test_crypto_offer() {
        let crypto_offer = crypto_offer();
        let btc_offer = BtcOffer::new(&crypto_offer);
        assert!(btc_offer.direction() == OfferDirection::Buy);
        assert!(btc_offer.volume() == NumberWithPrecision::new(5, 1));
        assert!(btc_offer.amount() == NumberWithPrecision::new(641025641025, 8));
    }
}