### Execute Polymarket Rust Examples from Command Line

Source: https://context7.com/pawsengineer/polymarket-rs/llms.txt

Provides instructions on how to run the provided Rust examples using `cargo run`. Differentiates between public data retrieval and authenticated trading, which requires a `PRIVATE_KEY` environment variable. Also covers WebSocket streaming examples.

```bash
# Public market data (no authentication needed)
cargo run --example clob_data
cargo run --example public_data
cargo run --example gamma_markets

# Authenticated trading (requires PRIVATE_KEY)
PRIVATE_KEY="0x..." cargo run --example authenticated_trading
PRIVATE_KEY="0x..." cargo run --example post_multiple_orders

# WebSocket streaming
cargo run --example websocket_market
PRIVATE_KEY="0x..." cargo run --example websocket_user

```

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

### Bash Examples for Polymarket-RS Functionality

Source: https://github.com/pawsengineer/polymarket-rs/blob/main/README.md

Provides command-line instructions to run various examples included in the polymarket-rs library. These examples cover public market data, market discovery via the Gamma API, authenticated trading, and WebSocket streaming for both market and user data.

```bash
# Public market data
cargo run --example clob_data
cargo run --example public_data

# Market discovery (Gamma API)
cargo run --example gamma_markets

# Authenticated trading
PRIVATE_KEY="0x..." cargo run --example authenticated_trading

# WebSocket streaming
cargo run --example websocket_market
PRIVATE_KEY="0x..." cargo run --example websocket_user
```

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

### Install polymarket-rs dependency

Source: https://github.com/pawsengineer/polymarket-rs/blob/main/README.md

Add the library to your Rust project by including the git repository in your Cargo.toml file.

```toml
[dependencies]
polymarket-rs = { git = "https://github.com/pawsengineer/polymarket-rs.git" }
```

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

### Setup AuthenticatedClient with PolyProxy Wallet (Rust)

Source: https://context7.com/pawsengineer/polymarket-rs/llms.txt

Demonstrates how to configure an AuthenticatedClient for PolyProxy wallets, using the proxy wallet address as the funder and an EOA signer for authentication. This setup is crucial for managing funds separately from the signing key.

```rust
use alloy_primitives::Address;
use alloy_signer_local::PrivateKeySigner;
use polymarket_rs::client::AuthenticatedClient;
use polymarket_rs::Result;
use std::str::FromStr;

#[tokio::main]
async fn main() -> Result<()> {
    let private_key = std::env::var("PRIVATE_KEY")?;
    let signer = PrivateKeySigner::from_str(&private_key)?;

    let chain_id = 137;
    let host = "https://clob.polymarket.com";

    // Your PolyProxy wallet address
    let proxy_wallet_address = Address::from_str("0xYourProxyWalletAddress")?;

    // Create authenticated client with proxy wallet
    // - signer: Your EOA private key (delegated signer)
    // - funder: Your proxy wallet address (holds the funds)
    let auth_client = AuthenticatedClient::new(
        host,
        signer.clone(),
        chain_id,
        None,
        Some(proxy_wallet_address),  // Pass proxy wallet address
    );

    // API authentication uses the signer address
    let api_creds = auth_client.create_or_derive_api_key().await?;
    println!("API Key: {}", api_creds.api_key);

    // Check funder address
    if let Some(funder) = auth_client.get_funder() {
        println!("Funder (proxy wallet): {}", funder);
    }

    println!("Signer address: {}", auth_client.get_address());

    Ok(())
}

```

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

### Manage Orders with TradingClient (Rust)

Source: https://context7.com/pawsengineer/polymarket-rs/llms.txt

Illustrates how to use the TradingClient to create, post, and query orders on the Polymarket exchange. It requires L2 authentication and involves steps like getting API credentials, building orders, and interacting with the exchange API.

