lfest 0.138.3

A leveraged perpetual futures exchange for simulated trading and backtesting
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

use const_decimal::Decimal;

use super::Mon;
use crate::types::{
    BaseCurrency,
    QuoteCurrency,
};

/// Fee as a part per one hundred thousand.
/// The generic `MarkerTaker` marker indicates to the type system if its a maker or taker fee.
#[derive(Default, Debug, Clone, Copy, PartialEq, Eq)]
pub struct Fee<I, const D: u8, MakerTaker> {
    value: Decimal<I, D>,
    _fee_type: std::marker::PhantomData<MakerTaker>,
}

impl<I, const D: u8, MakerTaker> From<Decimal<I, D>> for Fee<I, D, MakerTaker>
where
    I: Mon<D>,
{
    fn from(value: Decimal<I, D>) -> Self {
        Self {
            value,
            _fee_type: std::marker::PhantomData,
        }
    }
}

impl<I, const D: u8, MakerTaker> AsRef<Decimal<I, D>> for Fee<I, D, MakerTaker> {
    #[inline]
    fn as_ref(&self) -> &Decimal<I, D> {
        &self.value
    }
}

impl<I, const D: u8, MakerTaker> std::ops::Mul<QuoteCurrency<I, D>> for Fee<I, D, MakerTaker>
where
    I: Mon<D>,
{
    type Output = QuoteCurrency<I, D>;

    #[inline(always)]
    fn mul(self, rhs: QuoteCurrency<I, D>) -> Self::Output {
        rhs * self.value
    }
}

impl<I, const D: u8, MakerTaker> std::ops::Mul<BaseCurrency<I, D>> for Fee<I, D, MakerTaker>
where
    I: Mon<D>,
{
    type Output = BaseCurrency<I, D>;

    #[inline(always)]
    fn mul(self, rhs: BaseCurrency<I, D>) -> Self::Output {
        rhs * self.value
    }
}

/// The fee limit orders pay.
#[derive(Debug, Clone, Copy)]
pub struct Maker;

/// The fee market orders pay.
#[derive(Debug, Clone, Copy)]
pub struct Taker;

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn size_of_fee() {
        assert_eq!(size_of::<Fee<i32, 5, Maker>>(), 4);
        assert_eq!(size_of::<Fee<i32, 5, Taker>>(), 4);
        assert_eq!(size_of::<Fee<i64, 5, Maker>>(), 8);
    }
}