polymarket 0.1.0

Rust SDK for Polymarket prediction market - CLOB trading, on-chain operations, and WebSocket streaming
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

use crate::clob::constants::{AMOY, POLYGON};

/// CLOB API hosts
pub const CLOB_API_URL: &str = "https://clob.polymarket.com";
pub const CLOB_TESTNET_API_URL: &str = "https://clob-testnet.polymarket.com";

/// Configuration for the CLOB client
#[derive(Debug, Clone)]
pub struct ClobConfig {
    /// The base URL for the CLOB API
    pub host: String,

    /// The chain ID (POLYGON for mainnet, AMOY for testnet)
    pub chain_id: u64,

    /// Optional funder address for neg risk markets
    pub funder: Option<String>,

    /// Signature type (0 = EOA, 1 = POLY_PROXY, 2 = POLY_GNOSIS_SAFE)
    pub signature_type: u8,
}

impl ClobConfig {
    /// Create a new mainnet configuration
    pub fn new_mainnet() -> Self {
        Self {
            host: CLOB_API_URL.to_string(),
            chain_id: POLYGON,
            funder: None,
            signature_type: 0,
        }
    }

    /// Create a new testnet configuration
    pub fn new_testnet() -> Self {
        Self {
            host: CLOB_TESTNET_API_URL.to_string(),
            chain_id: AMOY,
            funder: None,
            signature_type: 0,
        }
    }

    /// Create a custom configuration
    ///
    /// # Arguments
    /// * `host` - The CLOB API host URL
    /// * `chain_id` - The chain ID
    pub fn new(host: impl Into<String>, chain_id: u64) -> Self {
        Self {
            host: host.into(),
            chain_id,
            funder: None,
            signature_type: 0,
        }
    }

    /// Set the funder address
    pub fn with_funder(mut self, funder: impl Into<String>) -> Self {
        self.funder = Some(funder.into());
        self
    }

    /// Set the signature type
    pub fn with_signature_type(mut self, signature_type: u8) -> Self {
        self.signature_type = signature_type;
        self
    }
}

impl Default for ClobConfig {
    fn default() -> Self {
        Self::new_mainnet()
    }
}

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

    #[test]
    fn test_mainnet_config() {
        let config = ClobConfig::new_mainnet();
        assert_eq!(config.host, CLOB_API_URL);
        assert_eq!(config.chain_id, POLYGON);
        assert_eq!(config.signature_type, 0);
        assert!(config.funder.is_none());
    }

    #[test]
    fn test_testnet_config() {
        let config = ClobConfig::new_testnet();
        assert_eq!(config.host, CLOB_TESTNET_API_URL);
        assert_eq!(config.chain_id, AMOY);
        assert_eq!(config.signature_type, 0);
        assert!(config.funder.is_none());
    }

    #[test]
    fn test_custom_config() {
        let config = ClobConfig::new("https://custom.api", 1337);
        assert_eq!(config.host, "https://custom.api");
        assert_eq!(config.chain_id, 1337);
    }

    #[test]
    fn test_with_funder() {
        let config = ClobConfig::new_mainnet()
            .with_funder("0x1234567890123456789012345678901234567890");
        assert_eq!(config.funder.as_ref().unwrap(), "0x1234567890123456789012345678901234567890");
    }

    #[test]
    fn test_with_signature_type() {
        let config = ClobConfig::new_mainnet().with_signature_type(1);
        assert_eq!(config.signature_type, 1);
    }

    #[test]
    fn test_default_config() {
        let config = ClobConfig::default();
        assert_eq!(config.host, CLOB_API_URL);
        assert_eq!(config.chain_id, POLYGON);
    }
}