Merge pull request #9 from boundlessfi/fix/vote-rejection-handling

fix: Handle community vote rejection and expiry in check_vote_threshold

Author: 0xdevcollins

contracts/crowdfund_registry/src/contract.rs

@@ -2,12 +2,12 @@ use crate::error::CrowdfundError;
 use crate::events::{
     CampaignApproved, CampaignCancelled, CampaignCreated, CampaignFailed, CampaignFunded,
     CampaignRejected, CampaignSubmittedForReview, CampaignTerminated, CampaignValidated,
-    DisputeResolved, MilestoneApproved, MilestoneDisputed, MilestoneOverdue,
+    CampaignVoteRejected, DisputeResolved, MilestoneApproved, MilestoneDisputed, MilestoneOverdue,
     MilestoneRevisionRequested, MilestoneSubmitted, PledgeRecorded, RefundBatchProcessed,
 };
 use crate::storage::{
     Campaign, CampaignStatus, CrowdfundDataKey, CrowdfundMilestoneStatus, DisputeResolution,
-    Milestone, VoteContext,
+    Milestone, VoteContext, VoteOption, VotingSession,
 };
 use boundless_types::ttl::{
     INSTANCE_TTL_EXTEND, INSTANCE_TTL_THRESHOLD, PERSISTENT_TTL_EXTEND, PERSISTENT_TTL_THRESHOLD,
@@ -387,7 +387,11 @@ impl CrowdfundRegistry {
         campaign.vote_session_id = None;
         env.storage().persistent().set(&key, &campaign);
 
-        CampaignRejected { id: campaign_id, reason }.publish(&env);
+        CampaignRejected {
+            id: campaign_id,
+            reason,
+        }
+        .publish(&env);
         Ok(())
     }
 
@@ -441,17 +445,76 @@ impl CrowdfundRegistry {
             .ok_or(CrowdfundError::NoVoteSession)?;
 
         let gov_addr = Self::get_gov_addr(&env);
-        let args: Vec<Val> = Vec::from_array(&env, [session_id.into_val(&env)]);
-        let reached: bool = env.invoke_contract(&gov_addr, &sym(&env, "threshold_reached"), args);
 
-        if !reached {
-            return Err(CrowdfundError::VoteThresholdNotMet);
-        }
+        // Check if vote threshold has been reached
+        let threshold_args: Vec<Val> = Vec::from_array(&env, [session_id.clone().into_val(&env)]);
+        let reached: bool =
+            env.invoke_contract(&gov_addr, &sym(&env, "threshold_reached"), threshold_args);
 
-        campaign.status = CampaignStatus::Campaigning;
-        env.storage().persistent().set(&key, &campaign);
+        if reached {
+            // Threshold reached — check which option won
+            let approve_args: Vec<Val> = Vec::from_array(
+                &env,
+                [
+                    session_id.clone().into_val(&env),
+                    0u32.into_val(&env), // option 0 = Approve
+                ],
+            );
+            let reject_args: Vec<Val> = Vec::from_array(
+                &env,
+                [
+                    session_id.into_val(&env),
+                    1u32.into_val(&env), // option 1 = Reject
+                ],
+            );
+
+            let approve_option: VoteOption =
+                env.invoke_contract(&gov_addr, &sym(&env, "get_option"), approve_args);
+            let reject_option: VoteOption =
+                env.invoke_contract(&gov_addr, &sym(&env, "get_option"), reject_args);
+
+            let approve_votes = approve_option.votes;
+            let reject_votes = reject_option.votes;
+
+            if approve_votes > reject_votes {
+                campaign.status = CampaignStatus::Campaigning;
+                env.storage().persistent().set(&key, &campaign);
+                CampaignValidated { id: campaign_id }.publish(&env);
+            } else if reject_votes > approve_votes {
+                campaign.status = CampaignStatus::Draft;
+                campaign.vote_session_id = None;
+                env.storage().persistent().set(&key, &campaign);
+                CampaignVoteRejected {
+                    id: campaign_id,
+                    reason: String::from_str(&env, "reject_majority"),
+                }
+                .publish(&env);
+            } else {
+                // Tie — leave state unchanged, session stays open
+                return Err(CrowdfundError::VoteThresholdNotMet);
+            }
+        } else {
+            // Threshold not reached — check if voting period has expired
+            let session_args: Vec<Val> = Vec::from_array(&env, [session_id.into_val(&env)]);
+            let session: VotingSession =
+                env.invoke_contract(&gov_addr, &sym(&env, "get_session"), session_args);
+
+            if env.ledger().timestamp() <= session.end_at {
+                // Voting still open, threshold not met yet
+                return Err(CrowdfundError::VoteThresholdNotMet);
+            }
+
+            // Voting expired without reaching threshold — reject
+            campaign.status = CampaignStatus::Draft;
+            campaign.vote_session_id = None;
+            env.storage().persistent().set(&key, &campaign);
+            CampaignVoteRejected {
+                id: campaign_id,
+                reason: String::from_str(&env, "expired_without_approval"),
+            }
+            .publish(&env);
+        }
 
-        CampaignValidated { id: campaign_id }.publish(&env);
         Ok(())
     }
 
@@ -961,11 +1024,7 @@ impl CrowdfundRegistry {
                         milestone_index.into_val(&env),
                     ],
                 );