```rust
use alloy_signer_local::PrivateKeySigner;
use polymarket_rs::client::{AuthenticatedClient, TradingClient};
use polymarket_rs::orders::OrderBuilder;
use polymarket_rs::types::{CreateOrderOptions, OrderArgs, Side, SignatureType, OrderType};
use polymarket_rs::Result;
use rust_decimal::Decimal;
use std::str::FromStr;

#[tokio::main]
async fn main() -> Result<()> {
    let private_key = std::env::var("PRIVATE_KEY")?;
    let signer = PrivateKeySigner::from_str(&private_key)?;

    let chain_id = 137;
    let host = "https://clob.polymarket.com";

    // Step 1: Get API credentials
    let auth_client = AuthenticatedClient::new(host, signer.clone(), chain_id, None, None);
    let api_creds = auth_client.create_or_derive_api_key().await?;

    // Step 2: Create order builder and trading client
    let order_builder = OrderBuilder::new(signer.clone(), Some(SignatureType::Eoa), None);
    let trading_client = TradingClient::new(
        host,
        signer.clone(),
        chain_id,
        api_creds.clone(),
        order_builder,
    );

    // Step 3: Define order parameters
    let token_id = "109648317055340591503076024421581448189531885907475125926203413622318314876012";

    let order_args = OrderArgs::new(
        token_id,
        Decimal::from_str("0.50").unwrap(),  // price
        Decimal::from_str("10.0").unwrap(),  // size
        Side::Buy,
    );

    let options = CreateOrderOptions::default()
        .tick_size(Decimal::from_str("0.01").unwrap())
        .neg_risk(false);

    // Step 4: Create a signed order (local operation)
    let signed_order = trading_client.create_order(
        &order_args,
        None,  // expiration (0 = no expiration)
        None,  // extras (defaults to ExtraOrderArgs::default())
        options,
    )?;
    println!("Created order with salt: {}", signed_order.salt);

    // Step 5: Post the order to the exchange
    let result = trading_client.post_order(signed_order, OrderType::Gtc).await?;
    println!("Order posted: ID={}, Status={}", result.order_id.as_str(), result.status);

    // Get existing open orders
    let orders = trading_client.get_orders(Default::default()).await?;
    println!("Open orders: {}", orders.data.len());
    for order in orders.data.iter().take(5) {
        println!("  {} {:?} {} @ {}", order.asset_id, order.side, order.original_size, order.price);
    }

    // Get a specific order by ID
    let order = trading_client.get_order(&result.order_id).await?;
    println!("Order status: {}", order.status);

    // Get trade history
    let trades = trading_client.get_trades(Default::default()).await?;
    println!("Trade history: {:?}", trades);

    Ok(())
}

```

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

### Cancel Orders with TradingClient

Source: https://context7.com/pawsengineer/polymarket-rs/llms.txt

Provides examples for various order cancellation patterns, including cancelling a single order, a list of specific orders, all orders, or orders filtered by market and asset identifiers.

```rust
use polymarket_rs::client::TradingClient;
use polymarket_rs::types::OrderId;
use polymarket_rs::Result;

async fn cancel_orders_example(trading_client: &TradingClient) -> Result<()> {
    let order_id = OrderId::new("0xabc123...");
    let result = trading_client.cancel(&order_id).await?;

    let order_ids = vec![
        OrderId::new("0xorder1..."),
        OrderId::new("0xorder2..."),
        OrderId::new("0xorder3..."),
    ];
    let result = trading_client.cancel_orders(&order_ids).await?;

    let result = trading_client.cancel_all().await?;

    let result = trading_client.cancel_market_orders(Some("0xmarket_condition_id"), None).await?;

    let result = trading_client.cancel_market_orders(None, Some("token_id")).await?;

    let result = trading_client.cancel_market_orders(
        Some("0xmarket_condition_id"),
        Some("token_id"),
    ).await?;

    Ok(()) 
}
```

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

### Create and Post Order with TradingClient in Rust

Source: https://context7.com/pawsengineer/polymarket-rs/llms.txt

Demonstrates how to create and post a market order using the `create_and_post_order` convenience method of the `TradingClient`. It requires setting up an authenticated client with API credentials and an order builder.

```rust
use alloy_signer_local::PrivateKeySigner;
use polymarket_rs::client::{AuthenticatedClient, TradingClient};
use polymarket_rs::orders::OrderBuilder;
use polymarket_rs::types::{CreateOrderOptions, OrderArgs, OrderType, Side, SignatureType};
use polymarket_rs::Result;
use rust_decimal::Decimal;
use std::str::FromStr;

#[tokio::main]
async fn main() -> Result<()> {
    let private_key = std::env::var("PRIVATE_KEY")?;
    let signer = PrivateKeySigner::from_str(&private_key)?;

    let chain_id = 137;
    let host = "https://clob.polymarket.com";

    let auth_client = AuthenticatedClient::new(host, signer.clone(), chain_id, None, None);
    let api_creds = auth_client.create_or_derive_api_key().await?;

    let order_builder = OrderBuilder::new(signer.clone(), Some(SignatureType::Eoa), None);
    let trading_client = TradingClient::new(host, signer, chain_id, api_creds, order_builder);

    let token_id = "109648317055340591503076024421581448189531885907475125926203413622318314876012";

    let order_args = OrderArgs::new(
        token_id,
        Decimal::from_str("0.50").unwrap(),
        Decimal::from_str("10.0").unwrap(),
        Side::Buy,
    );

    let options = CreateOrderOptions::default()
        .tick_size(Decimal::from_str("0.01").unwrap())
        .neg_risk(false);

    // Create and post in one call
    let result = trading_client.create_and_post_order(
        &order_args,
        None,           // expiration
        None,           // extras
        options,
        OrderType::Gtc, // GTC, FOK, FAK, or GTD
    ).await?;

    println!("Order posted: ID={}, Success={}", result.order_id.as_str(), result.success);

    Ok(())
}

```

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

