For Proxy/Safe wallets (like Magic/email wallets or browser proxy contracts), the signing key is different from the address holding the funds. The SDK can automatically derive the correct funder address using CREATE2 when you specify the appropriate SignatureType.

Automatic Derivation

When using .signature_type(SignatureType::GnosisSafe) or .signature_type(SignatureType::Proxy), the SDK computes the deterministic wallet address.

Manual Derivation

You can also derive these addresses manually using the provided utility functions:

• GnosisSafe (Browser wallets): derive_safe_wallet(signer.address(), POLYGON)
• Proxy (Magic/Email wallets): derive_proxy_wallet(signer.address(), POLYGON)

Overriding the Funder

If you need to explicitly provide a funder address, use the .funder(address) method in the authentication builder.

// Automatic derivation
let client = Client::new("https://clob.polymarket.com", Config::default())?
    .authentication_builder(&signer)
    .signature_type(SignatureType::GnosisSafe)  // Funder auto-derived via CREATE2
    .authenticate()
    .await?;

// Explicit override
let client = Client::new("https://clob.polymarket.com", Config::default())?
    .authentication_builder(&signer)
    .funder(address!("<your-polymarket-wallet-address>"))
    .signature_type(SignatureType::GnosisSafe)
    .authenticate()
    .await?;

The SDK supports real-time streaming of orderbooks, prices, and user events via WebSockets. This requires the ws feature enabled in your Cargo.toml:

polymarket-client-sdk = { version = "0.3", features = ["ws"] }

Available Streams

• subscribe_orderbook(): Bid/ask levels for specific assets.
• subscribe_prices(): Price change events.
• subscribe_midpoints(): Calculated midpoint prices.
• subscribe_orders(): User order updates (requires authentication).
• subscribe_trades(): User trade executions (requires authentication).

use futures::StreamExt as _;
use polymarket_client_sdk::clob::ws::Client;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let client = Client::default();

    // Subscribe to orderbook updates for specific assets
    let asset_ids = vec!["<asset-id>".to_owned()];
    let stream = client.subscribe_orderbook(asset_ids)?;
    let mut stream = Box::pin(stream);

    while let Some(book_result) = stream.next().await {
        let book = book_result?;
        println!("Orderbook update for {}: {} bids, {} asks",
            book.asset_id, book.bids.len(), book.asks.len());
    }
    Ok(())
}

The RTDS (Real-Time Data Socket) client allows you to stream real-time Polymarket data, including cryptocurrency prices (Binance and Chainlink) and comment events.

There are two primary client states:

• Client<Unauthenticated>: Access to all streams and unauthenticated comment events.
• Client<Authenticated<Normal>>: Access to all streams plus authenticated comment events via CLOB credentials.

You can initialize a default client using Client::default() or create a custom one with Client::new(endpoint, config).

To transition from an unauthenticated client to an authenticated one, use the .authenticate(address, credentials) method. To return to an unauthenticated state, use .deauthenticate() on an authenticated client. Note that these state-transition methods consume the client, meaning they require ownership of the instance.

use polymarket_client_sdk::rtds::Client;
use futures::StreamExt;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let client = Client::default();

    // Subscribe to BTC and ETH prices from Binance
    let symbols = vec!["btcusdt".to_owned(), "ethusdt".to_owned()];
    let stream = client.subscribe_crypto_prices(Some(symbols))?;
    let mut stream = Box::pin(stream);

    while let Some(price) = stream.next().await {
        println!("Price: {:?}", price?);
    }

    Ok(())
}

All messages received via the Polymarket WebSocket are wrapped in the WsMessage enum. You can distinguish between market data and user-specific data using the following helper methods:

• is_user(): Returns true if the message is a Trade or an Order (authenticated channel).
• is_market(): Returns true if the message is market data (not a user message).

Available WsMessage variants (mapped from event_type):

• Book(BookUpdate): Full or incremental orderbook update.
• PriceChange(PriceChange): Price change notification.
• TickSizeChange(TickSizeChange): Tick size change notification.
• LastTradePrice(LastTradePrice): Last trade price update.
• BestBidAsk(BestBidAsk): Best bid/ask update (requires custom_feature_enabled).
• NewMarket(NewMarket): New market created (requires custom_feature_enabled).
• MarketResolved(MarketResolved): Market resolved (requires custom_feature_enabled).
• Trade(TradeMessage): User trade execution (authenticated channel).
• Order(OrderMessage): User order update (authenticated channel).

match message {
    WsMessage::Book(update) => handle_book(update),
    WsMessage::Trade(trade) => handle_trade(trade),
    _ => {}
}

The SDK is modular. You must enable specific features in your Cargo.toml to access different Polymarket APIs. Use the following table to determine which features to enable:

[dependencies]
polymarket-client-sdk = { version = "0.3", features = ["ws", "data"] }