predict-sdk 0.1.0

/// API types for predict.fun REST API responses
///
/// These types represent the data structures returned by the predict.fun API.

use rust_decimal::Decimal;
use serde::{Deserialize, Serialize};

/// Represents a Predict market
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PredictMarket {
    /// Market ID
    pub id: u64,
    /// Market title
    pub title: String,
    /// Market question
    pub question: String,
    /// Condition ID (for on-chain settlement)
    pub condition_id: String,
    /// Market status (REGISTERED, OPEN, RESOLVED)
    pub status: String,
    /// Category slug this market belongs to
    pub category_slug: String,
    /// Whether this is a neg risk market
    pub is_neg_risk: bool,
    /// Whether yield bearing is enabled
    pub is_yield_bearing: bool,
    /// Fee rate in basis points (fetched from GET /markets endpoint)
    #[serde(default)]
    pub fee_rate_bps: u64,
    /// Market outcomes
    pub outcomes: Vec<PredictOutcome>,
    /// Created at timestamp
    pub created_at: String,

    // --- Strike price fields (populated from GraphQL) ---

    /// Strike price (Pyth) - populated from GraphQL marketData.startPrice
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub start_price: Option<Decimal>,
    /// Price feed ID (e.g., "1" for BTC/USD) - populated from GraphQL
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub price_feed_id: Option<String>,
}

impl PredictMarket {
    /// Get the strike price if available
    pub fn strike_price(&self) -> Option<Decimal> {
        self.start_price
    }

    /// Set the strike price from GraphQL market data
    pub fn set_strike_price(&mut self, start_price: Decimal, price_feed_id: String) {
        self.start_price = Some(start_price);
        self.price_feed_id = Some(price_feed_id);
    }
}

/// Represents a market outcome
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PredictOutcome {
    /// Outcome name (e.g., "Up", "Down")
    pub name: String,
    /// Index set for this outcome
    pub index_set: u64,
    /// On-chain token ID
    pub on_chain_id: String,
    /// Resolution status (null if not resolved)
    pub status: Option<String>,
}

/// Represents an order book for a Predict market
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PredictOrderBook {
    /// Market ID
    pub market_id: String,
    /// Best bid price
    pub best_bid: Option<Decimal>,
    /// Best ask price
    pub best_ask: Option<Decimal>,
    /// Bid orders (price, size)
    pub bids: Vec<(Decimal, Decimal)>,
    /// Ask orders (price, size)
    pub asks: Vec<(Decimal, Decimal)>,
}

// ============================================================================
// Order types matching Predict API v1
// ============================================================================

/// Order status
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum OrderStatus {
    Open,
    Filled,
    Expired,
    Cancelled,
    Invalidated,
}

/// The signed order data embedded in an order response
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PredictOrderData {
    pub hash: String,
    #[serde(deserialize_with = "string_or_number")]
    pub salt: String,
    pub maker: String,
    pub signer: String,
    pub taker: String,
    pub token_id: String,
    #[serde(deserialize_with = "string_or_number")]
    pub maker_amount: String,
    #[serde(deserialize_with = "string_or_number")]
    pub taker_amount: String,
    #[serde(deserialize_with = "string_or_number")]
    pub expiration: String,
    #[serde(deserialize_with = "string_or_number")]
    pub nonce: String,
    #[serde(deserialize_with = "string_or_number")]
    pub fee_rate_bps: String,
    /// 0 = BUY, 1 = SELL
    pub side: u8,
    /// 0 = EOA
    pub signature_type: u8,
    pub signature: String,
}

/// Deserialize a field that can be either a string or a number, always returning a String
fn string_or_number<'de, D>(deserializer: D) -> std::result::Result<String, D::Error>
where
    D: serde::Deserializer<'de>,
{
    use serde::de;

    struct StringOrNumberVisitor;

    impl<'de> de::Visitor<'de> for StringOrNumberVisitor {
        type Value = String;

        fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
            formatter.write_str("a string or number")
        }

        fn visit_str<E: de::Error>(self, v: &str) -> std::result::Result<String, E> {
            Ok(v.to_string())
        }

        fn visit_string<E: de::Error>(self, v: String) -> std::result::Result<String, E> {
            Ok(v)
        }

        fn visit_u64<E: de::Error>(self, v: u64) -> std::result::Result<String, E> {
            Ok(v.to_string())
        }

        fn visit_i64<E: de::Error>(self, v: i64) -> std::result::Result<String, E> {
            Ok(v.to_string())
        }

        fn visit_f64<E: de::Error>(self, v: f64) -> std::result::Result<String, E> {
            Ok(v.to_string())
        }
    }

    deserializer.deserialize_any(StringOrNumberVisitor)
}