### Discover markets using GammaClient

Source: https://github.com/pawsengineer/polymarket-rs/blob/main/README.md

Shows how to use the GammaClient to fetch active markets, filter results, and retrieve metadata like events, tags, and categories.

```rust
use polymarket_rs::{GammaClient, request::GammaMarketParams};

let client = GammaClient::new("https://gamma-api.polymarket.com");

// Get active markets with filtering
let params = GammaMarketParams::new()
    .with_active(true)
    .with_limit(10);
let markets = client.get_markets(Some(params)).await?;

// Get market by ID
let market = client.get_market_by_id("646091").await?;

// Get events, series, tags, and categories
let events = client.get_events().await?;
let series = client.get_series().await?;
let tags = client.get_tags().await?;
let categories = client.get_categories().await?;
```

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

### API Key and Account Management with AuthenticatedClient

Source: https://context7.com/pawsengineer/polymarket-rs/llms.txt

Shows how to initialize an AuthenticatedClient using a private key, derive or create API credentials, and interact with account-specific endpoints like balance checks and notification management.

```rust
use alloy_signer_local::PrivateKeySigner;
use polymarket_rs::client::AuthenticatedClient;
use polymarket_rs::types::BalanceAllowanceParams;
use polymarket_rs::Result;
use std::str::FromStr;

#[tokio::main]
async fn main() -> Result<()> {
    let private_key = std::env::var("PRIVATE_KEY").expect("PRIVATE_KEY environment variable not set");
    let signer = PrivateKeySigner::from_str(&private_key)?;

    let auth_client = AuthenticatedClient::new("https://clob.polymarket.com", signer, 137, None, None);

    let api_creds = auth_client.create_or_derive_api_key().await?;
    println!("API Key: {}", api_creds.api_key);

    let params = BalanceAllowanceParams::default();
    let balance = auth_client.get_balance_allowance(params).await?;
    println!("Balance: {:?}", balance);

    Ok(()) 
}
```

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

### Query public market data with ClobClient

Source: https://github.com/pawsengineer/polymarket-rs/blob/main/README.md

Demonstrates how to initialize a ClobClient and retrieve public market information such as midpoints and order books for a specific token.

```rust
use polymarket_rs::{ClobClient, TokenId};

let client = ClobClient::new("https://clob.polymarket.com");
let token_id = TokenId::new("...");

// Get midpoint price, order books, spreads, etc.
let midpoint = client.get_midpoint(&token_id).await?;
let book = client.get_order_book(&token_id).await?;
```

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

### Post Multiple Orders with TradingClient

Source: https://context7.com/pawsengineer/polymarket-rs/llms.txt

Demonstrates how to initialize an authenticated TradingClient and submit multiple orders simultaneously using the post_orders method. This approach improves efficiency by reducing the number of individual API calls required for batch operations.

```rust
use alloy_signer_local::PrivateKeySigner;
use polymarket_rs::client::{AuthenticatedClient, TradingClient};
use polymarket_rs::orders::OrderBuilder;
use polymarket_rs::types::{
    CreateOrderOptions, OrderArgs, OrderType, PostOrderArgs, Side, SignatureType,
};
use polymarket_rs::Result;
use rust_decimal::Decimal;
use std::str::FromStr;

#[tokio::main]
async fn main() -> Result<()> {
    let private_key = std::env::var("PRIVATE_KEY")?;
    let signer = PrivateKeySigner::from_str(&private_key)?;

    let chain_id = 137;
    let host = "https://clob.polymarket.com";

    let auth_client = AuthenticatedClient::new(host, signer.clone(), chain_id, None, None);
    let api_creds = auth_client.create_or_derive_api_key().await?;

    let order_builder = OrderBuilder::new(signer.clone(), Some(SignatureType::Eoa), None);
    let trading_client = TradingClient::new(host, signer.clone(), chain_id, api_creds, order_builder);

    let token_id = "109648317055340591503076024421581448189531885907475125926203413622318314876012";
    let options = CreateOrderOptions::default()
        .tick_size(Decimal::from_str("0.01").unwrap())
        .neg_risk(false);

    let order1 = trading_client.create_order(
        &OrderArgs::new(token_id, Decimal::from_str("0.50").unwrap(), Decimal::from_str("10.0").unwrap(), Side::Buy),
        None, None, options.clone(),
    )?;

    let order2 = trading_client.create_order(
        &OrderArgs::new(token_id, Decimal::from_str("0.75").unwrap(), Decimal::from_str("15.0").unwrap(), Side::Sell),
        None, None, options.clone(),
    )?;

    let order3 = trading_client.create_order(
        &OrderArgs::new(token_id, Decimal::from_str("0.60").unwrap(), Decimal::from_str("5.0").unwrap(), Side::Buy),
        None, None, options,
    )?;

    let results = trading_client.post_orders(&[
        PostOrderArgs::new(order1, OrderType::Gtc),
        PostOrderArgs::new(order2, OrderType::Gtc),
        PostOrderArgs::new(order3, OrderType::Gtc),
    ]).await?;

    Ok(())
}
```

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

