Polysqueeze

https://docs.rs/polysqueeze/0.1.7/polysqueeze/
Admin
Polysqueeze is a Rust SDK for interacting with Polymarket's REST, Gamma, and WebSocket APIs to...
Tokens:231,999
Snippets:2,217
Trust Score:9.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### Full WebSocket Market Example

Source: https://docs.rs/polysqueeze/0.1.7/polysqueeze/client/struct.ClobClient.html

This example demonstrates how to create a ClobClient, fetch market data, derive asset IDs, and subscribe to WebSocket price and order book updates for a market. It requires POLY_API_URL and POLY_WSS_MIN_LIQUIDITY environment variables to be set.

```rust
async fn main() -> Result<()> {
    let base_url = env::var("POLY_API_URL").unwrap_or_else(|_| "https://clob.polymarket.com".to_string());
    let clob = ClobClient::new(&base_url);

    let min_liquidity = env::var("POLY_WSS_MIN_LIQUIDITY")
        .ok()
        .and_then(|value| Decimal::from_str(&value).ok())
        .unwrap_or_else(|| Decimal::from(1_000_000));

    let params = GammaListParams {
        limit: Some(50),
        liquidity_num_min: Some(min_liquidity),
        ..Default::default()
    };

    let response = clob.get_markets(None, Some(&params)).await?;
    let market = pick_liquid_market(&response.data, min_liquidity)?;

    println!(
        "Selected market {} (liquidity={:?})",
        market.condition_id, market.liquidity_num
    );

    let asset_ids = derive_asset_ids(market).unwrap_or_else(|| Vec::new());

    if asset_ids.is_empty() {
        return Err(PolyError::validation(
            "failed to derive asset IDs for the selected market",
        ));
    }

    let mut client = WssMarketClient::new();
    client.subscribe(asset_ids.clone()).await?;

    println!("Subscribed to market channel for assets={:?}", asset_ids);

    for _ in 0..20 {
        match client.next_event().await {
            Ok(WssMarketEvent::PriceChange(change)) => {
                println!(
                    "price_change for {}: {:?}",
                    change.market, change.price_changes
                );
            }
            Ok(WssMarketEvent::Book(book)) => {
                println!(
                    "book {} bids={} asks={}",
                    book.market,
                    book.bids.len(),
                    book.asks.len()
                );
            }
            Ok(WssMarketEvent::TickSizeChange(change)) => {
                println!(
                    "tick size change {} from {} to {}",
                    change.market, change.old_tick_size, change.new_tick_size
                );
            }
            Ok(WssMarketEvent::LastTrade(trade)) => {
                println!(
                    "last_trade {} {:?}@{}",
                    trade.market, trade.side, trade.price
                );
            }
            Err(err) => {
                eprintln!("stream error: {}", err);
                break;
            }
        }
    }

    Ok(())
}
```

--------------------------------

### Handling file metadata errors with `and_then`

Source: https://docs.rs/polysqueeze/0.1.7/polysqueeze/errors/type.Result.html

This example demonstrates using `and_then` to chain fallible operations like getting file metadata and then its modified time. It shows how to handle potential `NotFound` errors.

```rust
use std::{io::ErrorKind, path::Path};

// Note: on Windows "/" maps to "C:\\"
let root_modified_time = Path::new("/").metadata().and_then(|md| md.modified());
assert!(root_modified_time.is_ok());

let should_fail = Path::new("/bad/path").metadata().and_then(|md| md.modified());
assert!(should_fail.is_err());
assert_eq!(should_fail.unwrap_err().kind(), ErrorKind::NotFound);
```

--------------------------------

### Initialize ClobClient

Source: https://docs.rs/polysqueeze/0.1.7/polysqueeze/client/struct.ClobClient.html

Initializes a new ClobClient instance with a base URL. This is a basic client setup.

```rust
15    let clob = ClobClient::new(&base_url);

```

--------------------------------

### Main Function Setup and Market Data Fetching

Source: https://docs.rs/polysqueeze/0.1.7/polysqueeze/wss/struct.WssUserClient.html

Sets up the ClobClient, fetches markets based on liquidity, and derives relevant market IDs and token IDs for trading. This function prepares the necessary data before interacting with the WebSocket client.

