Merge pull request Predictify-org#278 from Jagadeeshftw/min-max

feat: implement minimum and maximum bet limits per event

Author: greatest0fallt1me

contracts/predictify-hybrid/src/bet_tests.rs

@@ -793,3 +793,158 @@ fn test_bet_equality() {
     assert_eq!(bet1.amount, bet2.amount);
     assert_eq!(bet1.status, bet2.status);
 }
+
+// ===== BET LIMITS TESTS =====
+
+#[test]
+fn test_set_global_bet_limits_and_place_bet_exactly_min_max() {
+    let setup = BetTestSetup::new();
+    let client = setup.client();
+    let min = 5_000000i128; // 0.5 XLM
+    let max = 50_000000i128; // 5 XLM
+
+    setup.env.mock_all_auths();
+    client.set_global_bet_limits(&setup.admin, &min, &max);
+
+    // Exactly min: must succeed
+    let bet_min = client.place_bet(
+        &setup.user,
+        &setup.market_id,
+        &String::from_str(&setup.env, "yes"),
+        &min,
+    );
+    assert_eq!(bet_min.amount, min);
+
+    // Exactly max: need second user (first already bet)
+    let stellar_client = StellarAssetClient::new(&setup.env, &setup.token_id);
+    stellar_client.mint(&setup.user2, &max);
+    setup.env.mock_all_auths();
+    let bet_max = client.place_bet(
+        &setup.user2,
+        &setup.market_id,
+        &String::from_str(&setup.env, "no"),
+        &max,
+    );
+    assert_eq!(bet_max.amount, max);
+}
+
+#[test]
+#[should_panic]
+fn test_place_bet_below_configured_min_rejects() {
+    let setup = BetTestSetup::new();
+    let client = setup.client();
+    let min = 10_000000i128;
+    let max = 100_000000i128;
+
+    setup.env.mock_all_auths();
+    client.set_global_bet_limits(&setup.admin, &min, &max);
+
+    setup.env.mock_all_auths();
+    client.place_bet(
+        &setup.user,
+        &setup.market_id,
+        &String::from_str(&setup.env, "yes"),
+        &(min - 1),
+    );
+}
+
+#[test]
+#[should_panic]
+fn test_place_bet_above_configured_max_rejects() {
+    let setup = BetTestSetup::new();
+    let client = setup.client();
+    let min = 1_000000i128;
+    let max = 20_000000i128;
+
+    setup.env.mock_all_auths();
+    client.set_global_bet_limits(&setup.admin, &min, &max);
+
+    setup.env.mock_all_auths();
+    client.place_bet(
+        &setup.user,
+        &setup.market_id,
+        &String::from_str(&setup.env, "yes"),
+        &(max + 1),
+    );
+}
+
+#[test]
+fn test_set_event_bet_limits_overrides_global() {
+    let setup = BetTestSetup::new();
+    let client = setup.client();
+    let global_min = 1_000000i128;
+    let global_max = 100_000000i128;
+    let event_min = 15_000000i128;
+    let event_max = 25_000000i128;
+
+    setup.env.mock_all_auths();
+    client.set_global_bet_limits(&setup.admin, &global_min, &global_max);
+    setup.env.mock_all_auths();
+    client.set_event_bet_limits(&setup.admin, &setup.market_id, &event_min, &event_max);
+
+    // Exactly event min must succeed (below event min tested in separate should_panic test)
+    setup.env.mock_all_auths();
+    let bet = client.place_bet(
+        &setup.user,
+        &setup.market_id,
+        &String::from_str(&setup.env, "yes"),
+        &event_min,
+    );
+    assert_eq!(bet.amount, event_min);
+}
+
+#[test]
+#[should_panic]
+fn test_place_bet_below_event_min_rejects() {
+    let setup = BetTestSetup::new();
+    let client = setup.client();
+    let event_min = 15_000000i128;
+    let event_max = 25_000000i128;
+
+    setup.env.mock_all_auths();
+    client.set_event_bet_limits(&setup.admin, &setup.market_id, &event_min, &event_max);
+
+    setup.env.mock_all_auths();
+    client.place_bet(
+        &setup.user,
+        &setup.market_id,
+        &String::from_str(&setup.env, "yes"),
+        &(event_min - 1),
+    );
+}
+
+#[test]
+#[should_panic]
+fn test_set_global_bet_limits_unauthorized() {
+    let setup = BetTestSetup::new();
+    let client = setup.client();
+    setup.env.mock_all_auths();
+    client.set_global_bet_limits(&setup.user, &MIN_BET_AMOUNT, &MAX_BET_AMOUNT);
+}
+
+#[test]
+#[should_panic]
+fn test_set_global_bet_limits_min_above_max_rejects() {
+    let setup = BetTestSetup::new();
+    let client = setup.client();
+    setup.env.mock_all_auths();
+    client.set_global_bet_limits(&setup.admin, &10_000000i128, &5_000000i128);
+}
+
+#[test]
+#[should_panic]
+fn test_set_global_bet_limits_below_absolute_min_rejects() {
+    let setup = BetTestSetup::new();
+    let client = setup.client();
+    setup.env.mock_all_auths();
+    client.set_global_bet_limits(&setup.admin, &(MIN_BET_AMOUNT - 1), &MAX_BET_AMOUNT);
+}
+
+#[test]
+#[should_panic]
+fn test_set_global_bet_limits_above_absolute_max_rejects() {
+    let setup = BetTestSetup::new();
+    let client = setup.client();
+    setup.env.mock_all_auths();
+    client.set_global_bet_limits(&setup.admin, &MIN_BET_AMOUNT, &(MAX_BET_AMOUNT + 1));
+}