### Market Discovery with GammaClient

Source: https://context7.com/pawsengineer/polymarket-rs/llms.txt

Demonstrates how to fetch market data, categories, tags, and event information from the Polymarket Gamma API. It includes filtering options for active markets and sorting by volume metrics.

```rust
use polymarket_rs::client::GammaClient;
use polymarket_rs::request::GammaMarketParams;
use polymarket_rs::Result;

#[tokio::main]
async fn main() -> Result<()> {
    let client = GammaClient::new("https://gamma-api.polymarket.com");

    let params = GammaMarketParams::new()
        .with_active(true)
        .with_closed(false)
        .with_limit(10)
        .with_offset(0)
        .with_order("volume", false);

    let markets = client.get_markets(Some(params)).await?;
    for market in markets {
        println!("Market ID: {}", market.id);
        println!("  Question: {}", market.question);
    }

    let market = client.get_market_by_id("646091").await?;
    println!("Market: {} - Active: {}", market.question, market.active);

    let tags = client.get_tags().await?;
    for tag in tags.iter().take(5) {
        println!("Tag: {} ({})", tag.label, tag.slug);
    }

    Ok(()) 
}
```

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

### Query Public Market Data with ClobClient

Source: https://context7.com/pawsengineer/polymarket-rs/llms.txt

Demonstrates how to initialize the ClobClient and perform common public data operations such as fetching order books, midpoints, spreads, and price history. This client does not require authentication and is designed for read-only market analysis.

```rust
use polymarket_rs::client::ClobClient;
use polymarket_rs::types::TokenId;
use polymarket_rs::{Result, Side};

#[tokio::main]
async fn main() -> Result<()> {
    let client = ClobClient::new("https://clob.polymarket.com");

    let status = client.get_ok().await?;
    let time = client.get_server_time().await?;
    println!("Server status: {:?}, time: {:?}", status, time);

    let token_id = TokenId::new("7045107161367241233811523851106536676632348173555291268726302515224841822187");

    let midpoint = client.get_midpoint(&token_id).await?;
    println!("Midpoint price: {}", midpoint.mid);

    let price = client.get_price(&token_id, Side::Buy).await?;
    println!("Current price: {}", price.price);

    let spread = client.get_spread(&token_id).await?;
    println!("Spread: {}", spread.spread);

    let tick_size = client.get_tick_size(&token_id).await?;
    println!("Minimum tick size: {}", tick_size.minimum_tick_size);

    let book = client.get_order_book(&token_id).await?;
    println!("Order book - Bids: {} levels, Asks: {} levels", book.bids.len(), book.asks.len());

    let last_trade = client.get_last_trade_price(&token_id).await?;
    println!("Last trade price: {}", last_trade.price);

    let history = client.get_prices_history(&token_id, "1h", None, None, Some(10)).await?;
    println!("Price history points: {:?}", history);

    let markets = client.get_sampling_markets(None).await?;
    println!("Retrieved {} markets", markets.data.len());

    Ok(())
}
```

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

### ClobClient: Batch Operations for Token Data in Rust

Source: https://context7.com/pawsengineer/polymarket-rs/llms.txt

Demonstrates how to use ClobClient to fetch multiple data points for various tokens simultaneously. This includes midpoints, prices, spreads, order books, and last trade prices. It requires the `polymarket-rs` crate and `tokio` for asynchronous operations.