```rust
async fn main() -> Result<()> {
    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 mut l2_client =
        ClobClient::with_l2_headers(&base_url, &private_key, chain_id, creds.clone());

    if let Ok(funder) = env::var("POLY_FUNDER") {
        l2_client.set_funder(&funder)?;
    }

    let min_liquidity =
        env::var("POLY_WSS_MIN_LIQUIDITY")
            .ok()
            .and_then(|value| Decimal::from_str(&value).ok())
            .unwrap_or_else(|| Decimal::from(1_000_000));

    let gamma_params = GammaListParams {
        limit: Some(5),
        liquidity_num_min: Some(min_liquidity),
        ..Default::default()
    };
    let markets_response = l2_client.get_markets(None, Some(&gamma_params)).await?;

    let market_ids: Vec<String> = markets_response
        .data
        .iter()
        .filter(|market| market.liquidity_num.unwrap_or(Decimal::ZERO) >= min_liquidity)
        .map(|market| market.condition_id.clone())
        .filter(|id| !id.is_empty())
        .take(2)
        .collect();

    if market_ids.is_empty() {
        return Err(PolyError::validation(
            "Gamma did not return any markets with condition_ids",
        ));
    }

    let primary_market =
        markets_response
            .data
            .iter()
            .find(|market| {
                !market.clob_token_ids.is_empty()
                    && market.liquidity_num.unwrap_or(Decimal::ZERO) >= min_liquidity
            })
            .ok_or_else(|| {
                PolyError::validation("No Gamma markets returned a CLOB token id for trading")
            })?;
    let token_id = primary_market.clob_token_ids.first().unwrap().clone();

    let book = l2_client.get_order_book(&token_id).await?;
    let _best_ask = book.asks.first().ok_or_else(|| {
        PolyError::validation("Order book has no asks; cannot derive a safe price")
    })?;
    let tick_size = primary_market.minimum_tick_size;
    let max_bid_level = book
        .bids
        .iter()
        .max_by(|a, b| {
            a.size
                .partial_cmp(&b.size)
                .unwrap_or(std::cmp::Ordering::Equal)
        })
        .ok_or_else(|| PolyError::validation("Order book has no depth data"))?;
    let far_price =
        max_bid_level.price - tick_size * Decimal::from_u32(10).unwrap_or(Decimal::ZERO);
    let order_price = if far_price > Decimal::ZERO {
        far_price
    } else {
        max_bid_level.price - tick_size
    };
    let order_size = Decimal::new(5, 0); // 0.1 size
    let order_args = OrderArgs::new(&token_id, order_price, order_size, Side::BUY);

    let mut user_client = WssUserClient::new(creds.clone());
    user_client.subscribe(market_ids.clone()).await?;

    println!(
        "Subscribed to user channel for markets {market_ids:?} (waiting for your cancel/update)..."
    );
    let signed_order = l2_client
        .create_order(&order_args, None, None, None)
        .await?;
    let response = l2_client.post_order(signed_order, OrderType::GTC).await?;
    let order_id = response
        .get("orderID")
        .and_then(|value| value.as_str())
        .ok_or_else(|| PolyError::validation("Post order response missing orderID"))?;
        .to_string();
    println!(
        "Placed order on {} @ {}: {response:#}",
        token_id,
        order_price
    );
    println!(
        "Order id {} - cancel it via the `wss_cancel` example while this stream is running.",
        order_id
    );

    loop {
        match user_client.next_event().await {
            Ok(WssUserEvent::Order(order)) => {
                println!(
                    "order {} {} matched={} price={} side={}",
                    order.id,
                    order.message_type,
                    order.size_matched,
                    order.price,
                    order.side.as_str()
                );
                if order.message_type.eq_ignore_ascii_case("CANCELLATION") {
                    println!("Order {} cancelled; exiting.", order.id);
                    break;
                }
            }
            Ok(WssUserEvent::Trade(trade)) => {
                println!(
                    "trade {} {} {}@{} status={}",
                    trade.id,
                    trade.side.as_str(),
                    trade.size,

```

--------------------------------

### Initialize and Subscribe WssUserClient

Source: https://docs.rs/polysqueeze/0.1.7/polysqueeze/wss/struct.WssUserClient.html

Initializes the ClobClient, retrieves market data, and subscribes the WssUserClient to specified market IDs. This setup is necessary before processing real-time events.

