polysqueeze 0.1.7

Rust SDK for authenticated access to Polymarket's CLOB, Gamma, and WebSocket APIs.
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

use polysqueeze::client::ClobClient;
use polysqueeze::errors::Result;
use std::env;

fn env_var(key: &str) -> String {
    env::var(key).expect(&format!("{} must be set for auth test", key))
}

fn should_run() -> bool {
    env::var("RUN_AUTH_TEST").is_ok()
}

#[tokio::test]
async fn derived_auth_matches_env() -> Result<()> {
    if !should_run() {
        eprintln!("Skipping auth test (set RUN_AUTH_TEST=1)");
        return Ok(());
    }

    let base_url =
        env::var("POLY_API_URL").unwrap_or_else(|_| "https://clob.polymarket.com".into());
    let private_key = env_var("POLY_PRIVATE_KEY");
    let expected_api_key = env_var("POLY_API_KEY");
    let expected_secret = env_var("POLY_API_SECRET");
    let expected_passphrase = env_var("POLY_API_PASSPHRASE");
    let chain_id = env::var("POLY_CHAIN_ID")
        .ok()
        .and_then(|value| value.parse::<u64>().ok())
        .unwrap_or(137);

    let client = ClobClient::with_l1_headers(&base_url, &private_key, chain_id);
    let creds = client.create_or_derive_api_key(None).await?;

    assert_eq!(
        creds.api_key, expected_api_key,
        "Derived API key should match the provided env var"
    );
    assert_eq!(
        creds.secret, expected_secret,
        "Derived secret should match the provided env var"
    );
    assert_eq!(
        creds.passphrase, expected_passphrase,
        "Derived passphrase should match the provided env var"
    );

    Ok(())
}

#[tokio::test]
async fn post_api_key_with_l1_headers_succeeds() -> Result<()> {
    if !should_run() {
        eprintln!("Skipping auth test (set RUN_AUTH_TEST=1)");
        return Ok(());
    }

    let base_url =
        env::var("POLY_API_URL").unwrap_or_else(|_| "https://clob.polymarket.com".into());
    let private_key = env_var("POLY_PRIVATE_KEY");
    let chain_id = env::var("POLY_CHAIN_ID")
        .ok()
        .and_then(|value| value.parse::<u64>().ok())
        .unwrap_or(137);

    let client = ClobClient::with_l1_headers(&base_url, &private_key, chain_id);
    let creds = client.create_or_derive_api_key(None).await?;

    assert!(!creds.api_key.is_empty(), "API key should be returned");
    assert!(!creds.secret.is_empty(), "Secret should be returned");
    assert!(
        !creds.passphrase.is_empty(),
        "Passphrase should be returned"
    );
    println!("creds are: {:?}", creds);
    Ok(())
}

#[tokio::test]
async fn l2_get_api_keys_succeeds() -> Result<()> {
    if !should_run() {
        eprintln!("Skipping auth test (set RUN_AUTH_TEST=1)");
        return Ok(());
    }

    let base_url =
        env::var("POLY_API_URL").unwrap_or_else(|_| "https://clob.polymarket.com".into());
    let private_key = env_var("POLY_PRIVATE_KEY");
    let chain_id = env::var("POLY_CHAIN_ID")
        .ok()
        .and_then(|value| value.parse::<u64>().ok())
        .unwrap_or(137);

    let l1_client = ClobClient::with_l1_headers(&base_url, &private_key, chain_id);
    let creds = l1_client.create_or_derive_api_key(None).await?;

    let l2_client = ClobClient::with_l2_headers(&base_url, &private_key, chain_id, creds.clone());
    let keys = l2_client.get_api_keys().await?;

    assert!(
        keys.contains(&creds.api_key),
        "Derived API key should appear in api-keys list"
    );

    println!("keys: {:?}", keys);

    Ok(())
}