```rust
use polymarket_rs::client::ClobClient;
use polymarket_rs::types::{TokenId, BookParams};
use polymarket_rs::Result;

#[tokio::main]
async fn main() -> Result<()> {
    let client = ClobClient::new("https://clob.polymarket.com");

    let token_ids = vec![
        TokenId::new("7045107161367241233811523851106536676632348173555291268726302515224841822187"),
        TokenId::new("87769991026114894163580777793845523168226980076553814689875238288185044414090"),
    ];

    // Get midpoints for multiple tokens
    let midpoints = client.get_midpoints(&token_ids).await?;
    for midpoint in midpoints {
        println!("Token midpoint: {}", midpoint.mid);
    }

    // Get prices for multiple tokens
    let prices = client.get_prices(&token_ids).await?;
    for price in prices {
        println!("Token price: {}", price.price);
    }

    // Get spreads for multiple tokens
    let spreads = client.get_spreads(&token_ids).await?;
    for spread in spreads {
        println!("Token spread: {}", spread.spread);
    }

    // Get order books for multiple tokens with custom depth
    let book_params: Vec<BookParams> = token_ids.iter()
        .map(|id| BookParams { token_id: id.to_string() })
        .collect();
    let books = client.get_order_books(&book_params).await?;
    for book in books {
        println!("Market {}: {} bids, {} asks", book.market, book.bids.len(), book.asks.len());
    }

    // Get last trade prices for multiple tokens
    let last_trades = client.get_last_trade_prices(&token_ids).await?;
    println!("Last trades: {:?}", last_trades);

    Ok(())
}

```

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

### Build Gamma API Market Query Parameters in Rust

Source: https://context7.com/pawsengineer/polymarket-rs/llms.txt

Utilizes the builder pattern with `GammaMarketParams` to construct query parameters for searching markets via the Gamma API. Allows filtering by active status, pagination, state, tags, and sorting. Requires `polymarket_rs`.

```rust
use polymarket_rs::request::GammaMarketParams;

// Basic active markets query
let params = GammaMarketParams::new()
    .with_active(true)
    .with_limit(10);

// Pagination
let params = GammaMarketParams::new()
    .with_limit(20)
    .with_offset(40);  // Skip first 40 results

// Filter by state
let params = GammaMarketParams::new()
    .with_active(true)
    .with_closed(false)
    .with_archived(false);

// Filter by tag
let params = GammaMarketParams::new()
    .with_active(true)
    .with_tag_id("politics");

// Sort by volume (descending)
let params = GammaMarketParams::new()
    .with_active(true)
    .with_order("volume", false);  // false = descending

// Combined query
let params = GammaMarketParams::new()
    .with_active(true)
    .with_closed(false)
    .with_limit(50)
    .with_offset(0)
    .with_tag_id("crypto")
    .with_order("volume", false);

// Convert to query string
let query_string = params.to_query_string();
// Result: "?active=true&closed=false&limit=50&offset=0&tag_id=crypto&order=volume&ascending=false"

```

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

### DataClient: User Position and Portfolio Data in Rust

Source: https://context7.com/pawsengineer/polymarket-rs/llms.txt

Illustrates how to retrieve user-specific financial data using the DataClient without requiring authentication. This includes fetching all positions, total portfolio value, closed positions, trade history, and activity feed for a given wallet address. It depends on the `polymarket-rs` crate and `tokio`.

```rust
use polymarket_rs::client::DataClient;
use polymarket_rs::Result;

#[tokio::main]
async fn main() -> Result<()> {
    let client = DataClient::new("https://data-api.polymarket.com");

    let user_address = "0xe0368af7f5777989b927b7ad0d420562fee8616c";

    // Get all positions for a user
    let positions = client.get_positions(user_address).await?;
    println!("Found {} positions:", positions.len());

    for position in positions.iter().take(5) {
        println!("Market: {}", position.title);
        println!("  Outcome: {}", position.outcome);
        println!("  Size: {}", position.size);
        println!("  Average Price: {}", position.avg_price);
        println!("  Current Price: {}", position.cur_price);
        println!("  Current Value: ${}", position.current_value);
        println!("  Cash P&L: ${}", position.cash_pnl);
        println!("  Percent P&L: {}%", position.percent_pnl);
        println!("  Realized P&L: ${}", position.realized_pnl);
        println!("  Redeemable: {}", position.redeemable);
    }

    // Get total portfolio value
    let values = client.get_positions_value(user_address).await?;
    for value in values {
        println!("User: {}, Total Value: ${}", value.user, value.value);
    }

    // Get closed positions
    let closed = client.get_closed_positions(user_address).await?;
    println!("Closed positions: {}", closed.len());

    // Get trade history
    let trades = client.get_trades(user_address, None).await?;
    println!("Trades: {}", trades.len());

    // Get activity feed
    let activity = client.get_activity(user_address, None).await?;
    println!("Activity events: {}", activity.len());

    Ok(())
}

```

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

### Create Signed Orders with OrderBuilder in Rust

Source: https://context7.com/pawsengineer/polymarket-rs/llms.txt

Demonstrates how to use the `OrderBuilder` to create and sign orders using EIP-712 signatures. Supports EOA, PolyProxy, and PolyGnosisSafe signature types. Requires `alloy_primitives`, `alloy_signer_local`, `polymarket_rs`, `rust_decimal`.

