polyte-gamma 0.1.4

Rust client library for Polymarket Gamma (market data) API
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

# polyte-gamma

Rust client library for Polymarket Gamma (market data) API.

The Gamma API provides read-only access to Polymarket's market data, including markets, events, series, tags, and sports metadata.

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

## Features

- **Type-Safe API**: Strongly-typed responses with serde deserialization
- **Fluent Builder Pattern**: Chainable methods for constructing queries
- **Comprehensive Coverage**: Support for markets, events, series, tags, sports, and comments

## Installation

```toml
[dependencies]
polyte-gamma = "0.1.0"
```

Or use the unified client:

```toml
[dependencies]
polyte = "0.1.0"
```

## Usage

### Basic Example

```rust
use polyte_gamma::Gamma;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let gamma = Gamma::new()?;

    // List active markets
    let markets = gamma.markets()
        .list()
        .active(true)
        .limit(10)
        .send()
        .await?;

    for market in markets {
        println!("{}: {}", market.question, market.volume);
    }

    Ok(())
}
```

### Get Market by ID

```rust
let market = gamma.markets()
    .get("condition_id_here")
    .send()
    .await?;

println!("Market: {}", market.question);
println!("Volume: {}", market.volume);
println!("Liquidity: {}", market.liquidity);
```

### List Series

```rust
let series = gamma.series()
    .list()
    .active(true)
    .send()
    .await?;

for s in series {
    println!("{} - {} events", s.title, s.events.len());
}
```

### Get Tags

```rust
let tags = gamma.tags().list().send().await?;

for tag in tags {
    println!("{}: {}", tag.label, tag.slug);
}
```

## Configuration

```rust
let gamma = Gamma::builder()
    .base_url("https://gamma-api.polymarket.com")
    .timeout_ms(30_000)
    .pool_size(10)
    .build()?;
```

## API Coverage

- **Markets**: List, get by ID, with filtering (active, closed, archived)
- **Events**: List and get event data with nested markets
- **Series**: Tournament/season data with events
- **Tags**: Market categorization and related tags
- **Sports**: Sports metadata and information
- **Comments**: Market comments and discussions

## Examples

The crate includes several examples:

```bash
# List markets
cargo run --example retrieve_markets

# Get sports data
cargo run --example retrieve_sports

# Browse tags
cargo run --example retrieve_tags

# Explore series
cargo run --example retrieve_series
```

## License

This project is licensed under the [MIT License](https://github.com/roushou/polyte/blob/main/LICENSE).