Configuration

pub struct ExchangeConfig {
    pub timeout: Duration,           // Request timeout
    pub rate_limit_per_second: u32,  // Max requests per second
    pub max_retries: u32,            // Retry attempts
    pub retry_delay: Duration,       // Delay between retries
    pub verbose: bool,               // Enable logging
}

use pc_core::ExchangeConfig;
use std::time::Duration;

let config = ExchangeConfig::default()
    .with_timeout(Duration::from_secs(60))
    .with_rate_limit(5)
    .with_retries(5, Duration::from_secs(2))
    .with_verbose(true);

use pc_exchange_polymarket::{PolymarketConfig, PolymarketSignatureType};

let config = PolymarketConfig::new()
    .with_private_key("0x...")                             // Ethereum private key
    .with_funder("0x...")                                  // Funder wallet address
    .with_signature_type(PolymarketSignatureType::Proxy)   // Wallet type
    .with_api_credentials("key", "secret", "passphrase")   // Pre-existing creds (optional)
    .with_gamma_url("https://...")                          // Custom Gamma API URL
    .with_clob_url("https://...")                           // Custom CLOB API URL
    .with_verbose(true);

use pc_exchange_limitless::LimitlessConfig;

let config = LimitlessConfig::new()
    .with_private_key("0x...")
    .with_verbose(true);

use pc_exchange_kalshi::KalshiConfig;

// Production
let config = KalshiConfig::new()
    .with_api_key_id("key-id")
    .with_private_key_path("/path/to/key.pem")
    .with_verbose(true);

// Demo environment
let demo = KalshiConfig::demo();

use pc_exchange_opinion::OpinionConfig;

let config = OpinionConfig::new()
    .with_api_key("api-key")
    .with_private_key("0x...")
    .with_multi_sig_addr("0x...")
    .with_verbose(true);

use pc_exchange_predictfun::PredictFunConfig;

// Production
let config = PredictFunConfig::new()
    .with_api_key("api-key")
    .with_private_key("0x...")
    .with_verbose(true);

// Testnet
let testnet = PredictFunConfig::testnet();

# Minimal local development setup
export LOCAL_MODE=true
export PARSEC_PORT=3000

# Add exchange credentials
export POLYMARKET_PRIVATE_KEY="0x..."

# Start the server
cargo run --bin pc-api

use std::env;

// Manual loading
let mut config = PolymarketConfig::new()
    .with_private_key(env::var("POLYMARKET_PRIVATE_KEY")?);

if let Ok(funder) = env::var("POLYMARKET_FUNDER") {
    config = config.with_funder(funder);
}

if let Ok(sig_type) = env::var("POLYMARKET_SIGNATURE_TYPE") {
    config = config.with_signature_type(
        pc_exchange_polymarket::PolymarketSignatureType::from(sig_type.as_str())
    );
}

// Or use validation helper
use pc_core::{ExchangeId, validate_env_config};

match validate_env_config(ExchangeId::Polymarket) {
    Ok(()) => println!("Configuration valid"),
    Err(e) => println!("Missing env vars: {}", e),
}

use pc_core::{ExchangeId, validate_env_config};

// Check if all required env vars are set
let result = validate_env_config(ExchangeId::Polymarket);

use pc_core::validate_private_key;

match validate_private_key("0x...") {
    Ok(()) => println!("Valid key"),
    Err(e) => println!("Invalid: {}", e),
}

use pc_core::{list_exchanges, list_exchange_names, ExchangeId};

// Get all exchange IDs
let ids = list_exchanges();
// [Polymarket, Opinion, Limitless, Kalshi, PredictFun]

// Get names as strings
let names = list_exchange_names();
// ["polymarket", "opinion", "limitless", "kalshi", "predictfun"]

// Parse from string
let id: ExchangeId = "polymarket".parse().unwrap();

// Get required env vars
let vars = id.required_env_vars();
// ["POLYMARKET_PRIVATE_KEY", "POLYMARKET_FUNDER"]

use pc_core::RateLimiter;

// Create a limiter for 5 requests/second
let mut limiter = RateLimiter::new(5);

// Automatically waits if needed
limiter.wait().await;
make_request().await;

limiter.wait().await;
make_request().await;

use pc_core::retry_with_backoff;
use std::time::Duration;

let result = retry_with_backoff(
    3,                           // max attempts
    Duration::from_secs(1),      // initial delay
    || async {
        exchange.fetch_markets(None).await
    },
).await?;