pyth-lazer-protocol 0.40.0

Pyth Lazer SDK - protocol types.
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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

use {super::Price, assert_float_eq::assert_float_absolute_eq};

#[test]
fn price_constructs() {
    let price = Price::parse_str("42.68", -8).unwrap();
    assert_eq!(price.0.get(), 4_268_000_000);
    assert_float_absolute_eq!(price.to_f64(-8).unwrap(), 42.68);

    let price2 = Price::from_integer(2, -8).unwrap();
    assert_eq!(price2.0.get(), 200_000_000);
    assert_float_absolute_eq!(price2.to_f64(-8).unwrap(), 2.);

    let price3 = Price::from_mantissa(123_456).unwrap();
    assert_eq!(price3.0.get(), 123_456);
    assert_float_absolute_eq!(price3.to_f64(-8).unwrap(), 0.001_234_56);

    let price4 = Price::from_f64(42.68, -8).unwrap();
    assert_eq!(price4.0.get(), 4_268_000_000);
    assert_float_absolute_eq!(price4.to_f64(-8).unwrap(), 42.68);
}

#[test]
fn price_constructs_with_negative_mantissa() {
    let price = Price::parse_str("-42.68", -8).unwrap();
    assert_eq!(price.0.get(), -4_268_000_000);
    assert_float_absolute_eq!(price.to_f64(-8).unwrap(), -42.68);

    let price2 = Price::from_integer(-2, -8).unwrap();
    assert_eq!(price2.0.get(), -200_000_000);
    assert_float_absolute_eq!(price2.to_f64(-8).unwrap(), -2.);

    let price3 = Price::from_mantissa(-123_456).unwrap();
    assert_eq!(price3.0.get(), -123_456);
    assert_float_absolute_eq!(price3.to_f64(-8).unwrap(), -0.001_234_56);

    let price4 = Price::from_f64(-42.68, -8).unwrap();
    assert_eq!(price4.0.get(), -4_268_000_000);
    assert_float_absolute_eq!(price4.to_f64(-8).unwrap(), -42.68);
}

#[test]
fn price_constructs_with_zero_exponent() {
    let price = Price::parse_str("42", 0).unwrap();
    assert_eq!(price.0.get(), 42);
    assert_float_absolute_eq!(price.to_f64(0).unwrap(), 42.);

    let price2 = Price::from_integer(2, 0).unwrap();
    assert_eq!(price2.0.get(), 2);
    assert_float_absolute_eq!(price2.to_f64(0).unwrap(), 2.);

    let price3 = Price::from_mantissa(123_456).unwrap();
    assert_eq!(price3.0.get(), 123_456);
    assert_float_absolute_eq!(price3.to_f64(0).unwrap(), 123_456.);

    let price4 = Price::from_f64(42., 0).unwrap();
    assert_eq!(price4.0.get(), 42);
    assert_float_absolute_eq!(price4.to_f64(0).unwrap(), 42.);
}

#[test]
fn price_constructs_with_positive_exponent() {
    let price = Price::parse_str("42_680_000", 3).unwrap();
    assert_eq!(price.0.get(), 42_680);
    assert_float_absolute_eq!(price.to_f64(3).unwrap(), 42_680_000.);

    let price2 = Price::from_integer(200_000, 3).unwrap();
    assert_eq!(price2.0.get(), 200);
    assert_float_absolute_eq!(price2.to_f64(3).unwrap(), 200_000.);

    let price3 = Price::from_mantissa(123_456).unwrap();
    assert_eq!(price3.0.get(), 123_456);
    assert_float_absolute_eq!(price3.to_f64(3).unwrap(), 123_456_000.);

    let price4 = Price::from_f64(42_680_000., 3).unwrap();
    assert_eq!(price4.0.get(), 42_680);
    assert_float_absolute_eq!(price4.to_f64(3).unwrap(), 42_680_000.);
}

#[test]
fn price_rejects_zero_mantissa() {
    Price::parse_str("0.0", -8).unwrap_err();
    Price::from_integer(0, -8).unwrap_err();
    Price::from_mantissa(0).unwrap_err();
    Price::from_f64(-0.0, -8).unwrap_err();

    Price::parse_str("0.0", 8).unwrap_err();
    Price::from_integer(0, 8).unwrap_err();
    Price::from_f64(-0.0, 8).unwrap_err();
}

#[test]
fn price_rejects_too_precise() {
    Price::parse_str("42.68", 0).unwrap_err();
    Price::parse_str("42.68", -1).unwrap_err();
    Price::parse_str("42.68", -2).unwrap();

    Price::parse_str("42_680", 3).unwrap_err();
    Price::parse_str("42_600", 3).unwrap_err();
    Price::parse_str("42_000", 3).unwrap();
}

#[test]
fn price_ops() {
    let price1 = Price::parse_str("12.34", -8).unwrap();
    let price2 = Price::parse_str("23.45", -8).unwrap();
    assert_float_absolute_eq!(
        price1
            .add_with_same_exponent(price2)
            .unwrap()
            .to_f64(-8)
            .unwrap(),
        12.34 + 23.45
    );
    assert_float_absolute_eq!(
        price1
            .sub_with_same_exponent(price2)
            .unwrap()
            .to_f64(-8)
            .unwrap(),
        12.34 - 23.45
    );
    assert_float_absolute_eq!(
        price1.mul_integer(2).unwrap().to_f64(-8).unwrap(),
        12.34 * 2.
    );
    assert_float_absolute_eq!(
        price1.div_integer(2).unwrap().to_f64(-8).unwrap(),
        12.34 / 2.
    );

    assert_float_absolute_eq!(
        price1.mul_decimal(3456, -2).unwrap().to_f64(-8).unwrap(),
        12.34 * 34.56
    );

    assert_eq!(
        price1.mul_decimal(34, 2).unwrap().mantissa_i64(),
        1234000000 * 3400
    );
    let price2 = Price::parse_str("42_000", 3).unwrap();
    assert_float_absolute_eq!(
        price2.mul_integer(2).unwrap().to_f64(3).unwrap(),
        42_000. * 2.
    );
    assert_float_absolute_eq!(
        price2.div_integer(2).unwrap().to_f64(3).unwrap(),
        42_000. / 2.
    );
    assert_float_absolute_eq!(
        price2.mul_decimal(3456, -2).unwrap().to_f64(3).unwrap(),
        (42_000_f64 * 34.56 / 1000.).floor() * 1000.
    );
}