Merge branch 'main' of https://github.com/0xVida/predifi

Author: 0xVida

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

@@ -104,6 +104,8 @@ pub enum PredifiError {
     PriceDataInvalid = 102,
     /// Price condition not set for pool.
     PriceConditionNotSet = 103,
+    /// Total pool stake cap reached or would be exceeded.
+    MaxTotalStakeExceeded = 104,
 }
 
 #[contracttype]
@@ -136,6 +138,8 @@ pub struct Pool {
     pub min_stake: i128,
     /// Maximum stake amount per prediction (0 = no limit).
     pub max_stake: i128,
+    /// Maximum total stake amount across the entire pool (0 = no limit).
+    pub max_total_stake: i128,
     /// Initial liquidity provided by the pool creator (house money).
     /// This is part of total_stake but excluded from fee calculations.
     pub initial_liquidity: i128,
@@ -466,6 +470,14 @@ pub struct TreasuryWithdrawnEvent {
     pub recipient: Address,
     pub timestamp: u64,
 }
+#[contractevent(topics = ["refund_claimed"])]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct RefundClaimedEvent {
+    pub pool_id: u64,
+    pub user: Address,
+    pub amount: i128,
+}
+
 #[contractevent(topics = ["upgrade"])]
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct UpgradeEvent {
@@ -1196,6 +1208,7 @@ impl PredifiContract {
             options_count,
             min_stake,
             max_stake,
+            max_total_stake: 0, // default: no cap
             initial_liquidity,
             creator: creator.clone(),
             category: category.clone(),
@@ -1263,6 +1276,59 @@ impl PredifiContract {
         pool_id
     }
 
+    /// Increase the maximum total stake cap for a pool.
+    /// Only the pool creator can increase it, and only before the market ends.
+    ///
+    /// - `new_max_total_stake` must be >= current `pool.total_stake`.
+    /// - Setting to 0 means "no cap" (only allowed if current cap is 0 or increasing from a non-zero).
+    pub fn increase_max_total_stake(
+        env: Env,
+        creator: Address,
+        pool_id: u64,
+        new_max_total_stake: i128,
+    ) -> Result<(), PredifiError> {
+        Self::require_not_paused(&env);
+        creator.require_auth();
+
+        let pool_key = DataKey::Pool(pool_id);
+        let mut 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);
+        }
+
+        // Pool must still be active and not ended
+        if pool.state != MarketState::Active || pool.resolved || pool.canceled {
+            return Err(PredifiError::InvalidPoolState);
+        }
+        assert!(env.ledger().timestamp() < pool.end_time, "Pool has ended");
+
+        // Must not set a cap below what is already staked
+        assert!(
+            new_max_total_stake == 0 || new_max_total_stake >= pool.total_stake,
+            "new_max_total_stake must be zero (unlimited) or >= total_stake"
+        );
+
+        // Only allow increasing the cap (or setting unlimited)
+        if pool.max_total_stake > 0 && new_max_total_stake > 0 {
+            assert!(
+                new_max_total_stake >= pool.max_total_stake,
+                "new_max_total_stake must be >= current max_total_stake"
+            );
+        }
+
+        pool.max_total_stake = new_max_total_stake;
+        env.storage().persistent().set(&pool_key, &pool);
+        Self::extend_persistent(&env, &pool_key);
+
+        Ok(())
+    }
+
     /// Resolve a pool with a winning outcome. Caller must have Operator role (1).
     /// Cannot resolve a canceled pool.
     /// PRE: pool.state = Active, operator has role 1
@@ -1495,6 +1561,15 @@ impl PredifiContract {
             );
         }
 