```rust
17async fn main() -> Result<()> {
18    let base_url =
19        env::var("POLY_API_URL").unwrap_or_else(|_| "https://clob.polymarket.com".into());
20    let private_key = env_var("POLY_PRIVATE_KEY");
21    let chain_id = env::var("POLY_CHAIN_ID")
22        .ok()
23        .and_then(|value| value.parse::<u64>().ok())
24        .unwrap_or(137);
25
26    let l1_client = ClobClient::with_l1_headers(&base_url, &private_key, chain_id);
27    let creds = l1_client.create_or_derive_api_key(None).await?;
28    let mut l2_client =
29        ClobClient::with_l2_headers(&base_url, &private_key, chain_id, creds.clone());
30
31    if let Ok(funder) = env::var("POLY_FUNDER") {
32        l2_client.set_funder(&funder)?;
33    }
34
35    let min_liquidity =
36        env::var("POLY_WSS_MIN_LIQUIDITY")
37            .ok()
38            .and_then(|value| Decimal::from_str(&value).ok())
39            .unwrap_or_else(|| Decimal::from(1_000_000));
40
41    let gamma_params = GammaListParams {
42        limit: Some(5),
43        liquidity_num_min: Some(min_liquidity),
44        ..Default::default()
45    };
46    let markets_response = l2_client.get_markets(None, Some(&gamma_params)).await?;
47
48    let market_ids: Vec<String> = markets_response
49        .data
50        .iter()
51        .filter(|market| market.liquidity_num.unwrap_or(Decimal::ZERO) >= min_liquidity)
52        .map(|market| market.condition_id.clone())
53        .filter(|id| !id.is_empty())
54        .take(2)
55        .collect();
56
57    if market_ids.is_empty() {
58        return Err(PolyError::validation(
59            "Gamma did not return any markets with condition_ids",
60        ));
61    }
62
63    let primary_market =
64        markets_response
65            .data
66            .iter()
67            .find(|market| {
68                !market.clob_token_ids.is_empty()
69                    && market.liquidity_num.unwrap_or(Decimal::ZERO) >= min_liquidity
70            })
71            .ok_or_else(|| {
72                PolyError::validation("No Gamma markets returned a CLOB token id for trading")
73            })?;
74    let token_id = primary_market.clob_token_ids.first().unwrap().clone();
75
76    let book = l2_client.get_order_book(&token_id).await?;
77    let _best_ask = book.asks.first().ok_or_else(|| {
78        PolyError::validation("Order book has no asks; cannot derive a safe price")
79    })?;
80    let tick_size = primary_market.minimum_tick_size;
81    let max_bid_level = book
82        .bids
83        .iter()
84        .max_by(|a, b| {
85            a.size
86                .partial_cmp(&b.size)
87                .unwrap_or(std::cmp::Ordering::Equal)
88        })
89        .ok_or_else(|| PolyError::validation("Order book has no depth data"))?;
90    let far_price =
91        max_bid_level.price - tick_size * Decimal::from_u32(10).unwrap_or(Decimal::ZERO);
92    let order_price = if far_price > Decimal::ZERO {
93        far_price
94    } else {
95        max_bid_level.price - tick_size
96    };
97    let order_size = Decimal::new(5, 0); // 0.1 size
98    let order_args = OrderArgs::new(&token_id, order_price, order_size, Side::BUY);
99
100    let mut user_client = WssUserClient::new(creds.clone());
101    user_client.subscribe(market_ids.clone()).await?;
102
103    println!(
104        "Subscribed to user channel for markets {market_ids:?} (waiting for your cancel/update)..."
105    );
106    let signed_order = l2_client
107        .create_order(&order_args, None, None, None)
108        .await?;
109    let response = l2_client.post_order(signed_order, OrderType::GTC).await?;
110    let order_id = response
111        .get("orderID")
112        .and_then(|value| value.as_str())
113        .ok_or_else(|| PolyError::validation("Post order response missing orderID"))?;
114    println!(
115        "Placed order on {} @ {}: {response:#}",
116        token_id,
117        order_price
118    );
119    println!(
120        "Order id {} - cancel it via the `wss_cancel` example while this stream is running.",
121        order_id
122    );
123
124    loop {
125        match user_client.next_event().await {
126            Ok(WssUserEvent::Order(order)) => {
127                println!(
128                    "order {} {} matched={} price={} side={}",
129                    order.id,
130                    order.message_type,
131                    order.size_matched,
132                    order.price,
133                    order.side.as_str()
134                );
135                if order.message_type.eq_ignore_ascii_case("CANCELLATION") {
136                    println!("Order {} cancelled; exiting.", order.id);
137                    break;
138                }
139            }
140            Ok(WssUserEvent::Trade(trade)) => {
141                println!(
142                    "trade {} {} {}@{} status={}",
143                    trade.id,
144                    trade.side.as_str(),
145                    trade.size,

```

--------------------------------

### Place and Subscribe to Orders with ClobClient

Source: https://docs.rs/polysqueeze/0.1.7/polysqueeze/types/enum.Side.html

This example demonstrates how to initialize the ClobClient, fetch market data, determine optimal order parameters, place a limit order, and subscribe to real-time order updates via WebSocket. It requires environment variables for API URL, private key, and optionally chain ID and funder.

```rust
async fn main() -> Result<()> {
    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 mut l2_client =
        ClobClient::with_l2_headers(&base_url, &private_key, chain_id, creds.clone());

    if let Ok(funder) = env::var("POLY_FUNDER") {
        l2_client.set_funder(&funder)?;
    }

    let min_liquidity = env::var("POLY_WSS_MIN_LIQUIDITY")
        .ok()
        .and_then(|value| Decimal::from_str(&value).ok())
        .unwrap_or_else(|| Decimal::from(1_000_000));

    let gamma_params = GammaListParams {
        limit: Some(5),
        liquidity_num_min: Some(min_liquidity),
        ..Default::default()
    };
    let markets_response = l2_client.get_markets(None, Some(&gamma_params)).await?;

    let market_ids: Vec<String> = markets_response
        .data
        .iter()
        .filter(|market| market.liquidity_num.unwrap_or(Decimal::ZERO) >= min_liquidity)
        .map(|market| market.condition_id.clone())
        .filter(|id| !id.is_empty())
        .take(2)
        .collect();

    if market_ids.is_empty() {
        return Err(PolyError::validation(
            "Gamma did not return any markets with condition_ids",
        ));
    }

    let primary_market =
        markets_response
            .data
            .iter()
            .find(|market| {
                !market.clob_token_ids.is_empty()
                    && market.liquidity_num.unwrap_or(Decimal::ZERO) >= min_liquidity
            })
            .ok_or_else(|| {
                PolyError::validation("No Gamma markets returned a CLOB token id for trading")
            })?;
    let token_id = primary_market.clob_token_ids.first().unwrap().clone();

    let book = l2_client.get_order_book(&token_id).await?;
    let _best_ask = book.asks.first().ok_or_else(|| {
        PolyError::validation("Order book has no asks; cannot derive a safe price")
    })?;
    let tick_size = primary_market.minimum_tick_size;
    let max_bid_level = book
        .bids
        .iter()
        .max_by(|a, b| {
            a.size
                .partial_cmp(&b.size)
                .unwrap_or(std::cmp::Ordering::Equal)
        })
        .ok_or_else(|| PolyError::validation("Order book has no depth data"))?;
    let far_price =
        max_bid_level.price - tick_size * Decimal::from_u32(10).unwrap_or(Decimal::ZERO);
    let order_price = if far_price > Decimal::ZERO {
        far_price
    } else {
        max_bid_level.price - tick_size
    };
    let order_size = Decimal::new(5, 0); // 0.1 size
    let order_args = OrderArgs::new(&token_id, order_price, order_size, Side::BUY);

    let mut user_client = WssUserClient::new(creds.clone());
    user_client.subscribe(market_ids.clone()).await?;

    println!(
        "Subscribed to user channel for markets {market_ids:?} (waiting for your cancel/update)..."
    );
    let signed_order = l2_client
        .create_order(&order_args, None, None, None)
        .await?;
    let response = l2_client.post_order(signed_order, OrderType::GTC).await?;
    let order_id = response
        .get("orderID")
        .and_then(|value| value.as_str())
        .ok_or_else(|| PolyError::validation("Post order response missing orderID"))?;
        .to_string();
    println!(
        "Placed order on {} @ {}: {response:#}",
        token_id,
        order_price
    );
    println!(
        "Order id {} - cancel it via the `wss_cancel` example while this stream is running.",
        order_id
    );

    loop {
        match user_client.next_event().await {
            Ok(WssUserEvent::Order(order)) => {
                println!(
                    "order {} {} matched={} price={} side={}",
                    order.id,
                    order.message_type,
                    order.size_matched,
                    order.price,
                    order.side.as_str()
                );
                if order.message_type.eq_ignore_ascii_case("CANCELLATION") {
                    println!("Order {} cancelled; exiting.", order.id);
                    break;
                }
            }
            Ok(WssUserEvent::Trade(trade)) => {
                println!(
                    "trade {} {} {}@{} status={}",
                    trade.id,
                    trade.side.as_str(),
                    trade.size,

```

