feat: implement reward distribution

Author: ComputerOracle

contracts/src/errors.rs

@@ -18,4 +18,8 @@ pub enum PredictXError {
     BetNotFound = 12,
     MarketPoolOverflow = 13,
     MarketNotEnded = 14,
+    MarketNotResolved = 15,
+    NotWinningBet = 16,
+    RewardAlreadyClaimed = 17,
+    RewardCalculationOverflow = 18,
 }

contracts/src/lib.rs

@@ -14,9 +14,10 @@ use crate::{
     market::Market,
     resolution::MarketResult,
     storage::{
-        get_bet as load_bet, get_market as load_market, get_market_count,
-        get_market_pool as load_market_pool, get_market_result as load_market_result,
-        get_next_market_id, save_bet, save_market, save_market_pool, save_market_result,
+        add_market_bettor, get_bet as load_bet, get_market as load_market, get_market_bettors,
+        get_market_count, get_market_pool as load_market_pool,
+        get_market_result as load_market_result, get_next_market_id, is_reward_claimed,
+        mark_reward_claimed, save_bet, save_market, save_market_pool, save_market_result,
     },
 };
 use soroban_sdk::{contract, contractimpl, Address, Env, String, Vec};
@@ -128,6 +129,7 @@ impl PredictXContract {
             .ok_or(PredictXError::MarketPoolOverflow)?;
 
         save_bet(&env, &bet);
+        add_market_bettor(&env, market_id, &bet.bettor);
         save_market_pool(&env, market_id, market_pool);
 
         Ok(())
@@ -184,6 +186,64 @@ impl PredictXContract {
             resolved: market.resolved,
         })
     }
+
+    pub fn calculate_reward(
+        env: Env,
+        market_id: u64,
+        bettor: Address,
+    ) -> Result<i128, PredictXError> {
+        let market = load_market(&env, market_id).ok_or(PredictXError::MarketNotFound)?;
+
+        if !market.resolved {
+            return Err(PredictXError::MarketNotResolved);
+        }
+
+        let result = load_market_result(&env, market_id).ok_or(PredictXError::MarketNotResolved)?;
+        let winning_outcome = result
+            .winning_outcome
+            .ok_or(PredictXError::MarketNotResolved)?;
+        let user_bet = load_bet(&env, market_id, &bettor).ok_or(PredictXError::BetNotFound)?;
+
+        if user_bet.outcome_index != winning_outcome {
+            return Err(PredictXError::NotWinningBet);
+        }
+
+        let bettors = get_market_bettors(&env, market_id);
+        let mut total_winning_pool = 0_i128;
+
+        for index in 0..bettors.len() {
+            let market_bettor = bettors.get(index).unwrap();
+            if let Some(bet) = load_bet(&env, market_id, &market_bettor) {
+                if bet.outcome_index == winning_outcome {
+                    total_winning_pool = total_winning_pool
+                        .checked_add(bet.amount)
+                        .ok_or(PredictXError::RewardCalculationOverflow)?;
+                }
+            }
+        }
+
+        let total_market_pool = load_market_pool(&env, market_id);
+
+        user_bet
+            .amount
+            .checked_mul(total_market_pool)
+            .ok_or(PredictXError::RewardCalculationOverflow)
+            .map(|weighted_bet| weighted_bet / total_winning_pool)
+    }
+
+    pub fn claim_reward(env: Env, market_id: u64, bettor: Address) -> Result<i128, PredictXError> {
+        if is_reward_claimed(&env, market_id, &bettor) {
+            return Err(PredictXError::RewardAlreadyClaimed);
+        }
+
+        bettor.require_auth();
+
+        let reward = Self::calculate_reward(env.clone(), market_id, bettor.clone())?;
+
+        mark_reward_claimed(&env, market_id, &bettor);
+
+        Ok(reward)
+    }
 }
 
 #[cfg(test)]

contracts/src/storage.rs

@@ -1,5 +1,5 @@
 use crate::{betting::Bet, market::Market, resolution::MarketResult};
-use soroban_sdk::{contracttype, Address, Env};
+use soroban_sdk::{contracttype, Address, Env, Vec};
 
 #[contracttype]
 #[derive(Clone, Debug, Eq, PartialEq)]
@@ -9,6 +9,8 @@ pub enum DataKey {
     Bet(u64, Address),
     MarketPool(u64),
     MarketResult(u64),
+    MarketBettors(u64),
+    RewardClaimed(u64, Address),
 }
 
 pub fn get_next_market_id(env: &Env) -> u64 {
@@ -49,6 +51,15 @@ pub fn save_bet(env: &Env, bet: &Bet) {
         .set(&DataKey::Bet(bet.market_id, bet.bettor.clone()), bet);
 }
 
+pub fn add_market_bettor(env: &Env, market_id: u64, bettor: &Address) {
+    let mut bettors = get_market_bettors(env, market_id);
+    bettors.push_back(bettor.clone());
+
+    env.storage()
+        .persistent()
+        .set(&DataKey::MarketBettors(market_id), &bettors);
+}
+
 pub fn get_bet(env: &Env, market_id: u64, bettor: &Address) -> Option<Bet> {
     env.storage()
         .persistent()
@@ -79,3 +90,23 @@ pub fn get_market_result(env: &Env, market_id: u64) -> Option<MarketResult> {
         .persistent()
         .get(&DataKey::MarketResult(market_id))
 }
+
+pub fn get_market_bettors(env: &Env, market_id: u64) -> Vec<Address> {
+    env.storage()
+        .persistent()
+        .get(&DataKey::MarketBettors(market_id))
+        .unwrap_or_else(|| Vec::new(env))
+}
+
+pub fn mark_reward_claimed(env: &Env, market_id: u64, bettor: &Address) {
+    env.storage()
+        .persistent()
+        .set(&DataKey::RewardClaimed(market_id, bettor.clone()), &true);
+}
+
+pub fn is_reward_claimed(env: &Env, market_id: u64, bettor: &Address) -> bool {
+    env.storage()
+        .persistent()
+        .get(&DataKey::RewardClaimed(market_id, bettor.clone()))
+        .unwrap_or(false)
+}