diff --git a/contracts/predictify-hybrid/src/admin.rs b/contracts/predictify-hybrid/src/admin.rs
index d5cc28b..bda4911 100644
--- a/contracts/predictify-hybrid/src/admin.rs
+++ b/contracts/predictify-hybrid/src/admin.rs
@@ -63,11 +63,11 @@ pub enum AdminPermission {
     /// Collect fees
     CollectFees,
     /// Manage disputes
-    ManageDisputes,
+    ManageDispute,
     /// View analytics
-    ViewAnalytics,
+    ViewAnalytic,
     /// Emergency actions
-    EmergencyActions,
+    Emergency,
 }
 
 /// Admin action record
@@ -827,9 +827,9 @@ impl AdminAccessControl {
     /// | `"update_config"` | `AdminPermission::UpdateConfig` |
     /// | `"reset_config"` | `AdminPermission::ResetConfig` |
     /// | `"collect_fees"` | `AdminPermission::CollectFees` |
-    /// | `"manage_disputes"` | `AdminPermission::ManageDisputes` |
-    /// | `"view_analytics"` | `AdminPermission::ViewAnalytics` |
-    /// | `"emergency_actions"` | `AdminPermission::EmergencyActions` |
+    /// | `"manage_disputes"` | `AdminPermission::ManageDispute` |
+    /// | `"view_analytics"` | `AdminPermission::ViewAnalytic` |
+    /// | `"emergency_actions"` | `AdminPermission::Emergency` |
     ///
     /// # Use Cases
     ///
@@ -855,9 +855,9 @@ impl AdminAccessControl {
             "update_config" => Ok(AdminPermission::UpdateConfig),
             "reset_config" => Ok(AdminPermission::ResetConfig),
             "collect_fees" => Ok(AdminPermission::CollectFees),
-            "manage_disputes" => Ok(AdminPermission::ManageDisputes),
-            "view_analytics" => Ok(AdminPermission::ViewAnalytics),
-            "emergency_actions" => Ok(AdminPermission::EmergencyActions),
+            "manage_disputes" => Ok(AdminPermission::ManageDispute),
+            "view_analytics" => Ok(AdminPermission::ViewAnalytic),
+            "emergency_actions" => Ok(AdminPermission::Emergency),
             _ => Err(Error::InvalidInput),
         }
     }
