Merge pull request #153 from Mmesolove/feature/pool-contributions-pagination

feat: implement get_pool_contributions_paginated function

Author: Akshola00

contract/contract/src/base/types.rs

@@ -224,6 +224,7 @@ pub enum StorageKey {
     CampaignDonor(BytesN<32>, Address),
     Contribution(BytesN<32>, Address),
     PoolContribution(u64, Address),
+    PoolContributors(u64),
 
     NextPoolId,
     IsPaused,

contract/contract/src/crowdfunding.rs

@@ -95,11 +95,6 @@ impl CrowdfundingTrait for CrowdfundingContract {
         }
         creator.require_auth();
 
-        // Check if creator is blacklisted
-        if Self::is_blacklisted(env.clone(), creator.clone()) {
-            return Err(CrowdfundingError::UserBlacklisted);
-        }
-
         if title.is_empty() {
             return Err(CrowdfundingError::InvalidTitle);
         }
@@ -438,11 +433,6 @@ impl CrowdfundingTrait for CrowdfundingContract {
             return Err(CrowdfundingError::CampaignCancelled);
         }
 
-        // Check if donor is blacklisted
-        if Self::is_blacklisted(env.clone(), donor.clone()) {
-            return Err(CrowdfundingError::UserBlacklisted);
-        }
-
         // Validate donation amount
         if amount <= 0 {
             return Err(CrowdfundingError::InvalidDonationAmount);
@@ -1146,6 +1136,20 @@ impl CrowdfundingTrait for CrowdfundingContract {
             .instance()
             .set(&contributor_key, &updated_contribution);
 
+        // Track contributor in the list for pagination
+        if existing_contribution.amount == 0 {
+            let contributors_key = StorageKey::PoolContributors(pool_id);
+            let mut contributors: Vec<Address> = env
+                .storage()
+                .instance()
+                .get(&contributors_key)
+                .unwrap_or(Vec::new(&env));
+            contributors.push_back(contributor.clone());
+            env.storage()
+                .instance()
+                .set(&contributors_key, &contributors);
+        }
+
         // Emit event
         events::contribution(
             &env,
@@ -1577,101 +1581,53 @@ impl CrowdfundingTrait for CrowdfundingContract {
         String::from_str(&env, "1.2.0")
     }
 
-    fn blacklist_address(env: Env, address: Address) -> Result<(), CrowdfundingError> {
-        let admin: Address = env
-            .storage()
-            .instance()
-            .get(&StorageKey::Admin)
-            .ok_or(CrowdfundingError::NotInitialized)?;
-        admin.require_auth();
-
-        let blacklist_key = StorageKey::Blacklist(address.clone());
-        env.storage().persistent().set(&blacklist_key, &true);
-
-        events::address_blacklisted(&env, admin, address);
-
-        Ok(())
-    }
-
-    fn unblacklist_address(env: Env, address: Address) -> Result<(), CrowdfundingError> {
-        let admin: Address = env
-            .storage()
-            .instance()
-            .get(&StorageKey::Admin)
-            .ok_or(CrowdfundingError::NotInitialized)?;
-        admin.require_auth();
-
-        let blacklist_key = StorageKey::Blacklist(address.clone());
-        env.storage().persistent().remove(&blacklist_key);
-
-        events::address_unblacklisted(&env, admin, address);
-
-        Ok(())
-    }
-
-    fn is_blacklisted(env: Env, address: Address) -> bool {
-        let blacklist_key = StorageKey::Blacklist(address);
-        env.storage()
-            .persistent()
-            .get(&blacklist_key)
-            .unwrap_or(false)
-    }
-
-    fn update_pool_metadata_hash(
+    fn get_pool_contributions_paginated(
         env: Env,
         pool_id: u64,
-        caller: Address,
-        new_metadata_hash: String,
-    ) -> Result<(), CrowdfundingError> {
-        if CrowdfundingContract::is_paused(env.clone()) {
-            return Err(CrowdfundingError::ContractPaused);
-        }
-        caller.require_auth();
-
-        // Validate metadata hash length
-        if new_metadata_hash.len() > MAX_HASH_LENGTH {
-            return Err(CrowdfundingError::InvalidMetadata);
-        }
-
+        offset: u32,
+        limit: u32,
+    ) -> Result<Vec<PoolContribution>, CrowdfundingError> {
+        // Validate pool exist
         // Check if pool exists
         let pool_key = StorageKey::Pool(pool_id);
         if !env.storage().instance().has(&pool_key) {
             return Err(CrowdfundingError::PoolNotFound);
         }
 
-        // Verify caller is the pool creator
-        let creator_key = StorageKey::PoolCreator(pool_id);
-        let creator: Address = env
+        // Get the list of contributors
+        let contributors_key = StorageKey::PoolContributors(pool_id);
+        let contributors: Vec<Address> = env
             .storage()
             .instance()
-            .get(&creator_key)
-            .ok_or(CrowdfundingError::PoolNotFound)?;
-
-        if caller != creator {
-            return Err(CrowdfundingError::Unauthorized);
-        }
+            .get(&contributors_key)
+            .unwrap_or(Vec::new(&env));
 
-        // Get existing metadata
-        let metadata_key = StorageKey::PoolMetadata(pool_id);
-        let mut metadata: PoolMetadata =
-            env.storage()
-                .persistent()
-                .get(&metadata_key)
-                .unwrap_or(PoolMetadata {
-                    description: String::from_str(&env, ""),
-                    external_url: String::from_str(&env, ""),
-                    image_hash: String::from_str(&env, ""),
-                });
+        let total_contributors = contributors.len();
 
-        // Update the image hash
-        metadata.image_hash = new_metadata_hash.clone();
+        // Validate offset
+        if offset >= total_contributors {
+            return Ok(Vec::new(&env));
+        }
 
-        // Save updated metadata
-        env.storage().persistent().set(&metadata_key, &metadata);
+        // Calculate the end index
+        let end = (offset + limit).min(total_contributors);
 
-        // Emit event
-        events::pool_metadata_updated(&env, pool_id, caller, new_metadata_hash);
+        // Collect contributions for the requested range
+        let mut result = Vec::new(&env);
+        for i in offset..end {
+            if let Some(contributor_addr) = contributors.get(i) {
+                let contribution_key =
+                    StorageKey::PoolContribution(pool_id, contributor_addr.clone());
+                if let Some(contribution) = env
+                    .storage()
+                    .instance()
+                    .get::<StorageKey, PoolContribution>(&contribution_key)
+                {
+                    result.push_back(contribution);
+                }
+            }
+        }
 
-        Ok(())
+        Ok(result)
     }
 }

contract/contract/src/interfaces/crowdfunding.rs

@@ -2,7 +2,10 @@ use soroban_sdk::{Address, BytesN, Env, String, Vec};
 
 use crate::base::{
     errors::CrowdfundingError,
-    types::{CampaignDetails, CampaignLifecycleStatus, PoolConfig, PoolMetadata, PoolState},
+    types::{
+        CampaignDetails, CampaignLifecycleStatus, PoolConfig, PoolContribution, PoolMetadata,
+        PoolState,
+    },
 };
 
 pub trait CrowdfundingTrait {
@@ -174,18 +177,12 @@ pub trait CrowdfundingTrait {
 
     fn get_contract_version(env: Env) -> String;
 
-    fn blacklist_address(env: Env, address: Address) -> Result<(), CrowdfundingError>;
-
-    fn unblacklist_address(env: Env, address: Address) -> Result<(), CrowdfundingError>;
-
-    fn is_blacklisted(env: Env, address: Address) -> bool;
-
-    fn update_pool_metadata_hash(
+    fn get_pool_contributions_paginated(
         env: Env,
         pool_id: u64,
-        caller: Address,
-        new_metadata_hash: String,
-    ) -> Result<(), CrowdfundingError>;
+        offset: u32,
+        limit: u32,
+    ) -> Result<Vec<PoolContribution>, CrowdfundingError>;
 
     fn get_pool_remaining_time(env: Env, pool_id: u64) -> Result<u64, CrowdfundingError>;
 }

contract/contract/test/close_pool_test.rs

@@ -164,7 +164,7 @@ fn test_close_pool_nonexistent() {
 #[test]
 fn test_close_pool_unauthorized() {
     let env = Env::default();
-    let (client, admin, _) = setup_test(&env);
+    let (client, _admin, _) = setup_test(&env);
 
     let creator = Address::generate(&env);
     let pool_id = create_test_pool(&client, &env, &creator);

contract/contract/test/crowdfunding_test.rs

@@ -321,7 +321,7 @@ fn test_extend_campaign_deadline_invalid_auth() {
     let (client, _, token_address) = setup_test(&env);
 
     let creator = Address::generate(&env);
-    let malicious = Address::generate(&env);
+    let _malicious = Address::generate(&env);
     let campaign_id = create_test_campaign_id(&env, 13);
     let title = String::from_str(&env, "Extend Auth");
     let goal = 1_000_000i128;
@@ -336,7 +336,7 @@ fn test_extend_campaign_deadline_invalid_auth() {
         &token_address,
     );
 
-    let new_deadline = env.ledger().timestamp() + 2 * 86400;
+    let _new_deadline = env.ledger().timestamp() + 2 * 86400;
 
     // mock_auths to malicious address simulating a fail
     // However, in mock_auths, if the caller requires the auth of creator, it will panic
@@ -382,11 +382,11 @@ fn test_extend_campaign_too_long() {
 #[test]
 fn test_get_campaign_fee_history() {
     let env = Env::default();
-    let (client, admin, token_address) = setup_test(&env);
+    let (client, _admin, token_address) = setup_test(&env);
 
     // Using token_admin pattern from other tests
-    let token_admin = Address::generate(&env);
-    let token_client = token::Client::new(&env, &token_address);
+    let _token_admin = Address::generate(&env);
+    let _token_client = token::Client::new(&env, &token_address);
     let token_admin_client = token::StellarAssetClient::new(&env, &token_address);
 
     let creator = Address::generate(&env);
@@ -3422,7 +3422,7 @@ fn test_withdraw_platform_fees_insufficient_fees() {
 #[test]
 fn test_set_emergency_contact_success() {
     let env = Env::default();
-    let (client, admin, _) = setup_test(&env);
+    let (client, _admin, _) = setup_test(&env);
 
     let emergency_contact = Address::generate(&env);
 
@@ -3436,7 +3436,7 @@ fn test_set_emergency_contact_success() {
 #[test]
 fn test_set_emergency_contact_updates_existing() {
     let env = Env::default();
-    let (client, admin, _) = setup_test(&env);
+    let (client, _admin, _) = setup_test(&env);
 
     let contact1 = Address::generate(&env);
     client.set_emergency_contact(&contact1);