--------------------------------

### Place and Monitor a Limit Order

Source: https://docs.rs/polysqueeze/0.1.7/polysqueeze/client/struct.ClobClient.html

This example demonstrates how to place a limit buy order on a CLOB market and then subscribe to user events to monitor its status, including cancellations or matches. It requires setting up market IDs, deriving an order price, and using both L2Client and WssUserClient.

```rust
let token_id = primary_market.clob_token_ids.first().unwrap().clone();

    let book = l2_client.get_order_book(&token_id).await?;
    let _best_ask = book.asks.first().ok_or_else(|| {
        PolyError::validation("Order book has no asks; cannot derive a safe price")
    })?;
    let tick_size = primary_market.minimum_tick_size;
    let max_bid_level = book
        .bids
        .iter()
        .max_by(|a, b| {
            a.size
                .partial_cmp(&b.size)
                .unwrap_or(std::cmp::Ordering::Equal)
        })
        .ok_or_else(|| PolyError::validation("Order book has no depth data"))?;
    let far_price =
        max_bid_level.price - tick_size * Decimal::from_u32(10).unwrap_or(Decimal::ZERO);
    let order_price = if far_price > Decimal::ZERO {
        far_price
    } else {
        max_bid_level.price - tick_size
    };
    let order_size = Decimal::new(5, 0); // 0.1 size
    let order_args = OrderArgs::new(&token_id, order_price, order_size, Side::BUY);

    let mut user_client = WssUserClient::new(creds.clone());
    user_client.subscribe(market_ids.clone()).await?;

    println!(
        "Subscribed to user channel for markets {market_ids:?} (waiting for your cancel/update)..."
    );
    let signed_order = l2_client
        .create_order(&order_args, None, None, None)
        .await?;
    let response = l2_client.post_order(signed_order, OrderType::GTC).await?;
    let order_id = response
        .get("orderID")
        .and_then(|value| value.as_str())
        .ok_or_else(|| PolyError::validation("Post order response missing orderID"))?;
    println!(
        "Placed order on {} @ {}: {response:#}",
        token_id,
        order_price
    );
    println!(
        "Order id {} - cancel it via the `wss_cancel` example while this stream is running.",
        order_id
    );

    loop {
        match user_client.next_event().await {
            Ok(WssUserEvent::Order(order)) => {
                println!(
                    "order {} {} matched={} price={} side={}",
                    order.id,
                    order.message_type,
                    order.size_matched,
                    order.price,
                    order.side.as_str()
                );
                if order.message_type.eq_ignore_ascii_case("CANCELLATION") {
                    println!("Order {} cancelled; exiting.", order.id);
                    break;
                }
            }
            Ok(WssUserEvent::Trade(trade)) => {
                println!(
                    "trade {} {} {}@{} status={}",
                    trade.id,
                    trade.side.as_str(),
                    trade.size,
                    trade.price,
                    trade.status
                );
            }
            Err(err) => {
                eprintln!("user stream error: {}", err);
                break;
            }
        }
    }

    Ok(())
}

```

--------------------------------

### Subscribe to Market Data and Process Events

Source: https://docs.rs/polysqueeze/0.1.7/polysqueeze/wss/struct.WssMarketClient.html

This example demonstrates how to initialize a WssMarketClient, subscribe to specific asset IDs, and then continuously process incoming market events like price changes, order book updates, and trades. It includes error handling for stream issues.