```rust
use alloy_primitives::Address;
use alloy_signer_local::PrivateKeySigner;
use polymarket_rs::orders::OrderBuilder;
use polymarket_rs::types::{
    CreateOrderOptions, ExtraOrderArgs, MarketOrderArgs, OrderArgs, Side, SignatureType,
};
use polymarket_rs::Result;
use rust_decimal::Decimal;
use std::str::FromStr;

fn create_orders_example() -> Result<()> {
    let signer = PrivateKeySigner::random();
    let chain_id = 137;

    // EOA wallet order builder
    let builder = OrderBuilder::new(signer.clone(), Some(SignatureType::Eoa), None);

    // PolyProxy wallet order builder
    let proxy_address = Address::from_str("0xProxyWalletAddress")?;
    let proxy_builder = OrderBuilder::new(
        signer.clone(),
        Some(SignatureType::PolyProxy),
        Some(proxy_address),
    );

    // PolyGnosisSafe wallet order builder
    let safe_builder = OrderBuilder::new(
        signer,
        Some(SignatureType::PolyGnosisSafe),
        Some(proxy_address),
    );

    let token_id = "109648317055340591503076024421581448189531885907475125926203413622318314876012";

    let options = CreateOrderOptions::default()
        .tick_size(Decimal::from_str("0.01").unwrap())
        .neg_risk(false);

    // Create limit order
    let order_args = OrderArgs::new(
        token_id,
        Decimal::from_str("0.50").unwrap(),
        Decimal::from_str("10.0").unwrap(),
        Side::Buy,
    );

    let extras = ExtraOrderArgs::default();
    let expiration = 0; // No expiration

    let signed_order = builder.create_order(
        chain_id,
        &order_args,
        expiration,
        &extras,
        options,
    )?;

    println!("Signed order:");
    println!("  Salt: {}", signed_order.salt);
    println!("  Maker: {}", signed_order.maker);
    println!("  Signer: {}", signed_order.signer);
    println!("  Token ID: {}", signed_order.token_id);
    println!("  Maker Amount: {}", signed_order.maker_amount);
    println!("  Taker Amount: {}", signed_order.taker_amount);
    println!("  Side: {}", signed_order.side);
    println!("  Signature: {}", signed_order.signature);

    Ok(())
}

```

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

### Perform authenticated trading operations

Source: https://github.com/pawsengineer/polymarket-rs/blob/main/README.md

Outlines the three-step process for authenticated trading: creating API credentials, initializing the trading client, and posting orders.

```rust
use polymarket_rs::{AuthenticatedClient, TradingClient, OrderBuilder, SignatureType};

// 1. Create or derive API credentials
let auth_client = AuthenticatedClient::new(host, signer.clone(), chain_id, None, None);
let api_creds = auth_client.create_or_derive_api_key().await?;

// 2. Create trading client with order builder
let order_builder = OrderBuilder::new(signer.clone(), Some(SignatureType::Eoa), None);
let trading_client = TradingClient::new(host, signer, chain_id, api_creds, order_builder);

// 3. Create and post orders
let order_args = OrderArgs::new(token_id, price, size, Side::Buy);
trading_client.create_and_post_order(&order_args, None, None, options, OrderType::Gtc).await?;
```

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

### Stream Authenticated User Events with UserWsClient (Rust)

Source: https://context7.com/pawsengineer/polymarket-rs/llms.txt

Demonstrates how to use the `UserWsClient` to stream authenticated user events like trades and order updates. It requires API credentials obtained via an `AuthenticatedClient` and configures automatic reconnection using `ReconnectingStream`. The output includes details of trades and orders received.