contracts/predictify-hybrid/src/bets.rs

@@ -24,16 +24,22 @@ use soroban_sdk::{contracttype, symbol_short, Address, Env, Map, String, Symbol}
 use crate::errors::Error;
 use crate::events::EventEmitter;
 use crate::markets::{MarketStateManager, MarketUtils, MarketValidator};
-use crate::types::{Bet, BetStats, BetStatus, Market, MarketState};
+use crate::types::{Bet, BetLimits, BetStats, BetStatus, Market, MarketState};
+use crate::validation;
 
 // ===== CONSTANTS =====
 
-/// Minimum bet amount (0.1 XLM = 1,000,000 stroops)
+/// Minimum bet amount (0.1 XLM = 1,000,000 stroops). Absolute floor for any configured limit.
 pub const MIN_BET_AMOUNT: i128 = 1_000_000;
 
-/// Maximum bet amount (10,000 XLM = 100,000,000,000 stroops)
+/// Maximum bet amount (10,000 XLM = 100,000,000,000 stroops). Absolute ceiling for any configured limit.
 pub const MAX_BET_AMOUNT: i128 = 100_000_000_000;
 
+/// Storage key for global bet limits.
+const GLOBAL_BET_LIMITS_KEY: &str = "bet_limits_global";
+/// Storage key for per-event bet limits map (Symbol -> BetLimits).
+const PER_EVENT_BET_LIMITS_KEY: &str = "bet_limits_evt";
+
 // ===== STORAGE KEY TYPES =====
 
 /// Storage key for user bets on a specific market
@@ -59,6 +65,65 @@ pub struct BetRegistryKey {
     pub market_id: Symbol,
 }
 
+// ===== BET LIMITS STORAGE =====
+
+/// Get effective bet limits for a market: per-event if set, else global, else default constants.
+pub fn get_effective_bet_limits(env: &Env, market_id: &Symbol) -> BetLimits {
+    let key_evt = Symbol::new(env, PER_EVENT_BET_LIMITS_KEY);
+    let per_event: soroban_sdk::Map<Symbol, BetLimits> = env
+        .storage()
+        .persistent()
+        .get(&key_evt)
+        .unwrap_or(soroban_sdk::Map::new(env));
+    if let Some(limits) = per_event.get(market_id.clone()) {
+        return limits;
+    }
+    let key_global = Symbol::new(env, GLOBAL_BET_LIMITS_KEY);
+    env.storage()
+        .persistent()
+        .get::<Symbol, BetLimits>(&key_global)
+        .unwrap_or(BetLimits {
+            min_bet: MIN_BET_AMOUNT,
+            max_bet: MAX_BET_AMOUNT,
+        })
+}
+
+/// Set global bet limits (admin only; validation of bounds done by caller).
+pub fn set_global_bet_limits(env: &Env, limits: &BetLimits) -> Result<(), Error> {
+    validate_limits_bounds(limits)?;
+    let key = Symbol::new(env, GLOBAL_BET_LIMITS_KEY);
+    env.storage().persistent().set(&key, limits);
+    Ok(())
+}
+
+/// Set per-event bet limits (admin only; validation of bounds done by caller).
+pub fn set_event_bet_limits(env: &Env, market_id: &Symbol, limits: &BetLimits) -> Result<(), Error> {
+    validate_limits_bounds(limits)?;
+    let key = Symbol::new(env, PER_EVENT_BET_LIMITS_KEY);
+    let mut per_event: soroban_sdk::Map<Symbol, BetLimits> = env
+        .storage()
+        .persistent()
+        .get(&key)
+        .unwrap_or(soroban_sdk::Map::new(env));
+    per_event.set(market_id.clone(), limits.clone());
+    env.storage().persistent().set(&key, &per_event);
+    Ok(())
+}
+
+/// Validate that min <= max and both are within absolute bounds.
+fn validate_limits_bounds(limits: &BetLimits) -> Result<(), Error> {
+    if limits.min_bet > limits.max_bet {
+        return Err(Error::InvalidInput);
+    }
+    if limits.min_bet < MIN_BET_AMOUNT {
+        return Err(Error::InsufficientStake);
+    }
+    if limits.max_bet > MAX_BET_AMOUNT {
+        return Err(Error::InvalidInput);
+    }
+    Ok(())
+}
+
 // ===== BET MANAGER =====
 
 /// Comprehensive bet manager for prediction market betting operations.
