Merge pull request Stellar-IndigoPay#255 from wagmiiii/feat/badge-weighted-voting

feat: implement badge-weighted governance voting

Author: LaPoshBaby

contracts/indigopay-contract/src/fuzz_tests.rs

@@ -832,10 +832,225 @@ mod fuzz {
 
             set_project_co2_rate_direct(&env, &cid, &project_id, u32::MAX);
 
-            let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
-                client.donate_usdc(&usdc_token, &donor, &project_id, &usdc_amount, &MSG_HASH);
-            }));
+            let result = client.try_donate_usdc(&usdc_token, &donor, &project_id, &usdc_amount, &MSG_HASH);
             prop_assert!(result.is_err(), "donate_usdc should panic on CO2 overflow");
         }
+    } // END of first proptest!
+
+    proptest! {
+        #![proptest_config(ProptestConfig::with_cases(100))]
+
+        #[test]
+        fn prop_fuzz_badge_weighted_voting(
+            amount in 10i128 * STROOP..=10_000i128 * STROOP,
+        ) {
+            let (env, admin, client, project_id) = setup_with_admin();
+            client.create_proposal(&admin, &project_id, &720u32);
+
+            let token_admin = Address::generate(&env);
+            let token = env
+                .register_stellar_asset_contract_v2(token_admin)
+                .address();
+
+            let donor = Address::generate(&env);
+            mint_tokens(&env, &token, &donor, amount);
+            client.donate(&token, &donor, &project_id, &amount, &42u32);
+
+            let stats = client.get_donor_stats(&donor);
+            let expected_weight = match stats.badge {
+                BadgeTier::Seedling => 1u32,
+                BadgeTier::Tree => 3u32,
+                BadgeTier::Forest => 10u32,
+                BadgeTier::EarthGuardian => 25u32,
+                BadgeTier::None => 0u32,
+            };
+
+            client.vote_verify_project(&donor, &project_id, &true);
+
+            let proposal = client.get_proposal(&project_id);
+            prop_assert_eq!(proposal.votes_for, expected_weight);
+        }
+    } // END of proptest!
+
+    #[test]
+    fn test_zero_amount_donation_rejected() {
+        let (env, _cid, client, project_id, token) = setup();
+        let donor = Address::generate(&env);
+        let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+            client.donate(&token, &donor, &project_id, &0i128, &42u32);
+        }));
+        assert!(result.is_err(), "donate with amount=0 should panic");
+    }
+
+    #[test]
+    fn test_deactivated_project_cannot_be_paused() {
+        let (_env, admin, client, project_id) = setup_with_admin();
+
+        client.deactivate_project(&admin, &project_id);
+
+        // Pausing a deactivated project must panic
+        let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+            client.pause_project(&admin, &project_id);
+        }));
+        assert!(
+            result.is_err(),
+            "pause_project should panic when project is deactivated"
+        );
+
+        let project = client.get_project(&project_id);
+        assert!(!project.active);
+    }
+
+    #[test]
+    fn test_zero_co2_rate_rejected() {
+        let (_env, admin, client, project_id) = setup_with_admin();
+        let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+            client.update_project_co2_rate(&admin, &project_id, &0u32);
+        }));
+        assert!(
+            result.is_err(),
+            "update_project_co2_rate with 0 should panic"
+        );
+    }
+
+    #[test]
+    fn test_excessive_co2_rate_rejected() {
+        let (_env, admin, client, project_id) = setup_with_admin();
+        let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+            client.update_project_co2_rate(&admin, &project_id, &(MAX_CO2_PER_XLM + 1));
+        }));
+        assert!(
+            result.is_err(),
+            "update_project_co2_rate > MAX should panic"
+        );
+    }
+
+    #[test]
+    fn test_admin_transfer_happy_path() {
+        let (env, admin, client, _project_id) = setup_with_admin();
+        let new_admin = Address::generate(&env);
+
+        client.transfer_admin(&admin, &new_admin);
+        let pending = client.get_pending_admin();
+        assert_eq!(pending, Some(new_admin.clone()));
+
+        client.accept_admin();
+        let stored_admin = client.get_admin();
+        assert_eq!(stored_admin, new_admin);
+        assert_eq!(client.get_pending_admin(), None);
+    }
+
+    #[test]
+    fn test_admin_transfer_cancel() {
+        let (env, admin, client, _project_id) = setup_with_admin();
+        let new_admin = Address::generate(&env);
+        client.transfer_admin(&admin, &new_admin);
+        assert!(client.get_pending_admin().is_some());
+
+        client.cancel_admin_transfer(&admin);
+        assert!(client.get_pending_admin().is_none());
+        assert_eq!(client.get_admin(), admin);
+    }
+
+    #[test]
+    fn test_duplicate_project_id_rejected() {
+        let (env, admin, client, project_id) = setup_with_admin();
+        let wallet2 = Address::generate(&env);
+        let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+            client.register_project(
+                &admin,
+                &project_id,
+                &SorobanString::from_str(&env, "Duplicate"),
+                &wallet2,
+                &50u32,
+            );
+        }));
+        assert!(
+            result.is_err(),
+            "register_project with duplicate ID should panic"
+        );
+    }
+
+    #[test]
+    fn test_veto_before_resolution() {
+        let (_env, admin, client, project_id) = setup_with_admin();
+        client.create_proposal(&admin, &project_id, &720u32);
+        let proposal_before = client.get_proposal(&project_id);
+        assert!(!proposal_before.resolved);
+
+        client.veto_proposal(&admin, &project_id);
+        let proposal_after = client.get_proposal(&project_id);
+        assert!(proposal_after.resolved);
+    }
+
+    #[test]
+    fn test_proposal_default_duration() {
+        let (_env, admin, client, project_id) = setup_with_admin();
+        client.create_proposal(&admin, &project_id, &0u32);
+        let proposal = client.get_proposal(&project_id);
+        assert!(!proposal.resolved);
+        assert_eq!(proposal.votes_for, 0u32);
+        assert_eq!(proposal.votes_against, 0u32);
+    }
+
+    #[test]
+    fn test_deactivate_all_projects() {
+        let (env, admin, client, project_id) = setup_with_admin();
+
+        let wallet_b = Address::generate(&env);
+        let project_b = SorobanString::from_str(&env, "proj-bulk-b");
+        client.register_project(
+            &admin,
+            &project_b,
+            &SorobanString::from_str(&env, "Bulk B"),
+            &wallet_b,
+            &75u32,
+        );
+
+        assert!(client.get_project(&project_id).active);
+        assert!(client.get_project(&project_b).active);
+
+        client.deactivate_all_projects(&admin);
+
+        assert!(!client.get_project(&project_id).active);
+        assert!(!client.get_project(&project_b).active);
+    }
+
+    #[test]
+    fn test_badge_weighted_voting_seedling_and_earth_guardian() {
+        let (env, admin, client, project_id) = setup_with_admin();
+        client.create_proposal(&admin, &project_id, &720u32);
+
+        let token_admin = Address::generate(&env);
+        let token = env
+            .register_stellar_asset_contract_v2(token_admin)
+            .address();
+
+        let donor_seedling = Address::generate(&env);
+        let amt_seedling = 10i128 * STROOP;
+        mint_tokens(&env, &token, &donor_seedling, amt_seedling);
+        client.donate(&token, &donor_seedling, &project_id, &amt_seedling, &42u32);
+
+        client.vote_verify_project(&donor_seedling, &project_id, &true);
+
+        let donor_earth = Address::generate(&env);
+        let amt_earth = 2000i128 * STROOP;
+        mint_tokens(&env, &token, &donor_earth, amt_earth);
+        client.donate(&token, &donor_earth, &project_id, &amt_earth, &42u32);
+
+        client.vote_verify_project(&donor_earth, &project_id, &true);
+
+        let proposal = client.get_proposal(&project_id);
+        assert_eq!(proposal.votes_for, 26u32);
+    }
+
+    #[test]
+    fn test_badge_weighted_voting_none_tier_panics() {
+        let (env, admin, client, project_id) = setup_with_admin();
+        client.create_proposal(&admin, &project_id, &720u32);
+
+        let voter = Address::generate(&env);
+        let result = client.try_vote_verify_project(&voter, &project_id, &true);
+        assert!(result.is_err(), "None tier voter should panic");
     }
 }

