feat: implement betting engine

Author: ComputerOracle

contracts/src/betting.rs

@@ -1,8 +1,17 @@
-use soroban_sdk::contracttype;
+use soroban_sdk::{contracttype, Address};
 
 #[contracttype]
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub enum BetSide {
     Yes,
     No,
 }
+
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Bet {
+    pub market_id: u64,
+    pub bettor: Address,
+    pub outcome_index: u32,
+    pub amount: i128,
+}

contracts/src/errors.rs

@@ -10,4 +10,11 @@ pub enum PredictXError {
     InvalidOutcomeCount = 4,
     InvalidEndTime = 5,
     MarketNotFound = 6,
+    MarketResolved = 7,
+    MarketEnded = 8,
+    InvalidBetAmount = 9,
+    InvalidOutcomeIndex = 10,
+    DuplicateBet = 11,
+    BetNotFound = 12,
+    MarketPoolOverflow = 13,
 }

contracts/src/lib.rs

@@ -9,11 +9,16 @@ pub mod rewards;
 pub mod storage;
 
 use crate::{
+    betting::Bet,
     errors::PredictXError,
     market::Market,
-    storage::{get_market as load_market, get_market_count, get_next_market_id, save_market},
+    storage::{
+        get_bet as load_bet, get_market as load_market, get_market_count,
+        get_market_pool as load_market_pool, get_next_market_id, save_bet, save_market,
+        save_market_pool,
+    },
 };
-use soroban_sdk::{contract, contractimpl, Env, String, Vec};
+use soroban_sdk::{contract, contractimpl, Address, Env, String, Vec};
 
 #[contract]
 pub struct PredictXContract;
@@ -79,6 +84,61 @@ impl PredictXContract {
 
         markets
     }
+
+    pub fn place_bet(
+        env: Env,
+        market_id: u64,
+        bettor: Address,
+        outcome_index: u32,
+        amount: i128,
+    ) -> Result<(), PredictXError> {
+        bettor.require_auth();
+
+        let market = load_market(&env, market_id).ok_or(PredictXError::MarketNotFound)?;
+
+        if market.resolved {
+            return Err(PredictXError::MarketResolved);
+        }
+
+        if env.ledger().timestamp() >= market.end_time {
+            return Err(PredictXError::MarketEnded);
+        }
+
+        if amount <= 0 {
+            return Err(PredictXError::InvalidBetAmount);
+        }
+
+        if outcome_index >= market.outcomes.len() {
+            return Err(PredictXError::InvalidOutcomeIndex);
+        }
+
+        if load_bet(&env, market_id, &bettor).is_some() {
+            return Err(PredictXError::DuplicateBet);
+        }
+
+        let bet = Bet {
+            market_id,
+            bettor,
+            outcome_index,
+            amount,
+        };
+        let market_pool = load_market_pool(&env, market_id)
+            .checked_add(amount)
+            .ok_or(PredictXError::MarketPoolOverflow)?;
+
+        save_bet(&env, &bet);
+        save_market_pool(&env, market_id, market_pool);
+
+        Ok(())
+    }
+
+    pub fn get_bet(env: Env, market_id: u64, bettor: Address) -> Result<Bet, PredictXError> {
+        load_bet(&env, market_id, &bettor).ok_or(PredictXError::BetNotFound)
+    }
+
+    pub fn get_market_pool(env: Env, market_id: u64) -> i128 {
+        load_market_pool(&env, market_id)
+    }
 }
 
 #[cfg(test)]

contracts/src/storage.rs

@@ -1,11 +1,13 @@
-use crate::market::Market;
-use soroban_sdk::{contracttype, Env};
+use crate::{betting::Bet, market::Market};
+use soroban_sdk::{contracttype, Address, Env};
 
 #[contracttype]
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum DataKey {
     Market(u64),
     MarketCounter,
+    Bet(u64, Address),
+    MarketPool(u64),
 }
 
 pub fn get_next_market_id(env: &Env) -> u64 {
@@ -39,3 +41,28 @@ pub fn save_market(env: &Env, market: &Market) {
 pub fn get_market(env: &Env, market_id: u64) -> Option<Market> {
     env.storage().persistent().get(&DataKey::Market(market_id))
 }
+
+pub fn save_bet(env: &Env, bet: &Bet) {
+    env.storage()
+        .persistent()
+        .set(&DataKey::Bet(bet.market_id, bet.bettor.clone()), bet);
+}
+
+pub fn get_bet(env: &Env, market_id: u64, bettor: &Address) -> Option<Bet> {
+    env.storage()
+        .persistent()
+        .get(&DataKey::Bet(market_id, bettor.clone()))
+}
+
+pub fn get_market_pool(env: &Env, market_id: u64) -> i128 {
+    env.storage()
+        .persistent()
+        .get(&DataKey::MarketPool(market_id))
+        .unwrap_or(0_i128)
+}
+
+pub fn save_market_pool(env: &Env, market_id: u64, amount: i128) {
+    env.storage()
+        .persistent()
+        .set(&DataKey::MarketPool(market_id), &amount);
+}