feat: time-lock fee-config updates

contracts/predictify-hybrid/src/admin.rs

@@ -2334,12 +2334,13 @@ impl AdminFunctions {
         env: &Env,
         admin: &Address,
         new_config: &FeeConfig,
-    ) -> Result<FeeConfig, Error> {
+        eta: u64,
+    ) -> Result<(), Error> {
         // Validate admin permissions
         AdminAccessControl::validate_admin_for_action(env, admin, "update_fees")?;
 
-        // Update fee configuration
-        let updated_config = FeeManager::update_fee_config(env, admin.clone(), new_config.clone())?;
+        // Queue fee configuration with governance time-lock
+        FeeManager::update_fee_config(env, admin.clone(), new_config.clone(), eta)?;
 
         // Log admin action
         let mut params = Map::new(env);
@@ -2353,7 +2354,24 @@ impl AdminFunctions {
         );
         AdminActionLogger::log_action(env, admin, "update_fees", None, params, true, None)?;
 
-        Ok(updated_config)
+        Ok(())
+    }
+
+    /// Apply a previously queued fee configuration update.
+    ///
+    /// Succeeds only when the ETA has been reached. Can be called by anyone
+    /// once the timelock expires.
+    pub fn apply_fee_update(env: &Env, admin: &Address) -> Result<(), Error> {
+        FeeManager::apply_fee_update(env, admin.clone())?;
+        Ok(())
+    }
+
+    /// Cancel a pending fee configuration update before its ETA.
+    ///
+    /// Only the contract admin may cancel a queued update.
+    pub fn cancel_fee_update(env: &Env, admin: &Address) -> Result<(), Error> {
+        FeeManager::cancel_fee_update(env, admin.clone())?;
+        Ok(())
     }
 
     /// Updates the core contract configuration (admin only).

contracts/predictify-hybrid/src/events.rs

@@ -2019,6 +2019,44 @@ pub struct AdminOverrideEvent {
     pub timestamp: u64,
 }
 
+/// Emitted when a fee config update is queued with a governance time-lock.
+/// The config is not applied until `now >= eta`.
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct FeeConfigQueuedEvent {
+    pub admin: Address,
+    pub eta: u64,
+    pub platform_fee_percentage: i128,
+    pub creation_fee: i128,
+    pub min_fee_amount: i128,
+    pub max_fee_amount: i128,
+    pub collection_threshold: i128,
+    pub fees_enabled: bool,
+    pub timestamp: u64,
+}
+
+/// Emitted when a queued fee config update is successfully applied.
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct FeeConfigAppliedEvent {
+    pub admin: Address,
+    pub platform_fee_percentage: i128,
+    pub creation_fee: i128,
+    pub min_fee_amount: i128,
+    pub max_fee_amount: i128,
+    pub collection_threshold: i128,
+    pub fees_enabled: bool,
+    pub timestamp: u64,
+}
+
+/// Emitted when a queued fee config update is cancelled by admin.
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct FeeConfigCancelledEvent {
+    pub admin: Address,
+    pub timestamp: u64,
+}
+
 /// Event emission utilities
 pub struct EventEmitter;
 
@@ -4656,6 +4694,9 @@ mod event_schema_registry_tests {
                 &env, &market_id, &disputer, 50_000_000, None,
             );
         });
+    }
+}
+
 impl EventEmitter {
     pub fn emit_threshold_proposed(
         env: &Env,
@@ -4796,4 +4837,52 @@ impl EventEmitter {
         env.events()
             .publish((symbol_short!("adm_ovrd"), market_id.clone()), event);
     }
+
+    /// Emit fee config queued event when a time-locked config update is proposed.
+    pub fn emit_fee_config_queued(
+        env: &Env,
+        admin: &Address,
+        eta: u64,
+        config: &crate::fees::FeeConfig,
+    ) {
+        let event = FeeConfigQueuedEvent {
+            admin: admin.clone(),
+            eta,
+            platform_fee_percentage: config.platform_fee_percentage,
+            creation_fee: config.creation_fee,
+            min_fee_amount: config.min_fee_amount,
+            max_fee_amount: config.max_fee_amount,
+            collection_threshold: config.collection_threshold,
+            fees_enabled: config.fees_enabled,
+            timestamp: env.ledger().timestamp(),
+        };
+        env.events()
+            .publish((symbol_short!("fee_qd"), admin.clone()), event);
+    }
+
+    /// Emit fee config applied event when a queued update becomes effective.
+    pub fn emit_fee_config_applied(env: &Env, admin: &Address, config: &crate::fees::FeeConfig) {
+        let event = FeeConfigAppliedEvent {
+            admin: admin.clone(),
+            platform_fee_percentage: config.platform_fee_percentage,
+            creation_fee: config.creation_fee,
+            min_fee_amount: config.min_fee_amount,
+            max_fee_amount: config.max_fee_amount,
+            collection_threshold: config.collection_threshold,
+            fees_enabled: config.fees_enabled,
+            timestamp: env.ledger().timestamp(),
+        };
+        env.events()
+            .publish((symbol_short!("fee_apd"), admin.clone()), event);
+    }
+
+    /// Emit fee config cancelled event when a queued update is cancelled.
+    pub fn emit_fee_config_cancelled(env: &Env, admin: &Address) {
+        let event = FeeConfigCancelledEvent {
+            admin: admin.clone(),
+            timestamp: env.ledger().timestamp(),
+        };
+        env.events()
+            .publish((symbol_short!("fee_ccl"), admin.clone()), event);
+    }
 }