polyoxide 0.9.1

Unified Rust client for Polymarket APIs (CLOB, Gamma and Data)
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

# Polyoxide

Rust client for Polymarket APIs.

More information about this crate can be found in the [crate documentation](https://docs.rs/polyoxide/).

## Crates

| Crate | Description |
|-------|-------------|
| [polyoxide](./) | Unified client for Polymarket APIs (CLOB, Gamma, Data, WebSocket) |
| [polyoxide-cli](../polyoxide-cli) | CLI tool for querying Polymarket APIs |
| [polyoxide-clob](../polyoxide-clob) | Client library for Polymarket CLOB (order book) API |
| [polyoxide-core](../polyoxide-core) | Core utilities and shared types |
| [polyoxide-data](../polyoxide-data) | Client library for Polymarket Data API |
| [polyoxide-gamma](../polyoxide-gamma) | Client library for Polymarket Gamma (market data) API |

## Installation

```
cargo add polyoxide
```

Or install individual APIs:

```
# Market data only
cargo add polyoxide --no-default-features --features gamma

# Trading only
cargo add polyoxide --no-default-features --features clob

# Data API only
cargo add polyoxide --no-default-features --features data

# WebSocket only
cargo add polyoxide --no-default-features --features ws
```

## Usage

### REST API

```rust
use polyoxide::prelude::*;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Load account from environment variables
    let account = Account::from_env()?;

    let client = Polymarket::builder(account)
        .chain(Chain::PolygonMainnet)
        .build()?;

    // Get markets
    let markets = client.gamma.markets().list().send().await?;

    // Get balance
    let balance = client.clob.balance_allowance().await?;

    Ok(())
}
```

### WebSocket

```rust
use polyoxide::prelude::*;
use futures_util::StreamExt;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Connect to market channel (no auth required)
    let mut ws = ws::WebSocket::connect_market(vec![
        "token_id".to_string(),
    ]).await?;

    while let Some(msg) = ws.next().await {
        match msg? {
            ws::Channel::Market(ws::MarketMessage::Book(book)) => {
                println!("Order book: {} bids, {} asks", book.bids.len(), book.asks.len());
            }
            ws::Channel::Market(ws::MarketMessage::PriceChange(pc)) => {
                println!("Price change: {:?}", pc.price_changes);
            }
            _ => {}
        }
    }

    Ok(())
}
```

## License

This project is licensed under the [MIT](./LICENSE) License.