+        // Enforce global pool cap (max total stake)
+        if pool.max_total_stake > 0 {
+            let new_total = pool.total_stake.checked_add(amount).expect("overflow");
+            if new_total > pool.max_total_stake {
+                Self::exit_reentrancy_guard(&env);
+                soroban_sdk::panic_with_error!(&env, PredifiError::MaxTotalStakeExceeded);
+            }
+        }
+
         let pred_key = DataKey::Pred(user.clone(), pool_id);
         let existing_pred = env.storage().persistent().get::<_, Prediction>(&pred_key);
         if let Some(mut existing_pred) = existing_pred {
@@ -1758,6 +1833,104 @@ impl PredifiContract {
         Ok(winnings)
     }
 
+    /// Claim a refund from a canceled pool. Returns the refunded amount.
+    /// Only available for canceled pools. User receives their full original stake.
+    ///
+    /// PRE: pool.state = Canceled, user has a prediction on the pool
+    /// POST: HasClaimed(user, pool) = true (INV-3), user receives full stake amount
+    ///
+    /// # Arguments
+    /// * `user` - Address claiming the refund (must provide auth)
+    /// * `pool_id` - ID of the canceled pool
+    ///
+    /// # Returns
+    /// Ok(amount) - Refund successfully claimed, returns refunded amount
+    /// Err(PredifiError) - Operation failed with specific error code
+    ///
+    /// # Errors
+    /// - `InvalidPoolState` if pool doesn't exist or is not canceled
+    /// - `InsufficientBalance` if user has no prediction or zero stake
+    /// - `AlreadyClaimed` if user already claimed refund for this pool
+    /// - `PoolNotResolved` if pool is resolved (not canceled)
+    #[allow(clippy::needless_borrows_for_generic_args)]
+    pub fn claim_refund(env: Env, user: Address, pool_id: u64) -> Result<i128, PredifiError> {
+        Self::require_not_paused(&env);
+        user.require_auth();
+
+        Self::enter_reentrancy_guard(&env);
+
+        // --- CHECKS ---
+
+        let pool_key = DataKey::Pool(pool_id);
+        let pool: Pool = match env.storage().persistent().get(&pool_key) {
+            Some(p) => p,
+            None => {
+                Self::exit_reentrancy_guard(&env);
+                return Err(PredifiError::InvalidPoolState);
+            }
+        };
+        Self::extend_persistent(&env, &pool_key);
+
+        // Verify pool is canceled
+        if pool.state != MarketState::Canceled {
+            Self::exit_reentrancy_guard(&env);
+            return Err(PredifiError::InvalidPoolState);
+        }
+
+        // Check if user already claimed refund
+        let claimed_key = DataKey::Claimed(user.clone(), pool_id);
+        if env.storage().persistent().has(&claimed_key) {
+            Self::exit_reentrancy_guard(&env);
+            return Err(PredifiError::AlreadyClaimed);
+        }
+
+        // Get user's prediction
+        let pred_key = DataKey::Pred(user.clone(), pool_id);
+        let prediction: Option<Prediction> = env.storage().persistent().get(&pred_key);
+
+        if env.storage().persistent().has(&pred_key) {
+            Self::extend_persistent(&env, &pred_key);
+        }
+
+        let prediction = match prediction {
+            Some(p) => p,
+            None => {
+                Self::exit_reentrancy_guard(&env);
+                return Err(PredifiError::InsufficientBalance);
+            }
+        };
+
+        // Verify user has a non-zero stake
+        if prediction.amount <= 0 {
+            Self::exit_reentrancy_guard(&env);
+            return Err(PredifiError::InsufficientBalance);
+        }
+
+        // --- EFFECTS ---
+
+        // Mark as claimed immediately to prevent re-entrancy (INV-3)
+        env.storage().persistent().set(&claimed_key, &true);
+        Self::extend_persistent(&env, &claimed_key);
+
+        let refund_amount = prediction.amount;
+
+        // --- INTERACTIONS ---
+
+        let token_client = token::Client::new(&env, &pool.token);
+        token_client.transfer(&env.current_contract_address(), &user, &refund_amount);
+
+        Self::exit_reentrancy_guard(&env);
+
+        RefundClaimedEvent {
+            pool_id,
+            user: user.clone(),
+            amount: refund_amount,
+        }
+        .publish(&env);
+
+        Ok(refund_amount)
+    }
+
     /// Update the stake limits for an active pool. Caller must have Operator role (1).
     /// PRE: pool.state = Active, operator has role 1
     /// POST: pool.min_stake and pool.max_stake updated

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

@@ -28,8 +28,8 @@ mod dummy_access_control {
     }
 }
 
-const ROLE_ADMIN: u32 = 0;
-const ROLE_OPERATOR: u32 = 1;
+const ROLE_ADMIN: u32 = 0; // i am testing this
+const ROLE_OPERATOR: u32 = 1; // i am testing this the second one
 const ROLE_ORACLE: u32 = 3;
 
 fn setup(