@@ -181,8 +246,8 @@ impl BetManager {
         let mut market = MarketStateManager::get_market(env, &market_id)?;
         BetValidator::validate_market_for_betting(env, &market)?;
 
-        // Validate bet parameters
-        BetValidator::validate_bet_parameters(env, &outcome, &market.outcomes, amount)?;
+        // Validate bet parameters (uses configurable min/max limits per event or global)
+        BetValidator::validate_bet_parameters(env, &market_id, &outcome, &market.outcomes, amount)?;
 
         // Check if user has already bet on this market
         if Self::has_user_bet(env, &market_id, &user) {
@@ -599,59 +664,37 @@ impl BetValidator {
 
     /// Validate bet parameters.
     ///
-    /// # Validation Rules
-    ///
-    /// - Outcome must be one of the valid market outcomes
-    /// - Amount must be within allowed range
-    ///
-    /// # Parameters
-    ///
-    /// - `env` - The Soroban environment
-    /// - `outcome` - The selected outcome
-    /// - `valid_outcomes` - List of valid outcomes for the market
-    /// - `amount` - The bet amount
-    ///
-    /// # Returns
-    ///
-    /// Returns `Ok(())` if parameters are valid, `Err(Error)` otherwise.
+    /// Uses effective bet limits (per-event if set, else global, else default min/max).
+    /// Rejects bets below min with InsufficientStake, above max with InvalidInput.
     pub fn validate_bet_parameters(
         env: &Env,
+        market_id: &Symbol,
         outcome: &String,
         valid_outcomes: &soroban_sdk::Vec<String>,
         amount: i128,
     ) -> Result<(), Error> {
-        // Validate outcome
         MarketValidator::validate_outcome(env, outcome, valid_outcomes)?;
+        Self::validate_bet_amount_against_limits(env, market_id, amount)
+    }
 
-        // Validate amount
-        Self::validate_bet_amount(amount)?;
-
-        Ok(())
+    /// Validate bet amount against effective limits (per-event or global or defaults).
+    pub fn validate_bet_amount_against_limits(
+        env: &Env,
+        market_id: &Symbol,
+        amount: i128,
+    ) -> Result<(), Error> {
+        let limits = get_effective_bet_limits(env, market_id);
+        validation::validate_bet_amount_against_limits(amount, &limits)
     }
 
-    /// Validate bet amount.
-    ///
-    /// # Validation Rules
-    ///
-    /// - Amount must be greater than or equal to MIN_BET_AMOUNT
-    /// - Amount must be less than or equal to MAX_BET_AMOUNT
-    ///
-    /// # Parameters
-    ///
-    /// - `amount` - The bet amount to validate
-    ///
-    /// # Returns
-    ///
-    /// Returns `Ok(())` if amount is valid, `Err(Error)` otherwise.
+    /// Validate bet amount using default constants (for tests / backward compatibility).
     pub fn validate_bet_amount(amount: i128) -> Result<(), Error> {
         if amount < MIN_BET_AMOUNT {
             return Err(Error::InsufficientStake);
         }
-
         if amount > MAX_BET_AMOUNT {
             return Err(Error::InvalidInput);
         }
-
         Ok(())
     }
 }

contracts/predictify-hybrid/src/events.rs

@@ -695,6 +695,22 @@ pub struct ConfigUpdatedEvent {
     pub timestamp: u64,
 }
 
+/// Event emitted when bet limits are updated (global or per-event).
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct BetLimitsUpdatedEvent {
+    /// Admin who updated the limits
+    pub admin: Address,
+    /// Market ID or "global" for global limits
+    pub scope: Symbol,
+    /// New minimum bet amount
+    pub min_bet: i128,
+    /// New maximum bet amount
+    pub max_bet: i128,
+    /// Update timestamp
+    pub timestamp: u64,
+}
+
 /// Error logged event
 #[contracttype]
 #[derive(Clone, Debug, Eq, PartialEq)]
@@ -1581,6 +1597,24 @@ impl EventEmitter {
         Self::store_event(env, &symbol_short!("cfg_upd"), &event);
     }
 
+    /// Emit bet limits updated event (global or per-event).
+    pub fn emit_bet_limits_updated(
+        env: &Env,
+        admin: &Address,
+        scope: &Symbol,
+        min_bet: i128,
+        max_bet: i128,
+    ) {
+        let event = BetLimitsUpdatedEvent {
+            admin: admin.clone(),
+            scope: scope.clone(),
+            min_bet,
+            max_bet,
+            timestamp: env.ledger().timestamp(),
+        };
+        Self::store_event(env, &symbol_short!("bet_lim"), &event);
+    }
+
     /// Emit error logged event
     pub fn emit_error_logged(
         env: &Env,