```rust
use futures_util::StreamExt;
use polymarket_rs::types::UserWsEvent;
use polymarket_rs::websocket::{ReconnectConfig, ReconnectingStream, UserWsClient};
use polymarket_rs::{AuthenticatedClient, PrivateKeySigner};
use std::str::FromStr;
use std::time::Duration;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let private_key = std::env::var("PRIVATE_KEY")?;
    let signer = PrivateKeySigner::from_str(&private_key)?;

    let chain_id = 137;
    let host = "https://clob.polymarket.com";

    // Get API credentials
    let auth_client = AuthenticatedClient::new(host, signer.clone(), chain_id, None, None);
    let api_creds = auth_client.create_or_derive_api_key().await?;

    // Create user WebSocket client
    let client = UserWsClient::new();

    // Configure automatic reconnection
    let config = ReconnectConfig {
        initial_delay: Duration::from_secs(1),
        max_delay: Duration::from_secs(30),
        multiplier: 2.0,
        max_attempts: None,
    };

    // Create reconnecting stream with credentials
    let creds_clone = api_creds.clone();
    let mut stream = ReconnectingStream::new(config, move || {
        let client = client.clone();
        let creds = creds_clone.clone();
        async move {
            println!("Connecting to user WebSocket...");
            let result = client.subscribe_with_creds(&creds).await;
            if result.is_ok() {
                println!("Connected!");
            }
            result
        }
    });

    // Process user events
    while let Some(result) = stream.next().await {
        match result {
            Ok(event) => match event {
                UserWsEvent::Trade(trade) => {
                    println!("[Trade] ID: {}", trade.id);
                    println!("  Market: {}", trade.market);
                    println!("  Side: {:?}, Price: {}, Size: {}", trade.side, trade.price, trade.size);
                    println!("  Status: {:?}", trade.status);
                    for (i, maker) in trade.maker_orders.iter().enumerate() {
                        println!("  Maker #{}: {} @ {}", i + 1, maker.matched_amount, maker.price);
                    }
                }
                UserWsEvent::Order(order) => {
                    println!("[Order] ID: {}", order.id);
                    println!("  Market: {}", order.market);
                    println!("  Side: {:?}, Status: {}", order.side, order.status);
                    println!("  Type: {}, Event: {}", order.order_type, order.order_event_type);
                    println!("  Price: {}, Original: {}, Matched: {}",
                        order.price, order.original_size, order.size_matched);
                }
            },
            Err(e) => eprintln!("Error: {} - Will reconnect...", e),
        }
    }

    Ok(())
}

```

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

### ClobClient - Batch Operations

Source: https://context7.com/pawsengineer/polymarket-rs/llms.txt

Query multiple tokens at once for efficient data retrieval using batch endpoints provided by the ClobClient.

```APIDOC
## ClobClient - Batch Operations

Query multiple tokens at once for efficient data retrieval using batch endpoints.

### Description
This section covers batch operations available through the `ClobClient` for retrieving various market data points for multiple tokens simultaneously.

### Methods

#### Get Midpoints for Multiple Tokens

##### Method
GET

##### Endpoint
`/clob/midpoints` (Assumed based on client method `get_midpoints`)

##### Parameters

*   **Path Parameters**
    *   None

*   **Query Parameters**
    *   `token_ids` (array of string) - Required - A list of token IDs to retrieve midpoints for.

*   **Request Body**
    *   None

### Request Example
```rust
use polymarket_rs::client::ClobClient;
use polymarket_rs::types::TokenId;

let client = ClobClient::new("https://clob.polymarket.com");
let token_ids = vec![TokenId::new("..."), TokenId::new("...")];
let midpoints = client.get_midpoints(&token_ids).await?;
```

### Response

#### Success Response (200)
- **midpoints** (array of objects) - A list of midpoint data for each requested token.
    - **mid** (number) - The midpoint price.

#### Response Example
```json
[
  { "mid": 0.5 },
  { "mid": 0.75 }
]
```

#### Get Prices for Multiple Tokens

##### Method
GET

##### Endpoint
`/clob/prices` (Assumed based on client method `get_prices`)

##### Parameters

*   **Path Parameters**
    *   None

*   **Query Parameters**
    *   `token_ids` (array of string) - Required - A list of token IDs to retrieve prices for.

*   **Request Body**
    *   None

### Request Example
```rust
use polymarket_rs::client::ClobClient;
use polymarket_rs::types::TokenId;

let client = ClobClient::new("https://clob.polymarket.com");
let token_ids = vec![TokenId::new("..."), TokenId::new("...")];
let prices = client.get_prices(&token_ids).await?;
```

### Response

#### Success Response (200)
- **prices** (array of objects) - A list of price data for each requested token.
    - **price** (number) - The current price.

#### Response Example
```json
[
  { "price": 0.55 },
  { "price": 0.70 }
]
```

#### Get Spreads for Multiple Tokens

##### Method
GET

##### Endpoint
`/clob/spreads` (Assumed based on client method `get_spreads`)

##### Parameters

*   **Path Parameters**
    *   None

*   **Query Parameters**
    *   `token_ids` (array of string) - Required - A list of token IDs to retrieve spreads for.

*   **Request Body**
    *   None

### Request Example
```rust
use polymarket_rs::client::ClobClient;
use polymarket_rs::types::TokenId;

