Merge pull request #562 from michaelvic123/bug/sweep-idempotency

fix: make unclaimed winnings sweep idempotent

Author: greatest0fallt1me

contracts/predictify-hybrid/src/err.rs

@@ -121,6 +121,8 @@ pub enum Error {
     DisputeFeeFailed = 409,
     /// Generic dispute subsystem error. Check dispute state and configuration.
     DisputeError = 410,
+    /// Unclaimed winnings have already been swept for this market. Repeat sweeps are not allowed.
+    SweepAlreadyDone = 411,
     /// Platform fee has already been collected from this market.
     FeeAlreadyCollected = 413,
     /// No fees are available to collect from this market.

contracts/predictify-hybrid/src/lib.rs

@@ -691,6 +691,7 @@ impl PredictifyHybrid {
             min_pool_size,
             bet_deadline,
             dispute_window_seconds: dispute_window_seconds.unwrap_or(86400),
+            winnings_swept: false,
         };
 
         // Store the market
@@ -1883,6 +1884,11 @@ impl PredictifyHybrid {
             return Err(Error::InvalidState);
         }
 
+        // Idempotency guard: reject a repeat sweep so the treasury is never double-credited.
+        if market.winnings_swept {
+            return Err(Error::SweepAlreadyDone);
+        }
+
         let fee_percent = crate::config::ConfigManager::get_config(&env)
             .map(|cfg| cfg.fees.platform_fee_percentage)
             .unwrap_or_else(|_| {
@@ -2024,6 +2030,8 @@ impl PredictifyHybrid {
             Some(treasury)
         };
 
+        // Mark this market as swept so a second call returns SweepAlreadyDone.
+        market.winnings_swept = true;
         env.storage().persistent().set(&market_id, &market);
         EventEmitter::emit_unclaimed_winnings_swept(
             &env,

contracts/predictify-hybrid/src/monitoring.rs

@@ -601,6 +601,7 @@ impl ContractMonitor {
             min_pool_size: None,
             bet_deadline: 0,
             dispute_window_seconds: 86400,
+            winnings_swept: false,
         })
     }
 

contracts/predictify-hybrid/src/storage_layout_tests.rs

@@ -82,6 +82,7 @@ fn create_test_market(env: &Env, admin: &Address) -> (Symbol, Market) {
         min_pool_size: None,
         bet_deadline: 0,
         dispute_window_seconds: 0,
+        winnings_swept: false,
     };
 
     (market_id, market)

contracts/predictify-hybrid/src/types.rs

@@ -1089,6 +1089,9 @@ pub struct Market {
     pub bet_deadline: u64,
     /// Dispute window in seconds after end_time. Payouts allowed only after end_time + this period (or dispute resolved).
     pub dispute_window_seconds: u64,
+    /// Whether unclaimed winnings have already been swept for this market.
+    /// Set to true after the first successful sweep to prevent double-crediting the treasury.
+    pub winnings_swept: bool,
 }
 
 // ===== CLAIM INFO =====
@@ -1452,6 +1455,7 @@ impl Market {
             min_pool_size: None,
             bet_deadline: 0,
             dispute_window_seconds: 86400, // 24h default
+            winnings_swept: false,
         }
     }
 

contracts/predictify-hybrid/src/unclaimed_winnings_timeout_tests.rs

@@ -294,3 +294,116 @@ fn test_delayed_resolution_has_fresh_claim_window() {
         .client()
         .sweep_unclaimed_winnings(&setup.admin, &setup.market_id, &true);
 }
+
+#[test]
+#[should_panic(expected = "Error(Contract, #411)")]
+fn test_double_sweep_rejected() {
+    // A second sweep on the same market must return SweepAlreadyDone (411).
+    let setup = TimeoutSweepSetup::new();
+
+    setup
+        .client()
+        .set_global_claim_period(&setup.admin, &100u64);
+    setup.client().set_treasury(&setup.admin, &setup.treasury);
+
+    setup.set_time(setup.end_time + 100);
+
+    // First sweep succeeds.
+    let first = setup
+        .client()
+        .sweep_unclaimed_winnings(&setup.admin, &setup.market_id, &false);
+    assert!(first > 0);
+
+    // Second sweep must panic with #411.
+    setup
+        .client()
+        .sweep_unclaimed_winnings(&setup.admin, &setup.market_id, &false);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #411)")]
+fn test_double_sweep_burn_rejected() {
+    // Same guard applies when burn=true.
+    let setup = TimeoutSweepSetup::new();
+
+    setup
+        .client()
+        .set_global_claim_period(&setup.admin, &100u64);
+
+    setup.set_time(setup.end_time + 100);
+
+    setup
+        .client()
+        .sweep_unclaimed_winnings(&setup.admin, &setup.market_id, &true);
+
+    // Second call must panic.
+    setup
+        .client()
+        .sweep_unclaimed_winnings(&setup.admin, &setup.market_id, &true);
+}
+
+#[test]
+fn test_claim_then_sweep_excludes_claimed_user() {
+    // winner_1 claims before the sweep; the swept amount must not include their payout,
+    // and the treasury must only receive the unclaimed portion.
+    let setup = TimeoutSweepSetup::new();
+
+    setup
+        .client()
+        .set_global_claim_period(&setup.admin, &100u64);
+    setup.client().set_treasury(&setup.admin, &setup.treasury);
+
+    // winner_1 claims while the window is still open.
+    setup.set_time(setup.end_time + 50);
+    setup
+        .client()
+        .claim_winnings(&setup.winner_1, &setup.market_id);
+
+    // Advance past the claim period.
+    setup.set_time(setup.end_time + 100);
+    let swept = setup
+        .client()
+        .sweep_unclaimed_winnings(&setup.admin, &setup.market_id, &false);
+
+    // Only winner_2's share should be swept (winner_1 already claimed).
+    let treasury_balance = setup
+        .client()
+        .get_balance(&setup.treasury, &ReflectorAsset::Stellar)
+        .amount;
+    assert_eq!(treasury_balance, swept);
+
+    // Verify winner_1 is still marked claimed (their own claim, not the sweep).
+    let market = setup.client().get_market(&setup.market_id).unwrap();
+    assert!(market
+        .claimed
+        .get(setup.winner_1.clone())
+        .map(|i| i.is_claimed())
+        .unwrap_or(false));
+    assert!(market
+        .claimed
+        .get(setup.winner_2.clone())
+        .map(|i| i.is_claimed())
+        .unwrap_or(false));
+
+    // The swept flag must be set.
+    assert!(market.winnings_swept);
+}
+
+#[test]
+fn test_sweep_sets_winnings_swept_flag() {
+    // After a successful sweep the market's winnings_swept field must be true.
+    let setup = TimeoutSweepSetup::new();
+
+    setup
+        .client()
+        .set_global_claim_period(&setup.admin, &100u64);
+    setup.client().set_treasury(&setup.admin, &setup.treasury);
+    setup.set_time(setup.end_time + 100);
+
+    setup
+        .client()
+        .sweep_unclaimed_winnings(&setup.admin, &setup.market_id, &false);
+
+    let market = setup.client().get_market(&setup.market_id).unwrap();
+    assert!(market.winnings_swept);
+}