```rust
async fn main() -> Result<()> {
    let base_url =
        env::var("POLY_API_URL").unwrap_or_else(|_| "https://clob.polymarket.com".to_string());
    let clob = ClobClient::new(&base_url);

    let min_liquidity = env::var("POLY_WSS_MIN_LIQUIDITY")
        .ok()
        .and_then(|value| Decimal::from_str(&value).ok())
        .unwrap_or_else(|| Decimal::from(1_000_000));

    let params = GammaListParams {
        limit: Some(50),
        liquidity_num_min: Some(min_liquidity),
        ..Default::default()
    };

    let response = clob.get_markets(None, Some(&params)).await?;
    let market = pick_liquid_market(&response.data, min_liquidity)?;

    println!(
        "Selected market {} (liquidity={:?})",
        market.condition_id, market.liquidity_num
    );

    let asset_ids = derive_asset_ids(market).unwrap_or_else(|| Vec::new());

    if asset_ids.is_empty() {
        return Err(PolyError::validation(
            "failed to derive asset IDs for the selected market",
        ));
    }

    let mut client = WssMarketClient::new();
    client.subscribe(asset_ids.clone()).await?;

    println!("Subscribed to market channel for assets={:?}", asset_ids);

    for _ in 0..20 {
        match client.next_event().await {
            Ok(WssMarketEvent::PriceChange(change)) => {
                println!(
                    "price_change for {}: {:?}",
                    change.market, change.price_changes
                );
            }
            Ok(WssMarketEvent::Book(book)) => {
                println!(
                    "book {} bids={} asks={}",
                    book.market,
                    book.bids.len(),
                    book.asks.len()
                );
            }
            Ok(WssMarketEvent::TickSizeChange(change)) => {
                println!(
                    "tick size change {} from {} toજી",
                    change.market, change.old_tick_size, change.new_tick_size
                );
            }
            Ok(WssMarketEvent::LastTrade(trade)) => {
                println!(
                    "last_trade {} {:?}@{}",
                    trade.market, trade.side, trade.price
                );
            }
            Err(err) => {
                eprintln!("stream error: {}", err);
                break;
            }
        }
    }

    Ok(())
}

```

--------------------------------

### Place and Monitor a Limit Order

Source: https://docs.rs/polysqueeze/0.1.7/polysqueeze/errors/enum.PolyError.html

This comprehensive example demonstrates placing a limit order (GTC) and then subscribing to user events to monitor its status, including matches and cancellations. It uses `PolyError::validation` for error handling during order placement.

```rust
    let order_args = OrderArgs::new(&token_id, order_price, order_size, Side::BUY);

    let mut user_client = WssUserClient::new(creds.clone());
    user_client.subscribe(market_ids.clone()).await?;

    println!(
        "Subscribed to user channel for markets {market_ids:?} (waiting for your cancel/update)..."
    );
    let signed_order = l2_client
        .create_order(&order_args, None, None, None)
        .await?;
    let response = l2_client.post_order(signed_order, OrderType::GTC).await?;
    let order_id = response
        .get("orderID")
        .and_then(|value| value.as_str())
        .ok_or_else(|| PolyError::validation("Post order response missing orderID"))?;
        .to_string();
    println!(
        "Placed order on {} @ {}: {response:#}",
        token_id, order_price
    );
    println!(
        "Order id {} - cancel it via the `wss_cancel` example while this stream is running.",
        order_id
    );

    loop {
        match user_client.next_event().await {
            Ok(WssUserEvent::Order(order)) => {
                println!(
                    "order {} {} matched={} price={} side={}",
                    order.id,
                    order.message_type,
                    order.size_matched,
                    order.price,
                    order.side.as_str()
                );
                if order.message_type.eq_ignore_ascii_case("CANCELLATION") {
                    println!("Order {} cancelled; exiting.", order.id);
                    break;
                }
            }
            Ok(WssUserEvent::Trade(trade)) => {
                println!(
                    "trade {} {} {}@{} status={}",
                    trade.id,
                    trade.side.as_str(),
                    trade.size,
                    trade.price,
                    trade.status
                );
            }
            Err(err) => {
                eprintln!("user stream error: {}", err);
                break;
            }
        }
    }

    Ok(())
}
```

--------------------------------

### Get Polygon Mainnet Configuration

Source: https://docs.rs/polysqueeze/0.1.7/polysqueeze/config/struct.NetworkConfig.html

Provides the predefined network configuration for the Polygon mainnet.

```rust
pub fn polygon_mainnet() -> Self
```

--------------------------------

### Get Bids (Fast Internal Format)

Source: https://docs.rs/polysqueeze/0.1.7/polysqueeze/book/struct.OrderBook.html

Retrieves all bids in the fast internal format. Use this for internal calculations to avoid conversion overhead.

```rust
pub fn bids_fast(&self, depth: Option<usize>) -> Vec<FastBookLevel>
```

--------------------------------

### Get Current Unix Timestamp in Nanoseconds

Source: https://docs.rs/polysqueeze/0.1.7/polysqueeze/utils/time/fn.now_nanos.html

Call this function to retrieve the current Unix timestamp with nanosecond precision. No setup or imports are required.

```rust
pub fn now_nanos() -> u128
```

--------------------------------

### Get Current Unix Timestamp in Microseconds

Source: https://docs.rs/polysqueeze/0.1.7/polysqueeze/utils/time/fn.now_micros.html

Call this function to obtain the current Unix timestamp, measured in microseconds. No setup or imports are required.

```rust
pub fn now_micros() -> u64
```

--------------------------------

### Initialize and Subscribe with WssUserClient

Source: https://docs.rs/polysqueeze/0.1.7/polysqueeze/wss/struct.WssUserClient.html

Initializes the WssUserClient with API credentials and subscribes to a list of market IDs. This is typically done after setting up the ClobClient and obtaining necessary market data.