/// Represents an order on Predict (from GET /v1/orders)
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PredictOrder {
    /// Order ID (bigint as string)
    pub id: String,
    /// Market ID (can be number or string depending on endpoint)
    #[serde(deserialize_with = "deserialize_market_id")]
    pub market_id: u64,
    /// Currency (e.g., "USDT")
    #[serde(default)]
    pub currency: Option<String>,
    /// Total order amount (wei string)
    pub amount: String,
    /// Amount filled so far (wei string)
    pub amount_filled: String,
    /// Whether this is a neg risk market
    #[serde(default)]
    pub is_neg_risk: bool,
    /// Whether yield bearing is enabled
    #[serde(default)]
    pub is_yield_bearing: bool,
    /// Order strategy: "LIMIT" or "MARKET"
    #[serde(default)]
    pub strategy: String,
    /// Order status
    pub status: OrderStatus,
    /// The signed order payload
    pub order: PredictOrderData,
}

/// Deserialize market_id from either a number or a string
fn deserialize_market_id<'de, D>(deserializer: D) -> std::result::Result<u64, D::Error>
where
    D: serde::Deserializer<'de>,
{
    use serde::de;

    struct MarketIdVisitor;

    impl<'de> de::Visitor<'de> for MarketIdVisitor {
        type Value = u64;

        fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
            formatter.write_str("a number or string containing a number")
        }

        fn visit_u64<E: de::Error>(self, v: u64) -> std::result::Result<u64, E> {
            Ok(v)
        }

        fn visit_i64<E: de::Error>(self, v: i64) -> std::result::Result<u64, E> {
            Ok(v as u64)
        }

        fn visit_str<E: de::Error>(self, v: &str) -> std::result::Result<u64, E> {
            v.parse::<u64>().map_err(de::Error::custom)
        }
    }

    deserializer.deserialize_any(MarketIdVisitor)
}

// ============================================================================
// API response wrappers
// ============================================================================

/// Response from GET /v1/orders
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GetOrdersResponse {
    pub success: bool,
    pub cursor: Option<String>,
    pub data: Vec<PredictOrder>,
}

/// Response from POST /v1/orders (place order)
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PlaceOrderResponse {
    pub success: bool,
    pub data: Option<PlaceOrderData>,
}

/// Inner data from place order response
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PlaceOrderData {
    pub code: Option<String>,
    pub order_id: String,
    pub order_hash: String,
}

/// Request body for POST /v1/orders
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CreateOrderRequest {
    pub data: CreateOrderData,
}

/// Inner data for create order request
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CreateOrderData {
    pub order: serde_json::Value,
    pub price_per_share: String,
    pub strategy: String,
}

/// Response from POST /v1/orders/remove (cancel orders)
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RemoveOrdersResponse {
    pub success: bool,
    pub removed: Vec<String>,
    pub noop: Vec<String>,
}

/// Request body for POST /v1/orders/remove
#[derive(Debug, Clone, Serialize)]
pub struct RemoveOrdersRequest {
    pub data: RemoveOrdersData,
}

/// Inner data for remove orders request
#[derive(Debug, Clone, Serialize)]
pub struct RemoveOrdersData {
    pub ids: Vec<String>,
}

// ============================================================================
// Auth types
// ============================================================================

/// Response from GET /v1/auth/message
#[derive(Debug, Clone, Deserialize)]
pub struct AuthMessageResponse {
    pub success: bool,
    pub data: AuthMessageData,
}

/// Inner data from auth message response
#[derive(Debug, Clone, Deserialize)]
pub struct AuthMessageData {
    pub message: String,
}

