Merge pull request #177 from luhrhenz/feature/governance-mintcap-multitoken-persistent-storage

feat: governance staking fix, persistent cert storage, TTL renew

Author: ayomideadeniran

contracts/src/lib.rs

@@ -126,6 +126,8 @@ const DEFAULT_MINT_CAP: u32 = 1000;
 const LEDGERS_PER_PERIOD: u32 = 17280;
 const GOVERNANCE_THRESHOLD: u32 = 2;
 const GOVERNANCE_ADMIN_COUNT: u32 = 3;
+/// ~1 year in ledgers (5-second ledger close time).
+const CERT_TTL_LEDGERS: u32 = 6_307_200;
 
 const NONCE_PREFIX: &str = "nonce";
 
@@ -487,7 +489,10 @@ impl CertificateContract {
                 revoked: false,
             };
 
-            env.storage().instance().set(&key, &cert);
+            env.storage().persistent().set(&key, &cert);
+            env.storage()
+                .persistent()
+                .extend_ttl(&key, CERT_TTL_LEDGERS, CERT_TTL_LEDGERS);
 
             env.events().publish(
                 (Symbol::new(&env, "cert_issued"), course_symbol.clone()),
@@ -554,7 +559,10 @@ impl CertificateContract {
             };
 
             // Batch storage operations for efficiency
-            env.storage().instance().set(&key, &cert);
+            env.storage().persistent().set(&key, &cert);
+            env.storage()
+                .persistent()
+                .extend_ttl(&key, CERT_TTL_LEDGERS, CERT_TTL_LEDGERS);
 
             // Batch event emission (emit one event per certificate for transparency)
             env.events().publish(
@@ -595,12 +603,15 @@ impl CertificateContract {
             student: student.clone(),
         };
 
-        let mut cert: Certificate = env.storage().instance().get(&key).unwrap_or_else(|| {
+        let mut cert: Certificate = env.storage().persistent().get(&key).unwrap_or_else(|| {
             panic_with_error!(&env, CertError::CertificateNotFound);
         });
 
         cert.revoked = true;
-        env.storage().instance().set(&key, &cert);
+        env.storage().persistent().set(&key, &cert);
+        env.storage()
+            .persistent()
+            .extend_ttl(&key, CERT_TTL_LEDGERS, CERT_TTL_LEDGERS);
 
         env.events().publish(
             (Symbol::new(&env, "cert_revoked"), course_symbol),
@@ -617,7 +628,37 @@ impl CertificateContract {
             course_symbol,
             student,
         };
-        env.storage().instance().get(&key)
+        env.storage().persistent().get(&key)
+    }
+
+    /// Extend the TTL of a certificate entry in persistent storage.
+    /// The student (or a governance admin) pays for the storage rent extension.
+    pub fn renew_certificate(env: Env, caller: Address, course_symbol: Symbol, student: Address) {
+        caller.require_auth();
+
+        // Only the student themselves or a governance admin may renew.
+        let is_admin = Self::governance_admin_index(&env, &caller).is_some();
+        if caller != student && !is_admin {
+            panic_with_error!(&env, CertError::Unauthorized);
+        }
+
+        let key = CertKey {
+            course_symbol: course_symbol.clone(),
+            student: student.clone(),
+        };
+
+        if !env.storage().persistent().has(&key) {
+            panic_with_error!(&env, CertError::CertificateNotFound);
+        }
+
+        env.storage()
+            .persistent()
+            .extend_ttl(&key, CERT_TTL_LEDGERS, CERT_TTL_LEDGERS);
+
+        env.events().publish(
+            (Symbol::new(&env, "cert_renewed"), course_symbol),
+            (caller, student),
+        );
     }
 
     pub fn execute_meta_tx(
@@ -686,7 +727,10 @@ impl CertificateContract {
             revoked: false,
         };
 
-        env.storage().instance().set(&key, &cert);
+        env.storage().persistent().set(&key, &cert);
+        env.storage()
+            .persistent()
+            .extend_ttl(&key, CERT_TTL_LEDGERS, CERT_TTL_LEDGERS);
 
         env.events().publish(
             (

contracts/src/staking.rs

@@ -19,6 +19,8 @@ pub enum StakingKey {
     Vote(Address, u32),
     /// Whether a proposal is currently active.
     ProposalActive(u32),
+    /// List of all currently-active proposal IDs (used to gate withdrawals).
+    ActiveProposals,
 }
 
 // ---------------------------------------------------------------------------
@@ -58,14 +60,29 @@ impl StakingContract {
     }
 
     /// Withdraw `amount` RS-Tokens for `staker`.
-    /// Panics if the staker has any active vote outstanding.
+    /// Panics if the staker has any active vote outstanding (checked via `ActiveProposals` list).
     pub fn withdraw_tokens(env: Env, staker: Address, amount: i128) {
         staker.require_auth();
 
         if amount <= 0 {
             panic_with_error!(&env, StakingError::InvalidAmount);
         }
 
+        // Block withdrawal if the staker has voted on any currently-active proposal.
+        let active_proposals: soroban_sdk::Vec<u32> = env
+            .storage()
+            .instance()
+            .get(&StakingKey::ActiveProposals)
+            .unwrap_or_else(|| soroban_sdk::Vec::new(&env));
+
+        for proposal_id in active_proposals.iter() {
+            let vote_key = StakingKey::Vote(staker.clone(), proposal_id);
+            let voted: i128 = env.storage().instance().get(&vote_key).unwrap_or(0);
+            if voted > 0 {
+                panic_with_error!(&env, StakingError::VoteActive);
+            }
+        }
+
         let stake_key = StakingKey::Stake(staker.clone());
         let current: i128 = env.storage().instance().get(&stake_key).unwrap_or(0);
 
@@ -110,6 +127,19 @@ impl StakingContract {
         env.storage()
             .instance()
             .set(&StakingKey::ProposalActive(proposal_id), &true);
+
+        // Track in the active proposals list so withdraw_tokens can check it.
+        let mut active: soroban_sdk::Vec<u32> = env
+            .storage()
+            .instance()
+            .get(&StakingKey::ActiveProposals)
+            .unwrap_or_else(|| soroban_sdk::Vec::new(&env));
+        if !active.contains(proposal_id) {
+            active.push_back(proposal_id);
+            env.storage()
+                .instance()
+                .set(&StakingKey::ActiveProposals, &active);
+        }
     }
 
     /// Close a proposal, allowing stakers to withdraw again.
@@ -118,6 +148,22 @@ impl StakingContract {
         env.storage()
             .instance()
             .set(&StakingKey::ProposalActive(proposal_id), &false);
+
+        // Remove from the active proposals list.
+        let active: soroban_sdk::Vec<u32> = env
+            .storage()
+            .instance()
+            .get(&StakingKey::ActiveProposals)
+            .unwrap_or_else(|| soroban_sdk::Vec::new(&env));
+        let mut updated: soroban_sdk::Vec<u32> = soroban_sdk::Vec::new(&env);
+        for id in active.iter() {
+            if id != proposal_id {
+                updated.push_back(id);
+            }
+        }
+        env.storage()
+            .instance()
+            .set(&StakingKey::ActiveProposals, &updated);
     }
 
     pub fn get_stake(env: Env, staker: Address) -> i128 {
@@ -179,6 +225,31 @@ mod tests {
         client.withdraw_tokens(&staker, &100);
     }
 
+    #[test]
+    #[should_panic]
+    fn cannot_withdraw_while_vote_active() {
+        let (env, admin, client) = setup();
+        let staker = Address::generate(&env);
+        client.stake_tokens(&staker, &100);
+        client.open_proposal(&admin, &5);
+        client.cast_vote(&staker, &5, &50);
+        // Should panic: staker has an active vote on proposal 5
+        client.withdraw_tokens(&staker, &10);
+    }
+
+    #[test]
+    fn can_withdraw_after_proposal_closed() {
+        let (env, admin, client) = setup();
+        let staker = Address::generate(&env);
+        client.stake_tokens(&staker, &100);
+        client.open_proposal(&admin, &6);
+        client.cast_vote(&staker, &6, &50);
+        client.close_proposal(&admin, &6);
+        // Proposal closed — withdrawal should succeed
+        client.withdraw_tokens(&staker, &10);
+        assert_eq!(client.get_stake(&staker), 90);
+    }
+
     #[test]
     fn cast_vote_records_weight() {
         let (env, admin, client) = setup();