```rust
    let mut user_client = WssUserClient::new(creds.clone());
    user_client.subscribe(market_ids.clone()).await?;

    println!(
        "Subscribed to user channel for markets {market_ids:?} (waiting for your cancel/update)..."
    );
```

--------------------------------

### Get Current Unix Timestamp in Milliseconds

Source: https://docs.rs/polysqueeze/0.1.7/polysqueeze/utils/time/fn.now_millis.html

Use this function to obtain the current Unix timestamp, represented as a u64 value in milliseconds. No specific setup or imports are required beyond the function's availability in the polysqueeze::utils::time module.

```rust
pub fn now_millis() -> u64
```

--------------------------------

### Filter Markets and Derive Trading Price with ClobClient

Source: https://docs.rs/polysqueeze/0.1.7/polysqueeze/client/struct.ClobClient.html

Shows how to filter markets based on liquidity and derive a trading price from the order book. This example is useful for identifying markets with sufficient liquidity and determining a suitable price for trades, potentially for WebSocket subscriptions.

```rust
17async fn main() -> Result<()> {
    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 mut l2_client =
        ClobClient::with_l2_headers(&base_url, &private_key, chain_id, creds.clone());

    if let Ok(funder) = env::var("POLY_FUNDER") {
        l2_client.set_funder(&funder)?;
    }

    let min_liquidity = env::var("POLY_WSS_MIN_LIQUIDITY")
        .ok()
        .and_then(|value| Decimal::from_str(&value).ok())
        .unwrap_or_else(|| Decimal::from(1_000_000));

    let gamma_params = GammaListParams {
        limit: Some(5),
        liquidity_num_min: Some(min_liquidity),
        ..Default::default()
    };
    let markets_response = l2_client.get_markets(None, Some(&gamma_params)).await?;

    let market_ids: Vec<String> = markets_response
        .data
        .iter()
        .filter(|market| market.liquidity_num.unwrap_or(Decimal::ZERO) >= min_liquidity)
        .map(|market| market.condition_id.clone())
        .filter(|id| !id.is_empty())
        .take(2)
        .collect();

    if market_ids.is_empty() {
        return Err(PolyError::validation(
            "Gamma did not return any markets with condition_ids",
        ));
    }

    let primary_market =
        markets_response
            .data
            .iter()
            .find(|market| {
                !market.clob_token_ids.is_empty()
                    && market.liquidity_num.unwrap_or(Decimal::ZERO) >= min_liquidity
            })
            .ok_or_else(|| {
                PolyError::validation("No Gamma markets returned a CLOB token id for trading")
            })?;
    let token_id = primary_market.clob_token_ids.first().unwrap().clone();

    let book = l2_client.get_order_book(&token_id).await?;
    let _best_ask = book.asks.first().ok_or_else(|| {
        PolyError::validation("Order book has no asks; cannot derive a safe price")
    })?;
    let tick_size = primary_market.minimum_tick_size;
    let max_bid_level =
        book.bids.iter().max_by(|a, b| {
            a.size
                .partial_cmp(&b.size)
                .unwrap_or(std::cmp::Ordering::Equal)
        }).ok_or_else(|| PolyError::validation("Order book has no depth data"))?;
    let far_price =
        max_bid_level.price - tick_size * Decimal::from_u32(10).unwrap_or(Decimal::ZERO);

```

--------------------------------

### Getting String Length in Bytes

Source: https://docs.rs/polysqueeze/0.1.7/polysqueeze/types/type.OrderId.html

Illustrates how to get the byte length of a String using the `len()` method. Note that this returns the number of bytes, not necessarily the number of characters.

```rust
let a = String::from("foo");
assert_eq!(a.len(), 3);

let fancy_f = String::from("ƒoo");
assert_eq!(fancy_f.len(), 4);
assert_eq!(fancy_f.chars().count(), 3);
```

--------------------------------

### Get Balance and Allowance with ClobClient

Source: https://docs.rs/polysqueeze/0.1.7/polysqueeze/client/struct.ClobClient.html

Retrieves balance and allowance information using the ClobClient. Allows filtering by asset type and setting a funder address.

```rust
17async fn main() -> Result<()> {
    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 mut client = ClobClient::with_l2_headers(&base_url, &private_key, chain_id, creds.clone());

    if let Ok(funder) = env::var("POLY_FUNDER") {
        client.set_funder(&funder)?;
    }

    let mut params = BalanceAllowanceParams::default();
    params.asset_type = Some(AssetType::COLLATERAL);

    let balances = client.get_balance_allowance(Some(params)).await?;
    println!("balance allowance response: {balances:#}");

    Ok(())
}
```

--------------------------------

### Create WssMarketClient Instance

Source: https://docs.rs/polysqueeze/0.1.7/polysqueeze/wss/struct.WssMarketClient.html

Instantiate a new WssMarketClient using the default Polymarket WSS base URL. This is the primary method for creating a client to connect to the market channel.

```rust
let mut client = WssMarketClient::new();
```

--------------------------------

### now_secs

Source: https://docs.rs/polysqueeze/0.1.7/polysqueeze/utils/time/index.html

Gets the current Unix timestamp in seconds.

```APIDOC
## now_secs

### Description
Get current Unix timestamp in seconds

### Function Signature
```rust
fn now_secs() -> u64
```

### Parameters
None

### Request Example
None

### Response
#### Success Response (200)
- **timestamp** (u64) - Current Unix timestamp in seconds

### Response Example
None
```