let client = ClobClient::new("https://clob.polymarket.com");
let token_ids = vec![TokenId::new("..."), TokenId::new("...")];
let spreads = client.get_spreads(&token_ids).await?;
```

### Response

#### Success Response (200)
- **spreads** (array of objects) - A list of spread data for each requested token.
    - **spread** (number) - The bid-ask spread.

#### Response Example
```json
[
  { "spread": 0.05 },
  { "spread": 0.10 }
]
```

#### Get Order Books for Multiple Tokens

##### Method
POST

##### Endpoint
`/clob/orderbooks` (Assumed based on client method `get_order_books`)

##### Parameters

*   **Path Parameters**
    *   None

*   **Query Parameters**
    *   None

*   **Request Body**
    - **book_params** (array of objects) - Required - A list of parameters for each token's order book.
        - **token_id** (string) - Required - The ID of the token.
        - **depth** (integer) - Optional - The depth of the order book to retrieve. Defaults to a system-defined value.

### Request Example
```rust
use polymarket_rs::client::ClobClient;
use polymarket_rs::types::BookParams;

let client = ClobClient::new("https://clob.polymarket.com");
let book_params: Vec<BookParams> = vec![BookParams { token_id: "...".to_string() }];
let books = client.get_order_books(&book_params).await?;
```

### Response

#### Success Response (200)
- **books** (array of objects) - A list of order book data for each requested token.
    - **market** (string) - The market identifier.
    - **bids** (array of objects) - A list of bid orders.
    - **asks** (array of objects) - A list of ask orders.

#### Response Example
```json
[
  {
    "market": "market_id_1",
    "bids": [{"price": 0.5, "size": 10}],
    "asks": [{"price": 0.55, "size": 8}]
  }
]
```

#### Get Last Trade Prices for Multiple Tokens

##### Method
GET

##### Endpoint
`/clob/last_trade_prices` (Assumed based on client method `get_last_trade_prices`)

##### Parameters

*   **Path Parameters**
    *   None

*   **Query Parameters**
    *   `token_ids` (array of string) - Required - A list of token IDs to retrieve last trade prices for.

*   **Request Body**
    *   None

### Request Example
```rust
use polymarket_rs::client::ClobClient;
use polymarket_rs::types::TokenId;

let client = ClobClient::new("https://clob.polymarket.com");
let token_ids = vec![TokenId::new("..."), TokenId::new("...")];
let last_trades = client.get_last_trade_prices(&token_ids).await?;
```

### Response

#### Success Response (200)
- **last_trades** (array of objects) - A list of last trade price data for each requested token.
    - **price** (number) - The price of the last trade.
    - **timestamp** (string) - The timestamp of the last trade.

#### Response Example
```json
[
  { "price": 0.52, "timestamp": "2023-10-27T10:00:00Z" },
  { "price": 0.72, "timestamp": "2023-10-27T10:05:00Z" }
]
```
```

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

### Configure WebSocket Reconnection with ReconnectConfig (Rust)

Source: https://context7.com/pawsengineer/polymarket-rs/llms.txt

Illustrates how to configure automatic WebSocket reconnection behavior using the `ReconnectConfig` struct. This allows for setting initial delays, maximum delays, a multiplier for exponential backoff, and a maximum number of reconnection attempts, enabling resilient streaming connections.

```rust
use polymarket_rs::websocket::ReconnectConfig;
use std::time::Duration;

// Default configuration
let default_config = ReconnectConfig::default();
// initial_delay: 1 second
// max_delay: 60 seconds
// multiplier: 2.0
// max_attempts: None (infinite)

// Custom configuration
let custom_config = ReconnectConfig {
    initial_delay: Duration::from_millis(500),  // Start with 500ms delay
    max_delay: Duration::from_secs(30),         // Cap at 30 seconds
    multiplier: 1.5,                             // Grow by 1.5x each attempt
    max_attempts: Some(10),                      // Give up after 10 attempts
};

// Aggressive reconnection for high-frequency trading
let aggressive_config = ReconnectConfig {
    initial_delay: Duration::from_millis(100),
    max_delay: Duration::from_secs(5),
    multiplier: 1.2,
    max_attempts: None,
};

// Conservative reconnection for background monitoring
let conservative_config = ReconnectConfig {
    initial_delay: Duration::from_secs(5),
    max_delay: Duration::from_secs(300),  // 5 minutes max
    multiplier: 2.5,
    max_attempts: Some(50),
};

```

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

### Rust WebSocket Streaming with Reconnection

Source: https://github.com/pawsengineer/polymarket-rs/blob/main/README.md

Establishes a real-time WebSocket connection for market data and user events using MarketWsClient and ReconnectingStream. It handles automatic reconnection with a default configuration. The stream yields results that need to be processed within the loop.

```rust
use polymarket_rs::websocket::{MarketWsClient, ReconnectingStream, ReconnectConfig};
use futures_util::StreamExt;

let client = MarketWsClient::new();
let config = ReconnectConfig::default();

let mut stream = ReconnectingStream::new(config, move || {
    client.subscribe(token_ids.clone())
});

while let Some(result) = stream.next().await {
    // Process market events
}
```