Implement Private/Invite-Only Prediction Markets (#382)

* feat: implement safe math wrapper for proportion calculations (#304)

- Add SafeMath module with fixed-point arithmetic
- Implement safe percentage and proportion calculations
- Add three rounding modes: ProtocolFavor, Neutral, UserFavor
- Include overflow/underflow protection
- Add comprehensive unit tests (12 tests)
- Add usage examples for real-world scenarios (9 examples)
- All tests passing, clippy clean, formatted

* feat: implement private and invite-only prediction markets

* fix: resolve cargo fmt and clippy warnings

* fix: correct stake calculation in test_state_consistency_across_many_pools

Author: Ndifreke000

contract/contracts/predifi-contract/src/integration_test.rs

@@ -102,9 +102,9 @@ fn test_full_market_lifecycle() {
     );
 
     // 2. Place Predictions
-    client.place_prediction(&user1, &pool_id, &100, &1, &None); // User 1 bets 100 on Outcome 1
-    client.place_prediction(&user2, &pool_id, &200, &2, &None); // User 2 bets 200 on Outcome 2
-    client.place_prediction(&user3, &pool_id, &300, &1, &None); // User 3 bets 300 on Outcome 1 (Total Outcome 1 = 400)
+    client.place_prediction(&user1, &pool_id, &100, &1, &None, &None); // User 1 bets 100 on Outcome 1
+    client.place_prediction(&user2, &pool_id, &200, &2, &None, &None); // User 2 bets 200 on Outcome 2
+    client.place_prediction(&user3, &pool_id, &300, &1, &None, &None); // User 3 bets 300 on Outcome 1 (Total Outcome 1 = 400)
 
     // Total stake = 100 + 200 + 300 = 600
     assert_eq!(token_ctx.token.balance(&client.address), 600);
@@ -187,11 +187,11 @@ fn test_multi_user_betting_and_balance_verification() {
     // U4: 500 on 1
     // Total 1: 1500, Total 2: 1000, Total 3: 1500. Total Stake: 4000.
 
-    client.place_prediction(&users.get(0).unwrap(), &pool_id, &500, &1, &None);
-    client.place_prediction(&users.get(1).unwrap(), &pool_id, &1000, &2, &None);
-    client.place_prediction(&users.get(2).unwrap(), &pool_id, &500, &1, &None);
-    client.place_prediction(&users.get(3).unwrap(), &pool_id, &1500, &3, &None);
-    client.place_prediction(&users.get(4).unwrap(), &pool_id, &500, &1, &None);
+    client.place_prediction(&users.get(0).unwrap(), &pool_id, &500, &1, &None, &None);
+    client.place_prediction(&users.get(1).unwrap(), &pool_id, &1000, &2, &None, &None);
+    client.place_prediction(&users.get(2).unwrap(), &pool_id, &500, &1, &None, &None);
+    client.place_prediction(&users.get(3).unwrap(), &pool_id, &1500, &3, &None, &None);
+    client.place_prediction(&users.get(4).unwrap(), &pool_id, &500, &1, &None, &None);
 
     assert_eq!(token_ctx.token.balance(&client.address), 4000);
 
@@ -257,9 +257,9 @@ fn test_market_resolution_multiple_winners() {
     // U3: 500 on 2
     // Total 1: 500, Total 2: 500. Total Stake: 1000.
 
-    client.place_prediction(&user1, &pool_id, &200, &1, &None);
-    client.place_prediction(&user2, &pool_id, &300, &1, &None);
-    client.place_prediction(&user3, &pool_id, &500, &2, &None);
+    client.place_prediction(&user1, &pool_id, &200, &1, &None, &None);
+    client.place_prediction(&user2, &pool_id, &300, &1, &None, &None);
+    client.place_prediction(&user3, &pool_id, &500, &2, &None, &None);
 
     // Advance time past end_time=3600, then resolve
     env.ledger().with_mut(|li| li.timestamp = 3601);

contract/contracts/predifi-contract/src/lib.rs

@@ -120,6 +120,22 @@ pub enum MarketState {
     Canceled = 2,
 }
 
+#[contracttype]
+#[derive(Clone)]
+pub struct CreatePoolParams {
+    pub end_time: u64,
+    pub token: Address,
+    pub options_count: u32,
+    pub description: String,
+    pub metadata_url: String,
+    pub min_stake: i128,
+    pub max_stake: i128,
+    pub initial_liquidity: i128,
+    pub category: Symbol,
+    pub private: bool,
+    pub whitelist_key: Option<Symbol>,
+}
+
 #[contracttype]
 #[derive(Clone)]
 pub struct Pool {
@@ -1159,32 +1175,38 @@ impl PredifiContract {
 
         // Validate: category must be in the allowed list
         assert!(
-            Self::validate_category(&env, &category),
+            Self::validate_category(&env, &params.category),
             "category must be one of the allowed categories"
         );
 
         // Validate: token must be on the allowed betting whitelist
-        if !Self::is_token_whitelisted(&env, &token) {
+        if !Self::is_token_whitelisted(&env, &params.token) {
             soroban_sdk::panic_with_error!(&env, PredifiError::TokenNotWhitelisted);
         }
 
         let current_time = env.ledger().timestamp();
 
         // Validate: end_time must be in the future
-        assert!(end_time > current_time, "end_time must be in the future");
+        assert!(
+            params.end_time > current_time,
+            "end_time must be in the future"
+        );
 
         // Validate: minimum pool duration (1 hour)
         assert!(
-            end_time >= current_time + MIN_POOL_DURATION,
+            params.end_time >= current_time + MIN_POOL_DURATION,
             "end_time must be at least 1 hour in the future"
         );
 
         // Validate: options_count must be at least 2 (binary or more outcomes)
-        assert!(options_count >= 2, "options_count must be at least 2");
+        assert!(
+            params.options_count >= 2,
+            "options_count must be at least 2"
+        );
 
         // Validate: options_count must not exceed maximum limit
         assert!(
-            options_count <= MAX_OPTIONS_COUNT,
+            params.options_count <= MAX_OPTIONS_COUNT,
             "options_count exceeds maximum allowed value"
         );
 
@@ -1233,7 +1255,7 @@ impl PredifiContract {
             .unwrap_or(0);
         // Initialize pool data structure
         let pool = Pool {
-            end_time,
+            end_time: params.end_time,
             resolved: false,
             canceled: false,
             state: MarketState::Active,
@@ -1271,14 +1293,14 @@ impl PredifiContract {
         }
 
         // Update category index
-        let category_count_key = DataKey::CatPoolCt(category.clone());
+        let category_count_key = DataKey::CatPoolCt(params.category.clone());
         let category_count: u32 = env
             .storage()
             .persistent()
             .get(&category_count_key)
             .unwrap_or(0);
 
-        let category_index_key = DataKey::CatPoolIx(category.clone(), category_count);
+        let category_index_key = DataKey::CatPoolIx(params.category.clone(), category_count);
         env.storage()
             .persistent()
             .set(&category_index_key, &pool_id);
@@ -1615,6 +1637,7 @@ impl PredifiContract {
         amount: i128,
         outcome: u32,
         referrer: Option<Address>,
+        invite_key: Option<Symbol>,
     ) {
         Self::require_not_paused(&env);
         user.require_auth();
@@ -1643,6 +1666,32 @@ impl PredifiContract {
         assert!(pool.state == MarketState::Active, "Pool is not active");
         assert!(env.ledger().timestamp() < pool.end_time, "Pool has ended");
 
+        // Check private pool authorization
+        // Check private pool authorization
+        if pool.private {
+            let whitelist_key_data = DataKey::Whitelist(pool_id, user.clone());
+            let is_whitelisted = env
+                .storage()
+                .persistent()
+                .get(&whitelist_key_data)
+                .unwrap_or(false);
+
+            let has_valid_invite = if let Some(ref pool_key) = pool.whitelist_key {
+                if let Some(ref prov_key) = invite_key {
+                    pool_key == prov_key
+                } else {
+                    false
+                }
+            } else {
+                false
+            };
+
+            assert!(
+                is_whitelisted || user == pool.creator || has_valid_invite,
+                "User not authorized for private pool"
+            );
+        }
+
         // Validate: outcome must be within the valid options range
         assert!(
             outcome < pool.options_count,
@@ -2223,6 +2272,97 @@ impl PredifiContract {
         results
     }
 
+    /// Add a user to a private pool's whitelist. Only callable by pool creator.
+    pub fn add_to_whitelist(
+        env: Env,
+        creator: Address,
+        pool_id: u64,
+        user: Address,
+    ) -> Result<(), PredifiError> {
+        Self::require_not_paused(&env);
+        creator.require_auth();
+
+        let pool_key = DataKey::Pool(pool_id);
+        let pool: Pool = env
+            .storage()
+            .persistent()
+            .get(&pool_key)
+            .expect("Pool not found");
+        Self::extend_persistent(&env, &pool_key);
+
+        if pool.creator != creator {
+            return Err(PredifiError::Unauthorized);
+        }
+
+        assert!(pool.private, "Pool is not private");
+
+        let whitelist_key = DataKey::Whitelist(pool_id, user);
+        env.storage().persistent().set(&whitelist_key, &true);
+        Self::extend_persistent(&env, &whitelist_key);
+
+        Ok(())
+    }
+
+    /// Remove a user from a private pool's whitelist. Only callable by pool creator.
+    pub fn remove_from_whitelist(
+        env: Env,
+        creator: Address,
+        pool_id: u64,
+        user: Address,
+    ) -> Result<(), PredifiError> {
+        Self::require_not_paused(&env);
+        creator.require_auth();
+
+        let pool_key = DataKey::Pool(pool_id);
+        let pool: Pool = env
+            .storage()
+            .persistent()
+            .get(&pool_key)
+            .expect("Pool not found");
+        Self::extend_persistent(&env, &pool_key);
+
+        if pool.creator != creator {
+            return Err(PredifiError::Unauthorized);
+        }
+
+        assert!(pool.private, "Pool is not private");
+
+        let whitelist_key = DataKey::Whitelist(pool_id, user);
+        env.storage().persistent().remove(&whitelist_key);
+
+        Ok(())
+    }
+
+    /// Check if a user is whitelisted for a private pool.
+    pub fn is_whitelisted(env: Env, pool_id: u64, user: Address) -> bool {
+        let pool_key = DataKey::Pool(pool_id);
+        let pool: Pool = env
+            .storage()
+            .persistent()
+            .get(&pool_key)
+            .expect("Pool not found");
+        Self::extend_persistent(&env, &pool_key);
+
+        if !pool.private {
+            return true;
+        }
+
+        if user == pool.creator {
+            return true;
+        }
+
+        let whitelist_key = DataKey::Whitelist(pool_id, user);
+        let is_whitelisted = env
+            .storage()
+            .persistent()
+            .get(&whitelist_key)
+            .unwrap_or(false);
+        if env.storage().persistent().has(&whitelist_key) {
+            Self::extend_persistent(&env, &whitelist_key);
+        }
+        is_whitelisted
+    }
+
     /// Get comprehensive stats for a pool.
     pub fn get_pool_stats(env: Env, pool_id: u64) -> PoolStats {
         let pool_key = DataKey::Pool(pool_id);

contract/contracts/predifi-contract/src/stress_test.rs

@@ -110,7 +110,7 @@ fn test_high_volume_predictions_single_pool() {
 
         // Split users between outcome 0 and 1
         let outcome = i % 2;
-        client.place_prediction(&user, &pool_id, &stake_per_user, &outcome, &None);
+        client.place_prediction(&user, &pool_id, &stake_per_user, &outcome, &None, &None);
     }
 
     // Use client to get details instead of direct storage access
@@ -148,7 +148,7 @@ fn test_bulk_claim_winnings() {
     for _ in 0..num_users {
         let user = Address::generate(&env);
         token_admin_client.mint(&user, &stake_per_user);
-        client.place_prediction(&user, &pool_id, &stake_per_user, &0, &None); // All on outcome 0
+        client.place_prediction(&user, &pool_id, &stake_per_user, &0, &None, &None); // All on outcome 0
         users.push(user);
     }
 
@@ -221,7 +221,7 @@ fn test_max_outcomes_high_volume() {
     for i in 0..max_options {
         let user = Address::generate(&env);
         token_admin_client.mint(&user, &1000);
-        client.place_prediction(&user, &pool_id, &1000, &i, &None);
+        client.place_prediction(&user, &pool_id, &1000, &i, &None, &None);
     }
 
     let pool = client.get_pool(&pool_id);
@@ -256,7 +256,7 @@ fn test_prediction_throughput_measurement() {
     for _ in 0..num_predictions {
         let user = Address::generate(&env);
         token_admin_client.mint(&user, &100);
-        client.place_prediction(&user, &pool_id, &100, &0, &None);
+        client.place_prediction(&user, &pool_id, &100, &0, &None, &None);
     }
 
     let end_ledger = env.ledger().timestamp();
@@ -297,7 +297,7 @@ fn test_resolution_under_load() {
     for &pid in &pool_ids {
         let user = Address::generate(&env);
         token_admin_client.mint(&user, &1000);
-        client.place_prediction(&user, &pid, &1000, &0, &None);
+        client.place_prediction(&user, &pid, &1000, &0, &None, &None);
     }
 
     // Advance time