Feat add protocol governance (#108)

* implemented oracle contract updater

* implemented protocol governance

* latest implementation

---------

Co-authored-by: Wilfred007 <adzerwilfred007@gmail.com>
Co-authored-by: Stephen Joseph <81881979+Smartdevs17@users.noreply.github.com>

Author: 3 people

stellar-lend/contracts/hello-world/src/errors.rs

@@ -28,12 +28,12 @@ pub enum GovernanceError {
     ExecutionFailed = 122,
     InvalidMultisigConfig = 123,
     InsufficientApprovals = 124,
-    RecoveryInProgress = 125,
-    NoRecoveryInProgress = 126,
-    InvalidGuardianConfig = 127,
-    GuardianAlreadyExists = 128,
-    GuardianNotFound = 129,
-    MathOverflow = 130,
+    InvalidProposalType = 125,
+    GuardianAlreadyExists = 126,
+    GuardianNotFound = 127,
+    InvalidGuardianConfig = 128,
+    RecoveryInProgress = 129,
+    NoRecoveryInProgress = 130,
     Unauthorized = 131,
     AlreadyInitialized = 132,
     NotInitialized = 133,

stellar-lend/contracts/hello-world/src/governance.rs

@@ -14,9 +14,8 @@ pub use crate::types::{
 
 use crate::events::{
     GovernanceInitializedEvent, GuardianAddedEvent, GuardianRemovedEvent, ProposalApprovedEvent,
-    ProposalCancelledEvent, ProposalCreatedEvent, ProposalExecutedEvent, ProposalFailedEvent,
-    ProposalQueuedEvent, RecoveryApprovedEvent, RecoveryExecutedEvent, RecoveryStartedEvent,
-    VoteCastEvent,
+    ProposalCancelledEvent,     ProposalQueuedEvent, RecoveryApprovedEvent, RecoveryExecutedEvent, RecoveryStartedEvent,
+    VoteCastEvent, emit_proposal_approved,
 };
 
 // ========================================================================
@@ -425,14 +424,172 @@ pub fn execute_proposal(
     Ok(())
 }
 
-fn execute_proposal_type(_env: &Env, proposal_type: &ProposalType) -> Result<(), GovernanceError> {
+fn execute_proposal_type(env: &Env, proposal_type: &ProposalType) -> Result<(), GovernanceError> {
     match proposal_type {
-        ProposalType::MinCollateralRatio(_)
-        | ProposalType::RiskParams(_, _, _, _)
-        | ProposalType::PauseSwitch(_, _)
-        | ProposalType::EmergencyPause(_)
-        | ProposalType::GenericAction(_) => Ok(()),
+        ProposalType::MinCollateralRatio(ratio) => {
+            risk_params::set_risk_params(env, Some(*ratio), None, None, None)
+                .map_err(|_| GovernanceError::ExecutionFailed)?;
+        }
+        ProposalType::RiskParams(mcr, lt, cf, li) => {
+            risk_params::set_risk_params(env, *mcr, *lt, *cf, *li)
+                .map_err(|_| GovernanceError::ExecutionFailed)?;
+        }
+        ProposalType::InterestRateConfig(params) => {
+            let admin = get_admin(env).ok_or(GovernanceError::NotInitialized)?;
+            interest_rate::update_interest_rate_config(
+                env,
+                admin,
+                params.base_rate_bps,
+                params.kink_utilization_bps,
+                params.multiplier_bps,
+                params.jump_multiplier_bps,
+                params.rate_floor_bps,
+                params.rate_ceiling_bps,
+                params.spread_bps,
+            )
+            .map_err(|_| GovernanceError::ExecutionFailed)?;
+        }
+        ProposalType::PauseSwitch(op, paused) => {
+            let admin = get_admin(env).ok_or(GovernanceError::NotInitialized)?;
+            risk_management::set_pause_switch(env, admin, op.clone(), *paused)
+                .map_err(|_| GovernanceError::ExecutionFailed)?;
+        }
+        ProposalType::EmergencyPause(paused) => {
+            let admin = get_admin(env).ok_or(GovernanceError::NotInitialized)?;
+            risk_management::set_emergency_pause(env, admin, *paused)
+                .map_err(|_| GovernanceError::ExecutionFailed)?;
+        }
+        ProposalType::GenericAction(_) => {
+            return Err(GovernanceError::InvalidProposalType);
+        }
     }
+    Ok(())
+}
+
+pub fn create_admin_proposal(
+    env: &Env,
+    admin: Address,
+    proposal_type: ProposalType,
+    description: String,
+) -> Result<u64, GovernanceError> {
+    admin.require_auth();
+
+    let stored_admin: Address = env
+        .storage()
+        .instance()
+        .get(&GovernanceDataKey::Admin)
+        .ok_or(GovernanceError::NotInitialized)?;
+
+    if admin != stored_admin {
+        return Err(GovernanceError::Unauthorized);
+    }
+
+    let config: GovernanceConfig = env
+        .storage()
+        .instance()
+        .get(&GovernanceDataKey::Config)
+        .ok_or(GovernanceError::NotInitialized)?;
+
+    let now = env.ledger().timestamp();
+    let proposal_id: u64 = env
+        .storage()
+        .instance()
+        .get(&GovernanceDataKey::NextProposalId)
+        .unwrap_or(0);
+
+    let execution_time = now + config.execution_delay.max(MIN_TIMELOCK_DELAY);
+
+    let proposal = Proposal {
+        id: proposal_id,
+        proposer: admin.clone(),
+        proposal_type,
+        description,
+        status: ProposalStatus::Queued,
+        start_time: now,
+        end_time: now,
+        execution_time: Some(execution_time),
+        voting_threshold: 0,
+        for_votes: 0,
+        against_votes: 0,
+        abstain_votes: 0,
+        total_voting_power: 0,
+        created_at: now,
+    };
+
+    env.storage()
+        .persistent()
+        .set(&GovernanceDataKey::Proposal(proposal_id), &proposal);
+
+    env.storage()
+        .instance()
+        .set(&GovernanceDataKey::NextProposalId, &(proposal_id + 1));
+
+    emit_proposal_created_event(env, &proposal_id, &admin);
+    
+    let topics = (Symbol::new(env, "proposal_queued"), proposal_id);
+    env.events().publish(topics, execution_time);
+
+    Ok(proposal_id)
+}
+
+pub fn create_emergency_proposal(
+    env: &Env,
+    caller: Address,
+    proposal_type: ProposalType,
+    description: String,
+) -> Result<u64, GovernanceError> {
+    caller.require_auth();
+
+    // Verification of multisig auth happens via approvals in multisig module,
+    // but for "emergency bypass" we can allow direct execution if called by a valid multisig admin
+    // assuming it's correctly authorized by the multisig threshold.
+    // In this simplified version, we'll check against multisig admins.
+    
+    let multisig_config: MultisigConfig = env
+        .storage()
+        .instance()
+        .get(&GovernanceDataKey::MultisigConfig)
+        .ok_or(GovernanceError::NotInitialized)?;
+
+    if !multisig_config.admins.contains(&caller) {
+        return Err(GovernanceError::Unauthorized);
+    }
+
+    let now = env.ledger().timestamp();
+    let proposal_id: u64 = env
+        .storage()
+        .instance()
+        .get(&GovernanceDataKey::NextProposalId)
+        .unwrap_or(0);
+
+    let proposal = Proposal {
+        id: proposal_id,
+        proposer: caller.clone(),
+        proposal_type,
+        description,
+        status: ProposalStatus::Queued,
+        start_time: now,
+        end_time: now,
+        execution_time: Some(now), // No delay for emergency
+        voting_threshold: 0,
+        for_votes: 0,
+        against_votes: 0,
+        abstain_votes: 0,
+        total_voting_power: 0,
+        created_at: now,
+    };
+
+    env.storage()
+        .persistent()
+        .set(&GovernanceDataKey::Proposal(proposal_id), &proposal);
+
+    env.storage()
+        .instance()
+        .set(&GovernanceDataKey::NextProposalId, &(proposal_id + 1));
+
+    emit_proposal_created_event(env, &proposal_id, &caller);
+
+    Ok(proposal_id)
 }
 
 // ========================================================================
@@ -570,6 +727,91 @@ pub fn get_proposal_approvals(env: &Env, proposal_id: u64) -> Option<Vec<Address
     env.storage().persistent().get(&approvals_key)
 }
 
+pub fn get_multisig_config(env: &Env) -> Option<MultisigConfig> {
+    env.storage()
+        .instance()
+        .get(&GovernanceDataKey::MultisigConfig)
+}
+
+pub fn get_multisig_admins(env: &Env) -> Option<Vec<Address>> {
+    get_multisig_config(env).map(|c| c.admins)
+}
+
+pub fn get_multisig_threshold(env: &Env) -> u32 {
+    get_multisig_config(env).map(|c| c.threshold).unwrap_or(1)
+}
+
+pub fn set_multisig_admins(
+    env: &Env,
+    caller: Address,
+    admins: Vec<Address>,
+) -> Result<(), GovernanceError> {
+    let config = get_multisig_config(env).ok_or(GovernanceError::NotInitialized)?;
+    set_multisig_config(env, caller, admins, config.threshold)
+}
+
+pub fn set_multisig_threshold(
+    env: &Env,
+    caller: Address,
+    threshold: u32,
+) -> Result<(), GovernanceError> {
+    let config = get_multisig_config(env).ok_or(GovernanceError::NotInitialized)?;
+    set_multisig_config(env, caller, config.admins, threshold)
+}
+
+pub fn propose_set_min_collateral_ratio(
+    env: &Env,
+    proposer: Address,
+    new_ratio: i128,
+) -> Result<u64, GovernanceError> {
+    create_proposal(
+        env,
+        proposer,
+        ProposalType::MinCollateralRatio(new_ratio),
+        String::from_str(env, "Update min collateral ratio"),
+        None,
+    )
+}
+
+pub fn execute_multisig_proposal(
+    env: &Env,
+    executor: Address,
+    proposal_id: u64,
+) -> Result<(), GovernanceError> {
+    executor.require_auth();
+
+    let multisig_config = get_multisig_config(env).ok_or(GovernanceError::NotInitialized)?;
+    if !multisig_config.admins.contains(&executor) {
+        return Err(GovernanceError::Unauthorized);
+    }
+
+    let mut proposal: Proposal = env
+        .storage()
+        .persistent()
+        .get(&GovernanceDataKey::Proposal(proposal_id))
+        .ok_or(GovernanceError::ProposalNotFound)?;
+
+    if proposal.status != ProposalStatus::Pending {
+        return Err(GovernanceError::InvalidProposalStatus);
+    }
+
+    let approvals = get_proposal_approvals(env, proposal_id).unwrap_or_else(|| Vec::new(env));
+    if approvals.len() < multisig_config.threshold {
+        return Err(GovernanceError::InsufficientApprovals);
+    }
+
+    execute_proposal_type(env, &proposal.proposal_type)?;
+
+    proposal.status = ProposalStatus::Executed;
+    env.storage()
+        .persistent()
+        .set(&GovernanceDataKey::Proposal(proposal_id), &proposal);
+
+    emit_proposal_executed_event(env, &proposal_id, &executor);
+
+    Ok(())
+}
+
 // ============================================================================
 // Events
 // ============================================================================
@@ -608,14 +850,7 @@ fn emit_proposal_failed_event(env: &Env, proposal_id: &u64) {
     env.events().publish(topics, ());
 }
 
-pub fn emit_approval_event(env: &Env, proposal_id: &u64, approver: &Address) {
-    let topics = (
-        Symbol::new(env, "proposal_approved"),
-        *proposal_id,
-        approver.clone(),
-    );
-    env.events().publish(topics, ());
-}
+
 
 pub fn add_guardian(env: &Env, caller: Address, guardian: Address) -> Result<(), GovernanceError> {
     caller.require_auth();
@@ -935,12 +1170,6 @@ pub fn get_admin(env: &Env) -> Option<Address> {
     env.storage().instance().get(&GovernanceDataKey::Admin)
 }
 
-pub fn get_multisig_config(env: &Env) -> Option<MultisigConfig> {
-    env.storage()
-        .instance()
-        .get(&GovernanceDataKey::MultisigConfig)
-}
-
 pub fn emit_guardian_added_event(env: &Env, guardian: &Address) {
     let topics = (Symbol::new(env, "guardian_added"), guardian.clone());
     env.events().publish(topics, ());

stellar-lend/contracts/hello-world/src/lib.rs

@@ -24,6 +24,18 @@ pub mod risk_params;
 pub mod storage;
 pub mod types;
 pub mod withdraw;
+pub mod recovery;
+pub mod multisig;
+pub mod types;
+pub mod storage;
+pub mod reentrancy;
+
+mod admin;
+mod errors;
+mod reserve;
+mod risk_params;
+mod config;
+mod bridge;
 
 #[cfg(test)]
 // mod tests;
@@ -32,7 +44,9 @@ use crate::deposit::DepositDataKey;
 use crate::risk_management::RiskManagementError;
 use crate::interest_rate::InterestRateError;
 
-/// Helper function to require admin authorization
+// ─── Admin helper ─────────────────────────────────────────────────────────────
+
+/// Require that `caller` is the stored admin; panics via `?` on failure.
 fn require_admin(env: &Env, caller: &Address) -> Result<(), RiskManagementError> {
     caller.require_auth();
     let admin_key = DepositDataKey::Admin;
@@ -55,7 +69,31 @@ pub struct HelloContract;
 #[contractimpl]
 impl HelloContract {
     pub fn hello(env: Env) -> String {
-        String::from_str(&env, "Hello")
+        String::from_str(env, "Hello")
+    }
+
+    pub fn gov_initialize(
+        env: Env,
+        admin: Address,
+        vote_token: Address,
+        voting_period: Option<u64>,
+        execution_delay: Option<u64>,
+        quorum_bps: Option<u32>,
+        proposal_threshold: Option<i128>,
+        timelock_duration: Option<u64>,
+        default_voting_threshold: Option<i128>,
+    ) -> Result<(), GovernanceError> {
+        governance::initialize(
+            &env,
+            admin,
+            vote_token,
+            voting_period,
+            execution_delay,
+            quorum_bps,
+            proposal_threshold,
+            timelock_duration,
+            default_voting_threshold,
+        )
     }
 
     pub fn initialize(env: Env, admin: Address) -> Result<(), RiskManagementError> {