/// Request body for POST /v1/auth
#[derive(Debug, Clone, Serialize)]
pub struct AuthRequest {
    pub signer: String,
    pub signature: String,
    pub message: String,
}

/// Response from POST /v1/auth
#[derive(Debug, Clone, Deserialize)]
pub struct AuthResponse {
    pub success: bool,
    pub data: AuthResponseData,
}

/// Inner data from auth response
#[derive(Debug, Clone, Deserialize)]
pub struct AuthResponseData {
    pub token: String,
}

// ============================================================================
// Position types
// ============================================================================

/// Response from GET /v1/positions
#[derive(Debug, Clone, Deserialize)]
pub struct GetPositionsResponse {
    pub success: bool,
    pub cursor: Option<String>,
    pub data: Vec<PredictPosition>,
}

/// A position on Predict
#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PredictPosition {
    pub id: String,
    pub market: PredictPositionMarket,
    pub outcome: PredictPositionOutcome,
    /// Token amount (wei string)
    pub amount: String,
    /// USD value
    #[serde(default)]
    pub value_usd: Option<String>,
}

/// Market info embedded in a position
#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PredictPositionMarket {
    pub id: u64,
    pub title: String,
    #[serde(default)]
    pub condition_id: Option<String>,
}

/// Outcome info embedded in a position
#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PredictPositionOutcome {
    pub name: String,
    pub index_set: u64,
    pub on_chain_id: String,
    pub status: Option<String>,
}

// ============================================================================
// Wallet event types (from predictWalletEvents WebSocket topic)
// ============================================================================

/// Details from a wallet event's `details` object (present on transaction events)
#[derive(Debug, Clone, Default)]
pub struct WalletEventDetails {
    /// Fill price (e.g., "0.290")
    pub price: Option<String>,
    /// Order quantity (e.g., "5.000")
    pub quantity: Option<String>,
    /// Quantity filled (e.g., "5.000")
    pub quantity_filled: Option<String>,
    /// Outcome side (e.g., "YES" or "NO")
    pub outcome: Option<String>,
    /// Quote type (e.g., "ASK" or "BID")
    pub quote_type: Option<String>,
}

/// Wallet events received via predictWalletEvents/{jwt} WebSocket topic
#[derive(Debug, Clone)]
pub enum PredictWalletEvent {
    /// Order successfully placed in orderbook
    OrderAccepted {
        order_hash: String,
        order_id: String,
    },
    /// Order rejected
    OrderNotAccepted {
        order_hash: String,
        order_id: String,
        reason: Option<String>,
    },
    /// Order expired
    OrderExpired {
        order_hash: String,
        order_id: String,
    },
    /// Order cancelled by user
    OrderCancelled {
        order_hash: String,
        order_id: String,
    },
    /// Order matched, transaction sent to blockchain
    OrderTransactionSubmitted {
        order_hash: String,
        order_id: String,
        tx_hash: Option<String>,
        details: WalletEventDetails,
    },
    /// On-chain transaction succeeded (order filled)
    OrderTransactionSuccess {
        order_hash: String,
        order_id: String,
        tx_hash: Option<String>,
        details: WalletEventDetails,
    },
    /// On-chain transaction failed
    OrderTransactionFailed {
        order_hash: String,
        order_id: String,
        tx_hash: Option<String>,
        details: WalletEventDetails,
    },
    /// Unknown wallet event type
    Unknown {
        event_type: String,
        data: serde_json::Value,
    },
}

// ============================================================================
// Category types
// ============================================================================

/// API response wrapper for category endpoint
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CategoryResponse {
    pub success: bool,
    pub data: PredictCategory,
}

/// Predict category (collection of related markets)
///
/// Categories group markets by asset, time, and duration.
/// The slug follows the pattern: `{asset}-usd-up-down-{yyyy}-{mm}-{dd}-{hh}-{mm}-{duration}`
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PredictCategory {
    /// Category ID
    pub id: u64,
    /// Category slug (used for lookup)
    pub slug: String,
    /// Category title
    pub title: String,
    /// Markets within this category
    pub markets: Vec<PredictMarket>,
}