predict-sdk 0.1.0

Rust SDK for Predict.fun prediction market - order building, EIP-712 signing, and real-time WebSocket 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
98
99
100
101
102
103
104
105
106
107
108

# predict-sdk

Rust SDK for [Predict.fun](https://predict.fun) prediction market on BNB Chain.

## Features

- **Order Building** - Create and sign orders with EIP-712
- **WebSocket** - Real-time orderbook, prices, and wallet events
- **GraphQL** - Query markets, positions, and historical data
- **On-chain** - Direct contract interactions

## Installation

```toml
[dependencies]
predict-sdk = "0.1"
```

## Quick Start

### Create and Sign an Order

```rust
use predict_sdk::{PredictClient, OrderBuilder, Side, ChainId};
use alloy::signers::local::PrivateKeySigner;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let signer: PrivateKeySigner = "your_private_key".parse()?;
    let client = PredictClient::new(ChainId::BscMainnet, signer);

    // Build and sign an order
    let signed_order = OrderBuilder::new()
        .market_id(123)
        .side(Side::Buy)
        .price("0.50".parse()?)
        .quantity("10.0".parse()?)
        .build(&client)
        .await?;

    // Submit the order
    let result = client.place_order(signed_order).await?;
    println!("Order placed: {:?}", result);

    Ok(())
}
```

### WebSocket Orderbook Stream

```rust
use predict_sdk::websocket::PredictWebSocket;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let ws = PredictWebSocket::new("wss://ws.predict.fun/ws".to_string());
    let mut stream = ws.connect().await?;

    // Subscribe to orderbook updates
    ws.subscribe_orderbook(123).await?;

    // Process messages
    while let Some(msg) = stream.next().await {
        println!("{:?}", msg?);
    }

    Ok(())
}
```

### Wallet Events

```rust
use predict_sdk::websocket::{PredictWebSocket, parse_wallet_event};

// Subscribe to wallet events (requires JWT from authenticate())
ws.subscribe_wallet_events(&jwt).await?;

while let Some(msg) = stream.next().await {
    if let Ok(WsMessage::PushMessage(push)) = msg {
        if push.is_wallet_event() {
            let event = parse_wallet_event(&push)?;
            match event {
                PredictWalletEvent::OrderAccepted { order_id, .. } => {
                    println!("Order {} accepted", order_id);
                }
                PredictWalletEvent::OrderTransactionSuccess { tx_hash, .. } => {
                    println!("Order filled: {:?}", tx_hash);
                }
                _ => {}
            }
        }
    }
}
```

## Modules

- `client` - Main API client
- `order_builder` - Order construction and EIP-712 signing
- `websocket` - Real-time WebSocket streaming
- `graphql` - GraphQL queries for market data
- `onchain` - Blockchain contract interactions
- `types` - Core types (Order, Side, ChainId, etc.)

## License

MIT