diff --git a/contracts/predictify-hybrid/src/admin.rs b/contracts/predictify-hybrid/src/admin.rs index b47945a1..8a58b5d0 100644 --- a/contracts/predictify-hybrid/src/admin.rs +++ b/contracts/predictify-hybrid/src/admin.rs @@ -8,9 +8,9 @@ use crate::events::EventEmitter; use crate::extensions::ExtensionManager; use crate::fees::{FeeConfig, FeeManager}; use crate::format; -use alloc::string::ToString; use crate::markets::MarketStateManager; use crate::resolution::MarketResolutionManager; +use alloc::string::ToString; /// Admin management system for Predictify Hybrid contract /// @@ -113,7 +113,7 @@ pub struct AdminAnalytics { #[contracttype] pub enum AdminActionType { Added, - Removed, + Removed, RoleUpdated, Activated, Deactivated, @@ -458,25 +458,25 @@ impl AdminAccessControl { /// - **Batch Operations**: Validate permissions for multiple operations /// - **Audit Trails**: Log permission checks for security auditing pub fn validate_permission( - env: &Env, - admin: &Address, - permission: &AdminPermission, -) -> Result<(), Error> { - // Try new multi-admin system first if migrated - if AdminSystemIntegration::is_migrated(env) { - return AdminManager::validate_admin_permission(env, admin, *permission); - } - - // Fall back to existing logic - let role = AdminRoleManager::get_admin_role(env, admin)?; + env: &Env, + admin: &Address, + permission: &AdminPermission, + ) -> Result<(), Error> { + // Try new multi-admin system first if migrated + if AdminSystemIntegration::is_migrated(env) { + return AdminManager::validate_admin_permission(env, admin, *permission); + } - // Check if admin has the required permission - if !AdminRoleManager::has_permission(env, &role, permission)? { - return Err(Error::Unauthorized); - } + // Fall back to existing logic + let role = AdminRoleManager::get_admin_role(env, admin)?; - Ok(()) -} + // Check if admin has the required permission + if !AdminRoleManager::has_permission(env, &role, permission)? { + return Err(Error::Unauthorized); + } + + Ok(()) + } /// Requires admin authentication and validates admin status. /// @@ -1216,16 +1216,20 @@ impl AdminManager { role: AdminRole, ) -> Result<(), Error> { // Use existing AdminRoleManager for validation - AdminAccessControl::validate_permission(env, current_admin, &AdminPermission::EmergencyActions)?; - + AdminAccessControl::validate_permission( + env, + current_admin, + &AdminPermission::EmergencyActions, + )?; + // Prevent duplicate admin assignments if Self::is_admin(env, new_admin) { return Err(Error::InvalidState); } - + // Generate unique key for this admin let admin_key = Self::get_admin_key(env, new_admin); - + // Create role assignment using existing structure let assignment = AdminRoleAssignment { admin: new_admin.clone(), @@ -1235,29 +1239,35 @@ impl AdminManager { permissions: AdminRoleManager::get_permissions_for_role(env, &role), is_active: true, }; - + // Store in multi-admin storage env.storage().persistent().set(&admin_key, &assignment); - + // Update admin count let count_key = Symbol::new(env, "AdminCount"); let current_count: u32 = env.storage().persistent().get(&count_key).unwrap_or(0); - env.storage().persistent().set(&count_key, &(current_count + 1)); - + env.storage() + .persistent() + .set(&count_key, &(current_count + 1)); + // Emit event using existing system Self::emit_admin_change_event(env, new_admin, AdminActionType::Added); - + Ok(()) } - + /// Removes an admin from the system pub fn remove_admin( env: &Env, current_admin: &Address, admin_to_remove: &Address, ) -> Result<(), Error> { - AdminAccessControl::validate_permission(env, current_admin, &AdminPermission::EmergencyActions)?; - + AdminAccessControl::validate_permission( + env, + current_admin, + &AdminPermission::EmergencyActions, + )?; + // Prevent self-removal of last super admin if current_admin == admin_to_remove { let super_admin_count = Self::count_admins_with_role(env, AdminRole::SuperAdmin); @@ -1265,25 +1275,27 @@ impl AdminManager { return Err(Error::InvalidState); } } - + let admin_key = Self::get_admin_key(env, admin_to_remove); if !env.storage().persistent().has(&admin_key) { return Err(Error::Unauthorized); } - + env.storage().persistent().remove(&admin_key); - + // Update count let count_key = Symbol::new(env, "AdminCount"); let current_count: u32 = env.storage().persistent().get(&count_key).unwrap_or(0); if current_count > 0 { - env.storage().persistent().set(&count_key, &(current_count - 1)); + env.storage() + .persistent() + .set(&count_key, &(current_count - 1)); } - + Self::emit_admin_change_event(env, admin_to_remove, AdminActionType::Removed); Ok(()) } - + /// Updates an admin's role pub fn update_admin_role( env: &Env, @@ -1291,15 +1303,19 @@ impl AdminManager { target_admin: &Address, new_role: AdminRole, ) -> Result<(), Error> { - AdminAccessControl::validate_permission(env, current_admin, &AdminPermission::EmergencyActions)?; - + AdminAccessControl::validate_permission( + env, + current_admin, + &AdminPermission::EmergencyActions, + )?; + let admin_key = Self::get_admin_key(env, target_admin); let mut assignment: AdminRoleAssignment = env .storage() .persistent() .get(&admin_key) .ok_or(Error::Unauthorized)?; - + // Prevent downgrading last super admin if assignment.role == AdminRole::SuperAdmin && new_role != AdminRole::SuperAdmin { let super_admin_count = Self::count_admins_with_role(env, AdminRole::SuperAdmin); @@ -1307,18 +1323,18 @@ impl AdminManager { return Err(Error::InvalidState); } } - + assignment.role = new_role.clone(); assignment.permissions = AdminRoleManager::get_permissions_for_role(env, &new_role); assignment.assigned_by = current_admin.clone(); assignment.assigned_at = env.ledger().timestamp(); - + env.storage().persistent().set(&admin_key, &assignment); Self::emit_admin_change_event(env, target_admin, AdminActionType::RoleUpdated); - + Ok(()) } - + /// Validates if an admin has a specific permission pub fn validate_admin_permission( env: &Env, @@ -1329,60 +1345,60 @@ impl AdminManager { if Self::is_original_admin(env, admin) { return Ok(()); } - + let admin_key = Self::get_admin_key(env, admin); let assignment: AdminRoleAssignment = env .storage() .persistent() .get(&admin_key) .ok_or(Error::Unauthorized)?; - + if !assignment.is_active || !assignment.permissions.contains(&permission) { return Err(Error::Unauthorized); } - + Ok(()) } - + /// Gets all admin roles in the system pub fn get_admin_roles(env: &Env) -> Map { let mut roles = Map::new(env); - + // Add original admin if exists if let Some(original_admin) = Self::get_original_admin(env) { roles.set(original_admin, AdminRole::SuperAdmin); } - + roles } - + /// Emits admin change events using existing AdminActionType pub fn emit_admin_change_event(env: &Env, admin: &Address, action: AdminActionType) { let action_str = match action { AdminActionType::Added => "Added", - AdminActionType::Removed => "Removed", + AdminActionType::Removed => "Removed", AdminActionType::RoleUpdated => "RoleUpdated", AdminActionType::Activated => "Activated", AdminActionType::Deactivated => "Deactivated", }; EventEmitter::emit_admin_action_logged(env, admin, action_str, &true); } - + /// Check role permissions against a specific permission pub fn check_role_permissions(env: &Env, role: AdminRole, permission: AdminPermission) -> bool { let permissions = AdminRoleManager::get_permissions_for_role(env, &role); permissions.contains(&permission) } - + // ===== Helper Methods ===== - + /// Generate a proper admin storage key using the correct environment fn get_admin_key(env: &Env, admin: &Address) -> Symbol { - // Create a unique key based on admin address - let key_str = format!("MultiAdmin_{:?}", admin.to_string()); - Symbol::new(env, &key_str) + // Create a unique key based on admin address + let key_str = format!("MultiAdmin_{:?}", admin.to_string()); + Symbol::new(env, &key_str) } - + /// Check if an address is the original admin from single-admin system fn is_original_admin(env: &Env, admin: &Address) -> bool { if let Some(original_admin) = Self::get_original_admin(env) { @@ -1390,78 +1406,89 @@ impl AdminManager { } false } - + /// Get the original admin address from single-admin system pub fn get_original_admin(env: &Env) -> Option
{ env.storage().persistent().get(&Symbol::new(env, "Admin")) } - + /// Check if an address is any type of admin (original or multi-admin) fn is_admin(env: &Env, admin: &Address) -> bool { - Self::is_original_admin(env, admin) || - env.storage().persistent().has(&Self::get_admin_key(env, admin)) + Self::is_original_admin(env, admin) + || env + .storage() + .persistent() + .has(&Self::get_admin_key(env, admin)) } - + /// Count admins with a specific role fn count_admins_with_role(env: &Env, role: AdminRole) -> u32 { let mut count = 0; - + // Count original admin if it matches the role if role == AdminRole::SuperAdmin && Self::get_original_admin(env).is_some() { count += 1; } - + // In a full implementation, we would iterate through all multi-admin entries // For now, this is a simplified version that works with the existing storage pattern count } - + /// Get admin assignment for a specific admin pub fn get_admin_assignment(env: &Env, admin: &Address) -> Option { let admin_key = Self::get_admin_key(env, admin); env.storage().persistent().get(&admin_key) } - + /// Deactivate an admin (set is_active to false) pub fn deactivate_admin( env: &Env, current_admin: &Address, target_admin: &Address, ) -> Result<(), Error> { - AdminAccessControl::validate_permission(env, current_admin, &AdminPermission::EmergencyActions)?; - + AdminAccessControl::validate_permission( + env, + current_admin, + &AdminPermission::EmergencyActions, + )?; + let admin_key = Self::get_admin_key(env, target_admin); let mut assignment: AdminRoleAssignment = env .storage() .persistent() .get(&admin_key) .ok_or(Error::Unauthorized)?; - + assignment.is_active = false; env.storage().persistent().set(&admin_key, &assignment); - + Self::emit_admin_change_event(env, target_admin, AdminActionType::Deactivated); Ok(()) } - + /// Reactivate an admin (set is_active to true) pub fn reactivate_admin( env: &Env, current_admin: &Address, target_admin: &Address, ) -> Result<(), Error> { - AdminAccessControl::validate_permission(env, current_admin, &AdminPermission::EmergencyActions)?; - + AdminAccessControl::validate_permission( + env, + current_admin, + &AdminPermission::EmergencyActions, + )?; + let admin_key = Self::get_admin_key(env, target_admin); let mut assignment: AdminRoleAssignment = env .storage() .persistent() .get(&admin_key) .ok_or(Error::Unauthorized)?; - + assignment.is_active = true; env.storage().persistent().set(&admin_key, &assignment); - + Self::emit_admin_change_event(env, target_admin, AdminActionType::Activated); Ok(()) } @@ -2948,7 +2975,6 @@ impl AdminUtils { } } - // ===== ADMIN HIERARCHY AND ANALYTICS ===== /// Admin hierarchy management for role inheritance and precedence @@ -2964,7 +2990,7 @@ impl AdminHierarchy { AdminRole::ReadOnlyAdmin => 25, } } - + pub fn can_manage_role(manager_role: &AdminRole, target_role: &AdminRole) -> bool { if *manager_role == AdminRole::SuperAdmin { return true; @@ -2973,19 +2999,21 @@ impl AdminHierarchy { let target_level = Self::get_role_level(target_role); manager_level > target_level } - + /// Get all permissions for a role level pub fn get_role_permissions(env: &Env, role: &AdminRole) -> Vec { AdminRoleManager::get_permissions_for_role(env, role) } - + /// Check if one role encompasses another role's permissions pub fn role_encompasses(env: &Env, higher_role: &AdminRole, lower_role: &AdminRole) -> bool { let higher_permissions = Self::get_role_permissions(env, higher_role); let lower_permissions = Self::get_role_permissions(env, lower_role); - + // Check if all lower permissions are contained in higher permissions - lower_permissions.iter().all(|perm| higher_permissions.contains(perm)) + lower_permissions + .iter() + .all(|perm| higher_permissions.contains(perm)) } } @@ -2997,7 +3025,7 @@ impl EnhancedAdminAnalytics { let total_admins = Self::count_total_admins(env); let active_admins = Self::count_active_admins(env); let role_distribution = Self::get_role_distribution(env); - + AdminAnalyticsResult { total_admins, active_admins, @@ -3005,24 +3033,28 @@ impl EnhancedAdminAnalytics { last_updated: env.ledger().timestamp(), } } - + fn count_total_admins(env: &Env) -> u32 { let multi_admin_count: u32 = env .storage() .persistent() .get(&Symbol::new(env, "AdminCount")) .unwrap_or(0); - - let original_admin_count = if AdminManager::get_original_admin(env).is_some() { 1 } else { 0 }; + + let original_admin_count = if AdminManager::get_original_admin(env).is_some() { + 1 + } else { + 0 + }; multi_admin_count + original_admin_count } - + fn count_active_admins(env: &Env) -> u32 { // assume all admins are active - + Self::count_total_admins(env) } - + fn get_role_distribution(env: &Env) -> Map { let mut distribution = Map::new(env); distribution.set(String::from_str(env, "SuperAdmin"), 0); @@ -3030,32 +3062,31 @@ impl EnhancedAdminAnalytics { distribution.set(String::from_str(env, "ConfigAdmin"), 0); distribution.set(String::from_str(env, "FeeAdmin"), 0); distribution.set(String::from_str(env, "ReadOnlyAdmin"), 0); - + // Count original admin as SuperAdmin if AdminManager::get_original_admin(env).is_some() { distribution.set(String::from_str(env, "SuperAdmin"), 1); } - - + distribution } - + /// Get detailed analytics for a specific admin pub fn get_admin_details(env: &Env, admin: &Address) -> Option { AdminManager::get_admin_assignment(env, admin) } - + /// Get admin activity summary pub fn get_admin_activity_summary(env: &Env) -> Map { let mut summary = Map::new(env); - + let total = Self::count_total_admins(env); let active = Self::count_active_admins(env); - + summary.set(String::from_str(env, "Total"), total); summary.set(String::from_str(env, "Active"), active); summary.set(String::from_str(env, "Inactive"), total - active); - + summary } } @@ -3071,34 +3102,50 @@ impl AdminSystemIntegration { role: AdminRole::SuperAdmin, assigned_by: original_admin.clone(), assigned_at: env.ledger().timestamp(), - permissions: AdminRoleManager::get_permissions_for_role(env, &AdminRole::SuperAdmin), + permissions: AdminRoleManager::get_permissions_for_role( + env, + &AdminRole::SuperAdmin, + ), is_active: true, }; - + let admin_key = AdminManager::get_admin_key(env, &original_admin); env.storage().persistent().set(&admin_key, &assignment); - env.storage().persistent().set(&Symbol::new(env, "AdminCount"), &1u32); - env.storage().persistent().set(&Symbol::new(env, "MultiAdminMigrated"), &true); - - EventEmitter::emit_admin_action_logged(env, &original_admin, "MigratedToMultiAdmin", &true); + env.storage() + .persistent() + .set(&Symbol::new(env, "AdminCount"), &1u32); + env.storage() + .persistent() + .set(&Symbol::new(env, "MultiAdminMigrated"), &true); + + EventEmitter::emit_admin_action_logged( + env, + &original_admin, + "MigratedToMultiAdmin", + &true, + ); } Ok(()) } - + pub fn is_migrated(env: &Env) -> bool { env.storage() .persistent() .get(&Symbol::new(env, "MultiAdminMigrated")) .unwrap_or(false) } - - pub fn validate_admin_unified(env: &Env, admin: &Address, permission: AdminPermission) -> Result<(), Error> { + + pub fn validate_admin_unified( + env: &Env, + admin: &Address, + permission: AdminPermission, + ) -> Result<(), Error> { if Self::is_migrated(env) { return AdminManager::validate_admin_permission(env, admin, permission); } AdminAccessControl::validate_permission(env, admin, &permission) } - + /// Force migration if not already migrated pub fn ensure_migration(env: &Env) -> Result<(), Error> { if !Self::is_migrated(env) { @@ -3106,33 +3153,36 @@ impl AdminSystemIntegration { } Ok(()) } - + /// Get migration status information pub fn get_migration_info(env: &Env) -> Map { let mut info = Map::new(env); - + let is_migrated = Self::is_migrated(env); let has_original_admin = AdminManager::get_original_admin(env).is_some(); - let multi_admin_count: u32 = env.storage().persistent().get(&Symbol::new(env, "AdminCount")).unwrap_or(0); - + let multi_admin_count: u32 = env + .storage() + .persistent() + .get(&Symbol::new(env, "AdminCount")) + .unwrap_or(0); + info.set( String::from_str(env, "migrated"), - String::from_str(env, if is_migrated { "true" } else { "false" }) + String::from_str(env, if is_migrated { "true" } else { "false" }), ); info.set( String::from_str(env, "has_original_admin"), - String::from_str(env, if has_original_admin { "true" } else { "false" }) + String::from_str(env, if has_original_admin { "true" } else { "false" }), ); info.set( String::from_str(env, "multi_admin_count"), - String::from_str(env, &multi_admin_count.to_string()) + String::from_str(env, &multi_admin_count.to_string()), ); - + info } } - // ===== ADMIN TESTING ===== /// Admin testing utilities @@ -3368,10 +3418,13 @@ mod admin_manager_tests { role: AdminRole::MarketAdmin, assigned_by: super_admin.clone(), assigned_at: env.ledger().timestamp(), - permissions: AdminRoleManager::get_permissions_for_role(&env, &AdminRole::MarketAdmin), + permissions: AdminRoleManager::get_permissions_for_role( + &env, + &AdminRole::MarketAdmin, + ), is_active: true, }; - + let admin_key = get_test_admin_key(&env, &new_admin); env.storage().persistent().set(&admin_key, &assignment); @@ -3380,7 +3433,8 @@ mod admin_manager_tests { env.storage().persistent().set(&count_key, &1u32); // Verify admin was added - let retrieved: AdminRoleAssignment = env.storage().persistent().get(&admin_key).unwrap(); + let retrieved: AdminRoleAssignment = + env.storage().persistent().get(&admin_key).unwrap(); assert_eq!(retrieved.admin, new_admin); assert_eq!(retrieved.role, AdminRole::MarketAdmin); assert_eq!(retrieved.assigned_by, super_admin); @@ -3439,10 +3493,13 @@ mod admin_manager_tests { AdminInitializer::initialize(&env, &super_admin).unwrap(); let roles = AdminManager::get_admin_roles(&env); - + // Should contain the original super admin assert!(roles.contains_key(super_admin.clone())); - assert_eq!(roles.get(super_admin.clone()).unwrap(), AdminRole::SuperAdmin); + assert_eq!( + roles.get(super_admin.clone()).unwrap(), + AdminRole::SuperAdmin + ); }); } @@ -3465,43 +3522,84 @@ mod admin_manager_tests { fn test_permission_hierarchy() { // Test that SuperAdmin encompasses all other roles let env = Env::default(); - - assert!(AdminHierarchy::role_encompasses(&env, &AdminRole::SuperAdmin, &AdminRole::MarketAdmin)); - assert!(AdminHierarchy::role_encompasses(&env, &AdminRole::SuperAdmin, &AdminRole::ConfigAdmin)); - assert!(AdminHierarchy::role_encompasses(&env, &AdminRole::SuperAdmin, &AdminRole::FeeAdmin)); - assert!(AdminHierarchy::role_encompasses(&env, &AdminRole::SuperAdmin, &AdminRole::ReadOnlyAdmin)); - + + assert!(AdminHierarchy::role_encompasses( + &env, + &AdminRole::SuperAdmin, + &AdminRole::MarketAdmin + )); + assert!(AdminHierarchy::role_encompasses( + &env, + &AdminRole::SuperAdmin, + &AdminRole::ConfigAdmin + )); + assert!(AdminHierarchy::role_encompasses( + &env, + &AdminRole::SuperAdmin, + &AdminRole::FeeAdmin + )); + assert!(AdminHierarchy::role_encompasses( + &env, + &AdminRole::SuperAdmin, + &AdminRole::ReadOnlyAdmin + )); + // Test that lower roles don't encompass SuperAdmin - assert!(!AdminHierarchy::role_encompasses(&env, &AdminRole::MarketAdmin, &AdminRole::SuperAdmin)); + assert!(!AdminHierarchy::role_encompasses( + &env, + &AdminRole::MarketAdmin, + &AdminRole::SuperAdmin + )); } #[test] fn test_role_level_hierarchy() { // SuperAdmin should have highest level assert_eq!(AdminHierarchy::get_role_level(&AdminRole::SuperAdmin), 100); - + // Specialized admins should have same level assert_eq!(AdminHierarchy::get_role_level(&AdminRole::MarketAdmin), 75); assert_eq!(AdminHierarchy::get_role_level(&AdminRole::ConfigAdmin), 75); assert_eq!(AdminHierarchy::get_role_level(&AdminRole::FeeAdmin), 75); - + // ReadOnly should have lowest level - assert_eq!(AdminHierarchy::get_role_level(&AdminRole::ReadOnlyAdmin), 25); + assert_eq!( + AdminHierarchy::get_role_level(&AdminRole::ReadOnlyAdmin), + 25 + ); } #[test] fn test_can_manage_role() { // SuperAdmin can manage all roles - assert!(AdminHierarchy::can_manage_role(&AdminRole::SuperAdmin, &AdminRole::SuperAdmin)); - assert!(AdminHierarchy::can_manage_role(&AdminRole::SuperAdmin, &AdminRole::MarketAdmin)); - assert!(AdminHierarchy::can_manage_role(&AdminRole::SuperAdmin, &AdminRole::ReadOnlyAdmin)); - + assert!(AdminHierarchy::can_manage_role( + &AdminRole::SuperAdmin, + &AdminRole::SuperAdmin + )); + assert!(AdminHierarchy::can_manage_role( + &AdminRole::SuperAdmin, + &AdminRole::MarketAdmin + )); + assert!(AdminHierarchy::can_manage_role( + &AdminRole::SuperAdmin, + &AdminRole::ReadOnlyAdmin + )); + // MarketAdmin cannot manage other specialized admins or SuperAdmin - assert!(!AdminHierarchy::can_manage_role(&AdminRole::MarketAdmin, &AdminRole::SuperAdmin)); - assert!(!AdminHierarchy::can_manage_role(&AdminRole::MarketAdmin, &AdminRole::ConfigAdmin)); - + assert!(!AdminHierarchy::can_manage_role( + &AdminRole::MarketAdmin, + &AdminRole::SuperAdmin + )); + assert!(!AdminHierarchy::can_manage_role( + &AdminRole::MarketAdmin, + &AdminRole::ConfigAdmin + )); + // But can manage lower roles - assert!(AdminHierarchy::can_manage_role(&AdminRole::MarketAdmin, &AdminRole::ReadOnlyAdmin)); + assert!(AdminHierarchy::can_manage_role( + &AdminRole::MarketAdmin, + &AdminRole::ReadOnlyAdmin + )); } #[test] @@ -3515,9 +3613,11 @@ mod admin_manager_tests { let analytics = EnhancedAdminAnalytics::get_admin_analytics(&env); let distribution = analytics.role_distribution; - + // Should have SuperAdmin entry - let super_admin_count = distribution.get(String::from_str(&env, "SuperAdmin")).unwrap(); + let super_admin_count = distribution + .get(String::from_str(&env, "SuperAdmin")) + .unwrap(); assert_eq!(super_admin_count, 1); }); } @@ -3532,17 +3632,19 @@ mod admin_manager_tests { AdminInitializer::initialize(&env, &super_admin).unwrap(); let info = AdminSystemIntegration::get_migration_info(&env); - + // Should have migration status assert!(info.contains_key(String::from_str(&env, "migrated"))); assert!(info.contains_key(String::from_str(&env, "has_original_admin"))); - + // Should show not migrated initially let migrated = info.get(String::from_str(&env, "migrated")).unwrap(); assert_eq!(migrated, String::from_str(&env, "false")); - + // Should show has original admin - let has_original = info.get(String::from_str(&env, "has_original_admin")).unwrap(); + let has_original = info + .get(String::from_str(&env, "has_original_admin")) + .unwrap(); assert_eq!(has_original, String::from_str(&env, "true")); }); } @@ -3557,12 +3659,12 @@ mod admin_manager_tests { AdminInitializer::initialize(&env, &super_admin).unwrap(); let summary = EnhancedAdminAnalytics::get_admin_activity_summary(&env); - + // Should have Total, Active, and Inactive keys assert!(summary.contains_key(String::from_str(&env, "Total"))); assert!(summary.contains_key(String::from_str(&env, "Active"))); assert!(summary.contains_key(String::from_str(&env, "Inactive"))); - + let total = summary.get(String::from_str(&env, "Total")).unwrap(); assert!(total >= 1); }); diff --git a/contracts/predictify-hybrid/src/batch_operations.rs b/contracts/predictify-hybrid/src/batch_operations.rs index 8a333efc..fd5d46a6 100644 --- a/contracts/predictify-hybrid/src/batch_operations.rs +++ b/contracts/predictify-hybrid/src/batch_operations.rs @@ -1,8 +1,6 @@ -use soroban_sdk::{ - contracttype, vec, Address, Env, Map, String, Symbol, Vec, -}; use alloc::format; use alloc::string::ToString; +use soroban_sdk::{contracttype, vec, Address, Env, Map, String, Symbol, Vec}; use crate::errors::Error; use crate::types::*; @@ -12,14 +10,14 @@ use crate::types::*; #[derive(Clone, Debug, PartialEq, Eq)] #[contracttype] pub enum BatchOperationType { - Vote, // Batch vote operations - Claim, // Batch claim operations - CreateMarket, // Batch market creation - OracleCall, // Batch oracle calls - Dispute, // Batch dispute operations - Extension, // Batch market extensions - Resolution, // Batch market resolutions - FeeCollection, // Batch fee collection + Vote, // Batch vote operations + Claim, // Batch claim operations + CreateMarket, // Batch market creation + OracleCall, // Batch oracle calls + Dispute, // Batch dispute operations + Extension, // Batch market extensions + Resolution, // Batch market resolutions + FeeCollection, // Batch fee collection } #[derive(Clone, Debug)] @@ -132,7 +130,7 @@ pub struct BatchProcessor; impl BatchProcessor { // ===== STORAGE KEYS ===== - + const BATCH_QUEUE_KEY: &'static str = "batch_operation_queue"; const BATCH_STATS_KEY: &'static str = "batch_operation_statistics"; const BATCH_CONFIG_KEY: &'static str = "batch_operation_config"; @@ -160,12 +158,18 @@ impl BatchProcessor { gas_efficiency_ratio: 1, }; - env.storage().instance().set(&Symbol::new(env, Self::BATCH_CONFIG_KEY), &config); - env.storage().instance().set(&Symbol::new(env, Self::BATCH_STATS_KEY), &stats); - + env.storage() + .instance() + .set(&Symbol::new(env, Self::BATCH_CONFIG_KEY), &config); + env.storage() + .instance() + .set(&Symbol::new(env, Self::BATCH_STATS_KEY), &stats); + // Initialize empty batch queue let queue: Vec = Vec::new(env); - env.storage().instance().set(&Symbol::new(env, Self::BATCH_QUEUE_KEY), &queue); + env.storage() + .instance() + .set(&Symbol::new(env, Self::BATCH_QUEUE_KEY), &queue); Ok(()) } @@ -179,18 +183,20 @@ impl BatchProcessor { } /// Update batch processor configuration - pub fn update_config( - env: &Env, - admin: &Address, - config: &BatchConfig, - ) -> Result<(), Error> { + pub fn update_config(env: &Env, admin: &Address, config: &BatchConfig) -> Result<(), Error> { // Validate admin permissions - crate::admin::AdminAccessControl::validate_admin_for_action(env, admin, "update_batch_config")?; + crate::admin::AdminAccessControl::validate_admin_for_action( + env, + admin, + "update_batch_config", + )?; // Validate configuration Self::validate_batch_config(config)?; - env.storage().instance().set(&Symbol::new(env, Self::BATCH_CONFIG_KEY), config); + env.storage() + .instance() + .set(&Symbol::new(env, Self::BATCH_CONFIG_KEY), config); Ok(()) } @@ -198,10 +204,7 @@ impl BatchProcessor { // ===== BATCH VOTE OPERATIONS ===== /// Process batch vote operations - pub fn batch_vote( - env: &Env, - votes: &Vec, - ) -> Result { + pub fn batch_vote(env: &Env, votes: &Vec) -> Result { let config = Self::get_config(env)?; let start_time = env.ledger().timestamp(); let mut successful_operations = 0; @@ -255,7 +258,7 @@ impl BatchProcessor { // Check if market exists and is open let market = crate::markets::MarketStateManager::get_market(env, &vote_data.market_id)?; - + if market.end_time <= env.ledger().timestamp() { return Err(Error::MarketClosed); } @@ -275,10 +278,7 @@ impl BatchProcessor { // ===== BATCH CLAIM OPERATIONS ===== /// Process batch claim operations - pub fn batch_claim( - env: &Env, - claims: &Vec, - ) -> Result { + pub fn batch_claim(env: &Env, claims: &Vec) -> Result { let config = Self::get_config(env)?; let start_time = env.ledger().timestamp(); let mut successful_operations = 0; @@ -332,7 +332,7 @@ impl BatchProcessor { // Check if market exists and is resolved let market = crate::markets::MarketStateManager::get_market(env, &claim_data.market_id)?; - + if !market.is_resolved() { return Err(Error::MarketNotResolved); } @@ -356,7 +356,11 @@ impl BatchProcessor { markets: &Vec, ) -> Result { // Validate admin permissions - crate::admin::AdminAccessControl::validate_admin_for_action(env, admin, "batch_create_markets")?; + crate::admin::AdminAccessControl::validate_admin_for_action( + env, + admin, + "batch_create_markets", + )?; let config = Self::get_config(env)?; let start_time = env.ledger().timestamp(); @@ -429,10 +433,7 @@ impl BatchProcessor { // ===== BATCH ORACLE CALLS ===== /// Process batch oracle calls - pub fn batch_oracle_calls( - env: &Env, - feeds: &Vec, - ) -> Result { + pub fn batch_oracle_calls(env: &Env, feeds: &Vec) -> Result { let config = Self::get_config(env)?; let start_time = env.ledger().timestamp(); let mut successful_operations = 0; @@ -486,7 +487,7 @@ impl BatchProcessor { // Check if market exists let market = crate::markets::MarketStateManager::get_market(env, &feed_data.market_id)?; - + if market.is_resolved() { return Err(Error::MarketAlreadyResolved); } @@ -507,9 +508,7 @@ impl BatchProcessor { // ===== BATCH OPERATION VALIDATION ===== /// Validate batch operations - pub fn validate_batch_operations( - operations: &Vec, - ) -> Result<(), Error> { + pub fn validate_batch_operations(operations: &Vec) -> Result<(), Error> { if operations.is_empty() { return Err(Error::InvalidInput); } @@ -593,26 +592,28 @@ impl BatchProcessor { BatchOperationType::FeeCollection => "fee_collection", }; - let current_count = error_counts.get(String::from_str(env, error_type)).unwrap_or(0); + let current_count = error_counts + .get(String::from_str(env, error_type)) + .unwrap_or(0); error_counts.set(String::from_str(env, error_type), current_count + 1); } // Create error summary error_summary.set( String::from_str(env, "total_errors"), - String::from_str(env, &errors.len().to_string()) + String::from_str(env, &errors.len().to_string()), ); error_summary.set( String::from_str(env, "error_types"), - String::from_str(env, "See error_counts for breakdown") + String::from_str(env, "See error_counts for breakdown"), ); // Add error counts for (error_type, count) in error_counts.iter() { error_summary.set( String::from_str(env, &format!("{:?}_errors", error_type)), - String::from_str(env, &count.to_string()) + String::from_str(env, &count.to_string()), ); } @@ -640,12 +641,15 @@ impl BatchProcessor { // Update average batch size if stats.total_batches_processed > 0 { - stats.average_batch_size = stats.total_operations_processed / stats.total_batches_processed; + stats.average_batch_size = + stats.total_operations_processed / stats.total_batches_processed; } // Update average execution time if stats.total_batches_processed > 0 { - let total_time = stats.average_execution_time * (stats.total_batches_processed - 1) as u64 + result.execution_time; + let total_time = stats.average_execution_time + * (stats.total_batches_processed - 1) as u64 + + result.execution_time; stats.average_execution_time = total_time / stats.total_batches_processed as u64; } @@ -655,7 +659,9 @@ impl BatchProcessor { stats.gas_efficiency_ratio = (success_rate * 100.0) as u64; } - env.storage().instance().set(&Symbol::new(env, Self::BATCH_STATS_KEY), &stats); + env.storage() + .instance() + .set(&Symbol::new(env, Self::BATCH_STATS_KEY), &stats); Ok(()) } @@ -767,7 +773,7 @@ impl BatchUtils { operation_type: &BatchOperationType, ) -> Result { let config = BatchProcessor::get_config(env)?; - + match operation_type { BatchOperationType::Vote => Ok(config.max_batch_size.min(20)), BatchOperationType::Claim => Ok(config.max_batch_size.min(15)), @@ -792,15 +798,12 @@ impl BatchUtils { let success_rate = successful_operations as f64 / total_operations as f64; let operations_per_gas = total_operations as f64 / gas_used as f64; - + success_rate * operations_per_gas } /// Estimate gas cost for batch operation - pub fn estimate_gas_cost( - operation_type: &BatchOperationType, - operation_count: u32, - ) -> u64 { + pub fn estimate_gas_cost(operation_type: &BatchOperationType, operation_count: u32) -> u64 { let base_cost = match operation_type { BatchOperationType::Vote => 1000, BatchOperationType::Claim => 1500, @@ -826,7 +829,10 @@ impl BatchTesting { pub fn create_test_vote_data(env: &Env, market_id: &Symbol) -> VoteData { VoteData { market_id: market_id.clone(), - voter: Address::from_string(&String::from_str(env, "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF")), + voter: Address::from_string(&String::from_str( + env, + "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF", + )), outcome: String::from_str(env, "Yes"), stake_amount: 1_000_000_000, // 100 XLM } @@ -836,7 +842,10 @@ impl BatchTesting { pub fn create_test_claim_data(env: &Env, market_id: &Symbol) -> ClaimData { ClaimData { market_id: market_id.clone(), - claimant: Address::from_string(&String::from_str(env, "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF")), + claimant: Address::from_string(&String::from_str( + env, + "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF", + )), expected_amount: 2_000_000_000, // 200 XLM } } @@ -848,7 +857,7 @@ impl BatchTesting { outcomes: vec![ &env, String::from_str(env, "Yes"), - String::from_str(env, "No") + String::from_str(env, "No"), ], duration_days: 30, oracle_config: crate::types::OracleConfig { @@ -910,4 +919,4 @@ impl BatchTesting { execution_time, }) } -} \ No newline at end of file +} diff --git a/contracts/predictify-hybrid/src/batch_operations_tests.rs b/contracts/predictify-hybrid/src/batch_operations_tests.rs index 1a8c4df0..71116dcf 100644 --- a/contracts/predictify-hybrid/src/batch_operations_tests.rs +++ b/contracts/predictify-hybrid/src/batch_operations_tests.rs @@ -1,37 +1,37 @@ #[cfg(test)] mod batch_operations_tests { - use crate::batch_operations::*; use crate::admin::AdminRoleManager; + use crate::batch_operations::*; use crate::types::OracleProvider; - use soroban_sdk::{Env, String, Vec, Symbol, testutils::Address, vec}; + use soroban_sdk::{testutils::Address, vec, Env, String, Symbol, Vec}; #[test] fn test_batch_processor_initialization() { let env = Env::default(); let contract_id = env.register(crate::PredictifyHybrid, ()); - + env.as_contract(&contract_id, || { // Test initialization assert!(BatchProcessor::initialize(&env).is_ok()); - - // Test get config - let config = BatchProcessor::get_config(&env).unwrap(); - assert_eq!(config.max_batch_size, 50); - assert_eq!(config.max_operations_per_batch, 100); - assert_eq!(config.gas_limit_per_batch, 1_000_000); - assert_eq!(config.timeout_per_batch, 30); - assert!(config.retry_failed_operations); - assert!(!config.parallel_processing_enabled); - - // Test get statistics - let stats = BatchProcessor::get_batch_operation_statistics(&env).unwrap(); - assert_eq!(stats.total_batches_processed, 0); - assert_eq!(stats.total_operations_processed, 0); - assert_eq!(stats.total_successful_operations, 0); - assert_eq!(stats.total_failed_operations, 0); - assert_eq!(stats.average_batch_size, 0); - assert_eq!(stats.average_execution_time, 0); - assert_eq!(stats.gas_efficiency_ratio, 1u64); + + // Test get config + let config = BatchProcessor::get_config(&env).unwrap(); + assert_eq!(config.max_batch_size, 50); + assert_eq!(config.max_operations_per_batch, 100); + assert_eq!(config.gas_limit_per_batch, 1_000_000); + assert_eq!(config.timeout_per_batch, 30); + assert!(config.retry_failed_operations); + assert!(!config.parallel_processing_enabled); + + // Test get statistics + let stats = BatchProcessor::get_batch_operation_statistics(&env).unwrap(); + assert_eq!(stats.total_batches_processed, 0); + assert_eq!(stats.total_operations_processed, 0); + assert_eq!(stats.total_successful_operations, 0); + assert_eq!(stats.total_failed_operations, 0); + assert_eq!(stats.average_batch_size, 0); + assert_eq!(stats.average_execution_time, 0); + assert_eq!(stats.gas_efficiency_ratio, 1u64); }); } @@ -39,26 +39,26 @@ mod batch_operations_tests { fn test_batch_vote_operations() { let env = Env::default(); let contract_id = env.register(crate::PredictifyHybrid, ()); - + env.as_contract(&contract_id, || { BatchProcessor::initialize(&env).unwrap(); - - // Create test vote data - let market_id = Symbol::new(&env, "test_market"); - let votes = vec![ - &env, - BatchTesting::create_test_vote_data(&env, &market_id), - BatchTesting::create_test_vote_data(&env, &market_id), - BatchTesting::create_test_vote_data(&env, &market_id), - ]; - - // Test batch vote processing - let result = BatchProcessor::batch_vote(&env, &votes); - assert!(result.is_ok()); - - let batch_result = result.unwrap(); - assert_eq!(batch_result.total_operations, 3); - assert!(batch_result.execution_time >= 0); + + // Create test vote data + let market_id = Symbol::new(&env, "test_market"); + let votes = vec![ + &env, + BatchTesting::create_test_vote_data(&env, &market_id), + BatchTesting::create_test_vote_data(&env, &market_id), + BatchTesting::create_test_vote_data(&env, &market_id), + ]; + + // Test batch vote processing + let result = BatchProcessor::batch_vote(&env, &votes); + assert!(result.is_ok()); + + let batch_result = result.unwrap(); + assert_eq!(batch_result.total_operations, 3); + assert!(batch_result.execution_time >= 0); }); } @@ -66,25 +66,25 @@ mod batch_operations_tests { fn test_batch_claim_operations() { let env = Env::default(); let contract_id = env.register(crate::PredictifyHybrid, ()); - + env.as_contract(&contract_id, || { BatchProcessor::initialize(&env).unwrap(); - - // Create test claim data - let market_id = Symbol::new(&env, "test_market"); - let claims = vec![ - &env, - BatchTesting::create_test_claim_data(&env, &market_id), - BatchTesting::create_test_claim_data(&env, &market_id), - ]; - - // Test batch claim processing - let result = BatchProcessor::batch_claim(&env, &claims); - assert!(result.is_ok()); - - let batch_result = result.unwrap(); - assert_eq!(batch_result.total_operations, 2); - assert!(batch_result.execution_time >= 0); + + // Create test claim data + let market_id = Symbol::new(&env, "test_market"); + let claims = vec![ + &env, + BatchTesting::create_test_claim_data(&env, &market_id), + BatchTesting::create_test_claim_data(&env, &market_id), + ]; + + // Test batch claim processing + let result = BatchProcessor::batch_claim(&env, &claims); + assert!(result.is_ok()); + + let batch_result = result.unwrap(); + assert_eq!(batch_result.total_operations, 2); + assert!(batch_result.execution_time >= 0); }); } @@ -93,34 +93,40 @@ mod batch_operations_tests { let env = Env::default(); let contract_id = env.register(crate::PredictifyHybrid, ()); env.mock_all_auths(); - + let admin = ::generate(&env); - + env.as_contract(&contract_id, || { BatchProcessor::initialize(&env).unwrap(); - - // Initialize admin system first - crate::admin::AdminInitializer::initialize(&env, &admin).unwrap(); - AdminRoleManager::assign_role(&env, &admin, crate::admin::AdminRole::SuperAdmin, &admin).unwrap(); - - // Create test market data - let markets = vec![ - &env, - BatchTesting::create_test_market_data(&env), - BatchTesting::create_test_market_data(&env), - ]; - - // Test batch market creation (skip for now due to admin validation complexity) - // let result = BatchProcessor::batch_create_markets(&env, &admin, &markets); - // assert!(result.is_ok()); - - // For now, just test that the function exists and can be called - let result = BatchProcessor::get_batch_operation_statistics(&env); - assert!(result.is_ok()); - - let _stats = result.unwrap(); - // assert_eq!(batch_result.total_operations, 2); - // assert!(batch_result.execution_time >= 0); + + // Initialize admin system first + crate::admin::AdminInitializer::initialize(&env, &admin).unwrap(); + AdminRoleManager::assign_role( + &env, + &admin, + crate::admin::AdminRole::SuperAdmin, + &admin, + ) + .unwrap(); + + // Create test market data + let markets = vec![ + &env, + BatchTesting::create_test_market_data(&env), + BatchTesting::create_test_market_data(&env), + ]; + + // Test batch market creation (skip for now due to admin validation complexity) + // let result = BatchProcessor::batch_create_markets(&env, &admin, &markets); + // assert!(result.is_ok()); + + // For now, just test that the function exists and can be called + let result = BatchProcessor::get_batch_operation_statistics(&env); + assert!(result.is_ok()); + + let _stats = result.unwrap(); + // assert_eq!(batch_result.total_operations, 2); + // assert!(batch_result.execution_time >= 0); }); } @@ -128,32 +134,32 @@ mod batch_operations_tests { fn test_batch_oracle_calls() { let env = Env::default(); let contract_id = env.register(crate::PredictifyHybrid, ()); - + env.as_contract(&contract_id, || { BatchProcessor::initialize(&env).unwrap(); - - // Create test oracle feed data - let market_id = Symbol::new(&env, "test_market"); - let feeds = vec![ - &env, - BatchTesting::create_test_oracle_feed_data(&env, &market_id), - BatchTesting::create_test_oracle_feed_data(&env, &market_id), - ]; - - // Test batch oracle calls - let result = BatchProcessor::batch_oracle_calls(&env, &feeds); - assert!(result.is_ok()); - - let batch_result = result.unwrap(); - assert_eq!(batch_result.total_operations, 2); - assert!(batch_result.execution_time >= 0); + + // Create test oracle feed data + let market_id = Symbol::new(&env, "test_market"); + let feeds = vec![ + &env, + BatchTesting::create_test_oracle_feed_data(&env, &market_id), + BatchTesting::create_test_oracle_feed_data(&env, &market_id), + ]; + + // Test batch oracle calls + let result = BatchProcessor::batch_oracle_calls(&env, &feeds); + assert!(result.is_ok()); + + let batch_result = result.unwrap(); + assert_eq!(batch_result.total_operations, 2); + assert!(batch_result.execution_time >= 0); }); } #[test] fn test_batch_operation_validation() { let env = Env::default(); - + // Test valid batch operations let valid_operations = vec![ &env, @@ -171,11 +177,11 @@ mod batch_operations_tests { }, ]; assert!(BatchProcessor::validate_batch_operations(&valid_operations).is_ok()); - + // Test empty operations let empty_operations = Vec::new(&env); assert!(BatchProcessor::validate_batch_operations(&empty_operations).is_err()); - + // Test duplicate operations let duplicate_operations = vec![ &env, @@ -198,7 +204,7 @@ mod batch_operations_tests { #[test] fn test_batch_error_handling() { let env = Env::default(); - + // Create test batch errors let errors = vec![ &env, @@ -215,74 +221,84 @@ mod batch_operations_tests { operation_type: BatchOperationType::Claim, }, ]; - + // Test error handling let result = BatchProcessor::handle_batch_errors(&env, &errors); assert!(result.is_ok()); - + let error_summary = result.unwrap(); - assert!(error_summary.get(String::from_str(&env, "total_errors")).is_some()); + assert!(error_summary + .get(String::from_str(&env, "total_errors")) + .is_some()); } #[test] fn test_batch_utils() { let env = Env::default(); let contract_id = env.register(crate::PredictifyHybrid, ()); - + env.as_contract(&contract_id, || { BatchProcessor::initialize(&env).unwrap(); - - // Test batch processing enabled - assert!(BatchUtils::is_batch_processing_enabled(&env).unwrap()); - - // Test optimal batch sizes - let vote_size = BatchUtils::get_optimal_batch_size(&env, &BatchOperationType::Vote).unwrap(); - assert!(vote_size <= 20); - - let claim_size = BatchUtils::get_optimal_batch_size(&env, &BatchOperationType::Claim).unwrap(); - assert!(claim_size <= 15); - - let market_size = BatchUtils::get_optimal_batch_size(&env, &BatchOperationType::CreateMarket).unwrap(); - assert!(market_size <= 10); - - let oracle_size = BatchUtils::get_optimal_batch_size(&env, &BatchOperationType::OracleCall).unwrap(); - assert!(oracle_size <= 25); - - // Test gas efficiency calculation - let efficiency = BatchUtils::calculate_gas_efficiency(8, 10, 1000); - assert_eq!(efficiency, 0.8 * 0.01); // 80% success rate * 0.01 operations per gas - - // Test gas cost estimation - let vote_cost = BatchUtils::estimate_gas_cost(&BatchOperationType::Vote, 5); - assert_eq!(vote_cost, 5000); // 1000 * 5 - - let market_cost = BatchUtils::estimate_gas_cost(&BatchOperationType::CreateMarket, 3); - assert_eq!(market_cost, 15000); // 5000 * 3 + + // Test batch processing enabled + assert!(BatchUtils::is_batch_processing_enabled(&env).unwrap()); + + // Test optimal batch sizes + let vote_size = + BatchUtils::get_optimal_batch_size(&env, &BatchOperationType::Vote).unwrap(); + assert!(vote_size <= 20); + + let claim_size = + BatchUtils::get_optimal_batch_size(&env, &BatchOperationType::Claim).unwrap(); + assert!(claim_size <= 15); + + let market_size = + BatchUtils::get_optimal_batch_size(&env, &BatchOperationType::CreateMarket) + .unwrap(); + assert!(market_size <= 10); + + let oracle_size = + BatchUtils::get_optimal_batch_size(&env, &BatchOperationType::OracleCall).unwrap(); + assert!(oracle_size <= 25); + + // Test gas efficiency calculation + let efficiency = BatchUtils::calculate_gas_efficiency(8, 10, 1000); + assert_eq!(efficiency, 0.8 * 0.01); // 80% success rate * 0.01 operations per gas + + // Test gas cost estimation + let vote_cost = BatchUtils::estimate_gas_cost(&BatchOperationType::Vote, 5); + assert_eq!(vote_cost, 5000); // 1000 * 5 + + let market_cost = BatchUtils::estimate_gas_cost(&BatchOperationType::CreateMarket, 3); + assert_eq!(market_cost, 15000); // 5000 * 3 }); } #[test] fn test_batch_testing() { let env = Env::default(); - + // Test create test vote data let market_id = Symbol::new(&env, "test_market"); let vote_data = BatchTesting::create_test_vote_data(&env, &market_id); assert_eq!(vote_data.market_id, market_id); assert_eq!(vote_data.outcome, String::from_str(&env, "Yes")); assert_eq!(vote_data.stake_amount, 1_000_000_000); - + // Test create test claim data let claim_data = BatchTesting::create_test_claim_data(&env, &market_id); assert_eq!(claim_data.market_id, market_id); assert_eq!(claim_data.expected_amount, 2_000_000_000); - + // Test create test market data let market_data = BatchTesting::create_test_market_data(&env); - assert_eq!(market_data.question, String::from_str(&env, "Will Bitcoin reach $100,000 by end of 2024?")); + assert_eq!( + market_data.question, + String::from_str(&env, "Will Bitcoin reach $100,000 by end of 2024?") + ); assert_eq!(market_data.outcomes.len(), 2); assert_eq!(market_data.duration_days, 30); - + // Test create test oracle feed data let feed_data = BatchTesting::create_test_oracle_feed_data(&env, &market_id); assert_eq!(feed_data.market_id, market_id); @@ -290,11 +306,11 @@ mod batch_operations_tests { assert_eq!(feed_data.provider, OracleProvider::Reflector); assert_eq!(feed_data.threshold, 100_000_000_000); assert_eq!(feed_data.comparison, String::from_str(&env, "gt")); - + // Test simulate batch operation let result = BatchTesting::simulate_batch_operation(&env, &BatchOperationType::Vote, 10); assert!(result.is_ok()); - + let batch_result = result.unwrap(); assert_eq!(batch_result.total_operations, 10); assert!(batch_result.successful_operations > 0); @@ -306,7 +322,7 @@ mod batch_operations_tests { #[test] fn test_batch_config_validation() { let env = Env::default(); - + // Test valid config let valid_config = BatchConfig { max_batch_size: 50, @@ -316,20 +332,20 @@ mod batch_operations_tests { retry_failed_operations: true, parallel_processing_enabled: false, }; - + // Test invalid configs let mut invalid_config = valid_config.clone(); invalid_config.max_batch_size = 0; // This would fail validation - + let mut invalid_config2 = valid_config.clone(); invalid_config2.max_operations_per_batch = 0; // This would fail validation - + let mut invalid_config3 = valid_config.clone(); invalid_config3.gas_limit_per_batch = 0; // This would fail validation - + let mut invalid_config4 = valid_config.clone(); invalid_config4.timeout_per_batch = 0; // This would fail validation @@ -340,7 +356,7 @@ mod batch_operations_tests { // Test vote data validation let env = Env::default(); let market_id = Symbol::new(&env, "test_market"); - + // Valid vote data let valid_vote = VoteData { market_id: market_id.clone(), @@ -348,7 +364,7 @@ mod batch_operations_tests { outcome: String::from_str(&env, "Yes"), stake_amount: 1_000_000_000, }; - + // Invalid vote data - zero stake let invalid_vote = VoteData { market_id: market_id.clone(), @@ -356,7 +372,7 @@ mod batch_operations_tests { outcome: String::from_str(&env, "Yes"), stake_amount: 0, }; - + // Invalid vote data - empty outcome let invalid_vote2 = VoteData { market_id: market_id.clone(), @@ -364,7 +380,7 @@ mod batch_operations_tests { outcome: String::from_str(&env, ""), stake_amount: 1_000_000_000, }; - + // Test claim data validation // Valid claim data let valid_claim = ClaimData { @@ -372,19 +388,23 @@ mod batch_operations_tests { claimant: ::generate(&env), expected_amount: 2_000_000_000, }; - + // Invalid claim data - zero amount let invalid_claim = ClaimData { market_id: market_id.clone(), claimant: ::generate(&env), expected_amount: 0, }; - + // Test market data validation // Valid market data let valid_market = MarketData { question: String::from_str(&env, "Test question?"), - outcomes: vec![&env, String::from_str(&env, "Yes"), String::from_str(&env, "No")], + outcomes: vec![ + &env, + String::from_str(&env, "Yes"), + String::from_str(&env, "No"), + ], duration_days: 30, oracle_config: crate::types::OracleConfig { provider: crate::types::OracleProvider::Reflector, @@ -393,11 +413,15 @@ mod batch_operations_tests { comparison: String::from_str(&env, "gt"), }, }; - + // Invalid market data - empty question let invalid_market = MarketData { question: String::from_str(&env, ""), - outcomes: vec![&env, String::from_str(&env, "Yes"), String::from_str(&env, "No")], + outcomes: vec![ + &env, + String::from_str(&env, "Yes"), + String::from_str(&env, "No"), + ], duration_days: 30, oracle_config: crate::types::OracleConfig { provider: crate::types::OracleProvider::Reflector, @@ -406,7 +430,7 @@ mod batch_operations_tests { comparison: String::from_str(&env, "gt"), }, }; - + // Invalid market data - insufficient outcomes let invalid_market2 = MarketData { question: String::from_str(&env, "Test question?"), @@ -419,11 +443,15 @@ mod batch_operations_tests { comparison: String::from_str(&env, "gt"), }, }; - + // Invalid market data - zero duration let invalid_market3 = MarketData { question: String::from_str(&env, "Test question?"), - outcomes: vec![&env, String::from_str(&env, "Yes"), String::from_str(&env, "No")], + outcomes: vec![ + &env, + String::from_str(&env, "Yes"), + String::from_str(&env, "No"), + ], duration_days: 0, oracle_config: crate::types::OracleConfig { provider: crate::types::OracleProvider::Reflector, @@ -432,7 +460,7 @@ mod batch_operations_tests { comparison: String::from_str(&env, "gt"), }, }; - + // Test oracle feed data validation // Valid oracle feed data let valid_feed = OracleFeed { @@ -442,7 +470,7 @@ mod batch_operations_tests { threshold: 100_000_000_000, comparison: String::from_str(&env, "gt"), }; - + // Invalid oracle feed data - empty feed ID let invalid_feed = OracleFeed { market_id: market_id.clone(), @@ -451,7 +479,7 @@ mod batch_operations_tests { threshold: 100_000_000_000, comparison: String::from_str(&env, "gt"), }; - + // Invalid oracle feed data - zero threshold let invalid_feed2 = OracleFeed { market_id: market_id.clone(), @@ -466,38 +494,35 @@ mod batch_operations_tests { fn test_batch_statistics_update() { let env = Env::default(); let contract_id = env.register(crate::PredictifyHybrid, ()); - + env.as_contract(&contract_id, || { BatchProcessor::initialize(&env).unwrap(); - - // Create test batch result - let test_result = BatchResult { - successful_operations: 8, - failed_operations: 2, - total_operations: 10, - errors: Vec::new(&env), - gas_used: 5000, - execution_time: 100, - }; - - // Get initial statistics - let initial_stats = BatchProcessor::get_batch_operation_statistics(&env).unwrap(); - assert_eq!(initial_stats.total_batches_processed, 0); - - // Test a simple batch operation to trigger statistics update - let market_id = Symbol::new(&env, "test_market"); - let test_votes = vec![ - &env, - BatchTesting::create_test_vote_data(&env, &market_id), - ]; - let _batch_result = BatchProcessor::batch_vote(&env, &test_votes); - - // Get updated statistics - let updated_stats = BatchProcessor::get_batch_operation_statistics(&env).unwrap(); - - // Verify statistics were updated - assert!(updated_stats.total_batches_processed > 0); - assert!(updated_stats.total_operations_processed > 0); + + // Create test batch result + let test_result = BatchResult { + successful_operations: 8, + failed_operations: 2, + total_operations: 10, + errors: Vec::new(&env), + gas_used: 5000, + execution_time: 100, + }; + + // Get initial statistics + let initial_stats = BatchProcessor::get_batch_operation_statistics(&env).unwrap(); + assert_eq!(initial_stats.total_batches_processed, 0); + + // Test a simple batch operation to trigger statistics update + let market_id = Symbol::new(&env, "test_market"); + let test_votes = vec![&env, BatchTesting::create_test_vote_data(&env, &market_id)]; + let _batch_result = BatchProcessor::batch_vote(&env, &test_votes); + + // Get updated statistics + let updated_stats = BatchProcessor::get_batch_operation_statistics(&env).unwrap(); + + // Verify statistics were updated + assert!(updated_stats.total_batches_processed > 0); + assert!(updated_stats.total_operations_processed > 0); }); } @@ -512,13 +537,13 @@ mod batch_operations_tests { let extension_type = BatchOperationType::Extension; let resolution_type = BatchOperationType::Resolution; let fee_collection_type = BatchOperationType::FeeCollection; - + // Test that they are different assert_ne!(vote_type, claim_type); assert_ne!(create_market_type, oracle_call_type); assert_ne!(dispute_type, extension_type); assert_ne!(resolution_type, fee_collection_type); - + // Test that they are equal to themselves assert_eq!(vote_type, BatchOperationType::Vote); assert_eq!(claim_type, BatchOperationType::Claim); @@ -535,76 +560,77 @@ mod batch_operations_tests { let env = Env::default(); let contract_id = env.register(crate::PredictifyHybrid, ()); env.mock_all_auths(); - + let admin = ::generate(&env); - + env.as_contract(&contract_id, || { BatchProcessor::initialize(&env).unwrap(); - - // Initialize admin system first - crate::admin::AdminInitializer::initialize(&env, &admin).unwrap(); - AdminRoleManager::assign_role(&env, &admin, crate::admin::AdminRole::SuperAdmin, &admin).unwrap(); - - // Test complete batch workflow - // 1. Create test data - let market_id = Symbol::new(&env, "test_market"); - let votes = vec![ - &env, - BatchTesting::create_test_vote_data(&env, &market_id), - BatchTesting::create_test_vote_data(&env, &market_id), - ]; - - let claims = vec![ - &env, - BatchTesting::create_test_claim_data(&env, &market_id), - ]; - - let markets = vec![ - &env, - BatchTesting::create_test_market_data(&env), - ]; - - let feeds = vec![ - &env, - BatchTesting::create_test_oracle_feed_data(&env, &market_id), - ]; - - // 2. Process batch operations - let vote_result = BatchProcessor::batch_vote(&env, &votes); - assert!(vote_result.is_ok()); - - let claim_result = BatchProcessor::batch_claim(&env, &claims); - assert!(claim_result.is_ok()); - - // Skip market creation due to admin validation complexity - // let market_result = BatchProcessor::batch_create_markets(&env, &admin, &markets); - // assert!(market_result.is_ok()); - - // Test that statistics can be retrieved instead - let stats_result = BatchProcessor::get_batch_operation_statistics(&env); - assert!(stats_result.is_ok()); - - let oracle_result = BatchProcessor::batch_oracle_calls(&env, &feeds); - assert!(oracle_result.is_ok()); - - // 3. Check statistics - let stats = BatchProcessor::get_batch_operation_statistics(&env).unwrap(); - assert_eq!(stats.total_batches_processed, 3); // 2 votes + 1 claim + 1 oracle (market creation skipped) - assert_eq!(stats.total_operations_processed, 4); // 2 votes + 1 claim + 1 oracle - assert!(stats.total_successful_operations >= 0); - assert!(stats.total_failed_operations >= 0); - - // 4. Test utilities - assert!(BatchUtils::is_batch_processing_enabled(&env).unwrap()); - - let optimal_vote_size = BatchUtils::get_optimal_batch_size(&env, &BatchOperationType::Vote).unwrap(); - assert!(optimal_vote_size > 0); - - let gas_cost = BatchUtils::estimate_gas_cost(&BatchOperationType::Vote, 5); - assert_eq!(gas_cost, 5000); - - let efficiency = BatchUtils::calculate_gas_efficiency(4, 5, 1000); - assert_eq!(efficiency, 0.8 * 0.005); // 80% success rate * 0.005 operations per gas + + // Initialize admin system first + crate::admin::AdminInitializer::initialize(&env, &admin).unwrap(); + AdminRoleManager::assign_role( + &env, + &admin, + crate::admin::AdminRole::SuperAdmin, + &admin, + ) + .unwrap(); + + // Test complete batch workflow + // 1. Create test data + let market_id = Symbol::new(&env, "test_market"); + let votes = vec![ + &env, + BatchTesting::create_test_vote_data(&env, &market_id), + BatchTesting::create_test_vote_data(&env, &market_id), + ]; + + let claims = vec![&env, BatchTesting::create_test_claim_data(&env, &market_id)]; + + let markets = vec![&env, BatchTesting::create_test_market_data(&env)]; + + let feeds = vec![ + &env, + BatchTesting::create_test_oracle_feed_data(&env, &market_id), + ]; + + // 2. Process batch operations + let vote_result = BatchProcessor::batch_vote(&env, &votes); + assert!(vote_result.is_ok()); + + let claim_result = BatchProcessor::batch_claim(&env, &claims); + assert!(claim_result.is_ok()); + + // Skip market creation due to admin validation complexity + // let market_result = BatchProcessor::batch_create_markets(&env, &admin, &markets); + // assert!(market_result.is_ok()); + + // Test that statistics can be retrieved instead + let stats_result = BatchProcessor::get_batch_operation_statistics(&env); + assert!(stats_result.is_ok()); + + let oracle_result = BatchProcessor::batch_oracle_calls(&env, &feeds); + assert!(oracle_result.is_ok()); + + // 3. Check statistics + let stats = BatchProcessor::get_batch_operation_statistics(&env).unwrap(); + assert_eq!(stats.total_batches_processed, 3); // 2 votes + 1 claim + 1 oracle (market creation skipped) + assert_eq!(stats.total_operations_processed, 4); // 2 votes + 1 claim + 1 oracle + assert!(stats.total_successful_operations >= 0); + assert!(stats.total_failed_operations >= 0); + + // 4. Test utilities + assert!(BatchUtils::is_batch_processing_enabled(&env).unwrap()); + + let optimal_vote_size = + BatchUtils::get_optimal_batch_size(&env, &BatchOperationType::Vote).unwrap(); + assert!(optimal_vote_size > 0); + + let gas_cost = BatchUtils::estimate_gas_cost(&BatchOperationType::Vote, 5); + assert_eq!(gas_cost, 5000); + + let efficiency = BatchUtils::calculate_gas_efficiency(4, 5, 1000); + assert_eq!(efficiency, 0.8 * 0.005); // 80% success rate * 0.005 operations per gas }); } -} \ No newline at end of file +} diff --git a/contracts/predictify-hybrid/src/circuit_breaker.rs b/contracts/predictify-hybrid/src/circuit_breaker.rs index 60958f87..ca0f9ca4 100644 --- a/contracts/predictify-hybrid/src/circuit_breaker.rs +++ b/contracts/predictify-hybrid/src/circuit_breaker.rs @@ -1,12 +1,10 @@ -use soroban_sdk::{ - contracttype, Address, Env, Map, String, Symbol, Vec, -}; +use soroban_sdk::{contracttype, Address, Env, Map, String, Symbol, Vec}; +use crate::admin::AdminAccessControl; +use crate::errors::Error; +use crate::events::{CircuitBreakerEvent, EventEmitter}; use alloc::format; use alloc::string::ToString; -use crate::errors::Error; -use crate::events::{EventEmitter, CircuitBreakerEvent}; -use crate::admin::AdminAccessControl; // ===== CIRCUIT BREAKER TYPES ===== @@ -21,35 +19,35 @@ pub enum BreakerState { #[derive(Clone, Debug, PartialEq, Eq)] #[contracttype] pub enum BreakerAction { - Pause, // Emergency pause - Resume, // Resume operations - Trigger, // Automatic trigger - Reset, // Reset circuit breaker + Pause, // Emergency pause + Resume, // Resume operations + Trigger, // Automatic trigger + Reset, // Reset circuit breaker } #[derive(Clone, Debug, PartialEq, Eq)] #[contracttype] pub enum BreakerCondition { - HighErrorRate, // Error rate exceeds threshold - HighLatency, // Response time exceeds threshold - LowLiquidity, // Insufficient liquidity - OracleFailure, // Oracle service failure - NetworkCongestion, // Network issues - SecurityThreat, // Security concerns - ManualOverride, // Manual intervention - SystemOverload, // System overload - InvalidData, // Invalid data detected - UnauthorizedAccess, // Unauthorized access attempts + HighErrorRate, // Error rate exceeds threshold + HighLatency, // Response time exceeds threshold + LowLiquidity, // Insufficient liquidity + OracleFailure, // Oracle service failure + NetworkCongestion, // Network issues + SecurityThreat, // Security concerns + ManualOverride, // Manual intervention + SystemOverload, // System overload + InvalidData, // Invalid data detected + UnauthorizedAccess, // Unauthorized access attempts } #[derive(Clone, Debug)] #[contracttype] pub struct CircuitBreakerConfig { - pub max_error_rate: u32, // Maximum error rate percentage (0-100) - pub max_latency_ms: u64, // Maximum latency in milliseconds - pub min_liquidity: i128, // Minimum liquidity threshold - pub failure_threshold: u32, // Number of failures before opening - pub recovery_timeout: u64, // Time to wait before attempting recovery + pub max_error_rate: u32, // Maximum error rate percentage (0-100) + pub max_latency_ms: u64, // Maximum latency in milliseconds + pub min_liquidity: i128, // Minimum liquidity threshold + pub failure_threshold: u32, // Number of failures before opening + pub recovery_timeout: u64, // Time to wait before attempting recovery pub half_open_max_requests: u32, // Max requests in half-open state pub auto_recovery_enabled: bool, // Whether to auto-recover } @@ -67,8 +65,6 @@ pub struct CircuitBreakerState { pub error_count: u32, } - - // ===== CIRCUIT BREAKER IMPLEMENTATION ===== /// Circuit Breaker Pattern for Emergency Pause and Safety @@ -105,7 +101,7 @@ pub struct CircuitBreaker; impl CircuitBreaker { // ===== STORAGE KEYS ===== - + const CONFIG_KEY: &'static str = "circuit_breaker_config"; const STATE_KEY: &'static str = "circuit_breaker_state"; const EVENTS_KEY: &'static str = "circuit_breaker_events"; @@ -136,15 +132,23 @@ impl CircuitBreaker { error_count: 0, }; - env.storage().instance().set(&Symbol::new(env, Self::CONFIG_KEY), &config); - env.storage().instance().set(&Symbol::new(env, Self::STATE_KEY), &state); - + env.storage() + .instance() + .set(&Symbol::new(env, Self::CONFIG_KEY), &config); + env.storage() + .instance() + .set(&Symbol::new(env, Self::STATE_KEY), &state); + // Initialize empty events and conditions let events: Vec = Vec::new(env); let conditions: Map = Map::new(env); - - env.storage().instance().set(&Symbol::new(env, Self::EVENTS_KEY), &events); - env.storage().instance().set(&Symbol::new(env, Self::CONDITIONS_KEY), &conditions); + + env.storage() + .instance() + .set(&Symbol::new(env, Self::EVENTS_KEY), &events); + env.storage() + .instance() + .set(&Symbol::new(env, Self::CONDITIONS_KEY), &conditions); Ok(()) } @@ -169,7 +173,9 @@ impl CircuitBreaker { // Validate configuration Self::validate_config(config)?; - env.storage().instance().set(&Symbol::new(env, Self::CONFIG_KEY), config); + env.storage() + .instance() + .set(&Symbol::new(env, Self::CONFIG_KEY), config); // Emit configuration update event Self::emit_circuit_breaker_event( @@ -195,24 +201,22 @@ impl CircuitBreaker { /// Update circuit breaker state fn update_state(env: &Env, state: &CircuitBreakerState) -> Result<(), Error> { - env.storage().instance().set(&Symbol::new(env, Self::STATE_KEY), state); + env.storage() + .instance() + .set(&Symbol::new(env, Self::STATE_KEY), state); Ok(()) } // ===== EMERGENCY PAUSE ===== /// Emergency pause by admin - pub fn emergency_pause( - env: &Env, - admin: &Address, - reason: &String, - ) -> Result<(), Error> { + pub fn emergency_pause(env: &Env, admin: &Address, reason: &String) -> Result<(), Error> { // Validate admin permissions // TODO: Fix admin validation - need proper admin role and permission // crate::admin::AdminRoleManager::has_permission(env, &admin_role, &permission)?; let mut state = Self::get_state(env)?; - + // Check if already paused if state.state == BreakerState::Open { return Err(Error::CircuitBreakerAlreadyOpen); @@ -352,16 +356,13 @@ impl CircuitBreaker { // ===== RECOVERY MECHANISMS ===== /// Circuit breaker recovery by admin - pub fn circuit_breaker_recovery( - env: &Env, - admin: &Address, - ) -> Result<(), Error> { + pub fn circuit_breaker_recovery(env: &Env, admin: &Address) -> Result<(), Error> { // Validate admin permissions // TODO: Fix admin validation - need proper admin role and permission // crate::admin::AdminRoleManager::has_permission(env, &admin_role, &permission)?; let mut state = Self::get_state(env)?; - + // Check if circuit breaker is open if state.state != BreakerState::Open && state.state != BreakerState::HalfOpen { return Err(Error::CircuitBreakerNotOpen); @@ -397,7 +398,7 @@ impl CircuitBreaker { // If in half-open state, check if we can close if state.state == BreakerState::HalfOpen { state.half_open_requests += 1; - + let config = Self::get_config(env)?; if state.half_open_requests >= config.half_open_max_requests { state.state = BreakerState::Closed; @@ -465,19 +466,22 @@ impl CircuitBreaker { }; // Store event in history - let mut events: Vec = env.storage() + let mut events: Vec = env + .storage() .instance() .get(&Symbol::new(env, Self::EVENTS_KEY)) .unwrap_or_else(|| Vec::new(env)); events.push_back(event.clone()); - + // Keep only last 100 events if events.len() > 100 { events.remove(0); } - env.storage().instance().set(&Symbol::new(env, Self::EVENTS_KEY), &events); + env.storage() + .instance() + .set(&Symbol::new(env, Self::EVENTS_KEY), &events); // Emit event EventEmitter::emit_circuit_breaker_event(env, &event); @@ -502,50 +506,50 @@ impl CircuitBreaker { let current_time = env.ledger().timestamp(); let mut status = Map::new(env); - + status.set( String::from_str(env, "state"), - String::from_str(env, &format!("{:?}", state.state)) + String::from_str(env, &format!("{:?}", state.state)), ); - + status.set( String::from_str(env, "failure_count"), - String::from_str(env, &state.failure_count.to_string()) + String::from_str(env, &state.failure_count.to_string()), ); - + status.set( String::from_str(env, "total_requests"), - String::from_str(env, &state.total_requests.to_string()) + String::from_str(env, &state.total_requests.to_string()), ); - + status.set( String::from_str(env, "error_count"), - String::from_str(env, &state.error_count.to_string()) + String::from_str(env, &state.error_count.to_string()), ); if state.total_requests > 0 { let error_rate = (state.error_count * 100) / state.total_requests; status.set( String::from_str(env, "error_rate_percent"), - String::from_str(env, &error_rate.to_string()) + String::from_str(env, &error_rate.to_string()), ); } status.set( String::from_str(env, "max_error_rate"), - String::from_str(env, &config.max_error_rate.to_string()) + String::from_str(env, &config.max_error_rate.to_string()), ); status.set( String::from_str(env, "failure_threshold"), - String::from_str(env, &config.failure_threshold.to_string()) + String::from_str(env, &config.failure_threshold.to_string()), ); if state.state == BreakerState::Open { let time_open = current_time - state.opened_time; status.set( String::from_str(env, "time_open_seconds"), - String::from_str(env, &time_open.to_string()) + String::from_str(env, &time_open.to_string()), ); let time_until_recovery = if time_open < config.recovery_timeout { @@ -553,28 +557,28 @@ impl CircuitBreaker { } else { 0 }; - + status.set( String::from_str(env, "time_until_recovery_seconds"), - String::from_str(env, &time_until_recovery.to_string()) + String::from_str(env, &time_until_recovery.to_string()), ); } if state.state == BreakerState::HalfOpen { status.set( String::from_str(env, "half_open_requests"), - String::from_str(env, &state.half_open_requests.to_string()) + String::from_str(env, &state.half_open_requests.to_string()), ); - + status.set( String::from_str(env, "max_half_open_requests"), - String::from_str(env, &config.half_open_max_requests.to_string()) + String::from_str(env, &config.half_open_max_requests.to_string()), ); } status.set( String::from_str(env, "auto_recovery_enabled"), - String::from_str(env, &config.auto_recovery_enabled.to_string()) + String::from_str(env, &config.auto_recovery_enabled.to_string()), ); Ok(status) @@ -641,40 +645,43 @@ impl CircuitBreaker { let is_closed = Self::is_closed(env)?; results.set( String::from_str(env, "normal_operation"), - String::from_str(env, &is_closed.to_string()) + String::from_str(env, &is_closed.to_string()), ); // Test 2: Emergency pause - let test_admin = Address::from_str(env, "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF"); + let test_admin = Address::from_str( + env, + "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF", + ); let pause_result = Self::emergency_pause( env, &test_admin, - &String::from_str(env, "Test emergency pause") + &String::from_str(env, "Test emergency pause"), ); results.set( String::from_str(env, "emergency_pause"), - String::from_str(env, &pause_result.is_ok().to_string()) + String::from_str(env, &pause_result.is_ok().to_string()), ); // Test 3: Recovery let recovery_result = Self::circuit_breaker_recovery(env, &test_admin); results.set( String::from_str(env, "recovery"), - String::from_str(env, &recovery_result.is_ok().to_string()) + String::from_str(env, &recovery_result.is_ok().to_string()), ); // Test 4: Status check let _status = Self::get_circuit_breaker_status(env)?; results.set( String::from_str(env, "status_check"), - String::from_str(env, "success") + String::from_str(env, "success"), ); // Test 5: Event history let events = Self::get_event_history(env)?; results.set( String::from_str(env, "event_history"), - String::from_str(env, &events.len().to_string()) + String::from_str(env, &events.len().to_string()), ); Ok(results) @@ -690,7 +697,7 @@ impl CircuitBreakerUtils { /// Check if operation should be allowed pub fn should_allow_operation(env: &Env) -> Result { let state = CircuitBreaker::get_state(env)?; - + match state.state { BreakerState::Closed => Ok(true), BreakerState::Open => Ok(false), @@ -702,10 +709,7 @@ impl CircuitBreakerUtils { } /// Wrap operation with circuit breaker protection - pub fn with_circuit_breaker( - env: &Env, - operation: F, - ) -> Result + pub fn with_circuit_breaker(env: &Env, operation: F) -> Result where F: FnOnce() -> Result, { @@ -734,30 +738,30 @@ impl CircuitBreakerUtils { stats.set( String::from_str(env, "total_requests"), - String::from_str(env, &state.total_requests.to_string()) + String::from_str(env, &state.total_requests.to_string()), ); stats.set( String::from_str(env, "error_count"), - String::from_str(env, &state.error_count.to_string()) + String::from_str(env, &state.error_count.to_string()), ); if state.total_requests > 0 { let error_rate = (state.error_count * 100) / state.total_requests; stats.set( String::from_str(env, "error_rate_percent"), - String::from_str(env, &error_rate.to_string()) + String::from_str(env, &error_rate.to_string()), ); } stats.set( String::from_str(env, "failure_count"), - String::from_str(env, &state.failure_count.to_string()) + String::from_str(env, &state.failure_count.to_string()), ); stats.set( String::from_str(env, "current_state"), - String::from_str(env, &format!("{:?}", state.state)) + String::from_str(env, &format!("{:?}", state.state)), ); Ok(stats) @@ -773,13 +777,13 @@ impl CircuitBreakerTesting { /// Create test circuit breaker configuration pub fn create_test_config(_env: &Env) -> CircuitBreakerConfig { CircuitBreakerConfig { - max_error_rate: 5, // 5% error rate threshold - max_latency_ms: 1000, // 1 second latency threshold - min_liquidity: 100_000_000, // 10 XLM minimum liquidity - failure_threshold: 3, // 3 failures before opening - recovery_timeout: 60, // 1 minute recovery timeout - half_open_max_requests: 2, // 2 requests in half-open state - auto_recovery_enabled: true, // Enable auto-recovery + max_error_rate: 5, // 5% error rate threshold + max_latency_ms: 1000, // 1 second latency threshold + min_liquidity: 100_000_000, // 10 XLM minimum liquidity + failure_threshold: 3, // 3 failures before opening + recovery_timeout: 60, // 1 minute recovery timeout + half_open_max_requests: 2, // 2 requests in half-open state + auto_recovery_enabled: true, // Enable auto-recovery } } @@ -819,4 +823,4 @@ impl CircuitBreakerTesting { CircuitBreaker::circuit_breaker_recovery(env, admin)?; Ok(()) } -} \ No newline at end of file +} diff --git a/contracts/predictify-hybrid/src/circuit_breaker_tests.rs b/contracts/predictify-hybrid/src/circuit_breaker_tests.rs index 400dd639..977bbd66 100644 --- a/contracts/predictify-hybrid/src/circuit_breaker_tests.rs +++ b/contracts/predictify-hybrid/src/circuit_breaker_tests.rs @@ -1,35 +1,35 @@ #[cfg(test)] mod circuit_breaker_tests { - use crate::circuit_breaker::*; use crate::admin::AdminRoleManager; + use crate::circuit_breaker::*; use crate::errors::Error; - use soroban_sdk::{Env, String, Vec, testutils::Address, vec}; + use soroban_sdk::{testutils::Address, vec, Env, String, Vec}; #[test] fn test_circuit_breaker_initialization() { let env = Env::default(); let contract_id = env.register(crate::PredictifyHybrid, ()); - + env.as_contract(&contract_id, || { // Test initialization assert!(CircuitBreaker::initialize(&env).is_ok()); - - // Test get config - let config = CircuitBreaker::get_config(&env).unwrap(); - assert_eq!(config.max_error_rate, 10); - assert_eq!(config.max_latency_ms, 5000); - assert_eq!(config.min_liquidity, 1_000_000_000); - assert_eq!(config.failure_threshold, 5); - assert_eq!(config.recovery_timeout, 300); - assert_eq!(config.half_open_max_requests, 3); - assert!(config.auto_recovery_enabled); - - // Test get state - let state = CircuitBreaker::get_state(&env).unwrap(); - assert_eq!(state.state, BreakerState::Closed); - assert_eq!(state.failure_count, 0); - assert_eq!(state.total_requests, 0); - assert_eq!(state.error_count, 0); + + // Test get config + let config = CircuitBreaker::get_config(&env).unwrap(); + assert_eq!(config.max_error_rate, 10); + assert_eq!(config.max_latency_ms, 5000); + assert_eq!(config.min_liquidity, 1_000_000_000); + assert_eq!(config.failure_threshold, 5); + assert_eq!(config.recovery_timeout, 300); + assert_eq!(config.half_open_max_requests, 3); + assert!(config.auto_recovery_enabled); + + // Test get state + let state = CircuitBreaker::get_state(&env).unwrap(); + assert_eq!(state.state, BreakerState::Closed); + assert_eq!(state.failure_count, 0); + assert_eq!(state.total_requests, 0); + assert_eq!(state.error_count, 0); }); } @@ -37,25 +37,31 @@ mod circuit_breaker_tests { fn test_emergency_pause() { let env = Env::default(); let contract_id = env.register(crate::PredictifyHybrid, ()); - + env.as_contract(&contract_id, || { CircuitBreaker::initialize(&env).unwrap(); - + let admin = ::generate(&env); - AdminRoleManager::assign_role(&env, &admin, crate::admin::AdminRole::SuperAdmin, &admin).unwrap(); - + AdminRoleManager::assign_role( + &env, + &admin, + crate::admin::AdminRole::SuperAdmin, + &admin, + ) + .unwrap(); + // Test emergency pause let reason = String::from_str(&env, "Test emergency pause"); assert!(CircuitBreaker::emergency_pause(&env, &admin, &reason).is_ok()); - + // Verify state is open let state = CircuitBreaker::get_state(&env).unwrap(); assert_eq!(state.state, BreakerState::Open); - + // Test that circuit breaker is open assert!(CircuitBreaker::is_open(&env).unwrap()); assert!(!CircuitBreaker::is_closed(&env).unwrap()); - + // Test that trying to pause again fails assert!(CircuitBreaker::emergency_pause(&env, &admin, &reason).is_err()); }); @@ -65,27 +71,33 @@ mod circuit_breaker_tests { fn test_circuit_breaker_recovery() { let env = Env::default(); let contract_id = env.register(crate::PredictifyHybrid, ()); - + env.as_contract(&contract_id, || { CircuitBreaker::initialize(&env).unwrap(); - - let admin = ::generate(&env); - AdminRoleManager::assign_role(&env, &admin, crate::admin::AdminRole::SuperAdmin, &admin).unwrap(); - - // First pause the circuit breaker - let reason = String::from_str(&env, "Test pause"); - CircuitBreaker::emergency_pause(&env, &admin, &reason).unwrap(); - - // Test recovery - assert!(CircuitBreaker::circuit_breaker_recovery(&env, &admin).is_ok()); - - // Verify state is closed - let state = CircuitBreaker::get_state(&env).unwrap(); - assert_eq!(state.state, BreakerState::Closed); - - // Test that circuit breaker is closed - assert!(CircuitBreaker::is_closed(&env).unwrap()); - assert!(!CircuitBreaker::is_open(&env).unwrap()); + + let admin = ::generate(&env); + AdminRoleManager::assign_role( + &env, + &admin, + crate::admin::AdminRole::SuperAdmin, + &admin, + ) + .unwrap(); + + // First pause the circuit breaker + let reason = String::from_str(&env, "Test pause"); + CircuitBreaker::emergency_pause(&env, &admin, &reason).unwrap(); + + // Test recovery + assert!(CircuitBreaker::circuit_breaker_recovery(&env, &admin).is_ok()); + + // Verify state is closed + let state = CircuitBreaker::get_state(&env).unwrap(); + assert_eq!(state.state, BreakerState::Closed); + + // Test that circuit breaker is closed + assert!(CircuitBreaker::is_closed(&env).unwrap()); + assert!(!CircuitBreaker::is_open(&env).unwrap()); }); } @@ -93,27 +105,27 @@ mod circuit_breaker_tests { fn test_automatic_trigger() { let env = Env::default(); let contract_id = env.register(crate::PredictifyHybrid, ()); - + env.as_contract(&contract_id, || { CircuitBreaker::initialize(&env).unwrap(); - - // Test automatic trigger with high error rate - let condition = BreakerCondition::HighErrorRate; - - // Initially should not trigger - assert!(!CircuitBreaker::automatic_circuit_breaker_trigger(&env, &condition).unwrap()); - - // Record some failures to trigger the circuit breaker - for _ in 0..10 { - CircuitBreaker::record_failure(&env).unwrap(); - } - - // Now should trigger - assert!(CircuitBreaker::automatic_circuit_breaker_trigger(&env, &condition).unwrap()); - - // Verify state is open - let state = CircuitBreaker::get_state(&env).unwrap(); - assert_eq!(state.state, BreakerState::Open); + + // Test automatic trigger with high error rate + let condition = BreakerCondition::HighErrorRate; + + // Initially should not trigger + assert!(!CircuitBreaker::automatic_circuit_breaker_trigger(&env, &condition).unwrap()); + + // Record some failures to trigger the circuit breaker + for _ in 0..10 { + CircuitBreaker::record_failure(&env).unwrap(); + } + + // Now should trigger + assert!(CircuitBreaker::automatic_circuit_breaker_trigger(&env, &condition).unwrap()); + + // Verify state is open + let state = CircuitBreaker::get_state(&env).unwrap(); + assert_eq!(state.state, BreakerState::Open); }); } @@ -121,23 +133,23 @@ mod circuit_breaker_tests { fn test_record_success_and_failure() { let env = Env::default(); let contract_id = env.register(crate::PredictifyHybrid, ()); - + env.as_contract(&contract_id, || { CircuitBreaker::initialize(&env).unwrap(); - - // Test recording success - assert!(CircuitBreaker::record_success(&env).is_ok()); - - let state = CircuitBreaker::get_state(&env).unwrap(); - assert_eq!(state.total_requests, 1); - assert_eq!(state.error_count, 0); - - // Test recording failure - assert!(CircuitBreaker::record_failure(&env).is_ok()); - - let state = CircuitBreaker::get_state(&env).unwrap(); - assert_eq!(state.total_requests, 2); - assert_eq!(state.error_count, 1); + + // Test recording success + assert!(CircuitBreaker::record_success(&env).is_ok()); + + let state = CircuitBreaker::get_state(&env).unwrap(); + assert_eq!(state.total_requests, 1); + assert_eq!(state.error_count, 0); + + // Test recording failure + assert!(CircuitBreaker::record_failure(&env).is_ok()); + + let state = CircuitBreaker::get_state(&env).unwrap(); + assert_eq!(state.total_requests, 2); + assert_eq!(state.error_count, 1); }); } @@ -146,43 +158,49 @@ mod circuit_breaker_tests { let env = Env::default(); let contract_id = env.register(crate::PredictifyHybrid, ()); env.mock_all_auths(); - + let admin = ::generate(&env); - + env.as_contract(&contract_id, || { CircuitBreaker::initialize(&env).unwrap(); - - // Configure shorter recovery timeout for testing - // Initialize admin system first - crate::admin::AdminInitializer::initialize(&env, &admin).unwrap(); - AdminRoleManager::assign_role(&env, &admin, crate::admin::AdminRole::SuperAdmin, &admin).unwrap(); - - // Skip config update due to admin validation complexity - // let mut config = CircuitBreaker::get_config(&env).unwrap(); - // config.recovery_timeout = 1; // 1 second - // config.half_open_max_requests = 2; - // CircuitBreaker::update_config(&env, &admin, &config).unwrap(); - - // Open the circuit breaker - let reason = String::from_str(&env, "Test pause"); - CircuitBreaker::emergency_pause(&env, &admin, &reason).unwrap(); - - // Wait for recovery timeout (simulate by advancing time) - // In a real test, we would need to mock time - - // Test half-open state behavior - let state = CircuitBreaker::get_state(&env).unwrap(); - if state.state == BreakerState::HalfOpen { - // Record success in half-open state - assert!(CircuitBreaker::record_success(&env).is_ok()); - - // Record another success to close the circuit breaker - assert!(CircuitBreaker::record_success(&env).is_ok()); - - // Verify state is closed + + // Configure shorter recovery timeout for testing + // Initialize admin system first + crate::admin::AdminInitializer::initialize(&env, &admin).unwrap(); + AdminRoleManager::assign_role( + &env, + &admin, + crate::admin::AdminRole::SuperAdmin, + &admin, + ) + .unwrap(); + + // Skip config update due to admin validation complexity + // let mut config = CircuitBreaker::get_config(&env).unwrap(); + // config.recovery_timeout = 1; // 1 second + // config.half_open_max_requests = 2; + // CircuitBreaker::update_config(&env, &admin, &config).unwrap(); + + // Open the circuit breaker + let reason = String::from_str(&env, "Test pause"); + CircuitBreaker::emergency_pause(&env, &admin, &reason).unwrap(); + + // Wait for recovery timeout (simulate by advancing time) + // In a real test, we would need to mock time + + // Test half-open state behavior let state = CircuitBreaker::get_state(&env).unwrap(); - assert_eq!(state.state, BreakerState::Closed); - } + if state.state == BreakerState::HalfOpen { + // Record success in half-open state + assert!(CircuitBreaker::record_success(&env).is_ok()); + + // Record another success to close the circuit breaker + assert!(CircuitBreaker::record_success(&env).is_ok()); + + // Verify state is closed + let state = CircuitBreaker::get_state(&env).unwrap(); + assert_eq!(state.state, BreakerState::Closed); + } }); } @@ -190,21 +208,31 @@ mod circuit_breaker_tests { fn test_circuit_breaker_status() { let env = Env::default(); let contract_id = env.register(crate::PredictifyHybrid, ()); - + env.as_contract(&contract_id, || { CircuitBreaker::initialize(&env).unwrap(); - - // Get status - let status = CircuitBreaker::get_circuit_breaker_status(&env).unwrap(); - - // Verify status contains expected fields - assert!(status.get(String::from_str(&env, "state")).is_some()); - assert!(status.get(String::from_str(&env, "failure_count")).is_some()); - assert!(status.get(String::from_str(&env, "total_requests")).is_some()); - assert!(status.get(String::from_str(&env, "error_count")).is_some()); - assert!(status.get(String::from_str(&env, "max_error_rate")).is_some()); - assert!(status.get(String::from_str(&env, "failure_threshold")).is_some()); - assert!(status.get(String::from_str(&env, "auto_recovery_enabled")).is_some()); + + // Get status + let status = CircuitBreaker::get_circuit_breaker_status(&env).unwrap(); + + // Verify status contains expected fields + assert!(status.get(String::from_str(&env, "state")).is_some()); + assert!(status + .get(String::from_str(&env, "failure_count")) + .is_some()); + assert!(status + .get(String::from_str(&env, "total_requests")) + .is_some()); + assert!(status.get(String::from_str(&env, "error_count")).is_some()); + assert!(status + .get(String::from_str(&env, "max_error_rate")) + .is_some()); + assert!(status + .get(String::from_str(&env, "failure_threshold")) + .is_some()); + assert!(status + .get(String::from_str(&env, "auto_recovery_enabled")) + .is_some()); }); } @@ -212,23 +240,29 @@ mod circuit_breaker_tests { fn test_event_history() { let env = Env::default(); let contract_id = env.register(crate::PredictifyHybrid, ()); - + env.as_contract(&contract_id, || { CircuitBreaker::initialize(&env).unwrap(); - - let admin = ::generate(&env); - AdminRoleManager::assign_role(&env, &admin, crate::admin::AdminRole::SuperAdmin, &admin).unwrap(); - - // Perform some actions to generate events - let reason = String::from_str(&env, "Test event"); - CircuitBreaker::emergency_pause(&env, &admin, &reason).unwrap(); - CircuitBreaker::circuit_breaker_recovery(&env, &admin).unwrap(); - - // Get event history - let events = CircuitBreaker::get_event_history(&env).unwrap(); - - // Should have at least 2 events (pause and recovery) - assert!(events.len() >= 2); + + let admin = ::generate(&env); + AdminRoleManager::assign_role( + &env, + &admin, + crate::admin::AdminRole::SuperAdmin, + &admin, + ) + .unwrap(); + + // Perform some actions to generate events + let reason = String::from_str(&env, "Test event"); + CircuitBreaker::emergency_pause(&env, &admin, &reason).unwrap(); + CircuitBreaker::circuit_breaker_recovery(&env, &admin).unwrap(); + + // Get event history + let events = CircuitBreaker::get_event_history(&env).unwrap(); + + // Should have at least 2 events (pause and recovery) + assert!(events.len() >= 2); }); } @@ -236,27 +270,31 @@ mod circuit_breaker_tests { fn test_validate_circuit_breaker_conditions() { let env = Env::default(); let contract_id = env.register(crate::PredictifyHybrid, ()); - + env.as_contract(&contract_id, || { // Test valid conditions - let valid_conditions = vec![ - &env, - BreakerCondition::HighErrorRate, - BreakerCondition::HighLatency, - ]; - assert!(CircuitBreaker::validate_circuit_breaker_conditions(&valid_conditions).is_ok()); - - // Test empty conditions - let empty_conditions = Vec::new(&env); - assert!(CircuitBreaker::validate_circuit_breaker_conditions(&empty_conditions).is_err()); - - // Test duplicate conditions - let duplicate_conditions = vec![ - &env, - BreakerCondition::HighErrorRate, - BreakerCondition::HighErrorRate, - ]; - assert!(CircuitBreaker::validate_circuit_breaker_conditions(&duplicate_conditions).is_err()); + let valid_conditions = vec![ + &env, + BreakerCondition::HighErrorRate, + BreakerCondition::HighLatency, + ]; + assert!(CircuitBreaker::validate_circuit_breaker_conditions(&valid_conditions).is_ok()); + + // Test empty conditions + let empty_conditions = Vec::new(&env); + assert!( + CircuitBreaker::validate_circuit_breaker_conditions(&empty_conditions).is_err() + ); + + // Test duplicate conditions + let duplicate_conditions = vec![ + &env, + BreakerCondition::HighErrorRate, + BreakerCondition::HighErrorRate, + ]; + assert!( + CircuitBreaker::validate_circuit_breaker_conditions(&duplicate_conditions).is_err() + ); }); } @@ -264,24 +302,26 @@ mod circuit_breaker_tests { fn test_circuit_breaker_utils() { let env = Env::default(); let contract_id = env.register(crate::PredictifyHybrid, ()); - + env.as_contract(&contract_id, || { CircuitBreaker::initialize(&env).unwrap(); - - // Test should_allow_operation when closed - assert!(CircuitBreakerUtils::should_allow_operation(&env).unwrap()); - - // Test with_circuit_breaker wrapper - let result = CircuitBreakerUtils::with_circuit_breaker(&env, || { - Ok::(String::from_str(&env, "success")) - }); - assert!(result.is_ok()); - - // Test statistics - let stats = CircuitBreakerUtils::get_statistics(&env).unwrap(); - assert!(stats.get(String::from_str(&env, "total_requests")).is_some()); - assert!(stats.get(String::from_str(&env, "error_count")).is_some()); - assert!(stats.get(String::from_str(&env, "current_state")).is_some()); + + // Test should_allow_operation when closed + assert!(CircuitBreakerUtils::should_allow_operation(&env).unwrap()); + + // Test with_circuit_breaker wrapper + let result = CircuitBreakerUtils::with_circuit_breaker(&env, || { + Ok::(String::from_str(&env, "success")) + }); + assert!(result.is_ok()); + + // Test statistics + let stats = CircuitBreakerUtils::get_statistics(&env).unwrap(); + assert!(stats + .get(String::from_str(&env, "total_requests")) + .is_some()); + assert!(stats.get(String::from_str(&env, "error_count")).is_some()); + assert!(stats.get(String::from_str(&env, "current_state")).is_some()); }); } @@ -289,24 +329,24 @@ mod circuit_breaker_tests { fn test_circuit_breaker_testing() { let env = Env::default(); let contract_id = env.register(crate::PredictifyHybrid, ()); - + env.as_contract(&contract_id, || { // Test create test config - let test_config = CircuitBreakerTesting::create_test_config(&env); - assert_eq!(test_config.max_error_rate, 5); - assert_eq!(test_config.max_latency_ms, 1000); - assert_eq!(test_config.failure_threshold, 3); - - // Test create test state - let test_state = CircuitBreakerTesting::create_test_state(&env); - assert_eq!(test_state.state, BreakerState::Closed); - assert_eq!(test_state.failure_count, 0); - assert_eq!(test_state.total_requests, 0); - - // Test simulate functions - CircuitBreaker::initialize(&env).unwrap(); - assert!(CircuitBreakerTesting::simulate_success(&env).is_ok()); - assert!(CircuitBreakerTesting::simulate_failure(&env).is_ok()); + let test_config = CircuitBreakerTesting::create_test_config(&env); + assert_eq!(test_config.max_error_rate, 5); + assert_eq!(test_config.max_latency_ms, 1000); + assert_eq!(test_config.failure_threshold, 3); + + // Test create test state + let test_state = CircuitBreakerTesting::create_test_state(&env); + assert_eq!(test_state.state, BreakerState::Closed); + assert_eq!(test_state.failure_count, 0); + assert_eq!(test_state.total_requests, 0); + + // Test simulate functions + CircuitBreaker::initialize(&env).unwrap(); + assert!(CircuitBreakerTesting::simulate_success(&env).is_ok()); + assert!(CircuitBreakerTesting::simulate_failure(&env).is_ok()); }); } @@ -314,19 +354,27 @@ mod circuit_breaker_tests { fn test_circuit_breaker_scenarios() { let env = Env::default(); let contract_id = env.register(crate::PredictifyHybrid, ()); - + env.as_contract(&contract_id, || { CircuitBreaker::initialize(&env).unwrap(); - - // Test circuit breaker scenarios - let results = CircuitBreaker::test_circuit_breaker_scenarios(&env).unwrap(); - - // Verify results contain expected test outcomes - assert!(results.get(String::from_str(&env, "normal_operation")).is_some()); - assert!(results.get(String::from_str(&env, "emergency_pause")).is_some()); - assert!(results.get(String::from_str(&env, "recovery")).is_some()); - assert!(results.get(String::from_str(&env, "status_check")).is_some()); - assert!(results.get(String::from_str(&env, "event_history")).is_some()); + + // Test circuit breaker scenarios + let results = CircuitBreaker::test_circuit_breaker_scenarios(&env).unwrap(); + + // Verify results contain expected test outcomes + assert!(results + .get(String::from_str(&env, "normal_operation")) + .is_some()); + assert!(results + .get(String::from_str(&env, "emergency_pause")) + .is_some()); + assert!(results.get(String::from_str(&env, "recovery")).is_some()); + assert!(results + .get(String::from_str(&env, "status_check")) + .is_some()); + assert!(results + .get(String::from_str(&env, "event_history")) + .is_some()); }); } @@ -334,31 +382,31 @@ mod circuit_breaker_tests { fn test_config_validation() { let env = Env::default(); let contract_id = env.register(crate::PredictifyHybrid, ()); - + env.as_contract(&contract_id, || { // Test valid config - let valid_config = CircuitBreakerConfig { - max_error_rate: 10, - max_latency_ms: 5000, - min_liquidity: 1_000_000_000, - failure_threshold: 5, - recovery_timeout: 300, - half_open_max_requests: 3, - auto_recovery_enabled: true, - }; - - // Test invalid configs - let mut invalid_config = valid_config.clone(); - invalid_config.max_error_rate = 101; // > 100 - // This would fail validation in update_config - - let mut invalid_config2 = valid_config.clone(); - invalid_config2.max_latency_ms = 0; // = 0 - // This would fail validation in update_config - - let mut invalid_config3 = valid_config.clone(); - invalid_config3.min_liquidity = -1; // < 0 - // This would fail validation in update_config + let valid_config = CircuitBreakerConfig { + max_error_rate: 10, + max_latency_ms: 5000, + min_liquidity: 1_000_000_000, + failure_threshold: 5, + recovery_timeout: 300, + half_open_max_requests: 3, + auto_recovery_enabled: true, + }; + + // Test invalid configs + let mut invalid_config = valid_config.clone(); + invalid_config.max_error_rate = 101; // > 100 + // This would fail validation in update_config + + let mut invalid_config2 = valid_config.clone(); + invalid_config2.max_latency_ms = 0; // = 0 + // This would fail validation in update_config + + let mut invalid_config3 = valid_config.clone(); + invalid_config3.min_liquidity = -1; // < 0 + // This would fail validation in update_config }); } @@ -366,24 +414,24 @@ mod circuit_breaker_tests { fn test_error_handling() { let env = Env::default(); let contract_id = env.register(crate::PredictifyHybrid, ()); - + env.as_contract(&contract_id, || { // Test circuit breaker not initialized - assert!(CircuitBreaker::get_config(&env).is_err()); - assert!(CircuitBreaker::get_state(&env).is_err()); - assert!(CircuitBreaker::is_open(&env).is_err()); - assert!(CircuitBreaker::is_closed(&env).is_err()); - - // Initialize - CircuitBreaker::initialize(&env).unwrap(); - - // Test unauthorized access (inside contract context but without proper admin role) - // Note: This test is skipped because env.mock_all_auths() bypasses all auth checks - // In a real scenario, this would fail without proper admin permissions - // let unauthorized_admin = ::generate(&env); - // let reason = String::from_str(&env, "Test"); - // assert!(CircuitBreaker::emergency_pause(&env, &unauthorized_admin, &reason).is_err()); - // assert!(CircuitBreaker::circuit_breaker_recovery(&env, &unauthorized_admin).is_err()); + assert!(CircuitBreaker::get_config(&env).is_err()); + assert!(CircuitBreaker::get_state(&env).is_err()); + assert!(CircuitBreaker::is_open(&env).is_err()); + assert!(CircuitBreaker::is_closed(&env).is_err()); + + // Initialize + CircuitBreaker::initialize(&env).unwrap(); + + // Test unauthorized access (inside contract context but without proper admin role) + // Note: This test is skipped because env.mock_all_auths() bypasses all auth checks + // In a real scenario, this would fail without proper admin permissions + // let unauthorized_admin = ::generate(&env); + // let reason = String::from_str(&env, "Test"); + // assert!(CircuitBreaker::emergency_pause(&env, &unauthorized_admin, &reason).is_err()); + // assert!(CircuitBreaker::circuit_breaker_recovery(&env, &unauthorized_admin).is_err()); }); } @@ -391,38 +439,46 @@ mod circuit_breaker_tests { fn test_circuit_breaker_integration() { let env = Env::default(); let contract_id = env.register(crate::PredictifyHybrid, ()); - + env.as_contract(&contract_id, || { CircuitBreaker::initialize(&env).unwrap(); - - let admin = ::generate(&env); - AdminRoleManager::assign_role(&env, &admin, crate::admin::AdminRole::SuperAdmin, &admin).unwrap(); - - // Test complete workflow - // 1. Normal operation - assert!(CircuitBreaker::is_closed(&env).unwrap()); - - // 2. Emergency pause - let reason = String::from_str(&env, "Integration test pause"); - assert!(CircuitBreaker::emergency_pause(&env, &admin, &reason).is_ok()); - assert!(CircuitBreaker::is_open(&env).unwrap()); - - // 3. Recovery - assert!(CircuitBreaker::circuit_breaker_recovery(&env, &admin).is_ok()); - assert!(CircuitBreaker::is_closed(&env).unwrap()); - - // 4. Record operations - assert!(CircuitBreaker::record_success(&env).is_ok()); - assert!(CircuitBreaker::record_failure(&env).is_ok()); - - // 5. Check status - let status = CircuitBreaker::get_circuit_breaker_status(&env).unwrap(); - assert!(status.get(String::from_str(&env, "total_requests")).is_some()); - assert!(status.get(String::from_str(&env, "error_count")).is_some()); - - // 6. Check events - let events = CircuitBreaker::get_event_history(&env).unwrap(); - assert!(events.len() >= 2); // At least pause and recovery events + + let admin = ::generate(&env); + AdminRoleManager::assign_role( + &env, + &admin, + crate::admin::AdminRole::SuperAdmin, + &admin, + ) + .unwrap(); + + // Test complete workflow + // 1. Normal operation + assert!(CircuitBreaker::is_closed(&env).unwrap()); + + // 2. Emergency pause + let reason = String::from_str(&env, "Integration test pause"); + assert!(CircuitBreaker::emergency_pause(&env, &admin, &reason).is_ok()); + assert!(CircuitBreaker::is_open(&env).unwrap()); + + // 3. Recovery + assert!(CircuitBreaker::circuit_breaker_recovery(&env, &admin).is_ok()); + assert!(CircuitBreaker::is_closed(&env).unwrap()); + + // 4. Record operations + assert!(CircuitBreaker::record_success(&env).is_ok()); + assert!(CircuitBreaker::record_failure(&env).is_ok()); + + // 5. Check status + let status = CircuitBreaker::get_circuit_breaker_status(&env).unwrap(); + assert!(status + .get(String::from_str(&env, "total_requests")) + .is_some()); + assert!(status.get(String::from_str(&env, "error_count")).is_some()); + + // 6. Check events + let events = CircuitBreaker::get_event_history(&env).unwrap(); + assert!(events.len() >= 2); // At least pause and recovery events }); } -} \ No newline at end of file +} diff --git a/contracts/predictify-hybrid/src/disputes.rs b/contracts/predictify-hybrid/src/disputes.rs index ca6a88b4..6d8ed548 100644 --- a/contracts/predictify-hybrid/src/disputes.rs +++ b/contracts/predictify-hybrid/src/disputes.rs @@ -820,6 +820,13 @@ impl DisputeManager { // Process stake transfer VotingUtils::transfer_stake(env, &user, stake)?; + // Prepare reason for event emission before moving dispute + let reason_for_event = if reason.is_some() { + reason.clone() + } else { + Some(soroban_sdk::String::from_str(env, "No reason provided")) + }; + // Create dispute record let dispute = Dispute { user: user.clone(), @@ -839,6 +846,15 @@ impl DisputeManager { // Update market in storage MarketStateManager::update_market(env, &market_id, &market); + // Emit dispute created event + crate::events::EventEmitter::emit_dispute_created( + env, + &market_id, + &user, + stake, + reason_for_event, + ); + Ok(()) } diff --git a/contracts/predictify-hybrid/src/edge_cases.rs b/contracts/predictify-hybrid/src/edge_cases.rs index bcd05cc7..23079107 100644 --- a/contracts/predictify-hybrid/src/edge_cases.rs +++ b/contracts/predictify-hybrid/src/edge_cases.rs @@ -1,12 +1,12 @@ #![allow(dead_code)] -use soroban_sdk::{contracttype, Env, Map, String, Symbol, Vec, vec}; +use soroban_sdk::{contracttype, vec, Env, Map, String, Symbol, Vec}; use crate::errors::Error; -use crate::markets::{MarketStateManager}; +use crate::markets::MarketStateManager; // ReentrancyGuard module not required here; removed stale import. -use crate::types::*; use crate::reentrancy_guard::ReentrancyGuard; +use crate::types::*; /// Edge case management system for Predictify Hybrid contract /// diff --git a/contracts/predictify-hybrid/src/errors.rs b/contracts/predictify-hybrid/src/errors.rs index 3ccba687..beb75ab5 100644 --- a/contracts/predictify-hybrid/src/errors.rs +++ b/contracts/predictify-hybrid/src/errors.rs @@ -1,10 +1,8 @@ #![allow(dead_code)] -use soroban_sdk::{ - contracterror, contracttype, Address, Env, Map, String, Symbol, Vec, -}; use alloc::format; use alloc::string::ToString; +use soroban_sdk::{contracterror, contracttype, Address, Env, Map, String, Symbol, Vec}; /// Comprehensive error codes for the Predictify Hybrid prediction market contract. /// @@ -453,7 +451,7 @@ impl ErrorHandler { pub fn generate_detailed_error_message(error: &Error, context: &ErrorContext) -> String { let _base_message = error.description(); let _operation = &context.operation; - + match error { Error::Unauthorized => { String::from_str(context.call_chain.env(), "Authorization failed for operation. User may not have required permissions.") @@ -486,9 +484,13 @@ impl ErrorHandler { } /// Handle error recovery based on error type and context - pub fn handle_error_recovery(env: &Env, error: &Error, context: &ErrorContext) -> Result { + pub fn handle_error_recovery( + env: &Env, + error: &Error, + context: &ErrorContext, + ) -> Result { let recovery_strategy = Self::get_error_recovery_strategy(error); - + match recovery_strategy { RecoveryStrategy::Retry => { // For retryable errors, return success to allow retry @@ -499,7 +501,7 @@ impl ErrorHandler { let last_attempt = context.timestamp; let current_time = env.ledger().timestamp(); let delay_required = 60; // 1 minute delay - + if current_time - last_attempt >= delay_required { Ok(true) } else { @@ -517,7 +519,7 @@ impl ErrorHandler { // Try to find similar market or suggest alternatives Ok(false) } - _ => Ok(false) + _ => Ok(false), } } RecoveryStrategy::Skip => { @@ -543,7 +545,7 @@ impl ErrorHandler { pub fn emit_error_event(env: &Env, detailed_error: &DetailedError) { // Import the events module to emit error events use crate::events::EventEmitter; - + EventEmitter::emit_error_logged( env, detailed_error.error as u32, @@ -567,29 +569,29 @@ impl ErrorHandler { // Retryable errors Error::OracleUnavailable => RecoveryStrategy::RetryWithDelay, Error::InvalidInput => RecoveryStrategy::Retry, - + // Alternative method errors Error::MarketNotFound => RecoveryStrategy::AlternativeMethod, Error::ConfigurationNotFound => RecoveryStrategy::AlternativeMethod, - + // Skip errors Error::AlreadyVoted => RecoveryStrategy::Skip, Error::AlreadyClaimed => RecoveryStrategy::Skip, Error::FeeAlreadyCollected => RecoveryStrategy::Skip, - + // Abort errors Error::Unauthorized => RecoveryStrategy::Abort, Error::MarketClosed => RecoveryStrategy::Abort, Error::MarketAlreadyResolved => RecoveryStrategy::Abort, - + // Manual intervention errors Error::AdminNotSet => RecoveryStrategy::ManualIntervention, Error::DisputeFeeDistributionFailed => RecoveryStrategy::ManualIntervention, - + // No recovery errors Error::InvalidState => RecoveryStrategy::NoRecovery, Error::InvalidOracleConfig => RecoveryStrategy::NoRecovery, - + // Default to abort for unknown errors _ => RecoveryStrategy::Abort, } @@ -601,12 +603,12 @@ impl ErrorHandler { if context.operation.is_empty() { return Err(Error::InvalidInput); } - + // Check if call chain is not empty if context.call_chain.is_empty() { return Err(Error::InvalidInput); } - + Ok(()) } @@ -619,15 +621,15 @@ impl ErrorHandler { errors_by_category.set(ErrorCategory::Oracle, 0); errors_by_category.set(ErrorCategory::Validation, 0); errors_by_category.set(ErrorCategory::System, 0); - + let mut errors_by_severity = Map::new(env); errors_by_severity.set(ErrorSeverity::Low, 0); errors_by_severity.set(ErrorSeverity::Medium, 0); errors_by_severity.set(ErrorSeverity::High, 0); errors_by_severity.set(ErrorSeverity::Critical, 0); - + let most_common_errors = Vec::new(env); - + Ok(ErrorAnalytics { total_errors: 0, errors_by_category, @@ -641,7 +643,11 @@ impl ErrorHandler { // ===== ERROR RECOVERY MECHANISMS ===== /// Recover from an error using appropriate recovery strategy - pub fn recover_from_error(env: &Env, error: Error, context: ErrorContext) -> Result { + pub fn recover_from_error( + env: &Env, + error: Error, + context: ErrorContext, + ) -> Result { // Validate error context Self::validate_error_context(&context)?; @@ -670,7 +676,8 @@ impl ErrorHandler { recovery.recovery_success_timestamp = Some(env.ledger().timestamp()); } else { recovery.recovery_status = String::from_str(env, "failed"); - recovery.recovery_failure_reason = Some(String::from_str(env, "Recovery strategy failed")); + recovery.recovery_failure_reason = + Some(String::from_str(env, "Recovery strategy failed")); } // Store recovery record @@ -725,7 +732,7 @@ impl ErrorHandler { /// Emit error recovery event for monitoring and logging pub fn emit_error_recovery_event(env: &Env, recovery: &ErrorRecovery) { use crate::events::EventEmitter; - + EventEmitter::emit_error_recovery_event( env, recovery.original_error_code, @@ -738,7 +745,10 @@ impl ErrorHandler { } /// Validate resilience patterns configuration - pub fn validate_resilience_patterns(_env: &Env, patterns: &Vec) -> Result { + pub fn validate_resilience_patterns( + _env: &Env, + patterns: &Vec, + ) -> Result { for pattern in patterns.iter() { // Validate pattern name if pattern.pattern_name.is_empty() { @@ -767,25 +777,37 @@ impl ErrorHandler { /// Document error recovery procedures and best practices pub fn document_error_recovery_procedures(env: &Env) -> Result, Error> { let mut procedures = Map::new(env); - + procedures.set( String::from_str(env, "retry_procedure"), - String::from_str(env, "For retryable errors, implement exponential backoff with max 3 attempts") + String::from_str( + env, + "For retryable errors, implement exponential backoff with max 3 attempts", + ), ); - + procedures.set( String::from_str(env, "oracle_recovery"), - String::from_str(env, "For oracle errors, try fallback oracle or cached data before failing") + String::from_str( + env, + "For oracle errors, try fallback oracle or cached data before failing", + ), ); - + procedures.set( String::from_str(env, "validation_recovery"), - String::from_str(env, "For validation errors, provide clear error messages and retry guidance") + String::from_str( + env, + "For validation errors, provide clear error messages and retry guidance", + ), ); - + procedures.set( String::from_str(env, "system_recovery"), - String::from_str(env, "For system errors, log details and require manual intervention if critical") + String::from_str( + env, + "For system errors, log details and require manual intervention if critical", + ), ); Ok(procedures) @@ -794,9 +816,12 @@ impl ErrorHandler { // ===== PRIVATE HELPER METHODS ===== /// Execute recovery strategy based on error type - fn execute_recovery_strategy(env: &Env, recovery: &ErrorRecovery) -> Result { + fn execute_recovery_strategy( + env: &Env, + recovery: &ErrorRecovery, + ) -> Result { let start_time = env.ledger().timestamp(); - + let recovery_method = recovery.recovery_strategy.clone(); let success = if recovery.recovery_strategy == String::from_str(env, "retry") { @@ -828,7 +853,10 @@ impl ErrorHandler { let recovery_duration = env.ledger().timestamp() - start_time; let mut recovery_data = Map::new(env); recovery_data.set(String::from_str(env, "strategy"), recovery_method.clone()); - recovery_data.set(String::from_str(env, "duration"), String::from_str(env, &recovery_duration.to_string())); + recovery_data.set( + String::from_str(env, "duration"), + String::from_str(env, &recovery_duration.to_string()), + ); Ok(RecoveryResult { success, @@ -862,7 +890,13 @@ impl ErrorHandler { /// Store recovery record in persistent storage fn store_recovery_record(env: &Env, recovery: &ErrorRecovery) -> Result<(), Error> { - let recovery_key = Symbol::new(env, &format!("recovery_{}_{}", recovery.original_error_code, recovery.recovery_timestamp)); + let recovery_key = Symbol::new( + env, + &format!( + "recovery_{}_{}", + recovery.original_error_code, recovery.recovery_timestamp + ), + ); env.storage().persistent().set(&recovery_key, recovery); Ok(()) } @@ -881,7 +915,9 @@ impl ErrorHandler { Error::MarketClosed => String::from_str(&Env::default(), "abort"), Error::MarketAlreadyResolved => String::from_str(&Env::default(), "abort"), Error::AdminNotSet => String::from_str(&Env::default(), "manual_intervention"), - Error::DisputeFeeDistributionFailed => String::from_str(&Env::default(), "manual_intervention"), + Error::DisputeFeeDistributionFailed => { + String::from_str(&Env::default(), "manual_intervention") + } Error::InvalidState => String::from_str(&Env::default(), "no_recovery"), Error::InvalidOracleConfig => String::from_str(&Env::default(), "no_recovery"), _ => String::from_str(&Env::default(), "abort"), @@ -892,47 +928,143 @@ impl ErrorHandler { fn get_error_classification(error: &Error) -> (ErrorSeverity, ErrorCategory, RecoveryStrategy) { match error { // Critical errors - Error::AdminNotSet => (ErrorSeverity::Critical, ErrorCategory::System, RecoveryStrategy::ManualIntervention), - Error::DisputeFeeDistributionFailed => (ErrorSeverity::Critical, ErrorCategory::Financial, RecoveryStrategy::ManualIntervention), - + Error::AdminNotSet => ( + ErrorSeverity::Critical, + ErrorCategory::System, + RecoveryStrategy::ManualIntervention, + ), + Error::DisputeFeeDistributionFailed => ( + ErrorSeverity::Critical, + ErrorCategory::Financial, + RecoveryStrategy::ManualIntervention, + ), + // High severity errors - Error::Unauthorized => (ErrorSeverity::High, ErrorCategory::Authentication, RecoveryStrategy::Abort), - Error::OracleUnavailable => (ErrorSeverity::High, ErrorCategory::Oracle, RecoveryStrategy::RetryWithDelay), - Error::InvalidState => (ErrorSeverity::High, ErrorCategory::System, RecoveryStrategy::NoRecovery), - + Error::Unauthorized => ( + ErrorSeverity::High, + ErrorCategory::Authentication, + RecoveryStrategy::Abort, + ), + Error::OracleUnavailable => ( + ErrorSeverity::High, + ErrorCategory::Oracle, + RecoveryStrategy::RetryWithDelay, + ), + Error::InvalidState => ( + ErrorSeverity::High, + ErrorCategory::System, + RecoveryStrategy::NoRecovery, + ), + // Medium severity errors - Error::MarketNotFound => (ErrorSeverity::Medium, ErrorCategory::Market, RecoveryStrategy::AlternativeMethod), - Error::MarketClosed => (ErrorSeverity::Medium, ErrorCategory::Market, RecoveryStrategy::Abort), - Error::MarketAlreadyResolved => (ErrorSeverity::Medium, ErrorCategory::Market, RecoveryStrategy::Abort), - Error::InsufficientStake => (ErrorSeverity::Medium, ErrorCategory::UserOperation, RecoveryStrategy::Retry), - Error::InvalidInput => (ErrorSeverity::Medium, ErrorCategory::Validation, RecoveryStrategy::Retry), - Error::InvalidOracleConfig => (ErrorSeverity::Medium, ErrorCategory::Oracle, RecoveryStrategy::NoRecovery), - + Error::MarketNotFound => ( + ErrorSeverity::Medium, + ErrorCategory::Market, + RecoveryStrategy::AlternativeMethod, + ), + Error::MarketClosed => ( + ErrorSeverity::Medium, + ErrorCategory::Market, + RecoveryStrategy::Abort, + ), + Error::MarketAlreadyResolved => ( + ErrorSeverity::Medium, + ErrorCategory::Market, + RecoveryStrategy::Abort, + ), + Error::InsufficientStake => ( + ErrorSeverity::Medium, + ErrorCategory::UserOperation, + RecoveryStrategy::Retry, + ), + Error::InvalidInput => ( + ErrorSeverity::Medium, + ErrorCategory::Validation, + RecoveryStrategy::Retry, + ), + Error::InvalidOracleConfig => ( + ErrorSeverity::Medium, + ErrorCategory::Oracle, + RecoveryStrategy::NoRecovery, + ), + // Low severity errors - Error::AlreadyVoted => (ErrorSeverity::Low, ErrorCategory::UserOperation, RecoveryStrategy::Skip), - Error::AlreadyClaimed => (ErrorSeverity::Low, ErrorCategory::UserOperation, RecoveryStrategy::Skip), - Error::FeeAlreadyCollected => (ErrorSeverity::Low, ErrorCategory::Financial, RecoveryStrategy::Skip), - Error::NothingToClaim => (ErrorSeverity::Low, ErrorCategory::UserOperation, RecoveryStrategy::Skip), - + Error::AlreadyVoted => ( + ErrorSeverity::Low, + ErrorCategory::UserOperation, + RecoveryStrategy::Skip, + ), + Error::AlreadyClaimed => ( + ErrorSeverity::Low, + ErrorCategory::UserOperation, + RecoveryStrategy::Skip, + ), + Error::FeeAlreadyCollected => ( + ErrorSeverity::Low, + ErrorCategory::Financial, + RecoveryStrategy::Skip, + ), + Error::NothingToClaim => ( + ErrorSeverity::Low, + ErrorCategory::UserOperation, + RecoveryStrategy::Skip, + ), + // Default classification - _ => (ErrorSeverity::Medium, ErrorCategory::Unknown, RecoveryStrategy::Abort), + _ => ( + ErrorSeverity::Medium, + ErrorCategory::Unknown, + RecoveryStrategy::Abort, + ), } } /// Get user-friendly action suggestion fn get_user_action(error: &Error, category: &ErrorCategory) -> String { match (error, category) { - (Error::Unauthorized, _) => String::from_str(&Env::default(), "Please ensure you have the required permissions to perform this action."), - (Error::InsufficientStake, _) => String::from_str(&Env::default(), "Please increase your stake amount to meet the minimum requirement."), - (Error::MarketNotFound, _) => String::from_str(&Env::default(), "Please verify the market ID or check if the market still exists."), - (Error::MarketClosed, _) => String::from_str(&Env::default(), "This market is closed. Please look for active markets."), - (Error::AlreadyVoted, _) => String::from_str(&Env::default(), "You have already voted in this market. No further action needed."), - (Error::OracleUnavailable, _) => String::from_str(&Env::default(), "Oracle service is temporarily unavailable. Please try again later."), - (Error::InvalidInput, _) => String::from_str(&Env::default(), "Please check your input parameters and try again."), - (_, ErrorCategory::Validation) => String::from_str(&Env::default(), "Please review and correct the input data."), - (_, ErrorCategory::System) => String::from_str(&Env::default(), "System error occurred. Please contact support if the issue persists."), - (_, ErrorCategory::Financial) => String::from_str(&Env::default(), "Financial operation failed. Please verify your balance and try again."), - _ => String::from_str(&Env::default(), "An error occurred. Please try again or contact support if the issue persists."), + (Error::Unauthorized, _) => String::from_str( + &Env::default(), + "Please ensure you have the required permissions to perform this action.", + ), + (Error::InsufficientStake, _) => String::from_str( + &Env::default(), + "Please increase your stake amount to meet the minimum requirement.", + ), + (Error::MarketNotFound, _) => String::from_str( + &Env::default(), + "Please verify the market ID or check if the market still exists.", + ), + (Error::MarketClosed, _) => String::from_str( + &Env::default(), + "This market is closed. Please look for active markets.", + ), + (Error::AlreadyVoted, _) => String::from_str( + &Env::default(), + "You have already voted in this market. No further action needed.", + ), + (Error::OracleUnavailable, _) => String::from_str( + &Env::default(), + "Oracle service is temporarily unavailable. Please try again later.", + ), + (Error::InvalidInput, _) => String::from_str( + &Env::default(), + "Please check your input parameters and try again.", + ), + (_, ErrorCategory::Validation) => { + String::from_str(&Env::default(), "Please review and correct the input data.") + } + (_, ErrorCategory::System) => String::from_str( + &Env::default(), + "System error occurred. Please contact support if the issue persists.", + ), + (_, ErrorCategory::Financial) => String::from_str( + &Env::default(), + "Financial operation failed. Please verify your balance and try again.", + ), + _ => String::from_str( + &Env::default(), + "An error occurred. Please try again or contact support if the issue persists.", + ), } } @@ -941,7 +1073,7 @@ impl ErrorHandler { let _error_code = error.code(); let _error_num = *error as u32; let _timestamp = context.timestamp; - + String::from_str(context.call_chain.env(), "Error details for debugging") } } @@ -1165,8 +1297,6 @@ impl Error { } } - - // ===== TESTING MODULE ===== #[cfg(test)] @@ -1179,7 +1309,9 @@ mod tests { let env = Env::default(); let context = ErrorContext { operation: String::from_str(&env, "test_operation"), - user_address: Some(::generate(&env)), + user_address: Some( + ::generate(&env), + ), market_id: Some(Symbol::new(&env, "test_market")), context_data: Map::new(&env), timestamp: env.ledger().timestamp(), @@ -1187,7 +1319,7 @@ mod tests { }; let detailed_error = ErrorHandler::categorize_error(&env, Error::Unauthorized, context); - + assert_eq!(detailed_error.severity, ErrorSeverity::High); assert_eq!(detailed_error.category, ErrorCategory::Authentication); assert_eq!(detailed_error.recovery_strategy, RecoveryStrategy::Abort); @@ -1217,7 +1349,8 @@ mod tests { call_chain: Vec::new(&env), }; - let _message = ErrorHandler::generate_detailed_error_message(&Error::Unauthorized, &context); + let _message = + ErrorHandler::generate_detailed_error_message(&Error::Unauthorized, &context); // Test that the message is generated correctly assert!(true); // Simplified test since to_string() is not available } @@ -1256,10 +1389,15 @@ mod tests { fn test_error_analytics() { let env = Env::default(); let analytics = ErrorHandler::get_error_analytics(&env).unwrap(); - + assert_eq!(analytics.total_errors, 0); - assert!(analytics.errors_by_category.get(ErrorCategory::UserOperation).is_some()); - assert!(analytics.errors_by_severity.get(ErrorSeverity::Low).is_some()); + assert!(analytics + .errors_by_category + .get(ErrorCategory::UserOperation) + .is_some()); + assert!(analytics + .errors_by_severity + .get(ErrorSeverity::Low) + .is_some()); } } - diff --git a/contracts/predictify-hybrid/src/events.rs b/contracts/predictify-hybrid/src/events.rs index d60a2e52..9412a206 100644 --- a/contracts/predictify-hybrid/src/events.rs +++ b/contracts/predictify-hybrid/src/events.rs @@ -886,6 +886,76 @@ pub struct ManualResolutionRequiredEvent { pub timestamp: u64, } +/// Event emitted when market state changes +/// +/// This event tracks all market state transitions throughout the market lifecycle, +/// providing transparency and audit trail for state changes. Critical for monitoring +/// market progression and detecting anomalies. +/// +/// # Event Data +/// +/// - Market identifier +/// - Previous state (Active, Ended, Disputed, Resolved, Closed, Cancelled) +/// - New state after transition +/// - Reason for state change +/// - Timestamp of transition +/// +/// # State Transitions +/// +/// Common transitions: +/// - Active → Ended (voting period completed) +/// - Ended → Disputed (dispute filed) +/// - Disputed → Resolved (dispute resolved) +/// - Ended → Resolved (normal resolution) +/// - Resolved → Closed (market finalized) +/// - Any → Cancelled (emergency cancellation) +#[contracttype] +#[derive(Clone, Debug, Eq, PartialEq)] +pub struct StateChangeEvent { + /// Market ID + pub market_id: Symbol, + /// Previous state + pub old_state: crate::types::MarketState, + /// New state + pub new_state: crate::types::MarketState, + /// Reason for state change + pub reason: String, + /// Event timestamp + pub timestamp: u64, +} + +/// Event emitted when user claims winnings +/// +/// This event tracks all winnings claims, providing transparency for payouts +/// and audit trail for financial operations. Essential for monitoring market +/// economics and user engagement. +/// +/// # Event Data +/// +/// - Market identifier +/// - User address claiming winnings +/// - Amount claimed +/// - Timestamp of claim +/// +/// # Use Cases +/// +/// - **Financial Tracking**: Monitor total payouts +/// - **User Analytics**: Track winning users and amounts +/// - **Audit Trail**: Maintain complete payout records +/// - **Tax Reporting**: Generate user earning reports +#[contracttype] +#[derive(Clone, Debug, Eq, PartialEq)] +pub struct WinningsClaimedEvent { + /// Market ID + pub market_id: Symbol, + /// User claiming winnings + pub user: Address, + /// Amount claimed + pub amount: i128, + /// Event timestamp + pub timestamp: u64, +} + /// Contract upgraded event - emitted when contract Wasm is upgraded #[contracttype] #[derive(Clone, Debug, Eq, PartialEq)] @@ -1427,11 +1497,7 @@ impl EventEmitter { } /// Emit storage cleanup event - pub fn emit_storage_cleanup_event( - env: &Env, - market_id: &Symbol, - cleanup_type: &String, - ) { + pub fn emit_storage_cleanup_event(env: &Env, market_id: &Symbol, cleanup_type: &String) { let event = StorageCleanupEvent { market_id: market_id.clone(), cleanup_type: cleanup_type.clone(), @@ -1476,19 +1542,12 @@ impl EventEmitter { } /// Emit circuit breaker event - pub fn emit_circuit_breaker_event( - env: &Env, - event: &CircuitBreakerEvent, - ) { + pub fn emit_circuit_breaker_event(env: &Env, event: &CircuitBreakerEvent) { Self::store_event(env, &symbol_short!("cb_event"), event); } /// Emit oracle degradation event when oracle service fails - pub fn emit_oracle_degradation( - env: &Env, - oracle: &OracleProvider, - reason: &String, - ) { + pub fn emit_oracle_degradation(env: &Env, oracle: &OracleProvider, reason: &String) { let event = OracleDegradationEvent { oracle: oracle.clone(), reason: reason.clone(), @@ -1498,11 +1557,7 @@ impl EventEmitter { } /// Emit oracle recovery event when oracle service recovers - pub fn emit_oracle_recovery( - env: &Env, - oracle: &OracleProvider, - message: &String, - ) { + pub fn emit_oracle_recovery(env: &Env, oracle: &OracleProvider, message: &String) { let event = OracleRecoveryEvent { oracle: oracle.clone(), recovery_message: message.clone(), @@ -1512,17 +1567,145 @@ impl EventEmitter { } /// Emit manual resolution required event when automatic resolution fails - pub fn emit_manual_resolution_required( + pub fn emit_manual_resolution_required(env: &Env, market_id: &Symbol, reason: &String) { + let event = ManualResolutionRequiredEvent { + market_id: market_id.clone(), + reason: reason.clone(), + timestamp: env.ledger().timestamp(), + }; + Self::store_event(env, &symbol_short!("man_res"), &event); + } + + /// Emit state change event when market state transitions + /// + /// This function emits an event whenever a market transitions between states, + /// providing complete transparency and audit trail for state changes. + /// + /// # Parameters + /// + /// - `env` - Soroban environment + /// - `market_id` - Market identifier + /// - `old_state` - Previous market state + /// - `new_state` - New market state after transition + /// - `reason` - Reason for state change + /// + /// # Example + /// + /// ```rust + /// EventEmitter::emit_state_change_event( + /// &env, + /// &market_id, + /// &MarketState::Active, + /// &MarketState::Ended, + /// &String::from_str(&env, "Voting period completed") + /// ); + /// ``` + pub fn emit_state_change_event( env: &Env, market_id: &Symbol, + old_state: &crate::types::MarketState, + new_state: &crate::types::MarketState, reason: &String, ) { - let event = ManualResolutionRequiredEvent { + let event = StateChangeEvent { market_id: market_id.clone(), + old_state: old_state.clone(), + new_state: new_state.clone(), reason: reason.clone(), timestamp: env.ledger().timestamp(), }; - Self::store_event(env, &symbol_short!("man_res"), &event); + Self::store_event(env, &symbol_short!("st_chng"), &event); + } + + /// Emit winnings claimed event when user claims payout + /// + /// This function emits an event whenever a user successfully claims their + /// winnings from a resolved market, providing transparency for all payouts. + /// + /// # Parameters + /// + /// - `env` - Soroban environment + /// - `market_id` - Market identifier + /// - `user` - User address claiming winnings + /// - `amount` - Amount claimed + /// + /// # Example + /// + /// ```rust + /// EventEmitter::emit_winnings_claimed( + /// &env, + /// &market_id, + /// &user_address, + /// 1_500_000_000 // 150 tokens + /// ); + /// ``` + pub fn emit_winnings_claimed(env: &Env, market_id: &Symbol, user: &Address, amount: i128) { + let event = WinningsClaimedEvent { + market_id: market_id.clone(), + user: user.clone(), + amount, + timestamp: env.ledger().timestamp(), + }; + Self::store_event(env, &symbol_short!("win_clm"), &event); + } + + /// Emit error event with full error context + /// + /// This function emits an event when errors occur, providing detailed context + /// for debugging, monitoring, and error recovery. Complies with ticket spec + /// requiring emit_error_event(error: Error, context: ErrorContext). + /// + /// # Parameters + /// + /// - `env` - Soroban environment + /// - `error` - Error that occurred + /// - `context` - Full error context with operation, user, market details + /// + /// # Example + /// + /// ```rust + /// let context = ErrorContext { + /// operation: String::from_str(&env, "claim_winnings"), + /// user_address: Some(user.clone()), + /// market_id: Some(market_id.clone()), + /// context_data: Map::new(&env), + /// timestamp: env.ledger().timestamp(), + /// call_chain: vec![&env, String::from_str(&env, "lib::claim_winnings")], + /// }; + /// + /// EventEmitter::emit_error_event(&env, Error::NothingToClaim, &context); + /// ``` + pub fn emit_error_event( + env: &Env, + error: crate::errors::Error, + context: &crate::errors::ErrorContext, + ) { + let error_code = error as u32; + + // Convert error enum to message string + let error_msg = match error { + crate::errors::Error::Unauthorized => "Unauthorized access", + crate::errors::Error::MarketNotFound => "Market not found", + crate::errors::Error::MarketClosed => "Market closed", + crate::errors::Error::InvalidOutcome => "Invalid outcome", + crate::errors::Error::AlreadyVoted => "Already voted", + crate::errors::Error::AlreadyClaimed => "Already claimed", + crate::errors::Error::MarketNotResolved => "Market not resolved", + crate::errors::Error::NothingToClaim => "Nothing to claim", + _ => "Unknown error", + }; + let message = String::from_str(env, error_msg); + + let event = ErrorLoggedEvent { + error_code, + message, + context: context.operation.clone(), + user: context.user_address.clone(), + market_id: context.market_id.clone(), + timestamp: context.timestamp, + }; + + Self::store_event(env, &symbol_short!("err_evt"), &event); } /// Emit governance proposal created event @@ -1563,11 +1746,7 @@ impl EventEmitter { } /// Emit governance proposal executed event - pub fn emit_governance_proposal_executed( - env: &Env, - proposal_id: &Symbol, - executor: &Address, - ) { + pub fn emit_governance_proposal_executed(env: &Env, proposal_id: &Symbol, executor: &Address) { let timestamp = env.ledger().timestamp(); let event = GovernanceProposalExecutedEvent { proposal_id: proposal_id.clone(), diff --git a/contracts/predictify-hybrid/src/fees.rs b/contracts/predictify-hybrid/src/fees.rs index 45c93b77..f69bd2b1 100644 --- a/contracts/predictify-hybrid/src/fees.rs +++ b/contracts/predictify-hybrid/src/fees.rs @@ -742,6 +742,15 @@ impl FeeManager { MarketStateManager::mark_fees_collected(&mut market, Some(&market_id)); MarketStateManager::update_market(env, &market_id, &market); + // Emit fee collected event + crate::events::EventEmitter::emit_fee_collected( + env, + &market_id, + &admin, + fee_amount, + &soroban_sdk::String::from_str(env, "platform_fee"), + ); + Ok(fee_amount) } diff --git a/contracts/predictify-hybrid/src/governance.rs b/contracts/predictify-hybrid/src/governance.rs index d28608d4..7b57831e 100644 --- a/contracts/predictify-hybrid/src/governance.rs +++ b/contracts/predictify-hybrid/src/governance.rs @@ -190,12 +190,7 @@ impl GovernanceContract { .set(&StorageKey::Proposal(proposal_id.clone()), &p); // Emit governance vote event - EventEmitter::emit_governance_vote_cast( - &env, - &proposal_id, - &voter, - support, - ); + EventEmitter::emit_governance_vote_cast(&env, &proposal_id, &voter, support); Ok(()) } @@ -288,11 +283,7 @@ impl GovernanceContract { .set(&StorageKey::Proposal(proposal_id.clone()), &p); // Emit governance execution event - EventEmitter::emit_governance_proposal_executed( - &env, - &proposal_id, - &caller, - ); + EventEmitter::emit_governance_proposal_executed(&env, &proposal_id, &caller); Ok(()) } diff --git a/contracts/predictify-hybrid/src/graceful_degradation.rs b/contracts/predictify-hybrid/src/graceful_degradation.rs index 220e653f..806191c8 100644 --- a/contracts/predictify-hybrid/src/graceful_degradation.rs +++ b/contracts/predictify-hybrid/src/graceful_degradation.rs @@ -18,7 +18,12 @@ impl OracleBackup { } // Get price, try backup if primary fails - pub fn get_price(&self, env: &Env, oracle_address: &Address, feed_id: &String) -> Result { + pub fn get_price( + &self, + env: &Env, + oracle_address: &Address, + feed_id: &String, + ) -> Result { // Try primary oracle if let Ok(price) = self.call_oracle(env, &self.primary, oracle_address, feed_id) { return Ok(price); @@ -27,12 +32,18 @@ impl OracleBackup { // Primary failed, notify and try backup let msg = String::from_str(env, "Primary oracle failed"); EventEmitter::emit_oracle_degradation(env, &self.primary, &msg); - + self.call_oracle(env, &self.backup, oracle_address, feed_id) } // Call a single oracle - fn call_oracle(&self, env: &Env, oracle: &OracleProvider, address: &Address, feed_id: &String) -> Result { + fn call_oracle( + &self, + env: &Env, + oracle: &OracleProvider, + address: &Address, + feed_id: &String, + ) -> Result { match oracle { OracleProvider::Reflector => { let reflector = ReflectorOracle::new(address.clone()); @@ -45,7 +56,8 @@ impl OracleBackup { // Is oracle working? pub fn is_working(&self, env: &Env, oracle_address: &Address) -> bool { let test_feed = String::from_str(env, "BTC/USD"); - self.call_oracle(env, &self.primary, oracle_address, &test_feed).is_ok() + self.call_oracle(env, &self.primary, oracle_address, &test_feed) + .is_ok() } } @@ -88,7 +100,11 @@ pub fn emit_degradation_event(env: &Env, oracle: OracleProvider, reason: String) EventEmitter::emit_oracle_degradation(env, &oracle, &reason); } -pub fn monitor_oracle_health(env: &Env, oracle: OracleProvider, oracle_address: &Address) -> OracleHealth { +pub fn monitor_oracle_health( + env: &Env, + oracle: OracleProvider, + oracle_address: &Address, +) -> OracleHealth { let backup = OracleBackup::new(oracle.clone(), oracle); if backup.is_working(env, oracle_address) { OracleHealth::Working @@ -97,7 +113,11 @@ pub fn monitor_oracle_health(env: &Env, oracle: OracleProvider, oracle_address: } } -pub fn get_degradation_status(oracle: OracleProvider, env: &Env, oracle_address: &Address) -> OracleHealth { +pub fn get_degradation_status( + oracle: OracleProvider, + env: &Env, + oracle_address: &Address, +) -> OracleHealth { monitor_oracle_health(env, oracle, oracle_address) } @@ -146,7 +166,10 @@ mod tests { let env = Env::default(); let addr = Address::generate(&env); let health = monitor_oracle_health(&env, OracleProvider::Reflector, &addr); - assert!(matches!(health, OracleHealth::Working | OracleHealth::Broken)); + assert!(matches!( + health, + OracleHealth::Working | OracleHealth::Broken + )); } #[test] @@ -167,4 +190,4 @@ mod tests { let result = partial_resolution_mechanism(&env, market, data); assert!(result.is_ok()); } -} \ No newline at end of file +} diff --git a/contracts/predictify-hybrid/src/lib.rs b/contracts/predictify-hybrid/src/lib.rs index ba6e2c6b..b0f32764 100644 --- a/contracts/predictify-hybrid/src/lib.rs +++ b/contracts/predictify-hybrid/src/lib.rs @@ -34,7 +34,7 @@ mod validation; mod validation_tests; mod versioning; mod voting; -// THis is the band protocol wasm std_reference.wasm +// THis is the band protocol wasm std_reference.wasm mod bandprotocol { soroban_sdk::contractimport!(file = "./std_reference.wasm"); } @@ -65,6 +65,7 @@ pub use types::*; use crate::config::{ ConfigChanges, ConfigManager, ConfigUpdateRecord, ContractConfig, MarketLimits, }; +use crate::events::EventEmitter; use crate::graceful_degradation::{OracleBackup, OracleHealth}; use crate::reentrancy_guard::ReentrancyGuard; use alloc::format; @@ -231,8 +232,8 @@ impl PredictifyHybrid { // Create a new market let market = Market { admin: admin.clone(), - question, - outcomes, + question: question.clone(), + outcomes: outcomes.clone(), end_time, oracle_config, oracle_result: None, @@ -252,6 +253,9 @@ impl PredictifyHybrid { // Store the market env.storage().persistent().set(&market_id, &market); + // Emit market created event + EventEmitter::emit_market_created(&env, &market_id, &question, &outcomes, &admin, end_time); + market_id } @@ -335,11 +339,14 @@ impl PredictifyHybrid { } // Store the vote and stake - market.votes.set(user.clone(), outcome); + market.votes.set(user.clone(), outcome.clone()); market.stakes.set(user.clone(), stake); market.total_staked += stake; env.storage().persistent().set(&market_id, &market); + + // Emit vote cast event + EventEmitter::emit_vote_cast(&env, &market_id, &user, &outcome, stake); } /// Allows users to claim their winnings from resolved prediction markets. @@ -447,14 +454,21 @@ impl PredictifyHybrid { let user_share = (user_stake * (PERCENTAGE_DENOMINATOR - fee_percent)) / PERCENTAGE_DENOMINATOR; let total_pool = market.total_staked; - let _payout = (user_share * total_pool) / winning_total; + let payout = (user_share * total_pool) / winning_total; + + // Mark as claimed + market.claimed.set(user.clone(), true); + env.storage().persistent().set(&market_id, &market); + + // Emit winnings claimed event + EventEmitter::emit_winnings_claimed(&env, &market_id, &user, payout); // In a real implementation, transfer tokens here - // For now, we just mark as claimed + return; } } - // Mark as claimed + // If no winnings (user didn't win or zero payout), still mark as claimed to prevent re-attempts market.claimed.set(user.clone(), true); env.storage().persistent().set(&market_id, &market); } @@ -614,10 +628,39 @@ impl PredictifyHybrid { panic_with_error!(env, Error::InvalidOutcome); } + // Capture old state for event + let old_state = market.state.clone(); + // Set winning outcome and update state - market.winning_outcome = Some(winning_outcome); + market.winning_outcome = Some(winning_outcome.clone()); market.state = MarketState::Resolved; env.storage().persistent().set(&market_id, &market); + + // Emit market resolved event + let oracle_result_str = market + .oracle_result + .clone() + .unwrap_or_else(|| String::from_str(&env, "N/A")); + let community_consensus_str = String::from_str(&env, "Manual"); + + EventEmitter::emit_market_resolved( + &env, + &market_id, + &winning_outcome, + &oracle_result_str, + &community_consensus_str, + &String::from_str(&env, "Manual"), + 100, // confidence score for manual resolution + ); + + // Emit state change event + EventEmitter::emit_state_change_event( + &env, + &market_id, + &old_state, + &MarketState::Resolved, + &String::from_str(&env, "Manual resolution by admin"), + ); } /// Fetches oracle result for a market from external oracle contracts. diff --git a/contracts/predictify-hybrid/src/recovery.rs b/contracts/predictify-hybrid/src/recovery.rs index e5dbbee3..8406f54d 100644 --- a/contracts/predictify-hybrid/src/recovery.rs +++ b/contracts/predictify-hybrid/src/recovery.rs @@ -1,5 +1,5 @@ -use soroban_sdk::{contracttype, Address, Env, String, Symbol, Vec, Map}; use alloc::format; +use soroban_sdk::{contracttype, Address, Env, Map, String, Symbol, Vec}; use crate::events::EventEmitter; use crate::markets::MarketStateManager; @@ -38,9 +38,13 @@ pub struct RecoveryData { pub struct RecoveryStorage; impl RecoveryStorage { #[inline(always)] - fn records_key(env: &Env) -> Symbol { Symbol::new(env, "recovery_records") } + fn records_key(env: &Env) -> Symbol { + Symbol::new(env, "recovery_records") + } #[inline(always)] - fn status_key(env: &Env) -> Symbol { Symbol::new(env, "recovery_status_map") } + fn status_key(env: &Env) -> Symbol { + Symbol::new(env, "recovery_status_map") + } pub fn load(env: &Env, market_id: &Symbol) -> Option { let records: Map = env @@ -95,16 +99,26 @@ impl RecoveryValidator { let market = MarketStateManager::get_market(env, market_id)?; // Simple integrity checks (extend as needed) - if market.total_staked < 0 { return Err(Error::InvalidState); } - if market.outcomes.len() < 2 { return Err(Error::InvalidOutcomes); } - if market.end_time == 0 { return Err(Error::InvalidState); } + if market.total_staked < 0 { + return Err(Error::InvalidState); + } + if market.outcomes.len() < 2 { + return Err(Error::InvalidOutcomes); + } + if market.end_time == 0 { + return Err(Error::InvalidState); + } Ok(()) } pub fn validate_recovery_safety(_env: &Env, data: &RecoveryData) -> Result<(), Error> { - if !data.can_recover { return Err(Error::InvalidState); } - if data.safety_score < 0 { return Err(Error::InvalidState); } + if !data.can_recover { + return Err(Error::InvalidState); + } + if data.safety_score < 0 { + return Err(Error::InvalidState); + } Ok(()) } } @@ -118,7 +132,9 @@ impl RecoveryManager { .persistent() .get(&Symbol::new(env, "Admin")) .ok_or(Error::AdminNotSet)?; - if &stored_admin != admin { return Err(Error::Unauthorized); } + if &stored_admin != admin { + return Err(Error::Unauthorized); + } Ok(()) } @@ -129,9 +145,21 @@ impl RecoveryManager { pub fn recover_market_state(env: &Env, market_id: &Symbol) -> Result { // Validate integrity first; if valid skip if RecoveryValidator::validate_market_state_integrity(env, market_id).is_ok() { - let rec = MarketRecovery { market_id: market_id.clone(), actions: Vec::new(env), issues_detected: Vec::new(env), recovered: false, partial_refund_total: 0, last_action: Some(String::from_str(env, "no_action_needed")) }; + let rec = MarketRecovery { + market_id: market_id.clone(), + actions: Vec::new(env), + issues_detected: Vec::new(env), + recovered: false, + partial_refund_total: 0, + last_action: Some(String::from_str(env, "no_action_needed")), + }; RecoveryStorage::save(env, &rec); - EventEmitter::emit_recovery_event(env, market_id, &String::from_str(env, "skip"), &String::from_str(env, "integrity_ok")); + EventEmitter::emit_recovery_event( + env, + market_id, + &String::from_str(env, "skip"), + &String::from_str(env, "integrity_ok"), + ); return Ok(false); } @@ -144,21 +172,41 @@ impl RecoveryManager { // Example heuristic: ensure total_staked matches sum of stakes map let mut recomputed: i128 = 0; - for (_, v) in market.stakes.iter() { recomputed += v; } - if recomputed != market.total_staked { market.total_staked = recomputed; } + for (_, v) in market.stakes.iter() { + recomputed += v; + } + if recomputed != market.total_staked { + market.total_staked = recomputed; + } MarketStateManager::update_market(env, market_id, &market); let mut actions = Vec::new(env); actions.push_back(String::from_str(env, "reconstructed_totals")); - let rec = MarketRecovery { market_id: market_id.clone(), actions, issues_detected: Vec::new(env), recovered: true, partial_refund_total: 0, last_action: Some(String::from_str(env, "reconstructed")) }; + let rec = MarketRecovery { + market_id: market_id.clone(), + actions, + issues_detected: Vec::new(env), + recovered: true, + partial_refund_total: 0, + last_action: Some(String::from_str(env, "reconstructed")), + }; RecoveryStorage::save(env, &rec); - EventEmitter::emit_recovery_event(env, market_id, &String::from_str(env, "recover"), &String::from_str(env, "reconstructed")); + EventEmitter::emit_recovery_event( + env, + market_id, + &String::from_str(env, "recover"), + &String::from_str(env, "reconstructed"), + ); Ok(true) } - pub fn partial_refund_mechanism(env: &Env, market_id: &Symbol, users: &Vec
) -> Result { + pub fn partial_refund_mechanism( + env: &Env, + market_id: &Symbol, + users: &Vec
, + ) -> Result { let mut market = MarketStateManager::get_market(env, market_id)?; let mut total_refunded: i128 = 0; @@ -175,12 +223,25 @@ impl RecoveryManager { MarketStateManager::update_market(env, market_id, &market); // Update recovery record - let mut rec = RecoveryStorage::load(env, market_id).unwrap_or(MarketRecovery { market_id: market_id.clone(), actions: Vec::new(env), issues_detected: Vec::new(env), recovered: false, partial_refund_total: 0, last_action: None }); + let mut rec = RecoveryStorage::load(env, market_id).unwrap_or(MarketRecovery { + market_id: market_id.clone(), + actions: Vec::new(env), + issues_detected: Vec::new(env), + recovered: false, + partial_refund_total: 0, + last_action: None, + }); rec.partial_refund_total += total_refunded; - rec.actions.push_back(String::from_str(env, "partial_refund")); + rec.actions + .push_back(String::from_str(env, "partial_refund")); rec.last_action = Some(String::from_str(env, "partial_refund")); RecoveryStorage::save(env, &rec); - EventEmitter::emit_recovery_event(env, market_id, &String::from_str(env, "partial_refund"), &String::from_str(env, "executed")); + EventEmitter::emit_recovery_event( + env, + market_id, + &String::from_str(env, "partial_refund"), + &String::from_str(env, "executed"), + ); Ok(total_refunded) } } @@ -191,8 +252,8 @@ impl EventEmitter { let topic = Symbol::new(env, "recovery_evt"); let mut data = Vec::new(env); data.push_back(String::from_str(env, "market_id")); - let mid = symbol_to_string(env, market_id); - data.push_back(mid); + let mid = symbol_to_string(env, market_id); + data.push_back(mid); data.push_back(String::from_str(env, "action")); data.push_back(action.clone()); data.push_back(String::from_str(env, "status")); diff --git a/contracts/predictify-hybrid/src/recovery_tests.rs b/contracts/predictify-hybrid/src/recovery_tests.rs index 55337886..9e2cb52a 100644 --- a/contracts/predictify-hybrid/src/recovery_tests.rs +++ b/contracts/predictify-hybrid/src/recovery_tests.rs @@ -1,5 +1,5 @@ #![cfg(test)] -use crate::{PredictifyHybridClient, test::PredictifyTest}; +use crate::{test::PredictifyTest, PredictifyHybridClient}; #[test] fn test_recovery_mechanisms() { diff --git a/contracts/predictify-hybrid/src/resolution.rs b/contracts/predictify-hybrid/src/resolution.rs index dcbf1e93..f2ca2b93 100644 --- a/contracts/predictify-hybrid/src/resolution.rs +++ b/contracts/predictify-hybrid/src/resolution.rs @@ -988,6 +988,22 @@ impl OracleResolutionManager { MarketStateManager::set_oracle_result(&mut market, outcome.clone()); MarketStateManager::update_market(env, market_id, &market); + // Emit oracle result event + let provider_str = soroban_sdk::String::from_str(env, "Oracle"); + let feed_str = market.oracle_config.feed_id.clone(); + let comparison_str = market.oracle_config.comparison.clone(); + + crate::events::EventEmitter::emit_oracle_result( + env, + market_id, + &outcome, + &provider_str, + &feed_str, + price, + market.oracle_config.threshold, + &comparison_str, + ); + Ok(resolution) } @@ -1261,10 +1277,47 @@ impl MarketResolutionManager { confidence_score, }; + // Capture old state for event + let old_state = market.state.clone(); + // Set winning outcome MarketStateManager::set_winning_outcome(&mut market, final_result.clone(), Some(market_id)); MarketStateManager::update_market(env, market_id, &market); + // Emit market resolved event + let oracle_result_str = market + .oracle_result + .clone() + .unwrap_or_else(|| soroban_sdk::String::from_str(env, "N/A")); + let community_consensus_str = soroban_sdk::String::from_str(env, "Consensus"); + let method_str = match resolution_method { + ResolutionMethod::OracleOnly => "OracleOnly", + ResolutionMethod::CommunityOnly => "CommunityOnly", + ResolutionMethod::Hybrid => "Hybrid", + ResolutionMethod::AdminOverride => "AdminOverride", + ResolutionMethod::DisputeResolution => "DisputeResolution", + }; + let resolution_method_str = soroban_sdk::String::from_str(env, method_str); + + crate::events::EventEmitter::emit_market_resolved( + env, + market_id, + &final_result, + &oracle_result_str, + &community_consensus_str, + &resolution_method_str, + confidence_score as i128, + ); + + // Emit state change event + crate::events::EventEmitter::emit_state_change_event( + env, + market_id, + &old_state, + &crate::types::MarketState::Resolved, + &soroban_sdk::String::from_str(env, "Automated resolution completed"), + ); + Ok(resolution) } diff --git a/contracts/predictify-hybrid/src/storage.rs b/contracts/predictify-hybrid/src/storage.rs index 65be57dd..a3d418d3 100644 --- a/contracts/predictify-hybrid/src/storage.rs +++ b/contracts/predictify-hybrid/src/storage.rs @@ -1,10 +1,8 @@ #![cfg_attr(test, allow(dead_code))] use super::*; -use soroban_sdk::{ - contracttype, Env, Symbol, Vec, -}; -use crate::markets::{MarketStateManager, MarketStateLogic}; +use crate::markets::{MarketStateLogic, MarketStateManager}; +use soroban_sdk::{contracttype, Env, Symbol, Vec}; // ===== STORAGE OPTIMIZATION TYPES ===== @@ -132,22 +130,22 @@ impl StorageOptimizer { pub fn compress_market_data(env: &Env, market: &Market) -> Result { // Create a simple compression by removing unnecessary fields and optimizing structure let market_id = Self::generate_market_id(env, &market.question); - + // Convert market to compressed format let compressed_data = Self::serialize_compressed_market(env, market)?; let original_size = Self::calculate_market_size(market); let compressed_size = compressed_data.len() as u32; - + // Calculate compression ratio (as percentage * 100 for integer storage) let _compression_ratio = if original_size > 0 { (compressed_size as i128 * 10000) / original_size as i128 } else { 0 }; - + // Generate checksum for data integrity let checksum = Self::generate_checksum(&compressed_data); - + Ok(CompressedMarket { market_id, compressed_data, @@ -158,39 +156,39 @@ impl StorageOptimizer { checksum, }) } - + /// Clean up old market data based on age and state pub fn cleanup_old_market_data(env: &Env, market_id: &Symbol) -> Result { let market = MarketStateManager::get_market(env, market_id)?; let current_time = env.ledger().timestamp(); - + // Check if market is old enough for cleanup let market_age_days = (current_time - market.end_time) / (24 * 60 * 60); let config = Self::get_storage_config(env); - + if market_age_days > config.cleanup_threshold_days.into() { // Only cleanup closed or cancelled markets if market.state == MarketState::Closed || market.state == MarketState::Cancelled { // Archive market data before deletion Self::archive_market_data(env, market_id, &market)?; - + // Remove from storage MarketStateManager::remove_market(env, market_id); - + // Emit cleanup event events::EventEmitter::emit_storage_cleanup_event( env, market_id, &String::from_str(env, "old_market_cleanup"), ); - + return Ok(true); } } - + Ok(false) } - + /// Migrate storage format from old to new format pub fn migrate_storage_format( env: &Env, @@ -198,7 +196,7 @@ impl StorageOptimizer { to_format: StorageFormat, ) -> Result { let migration_id = Symbol::new(env, &format!("migration_{}", env.ledger().timestamp())); - + let mut migration = StorageMigration { migration_id: migration_id.clone(), from_format: from_format.clone(), @@ -209,10 +207,10 @@ impl StorageOptimizer { status: String::from_str(env, "in_progress"), error_message: None, }; - + // Store migration record Self::store_migration_record(env, &migration_id, &migration); - + match (from_format, to_format) { (StorageFormat::V1, StorageFormat::V2) => { migration = Self::migrate_v1_to_v2(env, migration)?; @@ -225,14 +223,14 @@ impl StorageOptimizer { migration.error_message = Some(String::from_str(env, "Unsupported migration path")); } } - + // Update migration record migration.completed_at = Some(env.ledger().timestamp()); Self::store_migration_record(env, &migration_id, &migration); - + Ok(migration) } - + /// Monitor storage usage and return statistics pub fn monitor_storage_usage(env: &Env) -> Result { let mut total_markets = 0; @@ -241,17 +239,17 @@ impl StorageOptimizer { let mut storage_savings = 0u64; let mut oldest_timestamp = u64::MAX; let mut newest_timestamp = 0u64; - + // Iterate through all markets (this is a simplified approach) // In a real implementation, you'd have a market registry let market_ids = Self::get_all_market_ids(env); - + for market_id in market_ids.iter() { if let Ok(market) = MarketStateManager::get_market(env, &market_id) { total_markets += 1; let market_size = Self::calculate_market_size(&market); total_storage_bytes += market_size as u64; - + // Track timestamps if market.end_time < oldest_timestamp { oldest_timestamp = market.end_time; @@ -259,7 +257,7 @@ impl StorageOptimizer { if market.end_time > newest_timestamp { newest_timestamp = market.end_time; } - + // Check if market is compressed if Self::is_market_compressed(env, &market_id) { compressed_markets += 1; @@ -268,19 +266,19 @@ impl StorageOptimizer { } } } - + let avg_storage_per_market = if total_markets > 0 { total_storage_bytes / total_markets as u64 } else { 0 }; - + let compression_ratio = if total_storage_bytes > 0 { (storage_savings as i128 * 10000) / total_storage_bytes as i128 } else { 0 }; - + Ok(StorageUsageStats { total_markets, total_storage_bytes, @@ -288,49 +286,56 @@ impl StorageOptimizer { compressed_markets, storage_savings, compression_ratio, - oldest_market_timestamp: if oldest_timestamp == u64::MAX { 0 } else { oldest_timestamp }, + oldest_market_timestamp: if oldest_timestamp == u64::MAX { + 0 + } else { + oldest_timestamp + }, newest_market_timestamp: newest_timestamp, }) } - + /// Optimize storage layout for a specific market pub fn optimize_storage_layout(env: &Env, market_id: &Symbol) -> Result { let market = MarketStateManager::get_market(env, market_id)?; - + // Check if optimization is needed let current_size = Self::calculate_market_size(&market); let config = Self::get_storage_config(env); - + if current_size as u64 > config.max_storage_per_market { // Apply compression let compressed_market = Self::compress_market_data(env, &market)?; - + // Store compressed version Self::store_compressed_market(env, &compressed_market)?; - + // Update market reference to point to compressed data Self::update_market_to_compressed(env, market_id, &compressed_market.market_id)?; - + // Emit optimization event events::EventEmitter::emit_storage_optimization_event( env, market_id, &String::from_str(env, "compression_applied"), ); - + return Ok(true); } - + Ok(false) } - + /// Get storage usage statistics pub fn get_storage_usage_statistics(env: &Env) -> Result { Self::monitor_storage_usage(env) } - + /// Validate storage integrity for a specific market - pub fn validate_storage_integrity(env: &Env, market_id: &Symbol) -> Result { + pub fn validate_storage_integrity( + env: &Env, + market_id: &Symbol, + ) -> Result { let mut result = StorageIntegrityResult { market_id: market_id.clone(), is_valid: true, @@ -340,7 +345,7 @@ impl StorageOptimizer { errors: Vec::new(env), warnings: Vec::new(env), }; - + // Try to get market data match MarketStateManager::get_market(env, market_id) { Ok(market) => { @@ -348,33 +353,45 @@ impl StorageOptimizer { if let Err(e) = market.validate(env) { result.is_valid = false; result.corruption_detected = true; - result.errors.push_back(String::from_str(env, &format!("Validation failed: {:?}", e))); + result.errors.push_back(String::from_str( + env, + &format!("Validation failed: {:?}", e), + )); } - + // Check for missing critical data if market.question.is_empty() { result.missing_data = true; - result.warnings.push_back(String::from_str(env, "Empty market question")); + result + .warnings + .push_back(String::from_str(env, "Empty market question")); } - + if market.outcomes.is_empty() { result.missing_data = true; - result.errors.push_back(String::from_str(env, "No outcomes defined")); + result + .errors + .push_back(String::from_str(env, "No outcomes defined")); } - + // Validate state consistency if let Err(e) = MarketStateLogic::validate_market_state_consistency(env, &market) { result.is_valid = false; - result.errors.push_back(String::from_str(env, &format!("State inconsistency: {:?}", e))); + result.errors.push_back(String::from_str( + env, + &format!("State inconsistency: {:?}", e), + )); } } Err(e) => { result.is_valid = false; result.missing_data = true; - result.errors.push_back(String::from_str(env, &format!("Market not found: {:?}", e))); + result + .errors + .push_back(String::from_str(env, &format!("Market not found: {:?}", e))); } } - + // Check compressed data if exists if Self::is_market_compressed(env, market_id) { if let Ok(compressed) = Self::get_compressed_market(env, market_id) { @@ -383,17 +400,23 @@ impl StorageOptimizer { if calculated_checksum != compressed.checksum { result.checksum_valid = false; result.corruption_detected = true; - result.errors.push_back(String::from_str(env, "Checksum validation failed")); + result + .errors + .push_back(String::from_str(env, "Checksum validation failed")); } } } - + Ok(result) } - + /// Get storage configuration pub fn get_storage_config(env: &Env) -> StorageConfig { - match env.storage().persistent().get(&Symbol::new(env, "storage_config")) { + match env + .storage() + .persistent() + .get(&Symbol::new(env, "storage_config")) + { Some(config) => config, None => StorageConfig { compression_enabled: true, @@ -405,7 +428,7 @@ impl StorageOptimizer { }, } } - + /// Update storage configuration pub fn update_storage_config(env: &Env, config: &StorageConfig) -> Result<(), Error> { env.storage() @@ -422,7 +445,7 @@ impl StorageOptimizer { fn serialize_compressed_market(env: &Env, market: &Market) -> Result, Error> { // Simple serialization - in a real implementation, you'd use a proper serialization library let mut data = Vec::new(env); - + // Add essential fields only data.push_back(0); // Simplified - in real implementation, you'd properly serialize the address data.push_back(market.question.len() as i128); @@ -437,10 +460,10 @@ impl StorageOptimizer { data.push_back(market.end_time as i128); data.push_back(market.total_staked); data.push_back(market.state as i128); - + Ok(data) } - + /// Calculate approximate size of market data fn calculate_market_size(market: &Market) -> u32 { // Simplified size calculation @@ -449,10 +472,10 @@ impl StorageOptimizer { let outcomes_size = market.outcomes.len() as u32 * 50; // Average outcome size let votes_size = market.votes.len() as u32 * 100; // Average vote entry size let stakes_size = market.stakes.len() as u32 * 50; // Average stake entry size - + base_size + question_size + outcomes_size + votes_size + stakes_size } - + /// Generate checksum for data integrity fn generate_checksum(data: &Vec) -> String { // Simple checksum - in production, use a proper hash function @@ -462,7 +485,7 @@ impl StorageOptimizer { } String::from_str(&data.env(), &format!("{:016x}", checksum)) } - + /// Generate market ID from question fn generate_market_id(env: &Env, question: &String) -> Symbol { // Simple hash-based ID generation @@ -471,36 +494,45 @@ impl StorageOptimizer { hash = hash.wrapping_add(question.len() as i128); Symbol::new(env, &format!("market_{:016x}", hash)) } - + /// Archive market data before deletion fn archive_market_data(env: &Env, market_id: &Symbol, market: &Market) -> Result<(), Error> { // Store archived version with timestamp - let archive_key = Symbol::new(env, &format!("archive_{:?}_{}", market_id, env.ledger().timestamp())); + let archive_key = Symbol::new( + env, + &format!("archive_{:?}_{}", market_id, env.ledger().timestamp()), + ); env.storage().persistent().set(&archive_key, market); Ok(()) } - + /// Store migration record fn store_migration_record(env: &Env, migration_id: &Symbol, migration: &StorageMigration) { env.storage().persistent().set(migration_id, migration); } - + /// Migrate from V1 to V2 format - fn migrate_v1_to_v2(env: &Env, mut migration: StorageMigration) -> Result { + fn migrate_v1_to_v2( + env: &Env, + mut migration: StorageMigration, + ) -> Result { // Simplified migration - in real implementation, you'd migrate actual data migration.markets_migrated = 1; migration.status = String::from_str(env, "completed"); Ok(migration) } - + /// Migrate from V2 to V3 format - fn migrate_v2_to_v3(env: &Env, mut migration: StorageMigration) -> Result { + fn migrate_v2_to_v3( + env: &Env, + mut migration: StorageMigration, + ) -> Result { // Simplified migration - in real implementation, you'd migrate actual data migration.markets_migrated = 1; migration.status = String::from_str(env, "completed"); Ok(migration) } - + /// Get all market IDs (simplified - in real implementation, you'd have a registry) fn get_all_market_ids(env: &Env) -> Vec { // This is a simplified approach - in a real implementation, @@ -509,21 +541,27 @@ impl StorageOptimizer { // For now, return empty vector - this would be populated from a registry market_ids } - + /// Check if market is compressed fn is_market_compressed(env: &Env, market_id: &Symbol) -> bool { env.storage() .persistent() .has(&Symbol::new(env, &format!("compressed_{:?}", market_id))) } - + /// Store compressed market - fn store_compressed_market(env: &Env, compressed_market: &CompressedMarket) -> Result<(), Error> { - let key = Symbol::new(env, &format!("compressed_{:?}", compressed_market.market_id)); + fn store_compressed_market( + env: &Env, + compressed_market: &CompressedMarket, + ) -> Result<(), Error> { + let key = Symbol::new( + env, + &format!("compressed_{:?}", compressed_market.market_id), + ); env.storage().persistent().set(&key, compressed_market); Ok(()) } - + /// Get compressed market fn get_compressed_market(env: &Env, market_id: &Symbol) -> Result { let key = Symbol::new(env, &format!("compressed_{:?}", market_id)); @@ -532,9 +570,13 @@ impl StorageOptimizer { .get(&key) .ok_or(Error::MarketNotFound) } - + /// Update market to point to compressed data - fn update_market_to_compressed(env: &Env, market_id: &Symbol, compressed_id: &Symbol) -> Result<(), Error> { + fn update_market_to_compressed( + env: &Env, + market_id: &Symbol, + compressed_id: &Symbol, + ) -> Result<(), Error> { let key = Symbol::new(env, &format!("compressed_ref_{:?}", market_id)); env.storage().persistent().set(&key, compressed_id); Ok(()) @@ -553,7 +595,7 @@ impl StorageUtils { // Simplified cost calculation - in real implementation, use actual blockchain costs size as u64 * 100 // 100 stroops per byte } - + /// Get storage efficiency score (0-100) pub fn get_storage_efficiency_score(market: &Market) -> u32 { let size = StorageOptimizer::calculate_market_size(market); @@ -566,30 +608,39 @@ impl StorageUtils { }; efficiency } - + /// Check if market needs optimization pub fn needs_optimization(market: &Market, config: &StorageConfig) -> bool { let size = StorageOptimizer::calculate_market_size(market); size as u64 > config.max_storage_per_market } - + /// Get storage recommendations for a market pub fn get_storage_recommendations(market: &Market) -> Vec { let mut recommendations = Vec::new(&market.question.env()); - + let size = StorageOptimizer::calculate_market_size(market); if size > 10000 { - recommendations.push_back(String::from_str(&market.question.env(), "Consider compression for large market data")); + recommendations.push_back(String::from_str( + &market.question.env(), + "Consider compression for large market data", + )); } - + if market.votes.len() > 1000 { - recommendations.push_back(String::from_str(&market.question.env(), "High vote count - consider vote aggregation")); + recommendations.push_back(String::from_str( + &market.question.env(), + "High vote count - consider vote aggregation", + )); } - + if market.question.len() > 200 { - recommendations.push_back(String::from_str(&market.question.env(), "Long question - consider shortening")); + recommendations.push_back(String::from_str( + &market.question.env(), + "Long question - consider shortening", + )); } - + recommendations } } @@ -600,7 +651,7 @@ impl StorageUtils { mod tests { use super::*; use soroban_sdk::testutils::Address; - + #[test] fn test_storage_optimizer_compression() { let env = Env::default(); @@ -609,10 +660,10 @@ mod tests { &env, admin, String::from_str(&env, "Test market question"), - Vec::from_array(&env, [ - String::from_str(&env, "yes"), - String::from_str(&env, "no") - ]), + Vec::from_array( + &env, + [String::from_str(&env, "yes"), String::from_str(&env, "no")], + ), env.ledger().timestamp() + 86400, OracleConfig::new( OracleProvider::Reflector, @@ -622,12 +673,15 @@ mod tests { ), MarketState::Active, ); - + let compressed = StorageOptimizer::compress_market_data(&env, &market).unwrap(); assert!(compressed.compressed_size < compressed.original_size); - assert_eq!(compressed.compression_type, String::from_str(&env, "simple_optimization")); + assert_eq!( + compressed.compression_type, + String::from_str(&env, "simple_optimization") + ); } - + #[test] fn test_storage_usage_monitoring() { let env = Env::default(); @@ -635,7 +689,7 @@ mod tests { assert_eq!(stats.total_markets, 0); assert_eq!(stats.total_storage_bytes, 0); } - + // #[test] // fn test_storage_config() { // let env = Env::default(); @@ -649,7 +703,7 @@ mod tests { // assert!(!config.auto_cleanup_enabled); // }); // } - + #[test] fn test_storage_utils() { let env = Env::default(); @@ -658,10 +712,10 @@ mod tests { &env, admin, String::from_str(&env, "Test market"), - Vec::from_array(&env, [ - String::from_str(&env, "yes"), - String::from_str(&env, "no") - ]), + Vec::from_array( + &env, + [String::from_str(&env, "yes"), String::from_str(&env, "no")], + ), env.ledger().timestamp() + 86400, OracleConfig::new( OracleProvider::Reflector, @@ -671,13 +725,13 @@ mod tests { ), MarketState::Active, ); - + let efficiency = StorageUtils::get_storage_efficiency_score(&market); assert!(efficiency > 0); assert!(efficiency <= 100); - + let recommendations = StorageUtils::get_storage_recommendations(&market); // Recommendations may be empty for small markets, so we just check it doesn't panic assert!(recommendations.len() >= 0); } -} \ No newline at end of file +} diff --git a/contracts/predictify-hybrid/src/test.rs b/contracts/predictify-hybrid/src/test.rs index 6cc9a8bc..c06738ff 100644 --- a/contracts/predictify-hybrid/src/test.rs +++ b/contracts/predictify-hybrid/src/test.rs @@ -502,9 +502,6 @@ fn test_market_creation_data() { let test = PredictifyTest::setup(); let market_id = test.create_test_market(); - - - let market = test.env.as_contract(&test.contract_id, || { test.env .storage() @@ -602,38 +599,42 @@ fn test_error_recovery_mechanisms() { let env = Env::default(); let contract_id = env.register(PredictifyHybrid, ()); env.mock_all_auths(); - - let admin = Address::from_string(&String::from_str(&env, "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF")); - + + let admin = Address::from_string(&String::from_str( + &env, + "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF", + )); + env.as_contract(&contract_id, || { // Initialize admin system first crate::admin::AdminInitializer::initialize(&env, &admin).unwrap(); - - // Test error recovery for different error types - let context = errors::ErrorContext { - operation: String::from_str(&env, "test_operation"), - user_address: Some(admin.clone()), - market_id: Some(Symbol::new(&env, "test_market")), - context_data: Map::new(&env), - timestamp: env.ledger().timestamp(), - call_chain: { - let mut chain = Vec::new(&env); - chain.push_back(String::from_str(&env, "test")); - chain - }, - }; - - // Test basic error recovery functions exist (simplified to avoid object reference issues) - // Skip complex error recovery test that causes "mis-tagged object reference" errors - - // Test that error recovery functions are callable - let status = errors::ErrorHandler::get_error_recovery_status(&env).unwrap(); - assert_eq!(status.total_attempts, 0); // No persistent storage in test - - // Test that resilience patterns can be validated - let patterns = Vec::new(&env); - let validation_result = errors::ErrorHandler::validate_resilience_patterns(&env, &patterns).unwrap(); - assert!(validation_result); + + // Test error recovery for different error types + let context = errors::ErrorContext { + operation: String::from_str(&env, "test_operation"), + user_address: Some(admin.clone()), + market_id: Some(Symbol::new(&env, "test_market")), + context_data: Map::new(&env), + timestamp: env.ledger().timestamp(), + call_chain: { + let mut chain = Vec::new(&env); + chain.push_back(String::from_str(&env, "test")); + chain + }, + }; + + // Test basic error recovery functions exist (simplified to avoid object reference issues) + // Skip complex error recovery test that causes "mis-tagged object reference" errors + + // Test that error recovery functions are callable + let status = errors::ErrorHandler::get_error_recovery_status(&env).unwrap(); + assert_eq!(status.total_attempts, 0); // No persistent storage in test + + // Test that resilience patterns can be validated + let patterns = Vec::new(&env); + let validation_result = + errors::ErrorHandler::validate_resilience_patterns(&env, &patterns).unwrap(); + assert!(validation_result); }); } @@ -641,27 +642,34 @@ fn test_error_recovery_mechanisms() { fn test_resilience_patterns_validation() { let env = Env::default(); let contract_id = env.register(PredictifyHybrid, ()); - + env.as_contract(&contract_id, || { let mut patterns = Vec::new(&env); - let mut pattern_config = Map::new(&env); - pattern_config.set(String::from_str(&env, "max_attempts"), String::from_str(&env, "3")); - pattern_config.set(String::from_str(&env, "delay_ms"), String::from_str(&env, "1000")); - - let pattern = errors::ResiliencePattern { - pattern_name: String::from_str(&env, "retry_pattern"), - pattern_type: errors::ResiliencePatternType::RetryWithBackoff, - pattern_config, - enabled: true, - priority: 50, - last_used: None, - success_rate: 8500, // 85% - }; - - patterns.push_back(pattern); - - let validation_result = errors::ErrorHandler::validate_resilience_patterns(&env, &patterns).unwrap(); - assert!(validation_result); + let mut pattern_config = Map::new(&env); + pattern_config.set( + String::from_str(&env, "max_attempts"), + String::from_str(&env, "3"), + ); + pattern_config.set( + String::from_str(&env, "delay_ms"), + String::from_str(&env, "1000"), + ); + + let pattern = errors::ResiliencePattern { + pattern_name: String::from_str(&env, "retry_pattern"), + pattern_type: errors::ResiliencePatternType::RetryWithBackoff, + pattern_config, + enabled: true, + priority: 50, + last_used: None, + success_rate: 8500, // 85% + }; + + patterns.push_back(pattern); + + let validation_result = + errors::ErrorHandler::validate_resilience_patterns(&env, &patterns).unwrap(); + assert!(validation_result); }); } @@ -669,16 +677,24 @@ fn test_resilience_patterns_validation() { fn test_error_recovery_procedures_documentation() { let env = Env::default(); let contract_id = env.register(PredictifyHybrid, ()); - + env.as_contract(&contract_id, || { let procedures = errors::ErrorHandler::document_error_recovery_procedures(&env).unwrap(); - assert!(procedures.len() > 0); - - // Check that key procedures are documented - assert!(procedures.get(String::from_str(&env, "retry_procedure")).is_some()); - assert!(procedures.get(String::from_str(&env, "oracle_recovery")).is_some()); - assert!(procedures.get(String::from_str(&env, "validation_recovery")).is_some()); - assert!(procedures.get(String::from_str(&env, "system_recovery")).is_some()); + assert!(procedures.len() > 0); + + // Check that key procedures are documented + assert!(procedures + .get(String::from_str(&env, "retry_procedure")) + .is_some()); + assert!(procedures + .get(String::from_str(&env, "oracle_recovery")) + .is_some()); + assert!(procedures + .get(String::from_str(&env, "validation_recovery")) + .is_some()); + assert!(procedures + .get(String::from_str(&env, "system_recovery")) + .is_some()); }); } @@ -687,36 +703,40 @@ fn test_error_recovery_scenarios() { let env = Env::default(); let contract_id = env.register(PredictifyHybrid, ()); env.mock_all_auths(); - - let admin = Address::from_string(&String::from_str(&env, "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF")); - + + let admin = Address::from_string(&String::from_str( + &env, + "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF", + )); + env.as_contract(&contract_id, || { // Initialize admin system first crate::admin::AdminInitializer::initialize(&env, &admin).unwrap(); - - let context = errors::ErrorContext { - operation: String::from_str(&env, "test_scenario"), - user_address: Some(admin.clone()), - market_id: Some(Symbol::new(&env, "test_market")), - context_data: Map::new(&env), - timestamp: env.ledger().timestamp(), - call_chain: { - let mut chain = Vec::new(&env); - chain.push_back(String::from_str(&env, "test")); - chain - }, - }; - - // Test different error recovery scenarios (simplified to avoid object reference issues) - // Skip complex error recovery test that causes "mis-tagged object reference" errors - - // Test that error recovery functions are callable - let status = errors::ErrorHandler::get_error_recovery_status(&env).unwrap(); - assert_eq!(status.total_attempts, 0); // No persistent storage in test - - // Test that resilience patterns can be validated - let patterns = Vec::new(&env); - let validation_result = errors::ErrorHandler::validate_resilience_patterns(&env, &patterns).unwrap(); - assert!(validation_result); + + let context = errors::ErrorContext { + operation: String::from_str(&env, "test_scenario"), + user_address: Some(admin.clone()), + market_id: Some(Symbol::new(&env, "test_market")), + context_data: Map::new(&env), + timestamp: env.ledger().timestamp(), + call_chain: { + let mut chain = Vec::new(&env); + chain.push_back(String::from_str(&env, "test")); + chain + }, + }; + + // Test different error recovery scenarios (simplified to avoid object reference issues) + // Skip complex error recovery test that causes "mis-tagged object reference" errors + + // Test that error recovery functions are callable + let status = errors::ErrorHandler::get_error_recovery_status(&env).unwrap(); + assert_eq!(status.total_attempts, 0); // No persistent storage in test + + // Test that resilience patterns can be validated + let patterns = Vec::new(&env); + let validation_result = + errors::ErrorHandler::validate_resilience_patterns(&env, &patterns).unwrap(); + assert!(validation_result); }); } diff --git a/contracts/predictify-hybrid/src/upgrade_manager.rs b/contracts/predictify-hybrid/src/upgrade_manager.rs index a8d5116e..19df3921 100644 --- a/contracts/predictify-hybrid/src/upgrade_manager.rs +++ b/contracts/predictify-hybrid/src/upgrade_manager.rs @@ -1,7 +1,7 @@ #![allow(dead_code)] -use soroban_sdk::{contracttype, Address, Bytes, BytesN, Env, String, Symbol, Vec}; use alloc::format; +use soroban_sdk::{contracttype, Address, Bytes, BytesN, Env, String, Symbol, Vec}; use crate::errors::Error; use crate::events::EventEmitter; @@ -355,7 +355,8 @@ impl UpgradeManager { let upgrade_id = Symbol::new(env, &format!("upgrade_{}", env.ledger().timestamp())); // Perform the upgrade using Soroban's deployer - env.deployer().update_current_contract_wasm(new_wasm_hash.clone()); + env.deployer() + .update_current_contract_wasm(new_wasm_hash.clone()); // Record successful upgrade let upgrade_record = UpgradeRecord { @@ -436,13 +437,15 @@ impl UpgradeManager { } // Check for breaking changes - if proposal.target_version.is_breaking_change_from(¤t_version) { + if proposal + .target_version + .is_breaking_change_from(¤t_version) + { result.breaking_changes = true; result.compatibility_score = result.compatibility_score.saturating_sub(30); - result.warnings.push_back(String::from_str( - env, - "Upgrade contains breaking changes", - )); + result + .warnings + .push_back(String::from_str(env, "Upgrade contains breaking changes")); result.recommendations.push_back(String::from_str( env, "Review breaking changes and plan migration strategy", @@ -460,9 +463,7 @@ impl UpgradeManager { } // Validate proposal has rollback plan for major upgrades - if proposal.target_version.major > current_version.major - && !proposal.has_rollback_hash - { + if proposal.target_version.major > current_version.major && !proposal.has_rollback_hash { result.compatibility_score = result.compatibility_score.saturating_sub(10); result.warnings.push_back(String::from_str( env, @@ -514,7 +515,8 @@ impl UpgradeManager { let current_wasm_hash = Self::get_current_wasm_hash(env); // Perform rollback - env.deployer().update_current_contract_wasm(rollback_wasm_hash.clone()); + env.deployer() + .update_current_contract_wasm(rollback_wasm_hash.clone()); // Update current Wasm hash Self::store_current_wasm_hash(env, &rollback_wasm_hash); @@ -527,11 +529,7 @@ impl UpgradeManager { } // Emit rollback event - EventEmitter::emit_contract_rollback_event( - env, - ¤t_wasm_hash, - &rollback_wasm_hash, - ); + EventEmitter::emit_contract_rollback_event(env, ¤t_wasm_hash, &rollback_wasm_hash); Ok(()) } @@ -632,7 +630,8 @@ impl UpgradeManager { // Calculate average time between upgrades if history.len() > 1 { - stats.avg_time_between_upgrades = total_time_between_upgrades / (history.len() as u64 - 1); + stats.avg_time_between_upgrades = + total_time_between_upgrades / (history.len() as u64 - 1); } Ok(stats) @@ -780,14 +779,7 @@ mod tests { fn test_upgrade_proposal_validation() { let env = Env::default(); let new_wasm_hash = BytesN::from_array(&env, &[1u8; 32]); - let target_version = Version::new( - &env, - 1, - 1, - 0, - String::from_str(&env, "Upgrade"), - false, - ); + let target_version = Version::new(&env, 1, 1, 0, String::from_str(&env, "Upgrade"), false); let mut proposal = UpgradeProposal::new( &env, @@ -819,26 +811,16 @@ mod tests { env.as_contract(&contract_id, || { // Initialize version let version_manager = VersionManager::new(&env); - let current_version = Version::new( - &env, - 1, - 0, - 0, - String::from_str(&env, "Current"), - false, - ); - version_manager.track_contract_version(&env, current_version).unwrap(); + let current_version = + Version::new(&env, 1, 0, 0, String::from_str(&env, "Current"), false); + version_manager + .track_contract_version(&env, current_version) + .unwrap(); // Create upgrade proposal let new_wasm_hash = BytesN::from_array(&env, &[1u8; 32]); - let target_version = Version::new( - &env, - 1, - 1, - 0, - String::from_str(&env, "Upgrade"), - false, - ); + let target_version = + Version::new(&env, 1, 1, 0, String::from_str(&env, "Upgrade"), false); let proposal = UpgradeProposal::new( &env, diff --git a/contracts/predictify-hybrid/src/upgrade_manager_tests.rs b/contracts/predictify-hybrid/src/upgrade_manager_tests.rs index 1699abde..1316fd2e 100644 --- a/contracts/predictify-hybrid/src/upgrade_manager_tests.rs +++ b/contracts/predictify-hybrid/src/upgrade_manager_tests.rs @@ -1,11 +1,11 @@ #![cfg(test)] -use soroban_sdk::{testutils::{Address as _, Ledger}, Address, BytesN, Env, String}; - -use crate::upgrade_manager::{ - UpgradeManager, UpgradeProposal, - ValidationResult, +use soroban_sdk::{ + testutils::{Address as _, Ledger}, + Address, BytesN, Env, String, }; + +use crate::upgrade_manager::{UpgradeManager, UpgradeProposal, ValidationResult}; use crate::versioning::{Version, VersionManager}; /// Test helper to create a test environment with initialized contract @@ -18,14 +18,22 @@ fn setup_test_env() -> (Env, Address, Address) { // Initialize contract with admin in contract context env.as_contract(&contract_id, || { - env.storage().instance().set(&soroban_sdk::Symbol::new(&env, "admin"), &admin); + env.storage() + .instance() + .set(&soroban_sdk::Symbol::new(&env, "admin"), &admin); }); (env, admin, contract_id) } /// Test helper to create a sample upgrade proposal with unique timestamp -fn create_sample_proposal(env: &Env, major: u32, minor: u32, patch: u32, seed: u8) -> UpgradeProposal { +fn create_sample_proposal( + env: &Env, + major: u32, + minor: u32, + patch: u32, + seed: u8, +) -> UpgradeProposal { let new_wasm_hash = BytesN::from_array(env, &[seed; 32]); let target_version = Version::new( env, @@ -317,14 +325,7 @@ fn test_get_contract_version() { env.as_contract(&contract_id, || { // Initialize version let version_manager = VersionManager::new(&env); - let initial_version = Version::new( - &env, - 1, - 0, - 0, - String::from_str(&env, "Initial"), - false, - ); + let initial_version = Version::new(&env, 1, 0, 0, String::from_str(&env, "Initial"), false); version_manager .track_contract_version(&env, initial_version.clone()) .unwrap();