Merge pull request #163 from vicajohn/feature/asset-based-discount

Author: Akshola00

contract/contract/src/base/errors.rs

@@ -50,9 +50,9 @@ pub enum CrowdfundingError {
     RefundGracePeriodNotPassed = 44,
     PoolAlreadyClosed = 45,
     PoolNotDisbursedOrRefunded = 46,
-    InvalidGoalUpdate = 47,
-    InsufficientFees = 48,
-    UserBlacklisted = 49,
+    InsufficientFees = 47,
+    UserBlacklisted = 48,
+    InvalidGoalUpdate = 49,
     CampaignCancelled = 50,
 }
 

contract/contract/src/base/events.rs

@@ -144,6 +144,19 @@ pub fn platform_fees_withdrawn(env: &Env, admin: Address, amount: i128) {
     env.events().publish(topics, amount);
 }
 
+ feature/asset-based-discount
+pub fn asset_discount_set(env: &Env, admin: Address, asset: Address, discount_bps: u32) {
+    let topics = (Symbol::new(env, "asset_discount_set"), admin, asset);
+    env.events().publish(topics, discount_bps);
+}
+
+pub fn platform_fee_percentage_set(env: &Env, admin: Address, fee_bps: u32) {
+    let topics = (Symbol::new(env, "platform_fee_percentage_set"), admin);
+    env.events().publish(topics, fee_bps);
+}
+
+
+ main
 pub fn address_blacklisted(env: &Env, admin: Address, address: Address) {
     let topics = (Symbol::new(env, "address_blacklisted"), admin);
     env.events().publish(topics, address);
@@ -153,8 +166,11 @@ pub fn address_unblacklisted(env: &Env, admin: Address, address: Address) {
     let topics = (Symbol::new(env, "address_unblacklisted"), admin);
     env.events().publish(topics, address);
 }
+ feature/asset-based-discount
+
 
 pub fn pool_metadata_updated(env: &Env, pool_id: u64, updater: Address, new_metadata_hash: String) {
     let topics = (Symbol::new(env, "pool_metadata_updated"), pool_id, updater);
     env.events().publish(topics, new_metadata_hash);
 }
+ main

contract/contract/src/base/types.rs

@@ -242,12 +242,19 @@ pub enum StorageKey {
     GlobalTotalRaised,
     CampaignCancelled(BytesN<32>),
     EmergencyContact,
+ feature/asset-based-discount
+    AssetDiscount(Address),
+    PlatformFeePercentage,
+    CampaignFeeHistory(BytesN<32>),
+    Blacklist(Address),
+
     CampaignFeeHistory(BytesN<32>),
     Blacklist(Address),
 
     ReentrancyLock(u64),
     EmergencyWithdrawalLock,
     PoolCreator(u64),
+main
 }
 
 #[cfg(test)]

contract/contract/src/crowdfunding.rs

@@ -1078,6 +1078,21 @@ impl CrowdfundingTrait for CrowdfundingContract {
             return Err(CrowdfundingError::InvalidPoolState);
         }
 
+ feature/asset-based-discount
+        // Calculate platform fee with discount
+        let base_fee_bps = Self::get_platform_fee_percentage(env.clone());
+        let discount_bps = Self::get_asset_discount(env.clone(), asset.clone());
+        
+        // Apply discount: effective_fee = base_fee * (1 - discount/10000)
+        let effective_fee_bps = if discount_bps > 0 {
+            base_fee_bps.saturating_sub((base_fee_bps * discount_bps) / 10000)
+        } else {
+            base_fee_bps
+        };
+
+        // Calculate fee amount: fee = amount * effective_fee_bps / 10000
+        let platform_fee = (amount * effective_fee_bps as i128) / 10000;
+        let net_contribution = amount - platform_fee;
         // Load pool configuration to enforce minimum contribution
         let pool_key = StorageKey::Pool(pool_id);
         let pool: PoolConfig = env
@@ -1089,15 +1104,27 @@ impl CrowdfundingTrait for CrowdfundingContract {
         if amount < pool.min_contribution {
             return Err(CrowdfundingError::InvalidAmount);
         }
+ main
 
         // Transfer tokens
-        // Note: In a real implementation we would use the token client.
-        // For this task we assume the token interface is available via soroban_sdk::token
         use soroban_sdk::token;
         let token_client = token::Client::new(&env, &asset);
         token_client.transfer(&contributor, env.current_contract_address(), &amount);
 
-        // Update metrics
+        // Track platform fees if any
+        if platform_fee > 0 {
+            let platform_fees_key = StorageKey::PlatformFees;
+            let current_fees: i128 = env
+                .storage()
+                .instance()
+                .get(&platform_fees_key)
+                .unwrap_or(0);
+            env.storage()
+                .instance()
+                .set(&platform_fees_key, &(current_fees + platform_fee));
+        }
+
+        // Update metrics with net contribution
         let metrics_key = StorageKey::PoolMetrics(pool_id);
         let mut metrics: PoolMetrics = env
             .storage()
@@ -1123,16 +1150,16 @@ impl CrowdfundingTrait for CrowdfundingContract {
             metrics.contributor_count += 1;
         }
 
-        metrics.total_raised += amount;
+        metrics.total_raised += net_contribution;
         metrics.last_donation_at = env.ledger().timestamp();
 
         env.storage().instance().set(&metrics_key, &metrics);
 
-        // Update per-user contribution tracking
+        // Update per-user contribution tracking with net contribution
         let updated_contribution = PoolContribution {
             pool_id,
             contributor: contributor.clone(),
-            amount: existing_contribution.amount + amount,
+            amount: existing_contribution.amount + net_contribution,
             asset: asset.clone(),
         };
         env.storage()
@@ -1159,7 +1186,7 @@ impl CrowdfundingTrait for CrowdfundingContract {
             pool_id,
             contributor,
             asset,
-            amount,
+            net_contribution,
             env.ledger().timestamp(),
             is_private,
         );
@@ -1580,10 +1607,124 @@ impl CrowdfundingTrait for CrowdfundingContract {
             .ok_or(CrowdfundingError::NotInitialized)
     }
 
+ feature/asset-based-discount
+    fn set_asset_discount(
+        env: Env,
+        asset: Address,
+        discount_bps: u32,
+    ) -> Result<(), CrowdfundingError> {
+        let admin: Address = env
+            .storage()
+            .instance()
+            .get(&StorageKey::Admin)
+            .ok_or(CrowdfundingError::NotInitialized)?;
+        admin.require_auth();
+
+        // Validate discount is not more than 100% (10000 basis points)
+        if discount_bps > 10000 {
+            return Err(CrowdfundingError::InvalidFee);
+        }
+
+        let key = StorageKey::AssetDiscount(asset.clone());
+        env.storage().instance().set(&key, &discount_bps);
+
+        events::asset_discount_set(&env, admin, asset, discount_bps);
+
+        Ok(())
+    }
+
+    fn get_asset_discount(env: Env, asset: Address) -> u32 {
+        let key = StorageKey::AssetDiscount(asset);
+        env.storage().instance().get(&key).unwrap_or(0)
+    }
+
+    fn set_platform_fee_percentage(env: Env, fee_bps: u32) -> Result<(), CrowdfundingError> {
+        let admin: Address = env
+            .storage()
+            .instance()
+            .get(&StorageKey::Admin)
+            .ok_or(CrowdfundingError::NotInitialized)?;
+        admin.require_auth();
+
+        // Validate fee is not more than 100% (10000 basis points)
+        if fee_bps > 10000 {
+            return Err(CrowdfundingError::InvalidFee);
+        }
+
+        let key = StorageKey::PlatformFeePercentage;
+        env.storage().instance().set(&key, &fee_bps);
+
+        events::platform_fee_percentage_set(&env, admin, fee_bps);
+
+        Ok(())
+    }
+
+    fn get_platform_fee_percentage(env: Env) -> u32 {
+        let key = StorageKey::PlatformFeePercentage;
+        env.storage().instance().get(&key).unwrap_or(0)
+    }
+
+ main
     fn get_contract_version(env: Env) -> String {
         String::from_str(&env, "1.2.0")
     }
 
+ feature/asset-based-discount
+    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 get_campaign_fee_history(
+        env: Env,
+        campaign_id: BytesN<32>,
+    ) -> Result<i128, CrowdfundingError> {
+        // Validate campaign exists
+        Self::get_campaign(env.clone(), campaign_id.clone())?;
+
+        let fee_history_key = StorageKey::CampaignFeeHistory(campaign_id);
+        let current_fees: i128 = env
+            .storage()
+            .persistent()
+            .get(&fee_history_key)
+            .unwrap_or(0);
+        Ok(current_fees)
+
     fn get_pool_contributions_paginated(
         env: Env,
         pool_id: u64,
@@ -1632,6 +1773,7 @@ impl CrowdfundingTrait for CrowdfundingContract {
         }
 
         Ok(result)
+ main
     }
 }
 

contract/contract/src/interfaces/crowdfunding.rs

@@ -174,6 +174,47 @@ pub trait CrowdfundingTrait {
     fn set_emergency_contact(env: Env, contact: Address) -> Result<(), CrowdfundingError>;
 
     fn get_emergency_contact(env: Env) -> Result<Address, CrowdfundingError>;
+ feature/asset-based-discount
+    fn set_asset_discount(
+        env: Env,
+        asset: Address,
+        discount_bps: u32,
+    ) -> Result<(), CrowdfundingError>;
+
+    fn get_asset_discount(env: Env, asset: Address) -> u32;
+
+    fn set_platform_fee_percentage(env: Env, fee_bps: u32) -> Result<(), CrowdfundingError>;
+
+    fn get_platform_fee_percentage(env: Env) -> u32;
+
+    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 get_campaign_fee_history(
+        env: Env,
+        campaign_id: BytesN<32>,
+    ) -> Result<i128, CrowdfundingError>;
+
+    fn update_campaign_goal(
+        env: Env,
+        campaign_id: BytesN<32>,
+        new_goal: i128,
+    ) -> Result<(), CrowdfundingError>;
+
+    fn extend_campaign_deadline(
+        env: Env,
+        campaign_id: BytesN<32>,
+        new_deadline: u64,
+    ) -> Result<(), CrowdfundingError>;
+
+    fn get_campaigns(env: Env, ids: Vec<BytesN<32>>) -> Vec<CampaignDetails>;
+
+    fn renounce_admin(env: Env) -> Result<(), CrowdfundingError>;
 
     fn get_contract_version(env: Env) -> String;
 
@@ -185,4 +226,5 @@ pub trait CrowdfundingTrait {
     ) -> Result<Vec<PoolContribution>, CrowdfundingError>;
 
     fn get_pool_remaining_time(env: Env, pool_id: u64) -> Result<u64, CrowdfundingError>;
+ main
 }