PolyCode Rust SDK

A comprehensive Rust SDK for interacting with the PolyCode API. PolyCode allows you to create prediction markets that are resolved with code.

Features

• ✅ Create and manage prediction markets
• ✅ Place and manage bets
• ✅ Query market and bet information
• ✅ Resolve markets with code execution results
• ✅ Full async/await support
• ✅ Type-safe API with comprehensive error handling
• ✅ Builder pattern for flexible configuration

Installation

Add this to your Cargo.toml:

[dependencies]
polycode-sdk = "0.1.0"
tokio = { version = "1.0", features = ["full"] }

Quick Start

Basic Usage

use polycode_sdk::{PolyCodeConfig, PolyCodeClient};
use polycode_sdk::api::{MarketsApi, BetsApi};
use polycode_sdk::models::{CreateMarketRequest, PlaceBetRequest, MarketStatus};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Configure the client
    let config = PolyCodeConfig::new()
        .with_base_url("https://api.polycode.com")?
        .with_api_key("your-api-key")
        .with_timeout(30);

    let client = PolyCodeClient::new(config)?;

    // Work with markets
    let markets = MarketsApi::new(client.clone());
    
    // Create a market
    let market_request = CreateMarketRequest {
        title: "Will it rain tomorrow?".to_string(),
        description: "Predicting weather for tomorrow".to_string(),
        resolution_code: "check_weather_api()".to_string(),
        code_language: Some("python".to_string()),
        outcomes: vec!["Yes".to_string(), "No".to_string()],
        metadata: None,
    };

    let market = markets.create_market(&market_request).await?;
    println!("Created market: {}", market.id);

    // List open markets
    let response = markets.list_markets(Some(MarketStatus::Open), Some(10), None).await?;
    println!("Found {} markets", response.markets.len());

    // Get a specific market
    let market = markets.get_market(&market.id).await?;
    println!("Market status: {:?}", market.status);

    // Work with bets
    let bets = BetsApi::new(client);
    
    // Place a bet
    let bet_request = PlaceBetRequest {
        market_id: market.id.clone(),
        outcome: "Yes".to_string(),
        amount: 100.0,
        currency: Some("USD".to_string()),
    };

    let bet = bets.place_bet(&bet_request).await?;
    println!("Placed bet: {}", bet.id);

    // List bets for a market
    let bet_response = bets.list_bets(Some(&market.id), None, Some(10), None).await?;
    println!("Found {} bets", bet_response.bets.len());

    Ok(())
}

Configuration

The SDK supports flexible configuration through the PolyCodeConfig builder:

use polycode_sdk::PolyCodeConfig;

let config = PolyCodeConfig::new()
    .with_base_url("https://api.polycode.com")?
    .with_api_key("your-api-key")
    .with_timeout(60)
    .with_header("X-Custom-Header", "value");

Error Handling

The SDK provides comprehensive error handling:

use polycode_sdk::{PolyCodeError, Result};

async fn example() -> Result<()> {
    match markets.create_market(&request).await {
        Ok(market) => println!("Success: {}", market.id),
        Err(PolyCodeError::ApiError { status, message }) => {
            eprintln!("API error {}: {}", status, message);
        }
        Err(PolyCodeError::AuthenticationError(msg)) => {
            eprintln!("Auth error: {}", msg);
        }
        Err(e) => eprintln!("Error: {}", e),
    }
    Ok(())
}

API Reference

Markets API

• create_market(request) - Create a new prediction market
• get_market(id) - Get market by ID
• list_markets(status, limit, cursor) - List markets with optional filters
• resolve_market(id, request) - Resolve a market with code execution result
• get_market_resolution(id) - Get resolution details for a market

Bets API

• place_bet(request) - Place a bet on a market outcome
• get_bet(id) - Get bet by ID
• list_bets(market_id, user_id, limit, cursor) - List bets with optional filters
• cancel_bet(id) - Cancel a bet (if allowed)

Data Models

Market

Represents a prediction market with the following fields:

• id: Unique identifier
• title: Market title
• description: Market description
• status: Current status (Open, Resolved, Cancelled, Pending)
• resolution_code: Code that will be executed to resolve the market
• code_language: Language/runtime for the resolution code
• outcomes: Possible outcomes
• created_at: Creation timestamp
• resolved_at: Resolution timestamp (if resolved)
• resolved_outcome: The resolved outcome (if resolved)

Bet

Represents a bet placed on a market:

• id: Unique identifier
• market_id: ID of the market
• outcome: The outcome being bet on
• amount: Bet amount
• currency: Currency (optional)
• user_id: User who placed the bet
• created_at: Creation timestamp
• status: Bet status (Active, Cancelled, Settled)

License

MIT OR Apache-2.0

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.