@@ -891,7 +891,7 @@ impl AdminRoleManager {
     /// # Errors
     ///
     /// This function returns specific errors:
-    /// - `Error::Unauthorized` - Assigner lacks EmergencyActions permission
+    /// - `Error::Unauthorized` - Assigner lacks Emergency permission
     /// - Permission validation errors from AdminAccessControl
     /// - Storage operation errors
     ///
@@ -933,14 +933,14 @@ impl AdminRoleManager {
     ///
     /// The assignment process:
     /// 1. **Bootstrap Check**: First assignment bypasses permission validation
-    /// 2. **Permission Validation**: Subsequent assignments require EmergencyActions permission
+    /// 2. **Permission Validation**: Subsequent assignments require Emergency permission
     /// 3. **Role Creation**: Creates AdminRoleAssignment with timestamp and permissions
     /// 4. **Storage Update**: Stores assignment in persistent storage
     /// 5. **Event Emission**: Emits role assignment event for monitoring
     ///
     /// # Security
     ///
-    /// Only admins with EmergencyActions permission can assign roles to others.
+    /// Only admins with Emergency permission can assign roles to others.
     /// The first admin assignment (bootstrapping) bypasses this check to enable
     /// initial contract setup.
     pub fn assign_role(
@@ -960,7 +960,7 @@ impl AdminRoleManager {
             AdminAccessControl::validate_permission(
                 env,
                 assigned_by,
-                &AdminPermission::EmergencyActions,
+                &AdminPermission::Emergency,
             )?;
         }
 
@@ -1179,7 +1179,7 @@ impl AdminRoleManager {
     /// # Returns
     ///
     /// Returns `Vec<AdminPermission>` containing all permissions for the role.
-    /// The vector is never empty - even ReadOnlyAdmin has ViewAnalytics permission.
+    /// The vector is never empty - even ReadOnlyAdmin has ViewAnalytic permission.
     ///
     /// # Example
     ///
@@ -1196,7 +1196,7 @@ impl AdminRoleManager {
     ///
     /// println!("SuperAdmin has {} permissions", super_permissions.len());
     /// assert!(super_permissions.contains(&AdminPermission::Initialize));
-    /// assert!(super_permissions.contains(&AdminPermission::EmergencyActions));
+    /// assert!(super_permissions.contains(&AdminPermission::Emergency));
     ///
     /// // Get permissions for MarketAdmin
     /// let market_permissions = AdminRoleManager::get_permissions_for_role(
@@ -1213,19 +1213,19 @@ impl AdminRoleManager {
     /// **SuperAdmin** (12 permissions):
     /// - Initialize, CreateMarket, CloseMarket, FinalizeMarket
     /// - ExtendMarket, UpdateFees, UpdateConfig, ResetConfig
-    /// - CollectFees, ManageDisputes, ViewAnalytics, EmergencyActions
+    /// - CollectFees, ManageDispute, ViewAnalytic, Emergency
     ///
     /// **MarketAdmin** (5 permissions):
-    /// - CreateMarket, CloseMarket, FinalizeMarket, ExtendMarket, ViewAnalytics
+    /// - CreateMarket, CloseMarket, FinalizeMarket, ExtendMarket, ViewAnalytic
     ///
     /// **ConfigAdmin** (3 permissions):
-    /// - UpdateConfig, ResetConfig, ViewAnalytics
+    /// - UpdateConfig, ResetConfig, ViewAnalytic
     ///
     /// **FeeAdmin** (3 permissions):
-    /// - UpdateFees, CollectFees, ViewAnalytics
+    /// - UpdateFees, CollectFees, ViewAnalytic
     ///
     /// **ReadOnlyAdmin** (1 permission):
-    /// - ViewAnalytics
+    /// - ViewAnalytic
     ///
     /// # Use Cases
     ///
@@ -1255,9 +1255,9 @@ impl AdminRoleManager {
                 AdminPermission::UpdateConfig,
                 AdminPermission::ResetConfig,
                 AdminPermission::CollectFees,
-                AdminPermission::ManageDisputes,
-                AdminPermission::ViewAnalytics,
-                AdminPermission::EmergencyActions,
+                AdminPermission::ManageDispute,
+                AdminPermission::ViewAnalytic,
+                AdminPermission::Emergency,
             ],
             AdminRole::MarketAdmin => soroban_sdk::vec![
                 env,
@@ -1265,21 +1265,21 @@ impl AdminRoleManager {
                 AdminPermission::CloseMarket,
                 AdminPermission::FinalizeMarket,
                 AdminPermission::ExtendMarket,
-                AdminPermission::ViewAnalytics,
+                AdminPermission::ViewAnalytic,
             ],
             AdminRole::ConfigAdmin => soroban_sdk::vec![
                 env,
                 AdminPermission::UpdateConfig,
                 AdminPermission::ResetConfig,
-                AdminPermission::ViewAnalytics,
+                AdminPermission::ViewAnalytic,
             ],
             AdminRole::FeeAdmin => soroban_sdk::vec![
                 env,
                 AdminPermission::UpdateFees,
                 AdminPermission::CollectFees,
-                AdminPermission::ViewAnalytics,
+                AdminPermission::ViewAnalytic,
             ],
-            AdminRole::ReadOnlyAdmin => soroban_sdk::vec![env, AdminPermission::ViewAnalytics,],
+            AdminRole::ReadOnlyAdmin => soroban_sdk::vec![env, AdminPermission::ViewAnalytic,],
         }
     }
 
@@ -1293,7 +1293,7 @@ impl AdminRoleManager {
         AdminAccessControl::validate_permission(
             env,
             deactivated_by,
-            &AdminPermission::EmergencyActions,
+            &AdminPermission::Emergency,
         )?;
 
         // Use a simple fixed key for admin role storage
@@ -1332,7 +1332,7 @@ impl AdminManager {
         AdminAccessControl::validate_permission(
             env,
             current_admin,
-            &AdminPermission::EmergencyActions,
+            &AdminPermission::Emergency,
         )?;
 
         // Prevent duplicate admin assignments
@@ -1378,7 +1378,7 @@ impl AdminManager {
         AdminAccessControl::validate_permission(
             env,
             current_admin,
-            &AdminPermission::EmergencyActions,
+            &AdminPermission::Emergency,
         )?;
 
         // Prevent self-removal of last super admin
@@ -1419,7 +1419,7 @@ impl AdminManager {
         AdminAccessControl::validate_permission(
             env,
             current_admin,
-            &AdminPermission::EmergencyActions,
+            &AdminPermission::Emergency,
         )?;
 
         let admin_key = Self::get_admin_key(env, target_admin);
@@ -1602,7 +1602,7 @@ impl AdminManager {
         AdminAccessControl::validate_permission(
             env,
             current_admin,
-            &AdminPermission::EmergencyActions,
+            &AdminPermission::Emergency,
         )?;
 
         let admin_key = Self::get_admin_key(env, target_admin);
@@ -1628,7 +1628,7 @@ impl AdminManager {
         AdminAccessControl::validate_permission(
             env,
             current_admin,
-            &AdminPermission::EmergencyActions,
+            &AdminPermission::Emergency,
         )?;
 
         let admin_key = Self::get_admin_key(env, target_admin);
@@ -1654,7 +1654,7 @@ pub struct MultisigManager;
 impl MultisigManager {
     /// Set the multisig threshold (M-of-N)
     pub fn set_threshold(env: &Env, admin: &Address, threshold: u32) -> Result<(), Error> {
-        AdminAccessControl::validate_permission(env, admin, &AdminPermission::EmergencyActions)?;
+        AdminAccessControl::validate_permission(env, admin, &AdminPermission::Emergency)?;
         
         let total_admins = Self::count_active_admins(env);
         if threshold == 0 || threshold > total_admins {
@@ -1691,7 +1691,7 @@ impl MultisigManager {
         target: Address,
         data: Map<String, String>,
     ) -> Result<u64, Error> {
-        AdminAccessControl::validate_permission(env, initiator, &AdminPermission::EmergencyActions)?;
+        AdminAccessControl::validate_permission(env, initiator, &AdminPermission::Emergency)?;
         
         let action_id = Self::get_next_action_id(env);
         let mut approvals = Vec::new(env);
@@ -1717,7 +1717,7 @@ impl MultisigManager {
     
     /// Approve a pending action
     pub fn approve_action(env: &Env, admin: &Address, action_id: u64) -> Result<bool, Error> {
-        AdminAccessControl::validate_permission(env, admin, &AdminPermission::EmergencyActions)?;
+        AdminAccessControl::validate_permission(env, admin, &AdminPermission::Emergency)?;
         
         let key = Self::get_action_key(env, action_id);
         let mut action: PendingAdminAction = env.storage().persistent().get(&key).ok_or(Error::ConfigNotFound)?;
@@ -3260,14 +3260,14 @@ impl AdminUtils {
             AdminPermission::CollectFees => {
                 String::from_str(&soroban_sdk::Env::default(), "CollectFees")
             }
-            AdminPermission::ManageDisputes => {
-                String::from_str(&soroban_sdk::Env::default(), "ManageDisputes")
+            AdminPermission::ManageDispute => {
+                String::from_str(&soroban_sdk::Env::default(), "ManageDispute")
             }
-            AdminPermission::ViewAnalytics => {
-                String::from_str(&soroban_sdk::Env::default(), "ViewAnalytics")
+            AdminPermission::ViewAnalytic => {
+                String::from_str(&soroban_sdk::Env::default(), "ViewAnalytic")
             }
-            AdminPermission::EmergencyActions => {
-                String::from_str(&soroban_sdk::Env::default(), "EmergencyActions")
+            AdminPermission::Emergency => {
+                String::from_str(&soroban_sdk::Env::default(), "Emergency")
             }
         }
     }
@@ -3768,11 +3768,11 @@ mod admin_manager_tests {
             AdminPermission::UpdateFees
         ));
 
-        // ReadOnlyAdmin should only have ViewAnalytics
+        // ReadOnlyAdmin should only have ViewAnalytic
         assert!(AdminManager::check_role_permissions(
             &env,
             AdminRole::ReadOnlyAdmin,
-            AdminPermission::ViewAnalytics
+            AdminPermission::ViewAnalytic
         ));
         assert!(!AdminManager::check_role_permissions(
             &env,
diff --git a/contracts/predictify-hybrid/src/errors.rs b/contracts/predictify-hybrid/src/errors.rs
index 45dc2da..943b889 100644
--- a/contracts/predictify-hybrid/src/errors.rs
+++ b/contracts/predictify-hybrid/src/errors.rs
@@ -58,9 +58,9 @@ pub enum Error {
     /// Market not ready for oracle verification
     MarketNotReady = 205,
     /// Fallback oracle is unavailable or unhealthy
-    FallbackOracleUnavailable = 206,
+    FallbackOracleUnavail = 206,
     /// Resolution timeout has been reached
-    ResolutionTimeoutReached = 207,
+    ResTimeoutReached = 207,
 
     // ===== VALIDATION ERRORS =====
     /// Invalid question format
@@ -173,15 +173,15 @@ pub enum RecoveryStrategy {
     /// Retry the operation
     Retry,
     /// Wait and retry later
-    RetryWithDelay,
+    RetryDelay,
     /// Use alternative method
-    AlternativeMethod,
+    Alternative,
     /// Skip operation and continue
     Skip,
     /// Abort operation
     Abort,
     /// Manual intervention required
-    ManualIntervention,
+    Manual,
     /// No recovery possible
     NoRecovery,
 }
@@ -309,7 +309,7 @@ pub struct ResiliencePattern {
     /// Pattern name/identifier
     pub pattern_name: String,
     /// Pattern type
-    pub pattern_type: ResiliencePatternType,
+    pub pattern_type: ResilienceType,
     /// Pattern configuration
     pub pattern_config: Map<String, String>,
     /// Pattern enabled status
@@ -325,11 +325,11 @@ pub struct ResiliencePattern {
 /// Resilience pattern types
 #[contracttype]
 #[derive(Clone, Debug, Eq, PartialEq)]
-pub enum ResiliencePatternType {
+pub enum ResilienceType {
     /// Retry with exponential backoff
-    RetryWithBackoff,
+    RetryBackoff,
     /// Circuit breaker pattern
-    CircuitBreaker,
+    CB,
     /// Bulkhead isolation
     Bulkhead,
     /// Timeout pattern
@@ -337,7 +337,7 @@ pub enum ResiliencePatternType {
     /// Fallback pattern
     Fallback,
     /// Health check pattern
-    HealthCheck,
+    Health,
     /// Rate limiting pattern
     RateLimit,
 }
@@ -434,7 +434,7 @@ impl ErrorHandler {
                 // For retryable errors, return success to allow retry
                 Ok(true)
             }
-            RecoveryStrategy::RetryWithDelay => {
+            RecoveryStrategy::RetryDelay => {
                 // For errors that need delay, check if enough time has passed
                 let last_attempt = context.timestamp;
                 let current_time = env.ledger().timestamp();
@@ -446,7 +446,7 @@ impl ErrorHandler {
                     Err(Error::InvalidState)
                 }
             }
-            RecoveryStrategy::AlternativeMethod => {
+            RecoveryStrategy::Alternative => {
                 // Try alternative approach based on error type
                 match error {
                     Error::OracleUnavailable => {
@@ -468,7 +468,7 @@ impl ErrorHandler {
                 // Abort the operation
                 Ok(false)
             }
-            RecoveryStrategy::ManualIntervention => {
+            RecoveryStrategy::Manual => {
                 // Require manual intervention
                 Err(Error::InvalidState)
             }
@@ -505,12 +505,12 @@ impl ErrorHandler {
     pub fn get_error_recovery_strategy(error: &Error) -> RecoveryStrategy {
         match error {
             // Retryable errors
-            Error::OracleUnavailable => RecoveryStrategy::RetryWithDelay,
+            Error::OracleUnavailable => RecoveryStrategy::RetryDelay,
             Error::InvalidInput => RecoveryStrategy::Retry,
 
             // Alternative method errors
-            Error::MarketNotFound => RecoveryStrategy::AlternativeMethod,
-            Error::ConfigNotFound => RecoveryStrategy::AlternativeMethod,
+            Error::MarketNotFound => RecoveryStrategy::Alternative,
+            Error::ConfigNotFound => RecoveryStrategy::Alternative,
 
             // Skip errors
             Error::AlreadyVoted => RecoveryStrategy::Skip,
@@ -523,8 +523,8 @@ impl ErrorHandler {
             Error::MarketResolved => RecoveryStrategy::Abort,
 
             // Manual intervention errors
-            Error::AdminNotSet => RecoveryStrategy::ManualIntervention,
-            Error::DisputeFeeFailed => RecoveryStrategy::ManualIntervention,
+            Error::AdminNotSet => RecoveryStrategy::Manual,
+            Error::DisputeFeeFailed => RecoveryStrategy::Manual,
 
             // No recovery errors
             Error::InvalidState => RecoveryStrategy::NoRecovery,
@@ -713,7 +713,7 @@ impl ErrorHandler {
     }
 
     /// Document error recovery procedures and best practices
-    pub fn document_error_recovery_procedures(env: &Env) -> Result<Map<String, String>, Error> {
+    pub fn document_error_recovery(env: &Env) -> Result<Map<String, String>, Error> {
         let mut procedures = Map::new(env);
 
         procedures.set(
@@ -869,12 +869,12 @@ impl ErrorHandler {
             Error::AdminNotSet => (
                 ErrorSeverity::Critical,
                 ErrorCategory::System,
-                RecoveryStrategy::ManualIntervention,
+                RecoveryStrategy::Manual,
             ),
             Error::DisputeFeeFailed => (
                 ErrorSeverity::Critical,
                 ErrorCategory::Financial,
-                RecoveryStrategy::ManualIntervention,
+                RecoveryStrategy::Manual,
             ),
 
             // High severity errors
@@ -886,7 +886,7 @@ impl ErrorHandler {
             Error::OracleUnavailable => (
                 ErrorSeverity::High,
                 ErrorCategory::Oracle,
-                RecoveryStrategy::RetryWithDelay,
+                RecoveryStrategy::RetryDelay,
             ),
             Error::InvalidState => (
                 ErrorSeverity::High,
@@ -898,7 +898,7 @@ impl ErrorHandler {
             Error::MarketNotFound => (
                 ErrorSeverity::Medium,
                 ErrorCategory::Market,
-                RecoveryStrategy::AlternativeMethod,
+                RecoveryStrategy::Alternative,
             ),
             Error::MarketClosed => (
                 ErrorSeverity::Medium,
@@ -1279,7 +1279,7 @@ mod tests {
     #[test]
     fn test_error_recovery_strategy() {
         let retry_strategy = ErrorHandler::get_error_recovery_strategy(&Error::OracleUnavailable);
-        assert_eq!(retry_strategy, RecoveryStrategy::RetryWithDelay);
+        assert_eq!(retry_strategy, RecoveryStrategy::RetryDelay);
 
         let abort_strategy = ErrorHandler::get_error_recovery_strategy(&Error::Unauthorized);
         assert_eq!(abort_strategy, RecoveryStrategy::Abort);
diff --git a/contracts/predictify-hybrid/src/events.rs b/contracts/predictify-hybrid/src/events.rs
index 33874f2..b2b1260 100644
--- a/contracts/predictify-hybrid/src/events.rs
+++ b/contracts/predictify-hybrid/src/events.rs
@@ -736,10 +736,10 @@ pub struct FeeWithdrawnEvent {
 ///
 /// ```rust
 /// # use soroban_sdk::{Env, Symbol, String, Address};
-/// # use predictify_hybrid::events::OracleVerificationInitiatedEvent;
+/// # use predictify_hybrid::events::OracleVerifInitiatedEvent;
 /// # let env = Env::default();
 ///
-/// let event = OracleVerificationInitiatedEvent {
+/// let event = OracleVerifInitiatedEvent {
 ///     market_id: Symbol::new(&env, \"btc_50k\"),
 ///     initiator: Address::generate(&env),
 ///     feed_id: String::from_str(&env, \"BTC/USD\"),
@@ -749,7 +749,7 @@ pub struct FeeWithdrawnEvent {
 /// ```
 #[contracttype]
 #[derive(Clone, Debug, Eq, PartialEq)]
-pub struct OracleVerificationInitiatedEvent {
+pub struct OracleVerifInitiatedEvent {
     /// Market ID being verified
     pub market_id: Symbol,
     /// Address that initiated verification
@@ -2042,7 +2042,7 @@ impl EventEmitter {
         feed_id: &String,
         oracle_count: u32,
     ) {
-        let event = OracleVerificationInitiatedEvent {
+        let event = OracleVerifInitiatedEvent {
             market_id: market_id.clone(),
             initiator: initiator.clone(),
             feed_id: feed_id.clone(),
diff --git a/contracts/predictify-hybrid/src/lib.rs b/contracts/predictify-hybrid/src/lib.rs
index b0a0a60..ec7ab90 100644
--- a/contracts/predictify-hybrid/src/lib.rs
+++ b/contracts/predictify-hybrid/src/lib.rs
@@ -1004,7 +1004,7 @@ impl PredictifyHybrid {
     }
 
     /// Removes users from the global betting whitelist (admin only).
-    pub fn remove_users_from_global_whitelist(
+    pub fn rm_users_global_whitelist(
         env: Env,
         admin: Address,
         addresses: Vec<Address>,
@@ -1048,7 +1048,7 @@ impl PredictifyHybrid {
     }
 
     /// Removes users from the global betting blacklist (admin only).
-    pub fn remove_users_from_global_blacklist(
+    pub fn rm_users_global_blacklist(
         env: Env,
         admin: Address,
         addresses: Vec<Address>,
@@ -1092,7 +1092,7 @@ impl PredictifyHybrid {
     }
 
     /// Removes event creators from the global creator blacklist (admin only).
-    pub fn remove_creators_from_global_blacklist(
+    pub fn rm_creators_global_blacklist(
         env: Env,
         admin: Address,
         addresses: Vec<Address>,