Merge pull request #168 from KingDavid9999/fix-issue---#109

feat: add get_contributor_count function to contract (#109)

Author: ritik4ever

contracts/src/lib.rs

@@ -20,6 +20,7 @@ pub struct Campaign {
     pub claimed: bool,
     pub canceled: bool,
     pub metadata: String,
+    pub contributor_count: u32,
 }
 
 #[contracttype]
@@ -115,6 +116,7 @@ impl StellarGoalVaultContract {
             claimed: false,
             canceled: false,
             metadata: metadata.clone(),
+            contributor_count: 0,
         };
 
         env.storage()
@@ -165,12 +167,18 @@ impl StellarGoalVaultContract {
         token_client.transfer(&contributor, &contract_address, &amount);
 
         campaign.pledged_amount += amount;
-        env.storage()
-            .persistent()
-            .set(&DataKey::Campaign(campaign_id), &campaign);
 
         let key = DataKey::Contribution(campaign_id, contributor.clone());
         let current_contribution: i128 = env.storage().persistent().get(&key).unwrap_or(0);
+
+        // Only increment contributor_count on first-time pledge
+        if current_contribution == 0 {
+            campaign.contributor_count += 1;
+        }
+
+        env.storage()
+            .persistent()
+            .set(&DataKey::Campaign(campaign_id), &campaign);
         env.storage()
             .persistent()
             .set(&key, &(current_contribution + amount));
@@ -276,6 +284,10 @@ impl StellarGoalVaultContract {
             .unwrap_or(0)
     }
 
+    pub fn get_contributor_count(env: Env, campaign_id: u64) -> u32 {
+        read_campaign(&env, campaign_id).contributor_count
+    }
+
     pub fn get_next_campaign_id(env: Env) -> u64 {
         env.storage()
             .persistent()
@@ -314,4 +326,4 @@ fn read_campaign(env: &Env, campaign_id: u64) -> Campaign {
 }
 
 #[cfg(test)]
-mod test;
+mod test;

contracts/src/test.rs

@@ -1 +1,337 @@
+fix-issue---#109
+#[cfg(test)]
+mod tests {
+    use soroban_sdk::{
+        testutils::{Address as _, Ledger},
+        token::StellarAssetClient,
+        Address, Env, String,
+    };
 
+    use crate::{StellarGoalVaultContract, StellarGoalVaultContractClient};
+
+    fn deploy_contract(env: &Env) -> StellarGoalVaultContractClient<'_> {
+        let contract_id = env.register_contract(None, StellarGoalVaultContract);
+        StellarGoalVaultContractClient::new(env, &contract_id)
+    }
+
+    fn deploy_token(env: &Env, admin: &Address, recipient: &Address, amount: i128) -> Address {
+        let token_id = env.register_stellar_asset_contract(admin.clone());
+        let asset_client = StellarAssetClient::new(env, &token_id);
+        asset_client.mint(recipient, &amount);
+        token_id
+    }
+
+    fn advance_time(env: &Env, seconds: u64) {
+        env.ledger().with_mut(|info| {
+            info.timestamp += seconds;
+        });
+    }
+
+
+    #[test]
+    fn test_claim_success() {
+        let env = Env::default();
+        env.mock_all_auths();
+
+        let creator = Address::generate(&env);
+        let contributor = Address::generate(&env);
+        let admin = Address::generate(&env);
+
+        let target: i128 = 1_000;
+        let deadline_offset: u64 = 100;
+        let now = env.ledger().timestamp();
+        let deadline = now + deadline_offset;
+
+        let token = deploy_token(&env, &admin, &contributor, target);
+        let client = deploy_contract(&env);
+
+        let campaign_id = client.create_campaign(
+            &creator,
+            &token,
+            &target,
+            &deadline,
+            &String::from_str(&env, "test campaign"),
+        );
+
+        client.contribute(&campaign_id, &contributor, &target);
+        advance_time(&env, deadline_offset + 1);
+        client.claim(&campaign_id, &creator);
+
+        let campaign = client.get_campaign(&campaign_id);
+        assert!(campaign.claimed, "campaign should be marked claimed");
+        assert_eq!(campaign.pledged_amount, target);
+    }
+
+    #[test]
+    #[should_panic(expected = "creator mismatch")]
+    fn test_claim_creator_mismatch() {
+        let env = Env::default();
+        env.mock_all_auths();
+
+        let creator = Address::generate(&env);
+        let attacker = Address::generate(&env);
+        let contributor = Address::generate(&env);
+        let admin = Address::generate(&env);
+
+        let target: i128 = 500;
+        let deadline_offset: u64 = 50;
+        let deadline = env.ledger().timestamp() + deadline_offset;
+
+        let token = deploy_token(&env, &admin, &contributor, target);
+        let client = deploy_contract(&env);
+
+        let campaign_id = client.create_campaign(
+            &creator,
+            &token,
+            &target,
+            &deadline,
+            &String::from_str(&env, "mismatch test"),
+        );
+
+        client.contribute(&campaign_id, &contributor, &target);
+        advance_time(&env, deadline_offset + 1);
+        client.claim(&campaign_id, &attacker);
+    }
+
+    #[test]
+    #[should_panic(expected = "campaign is still active")]
+    fn test_claim_before_deadline() {
+        let env = Env::default();
+        env.mock_all_auths();
+
+        let creator = Address::generate(&env);
+        let contributor = Address::generate(&env);
+        let admin = Address::generate(&env);
+
+        let target: i128 = 500;
+        let deadline = env.ledger().timestamp() + 1_000;
+
+        let token = deploy_token(&env, &admin, &contributor, target);
+        let client = deploy_contract(&env);
+
+        let campaign_id = client.create_campaign(
+            &creator,
+            &token,
+            &target,
+            &deadline,
+            &String::from_str(&env, "early claim test"),
+        );
+
+        client.contribute(&campaign_id, &contributor, &target);
+        client.claim(&campaign_id, &creator);
+    }
+
+    #[test]
+    #[should_panic(expected = "campaign is not funded")]
+    fn test_claim_underfunded() {
+        let env = Env::default();
+        env.mock_all_auths();
+
+        let creator = Address::generate(&env);
+        let contributor = Address::generate(&env);
+        let admin = Address::generate(&env);
+
+        let target: i128 = 1_000;
+        let deadline_offset: u64 = 50;
+        let deadline = env.ledger().timestamp() + deadline_offset;
+
+        let token = deploy_token(&env, &admin, &contributor, target / 2);
+        let client = deploy_contract(&env);
+
+        let campaign_id = client.create_campaign(
+            &creator,
+            &token,
+            &target,
+            &deadline,
+            &String::from_str(&env, "underfunded test"),
+        );
+
+        client.contribute(&campaign_id, &contributor, &(target / 2));
+        advance_time(&env, deadline_offset + 1);
+        client.claim(&campaign_id, &creator);
+    }
+
+    #[test]
+    #[should_panic(expected = "campaign already claimed")]
+    fn test_claim_double_claim() {
+        let env = Env::default();
+        env.mock_all_auths();
+
+        let creator = Address::generate(&env);
+        let contributor = Address::generate(&env);
+        let admin = Address::generate(&env);
+
+        let target: i128 = 200;
+        let deadline_offset: u64 = 50;
+        let deadline = env.ledger().timestamp() + deadline_offset;
+
+        let token = deploy_token(&env, &admin, &contributor, target);
+        let client = deploy_contract(&env);
+
+        let campaign_id = client.create_campaign(
+            &creator,
+            &token,
+            &target,
+            &deadline,
+            &String::from_str(&env, "double claim test"),
+        );
+
+        client.contribute(&campaign_id, &contributor, &target);
+        advance_time(&env, deadline_offset + 1);
+        client.claim(&campaign_id, &creator);
+        client.claim(&campaign_id, &creator);
+    }
+
+    #[test]
+    fn test_get_campaign_count_tracks_creates() {
+        let env = Env::default();
+        env.mock_all_auths();
+
+        let creator = Address::generate(&env);
+        let admin = Address::generate(&env);
+        let token = deploy_token(&env, &admin, &creator, 10_000);
+        let client = deploy_contract(&env);
+
+        assert_eq!(client.get_campaign_count(), 0);
+        assert_eq!(client.get_next_campaign_id(), 0);
+
+        let deadline = env.ledger().timestamp() + 1_000;
+        let meta = |s: &str| String::from_str(&env, s);
+
+        client.create_campaign(
+            &creator,
+            &token,
+            &100_i128,
+            &deadline,
+            &meta("c1"),
+        );
+        assert_eq!(client.get_campaign_count(), 1);
+        assert_eq!(client.get_next_campaign_id(), 1);
+
+        client.create_campaign(
+            &creator,
+            &token,
+            &200_i128,
+            &deadline,
+            &meta("c2"),
+        );
+        client.create_campaign(
+            &creator,
+            &token,
+            &300_i128,
+            &deadline,
+            &meta("c3"),
+        );
+
+    #[test]
+    fn test_contributor_count_zero_on_new_campaign() {
+        let env = Env::default();
+        env.mock_all_auths();
+
+        let creator = Address::generate(&env);
+        let admin = Address::generate(&env);
+        let token = deploy_token(&env, &admin, &creator, 1_000);
+        let client = deploy_contract(&env);
+
+        let campaign_id = client.create_campaign(
+            &creator,
+            &token,
+            &500_i128,
+            &(env.ledger().timestamp() + 1_000),
+            &String::from_str(&env, "count zero test"),
+        );
+
+        assert_eq!(client.get_contributor_count(&campaign_id), 0);
+    }
+
+    #[test]
+    fn test_contributor_count_single_contributor() {
+        let env = Env::default();
+        env.mock_all_auths();
+
+        let creator = Address::generate(&env);
+        let contributor = Address::generate(&env);
+        let admin = Address::generate(&env);
+
+        let token = deploy_token(&env, &admin, &contributor, 1_000);
+        let client = deploy_contract(&env);
+
+        let campaign_id = client.create_campaign(
+            &creator,
+            &token,
+            &1_000_i128,
+            &(env.ledger().timestamp() + 1_000),
+            &String::from_str(&env, "single contributor test"),
+        );
+
+        client.contribute(&campaign_id, &contributor, &500);
+        assert_eq!(client.get_contributor_count(&campaign_id), 1);
+    }
+
+    #[test]
+    fn test_contributor_count_multiple_unique_contributors() {
+        let env = Env::default();
+        env.mock_all_auths();
+
+        let creator = Address::generate(&env);
+        let contributor1 = Address::generate(&env);
+        let contributor2 = Address::generate(&env);
+        let contributor3 = Address::generate(&env);
+        let admin = Address::generate(&env);
+
+        // Mint tokens to each contributor separately
+        let token_id = env.register_stellar_asset_contract(admin.clone());
+        let asset_client = StellarAssetClient::new(&env, &token_id);
+        asset_client.mint(&contributor1, &200);
+        asset_client.mint(&contributor2, &200);
+        asset_client.mint(&contributor3, &200);
+
+        let client = deploy_contract(&env);
+
+        let campaign_id = client.create_campaign(
+            &creator,
+            &token_id,
+            &600_i128,
+            &(env.ledger().timestamp() + 1_000),
+            &String::from_str(&env, "multi contributor test"),
+        );
+
+        client.contribute(&campaign_id, &contributor1, &200);
+        assert_eq!(client.get_contributor_count(&campaign_id), 1);
+
+        client.contribute(&campaign_id, &contributor2, &200);
+        assert_eq!(client.get_contributor_count(&campaign_id), 2);
+
+        client.contribute(&campaign_id, &contributor3, &200);
+        assert_eq!(client.get_contributor_count(&campaign_id), 3);
+    }
+
+    #[test]
+    fn test_contributor_count_no_double_count_on_repeat_pledge() {
+        let env = Env::default();
+        env.mock_all_auths();
+
+        let creator = Address::generate(&env);
+        let contributor = Address::generate(&env);
+        let admin = Address::generate(&env);
+
+        let token = deploy_token(&env, &admin, &contributor, 1_000);
+        let client = deploy_contract(&env);
+
+        let campaign_id = client.create_campaign(
+            &creator,
+            &token,
+            &1_000_i128,
+            &(env.ledger().timestamp() + 1_000),
+            &String::from_str(&env, "repeat pledge test"),
+        );
+
+        // Same contributor pledges twice — count must stay at 1
+        client.contribute(&campaign_id, &contributor, &400);
+        assert_eq!(client.get_contributor_count(&campaign_id), 1);
+
+        client.contribute(&campaign_id, &contributor, &300);
+        assert_eq!(client.get_contributor_count(&campaign_id), 1);
+    }
+}
+main