Add referral tracking for group joins

contracts/sorosave/src/group.rs

@@ -53,7 +53,12 @@ pub fn create_group(
     Ok(group_id)
 }
 
-pub fn join_group(env: &Env, member: Address, group_id: u64) -> Result<(), ContractError> {
+pub fn join_group(
+    env: &Env,
+    member: Address,
+    group_id: u64,
+    referred_by: Option<Address>,
+) -> Result<(), ContractError> {
     member.require_auth();
 
     let mut group = storage::get_group(env, group_id).ok_or(ContractError::GroupNotFound)?;
@@ -66,17 +71,39 @@ pub fn join_group(env: &Env, member: Address, group_id: u64) -> Result<(), Contr
         return Err(ContractError::GroupFull);
     }
 
-    // Check if already a member
+    let mut referrer_is_member = false;
     for m in group.members.iter() {
         if m == member {
             return Err(ContractError::AlreadyMember);
         }
+        if let Some(referrer) = referred_by.clone() {
+            if m == referrer {
+                referrer_is_member = true;
+            }
+        }
+    }
+
+    if let Some(referrer) = referred_by.clone() {
+        if referrer == member {
+            return Err(ContractError::Unauthorized);
+        }
+        if !referrer_is_member {
+            return Err(ContractError::NotMember);
+        }
     }
 
     group.members.push_back(member.clone());
     storage::set_group(env, &group);
     storage::add_member_group(env, &member, group_id);
 
+    if let Some(referrer) = referred_by {
+        storage::increment_referral_count(env, &referrer);
+        env.events().publish(
+            (crate::symbol_short!("refer"),),
+            (group_id, referrer, member.clone()),
+        );
+    }
+
     env.events()
         .publish((crate::symbol_short!("grp_join"),), (group_id, member));
 
@@ -171,3 +198,7 @@ pub fn get_group(env: &Env, group_id: u64) -> Result<SavingsGroup, ContractError
 pub fn get_member_groups(env: &Env, member: Address) -> Vec<u64> {
     storage::get_member_groups(env, &member)
 }
+
+pub fn get_referral_count(env: &Env, member: Address) -> u32 {
+    storage::get_referral_count(env, &member)
+}

contracts/sorosave/src/lib.rs

@@ -50,8 +50,13 @@ impl SoroSaveContract {
     }
 
     /// Join an existing group that is still forming.
-    pub fn join_group(env: Env, member: Address, group_id: u64) -> Result<(), ContractError> {
-        group::join_group(&env, member, group_id)
+    pub fn join_group(
+        env: Env,
+        member: Address,
+        group_id: u64,
+        referred_by: Option<Address>,
+    ) -> Result<(), ContractError> {
+        group::join_group(&env, member, group_id, referred_by)
     }
 
     /// Leave a group (only allowed while group is still forming).
@@ -74,6 +79,11 @@ impl SoroSaveContract {
         group::get_member_groups(&env, member)
     }
 
+    /// Get the number of successful joins referred by a member.
+    pub fn get_referral_count(env: Env, member: Address) -> u32 {
+        group::get_referral_count(&env, member)
+    }
+
     // ─── Contributions ──────────────────────────────────────────────
 
     /// Contribute to the current round of a group.

contracts/sorosave/src/storage.rs

@@ -103,6 +103,24 @@ pub fn remove_member_group(env: &Env, member: &Address, group_id: u64) {
     extend_persistent_ttl(env, &key);
 }
 
+// --- Referrals ---
+
+pub fn get_referral_count(env: &Env, member: &Address) -> u32 {
+    let key = DataKey::ReferralCount(member.clone());
+    let result = env.storage().persistent().get(&key);
+    if result.is_some() {
+        extend_persistent_ttl(env, &key);
+    }
+    result.unwrap_or(0)
+}
+
+pub fn increment_referral_count(env: &Env, member: &Address) {
+    let key = DataKey::ReferralCount(member.clone());
+    let count = get_referral_count(env, member) + 1;
+    env.storage().persistent().set(&key, &count);
+    extend_persistent_ttl(env, &key);
+}
+
 // --- Dispute ---
 
 #[allow(dead_code)]

contracts/sorosave/src/test.rs

@@ -60,20 +60,36 @@ fn test_join_group() {
     let member1 = Address::generate(&env);
     let member2 = Address::generate(&env);
 
-    client.join_group(&member1, &group_id);
-    client.join_group(&member2, &group_id);
+    client.join_group(&member1, &group_id, &None);
+    client.join_group(&member2, &group_id, &None);
 
     let group = client.get_group(&group_id);
     assert_eq!(group.members.len(), 3); // admin + 2 members
 }
 
+#[test]
+fn test_referral_count_updates_on_referred_join() {
+    let (env, admin, client, token) = setup_env();
+    let group_id = create_test_group(&env, &client, &admin, &token);
+
+    let member1 = Address::generate(&env);
+    let member2 = Address::generate(&env);
+
+    client.join_group(&member1, &group_id, &None);
+    client.join_group(&member2, &group_id, &Some(member1.clone()));
+
+    assert_eq!(client.get_referral_count(&member1), 1);
+    assert_eq!(client.get_referral_count(&admin), 0);
+    assert_eq!(client.get_referral_count(&member2), 0);
+}
+
 #[test]
 fn test_leave_group() {
     let (env, admin, client, token) = setup_env();
     let group_id = create_test_group(&env, &client, &admin, &token);
 
     let member1 = Address::generate(&env);
-    client.join_group(&member1, &group_id);
+    client.join_group(&member1, &group_id, &None);
 
     assert_eq!(client.get_group(&group_id).members.len(), 2);
 
@@ -87,7 +103,7 @@ fn test_start_group() {
     let group_id = create_test_group(&env, &client, &admin, &token);
 
     let member1 = Address::generate(&env);
-    client.join_group(&member1, &group_id);
+    client.join_group(&member1, &group_id, &None);
 
     client.start_group(&admin, &group_id);
 
@@ -104,7 +120,7 @@ fn test_full_cycle() {
     let group_id = create_test_group(&env, &client, &admin, &token);
 
     let member1 = Address::generate(&env);
-    client.join_group(&member1, &group_id);
+    client.join_group(&member1, &group_id, &None);
 
     // Mint tokens to member
     let _token_admin_client = StellarAssetClient::new(&env, &token);
@@ -124,7 +140,7 @@ fn test_full_cycle() {
         &86400,
         &5,
     );
-    client.join_group(&member1, &group_id);
+    client.join_group(&member1, &group_id, &None);
     client.start_group(&admin, &group_id);
 
     // Round 1: both contribute
@@ -177,7 +193,7 @@ fn test_pause_resume_group() {
     let group_id = create_test_group(&env, &client, &admin, &token);
 
     let member1 = Address::generate(&env);
-    client.join_group(&member1, &group_id);
+    client.join_group(&member1, &group_id, &None);
     client.start_group(&admin, &group_id);
 
     // Pause
@@ -195,7 +211,7 @@ fn test_dispute_flow() {
     let group_id = create_test_group(&env, &client, &admin, &token);
 
     let member1 = Address::generate(&env);
-    client.join_group(&member1, &group_id);
+    client.join_group(&member1, &group_id, &None);
     client.start_group(&admin, &group_id);
 
     // Member raises dispute

contracts/sorosave/src/types.rs

@@ -60,5 +60,6 @@ pub enum DataKey {
     Group(u64),
     Round(u64, u32),
     MemberGroups(Address),
+    ReferralCount(Address),
     Dispute(u64),
 }