Implied Probability = Outcome Pool / Total Pool

Seeds: ["position", game_pubkey, player_pubkey]

pub struct GameV2 {
    // Identity
    pub game_id: u64,              // Unique identifier
    pub authority: Pubkey,          // Game creator
    pub operator_wallet: Pubkey,    // Fee recipient (hardcoded)
    pub oracle: Pubkey,             // Resolution authority (hardcoded)

    // Pool State
    pub pool_totals: [u64; 3],      // [Home, Away, Draw] in lamports
    pub total_pool: u64,            // Sum of all pools
    pub position_count: u32,        // Number of positions created

    // Event Metadata
    pub sports_event_id: String,    // External event reference (max 50 chars)
    pub lock_timestamp: i64,        // Unix timestamp when betting closes

    // Game State
    pub is_locked: bool,            // Betting closed
    pub is_resolved: bool,          // Outcome determined
    pub winning_outcome: Option<u8>,// 0=Home, 1=Away, 2=Draw, None=Refund

    // Financial
    pub fees_collected: bool,       // Fees transferred to recipients
    pub net_pool: u64,              // Pool after fees (for payout calc)

    // Optional
    pub sponsor_wallet: Option<Pubkey>,  // If game has sponsored positions
    pub is_emergency_refund: bool,       // True if emergency refund triggered

    pub bump: u8,                   // PDA bump seed
}

Seeds: ["game_v2", game_id.to_le_bytes()]

pub struct Position {
    pub game: Pubkey,              // Reference to GameV2
    pub player: Pubkey,            // Player wallet
    pub outcome: u8,               // 0=Home, 1=Away, 2=Draw
    pub amount: u64,               // Stake in lamports
    pub claimed: bool,             // Payout claimed
    pub referrer: Option<Pubkey>,  // Referrer for fee sharing
    pub sponsor: Option<Pubkey>,   // Sponsor (if sponsored stake)
    pub bump: u8,                  // PDA bump seed
}

Seeds: ["position", game.key(), player.key()]

#[repr(u8)]
pub enum Outcome {
    Home = 0,  // Home team / First option
    Away = 1,  // Away team / Second option
    Draw = 2,  // Tie / No winner
}

fn calculate_fees(distributable: u64, has_referrer: bool) -> FeeBreakdown {
    let total_fee = distributable * 600 / 10_000;  // 6%

    let oracle_fee = distributable * 100 / 10_000;  // 1%

    let (operator_fee, referrer_fee) = if has_referrer {
        (distributable * 400 / 10_000,  // 4%
         distributable * 100 / 10_000)  // 1%
    } else {
        (distributable * 500 / 10_000,  // 5%
         0)
    };

    FeeBreakdown { operator_fee, oracle_fee, referrer_fee, total_fee }
}

Distributable = Game Account Lamports - Rent Reserve

Net Pool = Distributable - Total Fees

payout = floor(position.amount × net_pool / winning_pool_total)

payout = floor(position.amount × net_pool / total_pool)

// Available when:
current_time >= lock_timestamp + 86400  // 24 hours

// Fee basis points (1 bp = 0.01%)
pub const OPERATOR_BPS_WITH_REFERRER: u64 = 400;   // 4%
pub const OPERATOR_BPS_NO_REFERRER: u64 = 500;     // 5%
pub const REFERRER_BPS: u64 = 100;                 // 1%
pub const ORACLE_BPS: u64 = 100;                   // 1%
pub const TOTAL_FEE_BPS: u64 = 600;                // 6%
pub const BPS_DENOMINATOR: u64 = 10_000;

// Time constants
pub const MIN_LOCK_LEAD_TIME: i64 = 120;           // 2 minutes
pub const EMERGENCY_REFUND_DELAY: i64 = 86_400;    // 24 hours

// Limits
pub const MAX_EVENT_ID_LEN: usize = 50;
pub const NUM_OUTCOMES: usize = 3;

// Operator wallet (receives 4-5% fee)
pub const OPERATOR_WALLET: &str = "BVZXwZpfgyzTBdRFHohkHZppPHnAyqyctRsKy3vWfQib";

// Oracle wallet (resolves games, receives 1% fee)
pub const ORACLE_WALLET: &str = "FWUJCthDfPcgmTvdQWM5uofxxiYjqJFMMwiLYvS7LBFa";

85wJGp9uc8w2FeKX9CEHsudTo1UVCrmuRFy37oCcaoG1