--------------------------------

### now_secs

Source: https://docs.rs/polysqueeze/0.1.7/polysqueeze/utils/time/fn.now_secs.html

Get current Unix timestamp in seconds.

```APIDOC
## now_secs

### Description
Get current Unix timestamp in seconds.

### Signature
```rust
pub fn now_secs() -> u64
```

### Returns
A `u64` representing the current Unix timestamp in seconds.
```

--------------------------------

### Get Balance and Allowance Information

Source: https://docs.rs/polysqueeze/0.1.7/polysqueeze/client/struct.ClobClient.html

Retrieves the balance and allowance for all assets in an account. This is necessary for placing orders as it confirms ownership and the exchange's spending permission.

```rust
async fn main() -> Result<()> {
    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 mut client = ClobClient::with_l2_headers(&base_url, &private_key, chain_id, creds.clone());

    if let Ok(funder) = env::var("POLY_FUNDER") {
        client.set_funder(&funder)?;
    }

    let mut params = BalanceAllowanceParams::default();
    params.asset_type = Some(AssetType::COLLATERAL);

    let balances = client.get_balance_allowance(Some(params)).await?;
    println!("balance allowance response: {balances:#}");

    Ok(())
}
```

--------------------------------

### now_nanos

Source: https://docs.rs/polysqueeze/0.1.7/polysqueeze/utils/time/fn.now_nanos.html

Get current Unix timestamp in nanoseconds.

```APIDOC
## now_nanos

### Description
Get current Unix timestamp in nanoseconds.

### Signature
```rust
pub fn now_nanos() -> u128
```

### Returns
A `u128` representing the current Unix timestamp in nanoseconds.
```

--------------------------------

### Initialize ClobClient for L1 and L2

Source: https://docs.rs/polysqueeze/0.1.7/polysqueeze/client/struct.ClobClient.html

Demonstrates initializing ClobClient instances for both L1 and L2 networks using base URL, private key, and chain ID. It also shows how to create or derive API keys.

```rust
    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 mut l2_client =
        ClobClient::with_l2_headers(&base_url, &private_key, chain_id, creds.clone());
```

--------------------------------

### now_micros

Source: https://docs.rs/polysqueeze/0.1.7/polysqueeze/utils/time/fn.now_micros.html

Get current Unix timestamp in microseconds.

```APIDOC
## Function now_micros

### Description
Get current Unix timestamp in microseconds.

### Signature
```rust
pub fn now_micros() -> u64
```

### Returns
A `u64` representing the current Unix timestamp in microseconds.
```

--------------------------------

### now_millis

Source: https://docs.rs/polysqueeze/0.1.7/polysqueeze/utils/time/fn.now_millis.html

Get current Unix timestamp in milliseconds.

```APIDOC
## now_millis

### Description
Get current Unix timestamp in milliseconds.

### Signature
```rust
pub fn now_millis() -> u64
```

### Returns
A `u64` representing the current Unix timestamp in milliseconds.
```

--------------------------------

### WssMarketClient::new

Source: https://docs.rs/polysqueeze/0.1.7/polysqueeze/wss/struct.WssMarketClient.html

Creates a new instance of WssMarketClient using the default Polymarket WSS base URL.

```APIDOC
## WssMarketClient::new

### Description
Creates a new instance using the default Polymarket WSS base.

### Method
```rust
pub fn new() -> Self
```

### Examples
```rust
let mut client = WssMarketClient::new();
```
```

--------------------------------

### WssUserClient::new

Source: https://docs.rs/polysqueeze/0.1.7/polysqueeze/wss/struct.WssUserClient.html

Creates a new instance of WssUserClient using the default Polymarket WSS base.

```APIDOC
## `new`

### Description
Creates a new instance using the default Polymarket WSS base.

### Signature
```rust
pub fn new(auth: ApiCredentials) -> Self
```

### Parameters
* `auth` - ApiCredentials: The authentication credentials required to connect.
```

--------------------------------

### BatchPriceRequest

Source: https://docs.rs/polysqueeze/0.1.7/polysqueeze/types/struct.BatchPriceRequest.html

Represents a request to get prices for a batch of tokens.

```APIDOC
## Struct BatchPriceRequest

### Description
Batch price request.

### Fields
* `token_ids` (Vec<String>) - A vector of token IDs for which to request prices.
```

--------------------------------

### Place and Monitor Order with ClobClient

Source: https://docs.rs/polysqueeze/0.1.7/polysqueeze/client/struct.ClobClient.html

Demonstrates placing a limit order and then subscribing to user events to monitor its status, including cancellations and trades. Requires credentials and market data subscriptions.