-                env.invoke_contract::<()>(
-                    &escrow_addr,
-                    &sym(&env, "release_slot"),
-                    release_args,
-                );
+                env.invoke_contract::<()>(&escrow_addr, &sym(&env, "release_slot"), release_args);
 
                 // Check if all milestones are released
                 let mut all_done = true;
@@ -1173,12 +1232,10 @@ impl CrowdfundRegistry {
                 pct,
                 status: CrowdfundMilestoneStatus::Pending,
             };
-            env.storage()
-                .persistent()
-                .set(
-                    &CrowdfundDataKey::CampaignMilestone(campaign_id, i),
-                    &milestone,
-                );
+            env.storage().persistent().set(
+                &CrowdfundDataKey::CampaignMilestone(campaign_id, i),
+                &milestone,
+            );
         }
     }
 }

contracts/crowdfund_registry/src/events/mod.rs

@@ -136,6 +136,14 @@ pub struct MilestoneRevisionRequested {
     pub milestone_id: u32,
 }
 
+#[contractevent]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct CampaignVoteRejected {
+    #[topic]
+    pub id: u64,
+    pub reason: String,
+}
+
 #[contractevent]
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct DisputeResolved {

contracts/crowdfund_registry/src/storage/mod.rs

@@ -1,6 +1,6 @@
 use soroban_sdk::{contracttype, Address, BytesN, String};
 
-// Local copy of governance_voting VoteContext for cross-contract serialization.
+// Local copies of governance_voting types for cross-contract serialization.
 #[contracttype]
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
 pub enum VoteContext {
@@ -10,6 +10,41 @@ pub enum VoteContext {
     HackathonJudging,
 }
 
+#[contracttype]
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum VoteStatus {
+    Pending,
+    Active,
+    Concluded,
+    Cancelled,
+}
+
+#[contracttype]
+#[derive(Clone, Debug)]
+pub struct VoteOption {
+    pub id: u32,
+    pub label: String,
+    pub votes: u32,
+    pub weighted_votes: u64,
+}
+
+#[contracttype]
+#[derive(Clone, Debug)]
+pub struct VotingSession {
+    pub session_id: BytesN<32>,
+    pub context: VoteContext,
+    pub module_id: u64,
+    pub created_at: u64,
+    pub start_at: u64,
+    pub end_at: u64,
+    pub status: VoteStatus,
+    pub threshold: Option<u32>,
+    pub threshold_reached: bool,
+    pub total_votes: u32,
+    pub quorum: Option<u32>,
+    pub weight_by_reputation: bool,
+}
+
 #[contracttype]
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
 pub enum CampaignStatus {

contracts/crowdfund_registry/src/tests/mod.rs

@@ -182,7 +182,8 @@ fn test_reject_campaign() {
     );
 
     t.client.submit_for_review(&cid);
-    t.client.reject_campaign(&cid, &String::from_str(&t.env, "Need more detail"));
+    t.client
+        .reject_campaign(&cid, &String::from_str(&t.env, "Need more detail"));
     assert_eq!(t.client.get_campaign(&cid).status, CampaignStatus::Draft);
 }
 
@@ -202,7 +203,10 @@ fn test_create_and_submit_campaign() {
         &true,
     );
 
-    assert_eq!(t.client.get_campaign(&cid).status, CampaignStatus::Submitted);
+    assert_eq!(
+        t.client.get_campaign(&cid).status,
+        CampaignStatus::Submitted
+    );
 }
 
 #[test]
@@ -580,3 +584,112 @@ fn test_resolve_dispute_not_disputed_fails() {
         .try_resolve_dispute(&cid, &0, &DisputeResolution::ApproveCreator);
     assert!(result.is_err());
 }
+
+#[test]
+fn test_vote_reject_returns_to_draft() {
+    let t = setup();
+    let owner = t.admin.clone();
+
+    let cid = t.client.create_campaign(
+        &owner,
+        &String::from_str(&t.env, "Vote reject"),
+        &10000i128,
+        &t.token_addr,
+        &(t.env.ledger().timestamp() + 86400),
+        &make_milestones(&t.env),
+        &100i128,
+        &false,
+    );
+
+    t.client.submit_for_review(&cid);
+
+    // Admin approves → creates vote session (threshold=1)
+    t.client.approve_campaign(&cid, &1000, &1);
+    assert_eq!(
+        t.client.get_campaign(&cid).status,
+        CampaignStatus::Submitted
+    );
+
+    // Voter votes "Reject" (option 1)
+    let voter = Address::generate(&t.env);
+    t.client.vote_campaign(&voter, &cid, &1);
+
+    // Check threshold → should reject back to Draft
+    t.client.check_vote_threshold(&cid);
+
+    let campaign = t.client.get_campaign(&cid);
+    assert_eq!(campaign.status, CampaignStatus::Draft);
+    assert!(campaign.vote_session_id.is_none());
+}
+
+#[test]
+fn test_vote_expired_without_quorum_returns_to_draft() {
+    let t = setup();
+    let owner = t.admin.clone();
+
+    let cid = t.client.create_campaign(
+        &owner,
+        &String::from_str(&t.env, "Vote expire"),
+        &10000i128,
+        &t.token_addr,
+        &(t.env.ledger().timestamp() + 86400),
+        &make_milestones(&t.env),
+        &100i128,
+        &false,
+    );
+
+    t.client.submit_for_review(&cid);
+
+    // Admin approves → creates vote session (threshold=5, duration=1000)
+    t.client.approve_campaign(&cid, &1000, &5);
+    assert_eq!(
+        t.client.get_campaign(&cid).status,
+        CampaignStatus::Submitted
+    );
+
+    // Only 1 vote cast (threshold is 5), so threshold not reached
+    let voter = Address::generate(&t.env);
+    t.client.vote_campaign(&voter, &cid, &0);
+
+    // Advance past voting deadline
+    t.env.ledger().with_mut(|l| {
+        l.timestamp += 1001;
+    });
+
+    // Check threshold → voting expired, should reject back to Draft
+    t.client.check_vote_threshold(&cid);
+
+    let campaign = t.client.get_campaign(&cid);
+    assert_eq!(campaign.status, CampaignStatus::Draft);
+    assert!(campaign.vote_session_id.is_none());
+}
+
+#[test]
+fn test_vote_threshold_not_met_while_active() {
+    let t = setup();
+    let owner = t.admin.clone();
+
+    let cid = t.client.create_campaign(
+        &owner,
+        &String::from_str(&t.env, "Still voting"),
+        &10000i128,
+        &t.token_addr,
+        &(t.env.ledger().timestamp() + 86400),
+        &make_milestones(&t.env),
+        &100i128,
+        &false,
+    );
+
+    t.client.submit_for_review(&cid);
+    t.client.approve_campaign(&cid, &1000, &5);
+
+    // No votes yet, voting still active → should error
+    let result = t.client.try_check_vote_threshold(&cid);
+    assert!(result.is_err());
+
+    // Campaign stays in Submitted
+    assert_eq!(
+        t.client.get_campaign(&cid).status,
+        CampaignStatus::Submitted
+    );
+}