contracts/indigopay-contract/src/lib.rs

@@ -327,6 +327,16 @@ fn calculate_badge(total_stroops: i128) -> BadgeTier {
     }
 }
 
+fn voting_weight_from_badge(badge: &BadgeTier) -> u32 {
+    match badge {
+        BadgeTier::None => 0,
+        BadgeTier::Seedling => 1,
+        BadgeTier::Tree => 3,
+        BadgeTier::Forest => 10,
+        BadgeTier::EarthGuardian => 25,
+    }
+}
+
 // ─── Contract ─────────────────────────────────────────────────────────────────
 
 #[contract]
@@ -1269,6 +1279,20 @@ impl IndigoPayContract {
         ensure_min_ttl(&env, VOTING_WINDOW_LEDGERS * 4);
     }
 
+    pub fn get_voter_weight(env: Env, voter: Address) -> u32 {
+        let stats: DonorStats = env
+            .storage()
+            .instance()
+            .get(&DataKey::DonorStats(voter))
+            .unwrap_or(DonorStats {
+                total_donated: 0,
+                donation_count: 0,
+                badge: BadgeTier::None,
+                co2_offset_grams: 0,
+            });
+        voting_weight_from_badge(&stats.badge)
+    }
+
     /// Badge holders (≥ Seedling) cast a vote. One vote per address per proposal.
     pub fn vote_verify_project(env: Env, voter: Address, project_id: String, approve: bool) {
         voter.require_auth();
@@ -1288,6 +1312,8 @@ impl IndigoPayContract {
             panic!("Only badge holders (Seedling or above) can vote");
         }
 
+        let weight = voting_weight_from_badge(&stats.badge);
+
         let mut proposal: VoteProposal = env
             .storage()
             .instance()
@@ -1324,12 +1350,12 @@ impl IndigoPayContract {
         if approve {
             proposal.votes_for = proposal
                 .votes_for
-                .checked_add(1)
+                .checked_add(weight)
                 .expect("votes_for overflow");
         } else {
             proposal.votes_against = proposal
                 .votes_against
-                .checked_add(1)
+                .checked_add(weight)
                 .expect("votes_against overflow");
         }
         env.storage()

frontend/lib/stellar.ts

@@ -747,6 +747,31 @@ export async function getDonorStats(donorAddress: string) {
   }
 }
 
+/**
+ * Queries the contract for a voter's badge-weighted voting power.
+ *
+ * @param voterAddress - Voter Stellar public key.
+ * @returns Voter weight (u32), or 0 when the contract is not configured or on errors.
+ */
+export async function getVoterWeight(voterAddress: string): Promise<number> {
+  if (!CONTRACT_ID) {
+    return 0;
+  }
+
+  const contract = new Contract(CONTRACT_ID);
+
+  try {
+    const voter = new Address(voterAddress);
+    const weight = await simulateCall(contract, "get_voter_weight", [
+      voter.toScVal(),
+    ]);
+    return Number(weight);
+  } catch (err) {
+    console.error("Failed to fetch voter weight:", err);
+    return 0;
+  }
+}
+
 /**
  * Simple djb2 hash function for donation messages.
  * Returns a 32-bit unsigned integer hash.