```rust
async fn example(creds: Creds, market_ids: Vec<MarketId>, token_id: TokenId, tick_size: Decimal, far_price: Decimal, max_bid_level: PriceLevel) -> Result<(), PolyError> {
    let order_price = if far_price > Decimal::ZERO {
        far_price
    } else {
        max_bid_level.price - tick_size
    };
    let order_size = Decimal::new(5, 0); // 0.1 size
    let order_args = OrderArgs::new(&token_id, order_price, order_size, Side::BUY);

    let mut user_client = WssUserClient::new(creds.clone());
    user_client.subscribe(market_ids.clone()).await?;

    println!(
        "Subscribed to user channel for markets {market_ids:?} (waiting for your cancel/update)..."
    );
    let signed_order = l2_client
        .create_order(&order_args, None, None, None)
        .await?;
    let response = l2_client.post_order(signed_order, OrderType::GTC).await?;
    let order_id = response
        .get("orderID")
        .and_then(|value| value.as_str())
        .ok_or_else(|| PolyError::validation("Post order response missing orderID"))?;
    println!(
        "Placed order on {} @ {}: {response:#}",
        token_id,
        order_price
    );
    println!(
        "Order id {} - cancel it via the `wss_cancel` example while this stream is running.",
        order_id
    );

    loop {
        match user_client.next_event().await {
            Ok(WssUserEvent::Order(order)) => {
                println!(
                    "order {} {} matched={} price={} side={}",
                    order.id,
                    order.message_type,
                    order.size_matched,
                    order.price,
                    order.side.as_str()
                );
                if order.message_type.eq_ignore_ascii_case("CANCELLATION") {
                    println!("Order {} cancelled; exiting.", order.id);
                    break;
                }
            }
            Ok(WssUserEvent::Trade(trade)) => {
                println!(
                    "trade {} {} {}@{} status={}",
                    trade.id,
                    trade.side.as_str(),
                    trade.size,
                    trade.price,
                    trade.status
                );
            }
            Err(err) => {
                eprintln!("user stream error: {}", err);
                break;
            }
        }
    }

    Ok(())
}

```

--------------------------------

### get_contract_config

Source: https://docs.rs/polysqueeze/0.1.7/polysqueeze/config/fn.get_contract_config.html

Get contract configuration for a specific chain and risk setting.

```APIDOC
## get_contract_config

### Description
Get contract configuration for a specific chain and risk setting.

### Signature
```rust
pub fn get_contract_config(
    chain_id: u64,
    neg_risk: bool,
) -> Option<ContractConfig>
```

### Parameters
* `chain_id` (u64) - The identifier for the blockchain.
* `neg_risk` (bool) - A flag indicating the risk setting.

### Returns
* `Option<ContractConfig>` - Returns `Some(ContractConfig)` if the configuration is found, otherwise `None`.
```

--------------------------------

### Create WssUserClient Instance

Source: https://docs.rs/polysqueeze/0.1.7/polysqueeze/wss/struct.WssUserClient.html

Creates a new instance of WssUserClient using the default Polymarket WSS base. Requires ApiCredentials for authentication.

```rust
pub fn new(auth: ApiCredentials) -> Self
```

--------------------------------

### Get API Keys

Source: https://docs.rs/polysqueeze/0.1.7/polysqueeze/client/struct.ClobClient.html

Retrieves all API keys associated with the authenticated user.

```APIDOC
## Get API Keys

### Description
Get all API keys for the authenticated user.

### Method
GET (assumed based on operation name)

### Endpoint
/api/keys (assumed based on operation name)

### Response
#### Success Response (200)
- **keys** (Vec<String>) - A list of API keys.
```

--------------------------------

### Process Market Events

Source: https://docs.rs/polysqueeze/0.1.7/polysqueeze/wss/struct.WssMarketClient.html

Continuously fetch and process events from the market channel. This example demonstrates handling different event types such as PriceChange, Book, TickSizeChange, and LastTrade. Errors during stream processing are also handled.

```rust
match client.next_event().await {
            Ok(WssMarketEvent::PriceChange(change)) => {
                println!(
                    "price_change for {}: {:?}",
                    change.market, change.price_changes
                );
            }
            Ok(WssMarketEvent::Book(book)) => {
                println!(
                    "book {} bids={} asks={}",
                    book.market,
                    book.bids.len(),
                    book.asks.len()
                );
            }
            Ok(WssMarketEvent::TickSizeChange(change)) => {
                println!(
                    "tick size change {} from {} to {}",
                    change.market, change.old_tick_size, change.new_tick_size
                );
            }
            Ok(WssMarketEvent::LastTrade(trade)) => {
                println!(
                    "last_trade {} {:?}@{}",
                    trade.market, trade.side, trade.price
                );
            }
            Err(err) => {
                eprintln!("stream error: {}", err);
                break;
            }
        }
```

--------------------------------

### Get Processed Fills

Source: https://docs.rs/polysqueeze/0.1.7/polysqueeze/fill/struct.FillProcessor.html

Retrieves a slice containing all fill events that have been processed.

```rust
pub fn get_processed_fills(&self) -> &[FillEvent]>
```

--------------------------------

### From and Into Implementations

Source: https://docs.rs/polysqueeze/0.1.7/polysqueeze/types/struct.MarketOrderArgs.html

Facilitates conversions to and from MarketOrderArgs.

```rust
fn from(t: T) -> T
```

```rust
fn into(self) -> U
```

--------------------------------

### Get Total Processed Volume

Source: https://docs.rs/polysqueeze/0.1.7/polysqueeze/fill/struct.FillProcessor.html

Returns the aggregate volume of all fills that have been processed.

```rust
pub fn total_processed_volume(&self) -> Decimal>
```

--------------------------------

### GlobalConfig::new

Source: https://docs.rs/polysqueeze/0.1.7/polysqueeze/config/struct.GlobalConfig.html

Creates a new instance of GlobalConfig with default settings.

```APIDOC
## GlobalConfig::new

### Description
Creates a default configuration for GlobalConfig.

### Signature
```rust
pub fn new() -> Self
```
```
Tokens:
Raw