Add delegated contribution support

contracts/sorosave/src/contribution.rs

@@ -6,22 +6,75 @@ use crate::types::{GroupStatus, RoundInfo};
 
 pub fn contribute(env: &Env, member: Address, group_id: u64) -> Result<(), ContractError> {
     member.require_auth();
+    record_contribution(env, member.clone(), member, group_id)
+}
+
+pub fn set_delegate(
+    env: &Env,
+    member: Address,
+    delegate: Address,
+    group_id: u64,
+) -> Result<(), ContractError> {
+    member.require_auth();
+
+    let group = storage::get_group(env, group_id).ok_or(ContractError::GroupNotFound)?;
+    if !is_group_member(&group, &member) {
+        return Err(ContractError::NotMember);
+    }
+
+    storage::set_delegate(env, group_id, &member, &delegate);
+    env.events().publish(
+        (crate::symbol_short!("del_set"),),
+        (group_id, member, delegate),
+    );
+
+    Ok(())
+}
+
+pub fn revoke_delegate(env: &Env, member: Address, group_id: u64) -> Result<(), ContractError> {
+    member.require_auth();
 
+    let group = storage::get_group(env, group_id).ok_or(ContractError::GroupNotFound)?;
+    if !is_group_member(&group, &member) {
+        return Err(ContractError::NotMember);
+    }
+
+    storage::remove_delegate(env, group_id, &member);
+    env.events()
+        .publish((crate::symbol_short!("del_revk"),), (group_id, member));
+
+    Ok(())
+}
+
+pub fn contribute_for(
+    env: &Env,
+    delegate: Address,
+    member: Address,
+    group_id: u64,
+) -> Result<(), ContractError> {
+    delegate.require_auth();
+
+    if storage::get_delegate(env, group_id, &member) != Some(delegate.clone()) {
+        return Err(ContractError::Unauthorized);
+    }
+
+    record_contribution(env, delegate, member, group_id)
+}
+
+fn record_contribution(
+    env: &Env,
+    payer: Address,
+    member: Address,
+    group_id: u64,
+) -> Result<(), ContractError> {
     let group = storage::get_group(env, group_id).ok_or(ContractError::GroupNotFound)?;
 
     if group.status != GroupStatus::Active {
         return Err(ContractError::GroupNotActive);
     }
 
     // Verify membership
-    let mut is_member = false;
-    for m in group.members.iter() {
-        if m == member {
-            is_member = true;
-            break;
-        }
-    }
-    if !is_member {
+    if !is_group_member(&group, &member) {
         return Err(ContractError::NotMember);
     }
 
@@ -40,7 +93,7 @@ pub fn contribute(env: &Env, member: Address, group_id: u64) -> Result<(), Contr
     // Transfer tokens from member to this contract
     let token_client = soroban_sdk::token::Client::new(env, &group.token);
     token_client.transfer(
-        &member,
+        &payer,
         &env.current_contract_address(),
         &group.contribution_amount,
     );
@@ -64,6 +117,15 @@ pub fn contribute(env: &Env, member: Address, group_id: u64) -> Result<(), Contr
     Ok(())
 }
 
+fn is_group_member(group: &crate::types::SavingsGroup, member: &Address) -> bool {
+    for group_member in group.members.iter() {
+        if group_member == *member {
+            return true;
+        }
+    }
+    false
+}
+
 pub fn get_round_status(env: &Env, group_id: u64, round: u32) -> Result<RoundInfo, ContractError> {
     storage::get_round(env, group_id, round).ok_or(ContractError::RoundNotActive)
 }

contracts/sorosave/src/lib.rs

@@ -81,6 +81,31 @@ impl SoroSaveContract {
         contribution::contribute(&env, member, group_id)
     }
 
+    /// Authorize a delegate to contribute on behalf of a member in a group.
+    pub fn set_delegate(
+        env: Env,
+        member: Address,
+        delegate: Address,
+        group_id: u64,
+    ) -> Result<(), ContractError> {
+        contribution::set_delegate(&env, member, delegate, group_id)
+    }
+
+    /// Revoke an active contribution delegate for a member in a group.
+    pub fn revoke_delegate(env: Env, member: Address, group_id: u64) -> Result<(), ContractError> {
+        contribution::revoke_delegate(&env, member, group_id)
+    }
+
+    /// Let an authorized delegate contribute on behalf of a group member.
+    pub fn contribute_for(
+        env: Env,
+        delegate: Address,
+        member: Address,
+        group_id: u64,
+    ) -> Result<(), ContractError> {
+        contribution::contribute_for(&env, delegate, member, group_id)
+    }
+
     /// Get the status of a specific round.
     pub fn get_round_status(
         env: Env,

contracts/sorosave/src/storage.rs

@@ -103,6 +103,28 @@ pub fn remove_member_group(env: &Env, member: &Address, group_id: u64) {
     extend_persistent_ttl(env, &key);
 }
 
+// --- Contribution Delegates ---
+
+pub fn get_delegate(env: &Env, group_id: u64, member: &Address) -> Option<Address> {
+    let key = DataKey::Delegate(group_id, member.clone());
+    let result = env.storage().persistent().get(&key);
+    if result.is_some() {
+        extend_persistent_ttl(env, &key);
+    }
+    result
+}
+
+pub fn set_delegate(env: &Env, group_id: u64, member: &Address, delegate: &Address) {
+    let key = DataKey::Delegate(group_id, member.clone());
+    env.storage().persistent().set(&key, delegate);
+    extend_persistent_ttl(env, &key);
+}
+
+pub fn remove_delegate(env: &Env, group_id: u64, member: &Address) {
+    let key = DataKey::Delegate(group_id, member.clone());
+    env.storage().persistent().remove(&key);
+}
+
 // --- Dispute ---
 
 #[allow(dead_code)]

contracts/sorosave/src/test.rs

@@ -151,6 +151,63 @@ fn test_full_cycle() {
     assert_eq!(group.status, GroupStatus::Completed);
 }
 
+#[test]
+fn test_delegate_can_contribute_for_group_member() {
+    let (env, admin, client, _token) = setup_env();
+
+    let member1 = Address::generate(&env);
+    let delegate = Address::generate(&env);
+    let replacement_delegate = Address::generate(&env);
+    let mint_admin = Address::generate(&env);
+    let token_id = env.register_stellar_asset_contract_v2(mint_admin);
+    let token_sac = StellarAssetClient::new(&env, &token_id.address());
+
+    token_sac.mint(&admin, &10_000_000);
+    token_sac.mint(&delegate, &10_000_000);
+    token_sac.mint(&replacement_delegate, &10_000_000);
+
+    let group_id = client.create_group(
+        &admin,
+        &String::from_str(&env, "Delegated Contribution"),
+        &token_id.address(),
+        &1_000_000,
+        &86400,
+        &5,
+    );
+    client.join_group(&member1, &group_id);
+
+    client.set_delegate(&member1, &delegate, &group_id);
+    assert_eq!(
+        env.as_contract(&client.address, || crate::storage::get_delegate(
+            &env, group_id, &member1
+        )),
+        Some(delegate.clone())
+    );
+
+    client.set_delegate(&member1, &replacement_delegate, &group_id);
+    assert_eq!(
+        env.as_contract(&client.address, || crate::storage::get_delegate(
+            &env, group_id, &member1
+        )),
+        Some(replacement_delegate.clone())
+    );
+
+    client.start_group(&admin, &group_id);
+    client.contribute(&admin, &group_id);
+    client.contribute_for(&replacement_delegate, &member1, &group_id);
+
+    assert!(client.has_contributed(&member1, &group_id, &1));
+    assert!(client.get_round_status(&group_id, &1).is_complete);
+
+    client.revoke_delegate(&member1, &group_id);
+    assert_eq!(
+        env.as_contract(&client.address, || crate::storage::get_delegate(
+            &env, group_id, &member1
+        )),
+        None
+    );
+}
+
 #[test]
 fn test_member_groups() {
     let (env, admin, client, token) = setup_env();

contracts/sorosave/src/types.rs

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