polymarket-rs 0.2.0

Rust client library for the Polymarket CLOB, Gamma, and Data API
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

use rust_decimal::Decimal;
use rust_decimal::RoundingStrategy::{AwayFromZero, MidpointTowardZero, ToZero};
use std::collections::HashMap;
use std::str::FromStr;
use std::sync::LazyLock;

/// Rounding configuration for a specific tick size
#[derive(Debug, Clone, Copy)]
pub struct RoundConfig {
    pub price: u32,
    pub size: u32,
    pub amount: u32,
}

/// Rounding configurations for different tick sizes
pub static ROUNDING_CONFIG: LazyLock<HashMap<Decimal, RoundConfig>> = LazyLock::new(|| {
    HashMap::from([
        (
            Decimal::from_str("0.1").unwrap(),
            RoundConfig {
                price: 1,
                size: 2,
                amount: 3,
            },
        ),
        (
            Decimal::from_str("0.01").unwrap(),
            RoundConfig {
                price: 2,
                size: 2,
                amount: 4,
            },
        ),
        (
            Decimal::from_str("0.001").unwrap(),
            RoundConfig {
                price: 3,
                size: 2,
                amount: 5,
            },
        ),
        (
            Decimal::from_str("0.0001").unwrap(),
            RoundConfig {
                price: 4,
                size: 2,
                amount: 6,
            },
        ),
    ])
});

/// Convert decimal amount to token units (multiply by 1e6 and round)
pub fn decimal_to_token_u64(amt: Decimal) -> u64 {
    let mut amt = Decimal::from_scientific("1e6").expect("1e6 is not scientific") * amt;
    if amt.scale() > 0 {
        amt = amt.round_dp_with_strategy(0, MidpointTowardZero);
    }
    amt.try_into().expect("Couldn't round decimal to integer")
}

/// Fix amount rounding to ensure proper precision
pub fn fix_amount_rounding(mut amt: Decimal, round_config: &RoundConfig) -> Decimal {
    if amt.scale() > round_config.amount {
        amt = amt.round_dp_with_strategy(round_config.amount + 4, AwayFromZero);
        if amt.scale() > round_config.amount {
            amt = amt.round_dp_with_strategy(round_config.amount, ToZero);
        }
    }
    amt
}

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

    #[test]
    fn test_rounding_configs_exist() {
        assert!(ROUNDING_CONFIG.contains_key(&Decimal::from_str("0.1").unwrap()));
        assert!(ROUNDING_CONFIG.contains_key(&Decimal::from_str("0.01").unwrap()));
        assert!(ROUNDING_CONFIG.contains_key(&Decimal::from_str("0.001").unwrap()));
        assert!(ROUNDING_CONFIG.contains_key(&Decimal::from_str("0.0001").unwrap()));
    }

    #[test]
    fn test_decimal_to_token() {
        let result = decimal_to_token_u64(Decimal::from_str("1.5").unwrap());
        assert_eq!(result, 1_500_000);
    }
}