`a3be0d1`

5.1 economic incentives foundation

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 8 months ago

SHA: a3be0d117a2495a4b207f58cc8f437dd5ac41296
Parents: 8c0fa0d
Tree: 0e92aae

11 changed files

Status	File	+
A	`src/allocation/democratic_allocation.rs`	825
A	`src/economics/earnings_calculator.rs`	616
A	`src/economics/market_maker.rs`	629
A	`src/economics/mod.rs`	21
A	`src/economics/network_health_minter.rs`	516
A	`src/economics/payment_processor.rs`	822
A	`src/economics/payout_scheduler.rs`	886
A	`src/economics/performance_rewards.rs`	1034
A	`src/economics/token_model.rs`	398
A	`src/economics/zephyr_coin.rs`	561
M	`src/lib.rs`	13

src/allocation/democratic_allocation.rsadded

 +//! Democratic space allocation algorithm for ZephyrFS
 +//!
 +//! Implements fair, transparent, and democratic allocation of storage space
 +//! across the network based on capacity, demand, and volunteer preferences.
++
 +use anyhow::{Context, Result};
 +use serde::{Deserialize, Serialize};
 +use std::collections::{HashMap, BTreeMap};
 +use std::time::{SystemTime, UNIX_EPOCH};
 +use uuid::Uuid;
++
 +/// Configuration for democratic space allocation
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct AllocationConfig {
 +    /// Minimum storage allocation per volunteer (GB)
 +    pub min_allocation_gb: f64,
 +    /// Maximum storage allocation per volunteer (GB)
 +    pub max_allocation_gb: f64,
 +    /// Target network utilization percentage (0.0-1.0)
 +    pub target_utilization: f64,
 +    /// Weight for capacity-based allocation (0.0-1.0)
 +    pub capacity_weight: f64,
 +    /// Weight for demand-based allocation (0.0-1.0)
 +    pub demand_weight: f64,
 +    /// Weight for performance-based allocation (0.0-1.0)
 +    pub performance_weight: f64,
 +    /// Rebalancing frequency (seconds)
 +    pub rebalancing_interval: u64,
 +    /// Enable fair queuing for requests
 +    pub enable_fair_queuing: bool,
 +}
++
 +impl Default for AllocationConfig {
 +    fn default() -> Self {
 +        Self {
 +            min_allocation_gb: 1.0,
 +            max_allocation_gb: 100.0,
 +            target_utilization: 0.75,
 +            capacity_weight: 0.4,
 +            demand_weight: 0.3,
 +            performance_weight: 0.3,
 +            rebalancing_interval: 3600, // 1 hour
 +            enable_fair_queuing: true,
 +        }
 +    }
 +}
++
 +/// Information about a storage volunteer node
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct VolunteerNode {
 +    /// Unique node identifier
 +    pub node_id: Uuid,
 +    /// Total available capacity (GB)
 +    pub total_capacity_gb: f64,
 +    /// Currently allocated space (GB)
 +    pub allocated_space_gb: f64,
 +    /// Currently used space (GB)
 +    pub used_space_gb: f64,
 +    /// Node performance metrics
 +    pub performance: NodePerformance,
 +    /// Node preferences and constraints
 +    pub preferences: NodePreferences,
 +    /// Geographic location (for distribution)
 +    pub location: Option<GeographicLocation>,
 +    /// Node reliability score (0.0-1.0)
 +    pub reliability_score: f64,
 +    /// Last seen timestamp
 +    pub last_seen: u64,
 +    /// Node status
 +    pub status: NodeStatus,
 +}
++
 +/// Node performance metrics
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct NodePerformance {
 +    /// Average response time (milliseconds)
 +    pub avg_response_time_ms: f64,
 +    /// Bandwidth capacity (Mbps)
 +    pub bandwidth_mbps: f64,
 +    /// Uptime percentage (0.0-1.0)
 +    pub uptime_percentage: f64,
 +    /// Error rate (0.0-1.0)
 +    pub error_rate: f64,
 +    /// CPU usage percentage (0.0-1.0)
 +    pub cpu_usage: f64,
 +    /// Memory usage percentage (0.0-1.0)
 +    pub memory_usage: f64,
 +}
++
 +/// Node preferences and constraints
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct NodePreferences {
 +    /// Maximum space willing to provide (GB)
 +    pub max_contribution_gb: f64,
 +    /// Preferred operating hours (24-hour format)
 +    pub preferred_hours: Option<(u8, u8)>,
 +    /// Bandwidth throttling preferences
 +    pub bandwidth_limit_mbps: Option<f64>,
 +    /// Content type preferences
 +    pub content_preferences: Vec<String>,
 +    /// Minimum reward rate required
 +    pub min_reward_rate: Option<f64>,
 +}
++
 +/// Geographic location for distribution
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct GeographicLocation {
 +    /// Country code
 +    pub country: String,
 +    /// Region/state
 +    pub region: String,
 +    /// City
 +    pub city: String,
 +    /// Latitude
 +    pub latitude: f64,
 +    /// Longitude
 +    pub longitude: f64,
 +}
++
 +/// Node operational status
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub enum NodeStatus {
 +    Active,
 +    Inactive,
 +    Maintenance,
 +    Overloaded,
 +    Error(String),
 +}
++
 +/// Storage allocation request
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct AllocationRequest {
 +    /// Request identifier
 +    pub request_id: Uuid,
 +    /// Requesting user ID
 +    pub user_id: String,
 +    /// Requested storage amount (GB)
 +    pub requested_gb: f64,
 +    /// Priority level (0-10, higher is more urgent)
 +    pub priority: u8,
 +    /// Content type hint
 +    pub content_type: Option<String>,
 +    /// Geographic preference
 +    pub geo_preference: Option<String>,
 +    /// Performance requirements
 +    pub performance_requirements: PerformanceRequirements,
 +    /// Request timestamp
 +    pub created_at: u64,
 +}
++
 +/// Performance requirements for allocation
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct PerformanceRequirements {
 +    /// Maximum acceptable latency (milliseconds)
 +    pub max_latency_ms: Option<f64>,
 +    /// Minimum bandwidth requirement (Mbps)
 +    pub min_bandwidth_mbps: Option<f64>,
 +    /// Minimum uptime requirement (0.0-1.0)
 +    pub min_uptime: Option<f64>,
 +    /// Redundancy factor (number of copies)
 +    pub redundancy_factor: u8,
 +}
++
 +/// Result of space allocation
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct AllocationResult {
 +    /// Request this allocation fulfills
 +    pub request_id: Uuid,
 +    /// Allocated nodes and their contributions
 +    pub allocations: Vec<NodeAllocation>,
 +    /// Total allocated space (GB)
 +    pub total_allocated_gb: f64,
 +    /// Allocation quality score (0.0-1.0)
 +    pub quality_score: f64,
 +    /// Allocation strategy used
 +    pub strategy: AllocationStrategy,
 +    /// Allocation timestamp
 +    pub allocated_at: u64,
 +}
++
 +/// Individual node allocation
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct NodeAllocation {
 +    /// Node receiving the allocation
 +    pub node_id: Uuid,
 +    /// Amount allocated to this node (GB)
 +    pub allocated_gb: f64,
 +    /// Expected reward for this allocation
 +    pub reward_amount: f64,
 +    /// Allocation priority on this node
 +    pub priority: u8,
 +    /// Performance score for this allocation
 +    pub performance_score: f64,
 +}
++
 +/// Allocation strategy used
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub enum AllocationStrategy {
 +    /// Capacity-based allocation
 +    CapacityBased,
 +    /// Performance-based allocation
 +    PerformanceBased,
 +    /// Geographic distribution
 +    GeographicDistribution,
 +    /// Load balancing
 +    LoadBalancing,
 +    /// Hybrid approach
 +    Hybrid,
 +}
++
 +/// Network allocation statistics
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct AllocationStats {
 +    /// Total network capacity (GB)
 +    pub total_capacity_gb: f64,
 +    /// Total allocated space (GB)
 +    pub total_allocated_gb: f64,
 +    /// Total used space (GB)
 +    pub total_used_gb: f64,
 +    /// Network utilization (0.0-1.0)
 +    pub utilization: f64,
 +    /// Number of active nodes
 +    pub active_nodes: usize,
 +    /// Number of pending requests
 +    pub pending_requests: usize,
 +    /// Average allocation quality
 +    pub avg_quality_score: f64,
 +}
++
 +/// Democratic space allocation engine
 +pub struct DemocraticAllocator {
 +    config: AllocationConfig,
 +    volunteer_nodes: HashMap<Uuid, VolunteerNode>,
 +    pending_requests: BTreeMap<u64, AllocationRequest>, // Ordered by timestamp
 +    active_allocations: HashMap<Uuid, AllocationResult>,
 +    allocation_history: Vec<AllocationResult>,
 +}
++
 +impl DemocraticAllocator {
 +    /// Create new democratic allocator
 +    pub fn new(config: AllocationConfig) -> Self {
 +        Self {
 +            config,
 +            volunteer_nodes: HashMap::new(),
 +            pending_requests: BTreeMap::new(),
 +            active_allocations: HashMap::new(),
 +            allocation_history: Vec::new(),
 +        }
 +    }
++
 +    /// Register a new volunteer node
 +    pub fn register_volunteer(&mut self, node: VolunteerNode) -> Result<()> {
 +        self.volunteer_nodes.insert(node.node_id, node);
 +        Ok(())
 +    }
++
 +    /// Update volunteer node information
 +    pub fn update_volunteer(&mut self, node_id: Uuid, updates: VolunteerNodeUpdate) -> Result<()> {
 +        if let Some(node) = self.volunteer_nodes.get_mut(&node_id) {
 +            self.apply_node_updates(node, updates);
 +            Ok(())
 +        } else {
 +            Err(anyhow::anyhow!("Volunteer node not found: {}", node_id))
 +        }
 +    }
++
 +    /// Submit a storage allocation request
 +    pub fn request_allocation(&mut self, mut request: AllocationRequest) -> Result<Uuid> {
 +        let current_time = SystemTime::now()
 +            .duration_since(UNIX_EPOCH)
 +            .context("Failed to get timestamp")?
 +            .as_secs();
++
 +        request.created_at = current_time;
 +        let request_id = request.request_id;
++
 +        self.pending_requests.insert(current_time, request);
 +        Ok(request_id)
 +    }
++
 +    /// Process pending allocation requests
 +    pub fn process_allocations(&mut self) -> Result<Vec<AllocationResult>> {
 +        let mut results = Vec::new();
++
 +        // Process requests in order (FIFO with priority consideration)
 +        let requests_to_process: Vec<_> = self.pending_requests.values().cloned().collect();
++
 +        for request in requests_to_process {
 +            if let Ok(result) = self.allocate_storage(&request) {
 +                // Remove from pending
 +                self.pending_requests.retain(|_, r| r.request_id != request.request_id);
++
 +                // Store result
 +                self.active_allocations.insert(result.request_id, result.clone());
 +                self.allocation_history.push(result.clone());
 +                results.push(result);
 +            }
 +        }
++
 +        Ok(results)
 +    }
++
 +    /// Allocate storage for a specific request
 +    pub fn allocate_storage(&self, request: &AllocationRequest) -> Result<AllocationResult> {
 +        // Filter eligible nodes
 +        let eligible_nodes = self.filter_eligible_nodes(request)?;
++
 +        if eligible_nodes.is_empty() {
 +            return Err(anyhow::anyhow!("No eligible nodes available for allocation"));
 +        }
++
 +        // Calculate optimal allocation strategy
 +        let strategy = self.determine_allocation_strategy(request, &eligible_nodes);
++
 +        // Perform allocation based on strategy
 +        let allocations = match strategy {
 +            AllocationStrategy::CapacityBased => self.allocate_by_capacity(request, &eligible_nodes)?,
 +            AllocationStrategy::PerformanceBased => self.allocate_by_performance(request, &eligible_nodes)?,
 +            AllocationStrategy::GeographicDistribution => self.allocate_by_geography(request, &eligible_nodes)?,
 +            AllocationStrategy::LoadBalancing => self.allocate_by_load_balancing(request, &eligible_nodes)?,
 +            AllocationStrategy::Hybrid => self.allocate_hybrid(request, &eligible_nodes)?,
 +        };
++
 +        let total_allocated_gb = allocations.iter().map(|a| a.allocated_gb).sum();
 +        let quality_score = self.calculate_allocation_quality(&allocations, request);
++
 +        let current_time = SystemTime::now()
 +            .duration_since(UNIX_EPOCH)
 +            .context("Failed to get timestamp")?
 +            .as_secs();
++
 +        Ok(AllocationResult {
 +            request_id: request.request_id,
 +            allocations,
 +            total_allocated_gb,
 +            quality_score,
 +            strategy,
 +            allocated_at: current_time,
 +        })
 +    }
++
 +    /// Get network allocation statistics
 +    pub fn get_allocation_stats(&self) -> AllocationStats {
 +        let total_capacity_gb = self.volunteer_nodes.values()
 +            .map(|n| n.total_capacity_gb)
 +            .sum();
++
 +        let total_allocated_gb = self.volunteer_nodes.values()
 +            .map(|n| n.allocated_space_gb)
 +            .sum();
++
 +        let total_used_gb = self.volunteer_nodes.values()
 +            .map(|n| n.used_space_gb)
 +            .sum();
++
 +        let utilization = if total_capacity_gb > 0.0 {
 +            total_used_gb / total_capacity_gb
 +        } else {
 +            0.0
 +        };
++
 +        let active_nodes = self.volunteer_nodes.values()
 +            .filter(|n| matches!(n.status, NodeStatus::Active))
 +            .count();
++
 +        let avg_quality_score = if !self.allocation_history.is_empty() {
 +            self.allocation_history.iter()
 +                .map(|a| a.quality_score)
 +                .sum::<f64>() / self.allocation_history.len() as f64
 +        } else {
 +            0.0
 +        };
++
 +        AllocationStats {
 +            total_capacity_gb,
 +            total_allocated_gb,
 +            total_used_gb,
 +            utilization,
 +            active_nodes,
 +            pending_requests: self.pending_requests.len(),
 +            avg_quality_score,
 +        }
 +    }
++
 +    /// Rebalance allocations across the network
 +    pub fn rebalance_network(&mut self) -> Result<Vec<RebalancingAction>> {
 +        let stats = self.get_allocation_stats();
 +        let mut actions = Vec::new();
++
 +        // Check if rebalancing is needed
 +        if stats.utilization > self.config.target_utilization + 0.1 ||
 +           stats.utilization < self.config.target_utilization - 0.2 {
++
 +            // Calculate optimal rebalancing moves
 +            let rebalancing_plan = self.calculate_rebalancing_plan(&stats)?;
++
 +            for action in rebalancing_plan {
 +                actions.push(action);
 +            }
 +        }
++
 +        Ok(actions)
 +    }
++
 +    /// Filter nodes eligible for a request
 +    fn filter_eligible_nodes(&self, request: &AllocationRequest) -> Result<Vec<&VolunteerNode>> {
 +        Ok(self.volunteer_nodes.values()
 +            .filter(|node| {
 +                // Basic eligibility checks
 +                matches!(node.status, NodeStatus::Active) &&
 +                node.total_capacity_gb - node.allocated_space_gb >= 0.1 && // At least 100MB free
 +                node.performance.uptime_percentage >= 0.9 && // At least 90% uptime
 +                self.meets_performance_requirements(node, &request.performance_requirements)
 +            })
 +            .collect())
 +    }
++
 +    /// Check if node meets performance requirements
 +    fn meets_performance_requirements(&self, node: &VolunteerNode, reqs: &PerformanceRequirements) -> bool {
 +        if let Some(max_latency) = reqs.max_latency_ms {
 +            if node.performance.avg_response_time_ms > max_latency {
 +                return false;
 +            }
 +        }
++
 +        if let Some(min_bandwidth) = reqs.min_bandwidth_mbps {
 +            if node.performance.bandwidth_mbps < min_bandwidth {
 +                return false;
 +            }
 +        }
++
 +        if let Some(min_uptime) = reqs.min_uptime {
 +            if node.performance.uptime_percentage < min_uptime {
 +                return false;
 +            }
 +        }
++
 +        true
 +    }
++
 +    /// Determine optimal allocation strategy
 +    fn determine_allocation_strategy(
 +        &self,
 +        request: &AllocationRequest,
 +        eligible_nodes: &[&VolunteerNode],
 +    ) -> AllocationStrategy {
 +        // Simple heuristic-based strategy selection
 +        if request.performance_requirements.min_bandwidth_mbps.is_some() ||
 +           request.performance_requirements.max_latency_ms.is_some() {
 +            AllocationStrategy::PerformanceBased
 +        } else if request.geo_preference.is_some() {
 +            AllocationStrategy::GeographicDistribution
 +        } else if eligible_nodes.len() > 10 {
 +            AllocationStrategy::LoadBalancing
 +        } else {
 +            AllocationStrategy::Hybrid
 +        }
 +    }
++
 +    /// Allocate storage based on node capacity
 +    fn allocate_by_capacity(
 +        &self,
 +        request: &AllocationRequest,
 +        eligible_nodes: &[&VolunteerNode],
 +    ) -> Result<Vec<NodeAllocation>> {
 +        let mut allocations = Vec::new();
 +        let mut remaining_gb = request.requested_gb;
++
 +        // Sort nodes by available capacity (descending)
 +        let mut sorted_nodes: Vec<_> = eligible_nodes.iter().collect();
 +        sorted_nodes.sort_by(|a, b| {
 +            let a_available = a.total_capacity_gb - a.allocated_space_gb;
 +            let b_available = b.total_capacity_gb - b.allocated_space_gb;
 +            b_available.partial_cmp(&a_available).unwrap()
 +        });
++
 +        for node in sorted_nodes {
 +            if remaining_gb <= 0.0 {
 +                break;
 +            }
++
 +            let available_gb = node.total_capacity_gb - node.allocated_space_gb;
 +            let to_allocate = remaining_gb.min(available_gb).min(self.config.max_allocation_gb);
++
 +            if to_allocate >= self.config.min_allocation_gb {
 +                allocations.push(NodeAllocation {
 +                    node_id: node.node_id,
 +                    allocated_gb: to_allocate,
 +                    reward_amount: to_allocate * 0.01, // $0.01 per GB
 +                    priority: request.priority,
 +                    performance_score: self.calculate_node_performance_score(node),
 +                });
++
 +                remaining_gb -= to_allocate;
 +            }
 +        }
++
 +        Ok(allocations)
 +    }
++
 +    /// Allocate storage based on node performance
 +    fn allocate_by_performance(
 +        &self,
 +        request: &AllocationRequest,
 +        eligible_nodes: &[&VolunteerNode],
 +    ) -> Result<Vec<NodeAllocation>> {
 +        let mut allocations = Vec::new();
 +        let mut remaining_gb = request.requested_gb;
++
 +        // Sort nodes by performance score (descending)
 +        let mut sorted_nodes: Vec<_> = eligible_nodes.iter()
 +            .map(|node| (node, self.calculate_node_performance_score(node)))
 +            .collect();
 +        sorted_nodes.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap());
++
 +        for (node, performance_score) in sorted_nodes {
 +            if remaining_gb <= 0.0 {
 +                break;
 +            }
++
 +            let available_gb = node.total_capacity_gb - node.allocated_space_gb;
 +            let to_allocate = remaining_gb.min(available_gb).min(self.config.max_allocation_gb);
++
 +            if to_allocate >= self.config.min_allocation_gb {
 +                allocations.push(NodeAllocation {
 +                    node_id: node.node_id,
 +                    allocated_gb: to_allocate,
 +                    reward_amount: to_allocate * 0.015 * performance_score, // Performance bonus
 +                    priority: request.priority,
 +                    performance_score,
 +                });
++
 +                remaining_gb -= to_allocate;
 +            }
 +        }
++
 +        Ok(allocations)
 +    }
++
 +    /// Allocate storage based on geographic distribution
 +    fn allocate_by_geography(
 +        &self,
 +        request: &AllocationRequest,
 +        eligible_nodes: &[&VolunteerNode],
 +    ) -> Result<Vec<NodeAllocation>> {
 +        // For now, fall back to capacity-based allocation
 +        // In a real implementation, this would consider geographic distribution
 +        self.allocate_by_capacity(request, eligible_nodes)
 +    }
++
 +    /// Allocate storage using load balancing
 +    fn allocate_by_load_balancing(
 +        &self,
 +        request: &AllocationRequest,
 +        eligible_nodes: &[&VolunteerNode],
 +    ) -> Result<Vec<NodeAllocation>> {
 +        let mut allocations = Vec::new();
 +        let mut remaining_gb = request.requested_gb;
++
 +        // Sort nodes by current utilization (ascending)
 +        let mut sorted_nodes: Vec<_> = eligible_nodes.iter().collect();
 +        sorted_nodes.sort_by(|a, b| {
 +            let a_utilization = a.used_space_gb / a.total_capacity_gb;
 +            let b_utilization = b.used_space_gb / b.total_capacity_gb;
 +            a_utilization.partial_cmp(&b_utilization).unwrap()
 +        });
++
 +        for node in sorted_nodes {
 +            if remaining_gb <= 0.0 {
 +                break;
 +            }
++
 +            let available_gb = node.total_capacity_gb - node.allocated_space_gb;
 +            let to_allocate = remaining_gb.min(available_gb).min(self.config.max_allocation_gb);
++
 +            if to_allocate >= self.config.min_allocation_gb {
 +                allocations.push(NodeAllocation {
 +                    node_id: node.node_id,
 +                    allocated_gb: to_allocate,
 +                    reward_amount: to_allocate * 0.01,
 +                    priority: request.priority,
 +                    performance_score: self.calculate_node_performance_score(node),
 +                });
++
 +                remaining_gb -= to_allocate;
 +            }
 +        }
++
 +        Ok(allocations)
 +    }
++
 +    /// Allocate storage using hybrid approach
 +    fn allocate_hybrid(
 +        &self,
 +        request: &AllocationRequest,
 +        eligible_nodes: &[&VolunteerNode],
 +    ) -> Result<Vec<NodeAllocation>> {
 +        // Hybrid scoring based on capacity, performance, and load
 +        let mut node_scores: Vec<_> = eligible_nodes.iter()
 +            .map(|node| {
 +                let available_gb = node.total_capacity_gb - node.allocated_space_gb;
 +                let utilization = node.used_space_gb / node.total_capacity_gb;
 +                let performance_score = self.calculate_node_performance_score(node);
++
 +                let capacity_score = available_gb / self.config.max_allocation_gb;
 +                let load_score = 1.0 - utilization;
++
 +                let hybrid_score =
 +                    self.config.capacity_weight * capacity_score +
 +                    self.config.performance_weight * performance_score +
 +                    (1.0 - self.config.capacity_weight - self.config.performance_weight) * load_score;
++
 +                (node, hybrid_score)
 +            })
 +            .collect();
++
 +        // Sort by hybrid score (descending)
 +        node_scores.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap());
++
 +        let mut allocations = Vec::new();
 +        let mut remaining_gb = request.requested_gb;
++
 +        for (node, score) in node_scores {
 +            if remaining_gb <= 0.0 {
 +                break;
 +            }
++
 +            let available_gb = node.total_capacity_gb - node.allocated_space_gb;
 +            let to_allocate = remaining_gb.min(available_gb).min(self.config.max_allocation_gb);
++
 +            if to_allocate >= self.config.min_allocation_gb {
 +                allocations.push(NodeAllocation {
 +                    node_id: node.node_id,
 +                    allocated_gb: to_allocate,
 +                    reward_amount: to_allocate * 0.012 * score, // Score-based reward
 +                    priority: request.priority,
 +                    performance_score: self.calculate_node_performance_score(node),
 +                });
++
 +                remaining_gb -= to_allocate;
 +            }
 +        }
++
 +        Ok(allocations)
 +    }
++
 +    /// Calculate node performance score
 +    fn calculate_node_performance_score(&self, node: &VolunteerNode) -> f64 {
 +        let latency_score = (1000.0 - node.performance.avg_response_time_ms).max(0.0) / 1000.0;
 +        let bandwidth_score = (node.performance.bandwidth_mbps / 100.0).min(1.0);
 +        let uptime_score = node.performance.uptime_percentage;
 +        let reliability_score = node.reliability_score;
 +        let error_score = 1.0 - node.performance.error_rate;
++
 +        (latency_score + bandwidth_score + uptime_score + reliability_score + error_score) / 5.0
 +    }
++
 +    /// Calculate quality score for an allocation
 +    fn calculate_allocation_quality(&self, allocations: &[NodeAllocation], request: &AllocationRequest) -> f64 {
 +        if allocations.is_empty() {
 +            return 0.0;
 +        }
++
 +        let total_allocated = allocations.iter().map(|a| a.allocated_gb).sum::<f64>();
 +        let fulfillment_ratio = (total_allocated / request.requested_gb).min(1.0);
++
 +        let avg_performance = allocations.iter()
 +            .map(|a| a.performance_score)
 +            .sum::<f64>() / allocations.len() as f64;
++
 +        let diversity_bonus = if allocations.len() > 1 { 0.1 } else { 0.0 };
++
 +        (fulfillment_ratio * 0.6 + avg_performance * 0.3 + diversity_bonus).min(1.0)
 +    }
++
 +    /// Apply updates to a volunteer node
 +    fn apply_node_updates(&self, node: &mut VolunteerNode, updates: VolunteerNodeUpdate) {
 +        if let Some(capacity) = updates.total_capacity_gb {
 +            node.total_capacity_gb = capacity;
 +        }
 +        if let Some(used) = updates.used_space_gb {
 +            node.used_space_gb = used;
 +        }
 +        if let Some(performance) = updates.performance {
 +            node.performance = performance;
 +        }
 +        if let Some(status) = updates.status {
 +            node.status = status;
 +        }
 +    }
++
 +    /// Calculate rebalancing plan
 +    fn calculate_rebalancing_plan(&self, _stats: &AllocationStats) -> Result<Vec<RebalancingAction>> {
 +        // Simplified rebalancing - in production this would be more sophisticated
 +        Ok(vec![])
 +    }
 +}
++
 +/// Updates for volunteer node information
 +#[derive(Debug, Clone)]
 +pub struct VolunteerNodeUpdate {
 +    pub total_capacity_gb: Option<f64>,
 +    pub used_space_gb: Option<f64>,
 +    pub performance: Option<NodePerformance>,
 +    pub status: Option<NodeStatus>,
 +}
++
 +/// Rebalancing action
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub enum RebalancingAction {
 +    MoveAllocation {
 +        from_node: Uuid,
 +        to_node: Uuid,
 +        amount_gb: f64,
 +    },
 +    ScaleUp {
 +        node_id: Uuid,
 +        additional_gb: f64,
 +    },
 +    ScaleDown {
 +        node_id: Uuid,
 +        reduction_gb: f64,
 +    },
 +}
++
 +#[cfg(test)]
 +mod tests {
 +    use super::*;
++
 +    fn create_test_node(node_id: Uuid, capacity_gb: f64) -> VolunteerNode {
 +        VolunteerNode {
 +            node_id,
 +            total_capacity_gb: capacity_gb,
 +            allocated_space_gb: 0.0,
 +            used_space_gb: 0.0,
 +            performance: NodePerformance {
 +                avg_response_time_ms: 50.0,
 +                bandwidth_mbps: 100.0,
 +                uptime_percentage: 0.99,
 +                error_rate: 0.01,
 +                cpu_usage: 0.3,
 +                memory_usage: 0.4,
 +            },
 +            preferences: NodePreferences {
 +                max_contribution_gb: capacity_gb,
 +                preferred_hours: None,
 +                bandwidth_limit_mbps: None,
 +                content_preferences: vec![],
 +                min_reward_rate: None,
 +            },
 +            location: None,
 +            reliability_score: 0.95,
 +            last_seen: SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs(),
 +            status: NodeStatus::Active,
 +        }
 +    }
++
 +    #[test]
 +    fn test_democratic_allocation_basic() -> Result<()> {
 +        let config = AllocationConfig::default();
 +        let mut allocator = DemocraticAllocator::new(config);
++
 +        // Register some volunteer nodes
 +        let node1 = create_test_node(Uuid::new_v4(), 10.0);
 +        let node2 = create_test_node(Uuid::new_v4(), 20.0);
 +        let node3 = create_test_node(Uuid::new_v4(), 15.0);
++
 +        allocator.register_volunteer(node1)?;
 +        allocator.register_volunteer(node2)?;
 +        allocator.register_volunteer(node3)?;
++
 +        // Create allocation request
 +        let request = AllocationRequest {
 +            request_id: Uuid::new_v4(),
 +            user_id: "test-user".to_string(),
 +            requested_gb: 5.0,
 +            priority: 5,
 +            content_type: None,
 +            geo_preference: None,
 +            performance_requirements: PerformanceRequirements {
 +                max_latency_ms: None,
 +                min_bandwidth_mbps: None,
 +                min_uptime: None,
 +                redundancy_factor: 1,
 +            },
 +            created_at: 0, // Will be set by request_allocation
 +        };
++
 +        let request_id = allocator.request_allocation(request)?;
 +        let results = allocator.process_allocations()?;
++
 +        assert!(!results.is_empty());
 +        assert_eq!(results[0].request_id, request_id);
 +        assert!(results[0].total_allocated_gb > 0.0);
++
 +        Ok(())
 +    }
++
 +    #[test]
 +    fn test_allocation_stats() {
 +        let config = AllocationConfig::default();
 +        let mut allocator = DemocraticAllocator::new(config);
++
 +        // Add some nodes
 +        allocator.register_volunteer(create_test_node(Uuid::new_v4(), 10.0)).unwrap();
 +        allocator.register_volunteer(create_test_node(Uuid::new_v4(), 20.0)).unwrap();
++
 +        let stats = allocator.get_allocation_stats();
++
 +        assert_eq!(stats.total_capacity_gb, 30.0);
 +        assert_eq!(stats.active_nodes, 2);
 +        assert_eq!(stats.utilization, 0.0); // No usage yet
 +    }
++
 +    #[test]
 +    fn test_node_performance_score() {
 +        let config = AllocationConfig::default();
 +        let allocator = DemocraticAllocator::new(config);
 +        let node = create_test_node(Uuid::new_v4(), 10.0);
++
 +        let score = allocator.calculate_node_performance_score(&node);
 +        assert!(score > 0.8); // Should be high score for good test node
 +        assert!(score <= 1.0);
 +    }
 +}

src/economics/earnings_calculator.rsadded

 +//! Real-Time Earnings Calculation System
 +//!
 +//! Comprehensive earnings tracking and calculation for ZephyrFS volunteers
++
 +use anyhow::Result;
 +use serde::{Deserialize, Serialize};
 +use std::collections::{HashMap, VecDeque};
 +use chrono::{DateTime, Utc, Duration};
++
 +use super::token_model::{RewardReason, NetworkHealthMetrics};
++
 +/// Real-time earnings calculator for volunteers
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct EarningsCalculator {
 +    /// Volunteer performance tracking
 +    pub volunteer_metrics: HashMap<String, VolunteerMetrics>,
 +    /// Earnings rates configuration
 +    pub rates: EarningsRates,
 +    /// Bonus multipliers
 +    pub bonuses: BonusStructure,
 +    /// Performance history for analytics
 +    pub performance_history: HashMap<String, VecDeque<PerformanceRecord>>,
 +    /// Network-wide metrics
 +    pub network_metrics: NetworkHealthMetrics,
 +    /// Daily earnings summary
 +    pub daily_earnings: HashMap<String, DailyEarnings>,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct VolunteerMetrics {
 +    pub volunteer_id: String,
 +    pub total_storage_gb: u64,
 +    pub available_storage_gb: u64,
 +    pub used_storage_gb: u64,
 +    pub uptime_hours_24h: f64,
 +    pub uptime_percentage: f64,
 +    pub response_time_ms: u64,
 +    pub transfer_speed_mbps: f64,
 +    pub successful_transfers: u64,
 +    pub failed_transfers: u64,
 +    pub geographic_region: GeographicRegion,
 +    pub connection_quality: ConnectionQuality,
 +    pub reliability_score: f64,
 +    pub last_seen: DateTime<Utc>,
 +    pub joined_at: DateTime<Utc>,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct EarningsRates {
 +    /// Base rate per GB per day (in wei-equivalent tokens)
 +    pub base_storage_rate: u64,
 +    /// Uptime bonus rate (per hour of 100% uptime)
 +    pub uptime_bonus_rate: u64,
 +    /// Performance bonus rate (based on speed/reliability)
 +    pub performance_bonus_rate: u64,
 +    /// Geographic diversity bonus
 +    pub geographic_bonus_rate: u64,
 +    /// Longevity bonus (tenure rewards)
 +    pub longevity_bonus_rate: u64,
 +    /// Network contribution bonus
 +    pub network_contribution_rate: u64,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct BonusStructure {
 +    /// Uptime thresholds and multipliers
 +    pub uptime_tiers: Vec<UptimeTier>,
 +    /// Performance score multipliers
 +    pub performance_multipliers: PerformanceMultipliers,
 +    /// Geographic diversity bonuses
 +    pub geographic_bonuses: HashMap<GeographicRegion, f64>,
 +    /// Tenure bonuses (loyalty rewards)
 +    pub tenure_bonuses: Vec<TenureTier>,
 +    /// Network health bonuses
 +    pub network_health_bonus: f64,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct UptimeTier {
 +    pub threshold_percent: f64,
 +    pub multiplier: f64,
 +    pub name: String,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct PerformanceMultipliers {
 +    pub excellent_speed: f64,      // >100 Mbps
 +    pub good_speed: f64,          // 50-100 Mbps
 +    pub average_speed: f64,       // 10-50 Mbps
 +    pub low_response_time: f64,   // <100ms
 +    pub high_reliability: f64,    // >99% success rate
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct TenureTier {
 +    pub months: u32,
 +    pub multiplier: f64,
 +    pub name: String,
 +}
++
 +#[derive(Debug, Clone, PartialEq, Hash, Serialize, Deserialize)]
 +pub enum GeographicRegion {
 +    NorthAmerica,
 +    Europe,
 +    Asia,
 +    SouthAmerica,
 +    Africa,
 +    Oceania,
 +    Rare, // Underrepresented regions
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub enum ConnectionQuality {
 +    Excellent, // Fiber, low latency
 +    Good,      // Broadband, stable
 +    Fair,      // Adequate speed
 +    Poor,      // Slow or unstable
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct PerformanceRecord {
 +    pub timestamp: DateTime<Utc>,
 +    pub uptime_hours: f64,
 +    pub storage_provided_gb: u64,
 +    pub transfer_speed_mbps: f64,
 +    pub response_time_ms: u64,
 +    pub success_rate: f64,
 +    pub earnings_tokens: u64,
 +    pub bonus_tokens: u64,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct DailyEarnings {
 +    pub date: DateTime<Utc>,
 +    pub base_earnings: u64,
 +    pub uptime_bonus: u64,
 +    pub performance_bonus: u64,
 +    pub geographic_bonus: u64,
 +    pub longevity_bonus: u64,
 +    pub network_bonus: u64,
 +    pub total_earnings: u64,
 +    pub storage_gb_hours: u64,
 +    pub actual_uptime_hours: f64,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct EarningsProjection {
 +    pub daily_estimate: u64,
 +    pub weekly_estimate: u64,
 +    pub monthly_estimate: u64,
 +    pub annual_estimate: u64,
 +    pub factors: ProjectionFactors,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct ProjectionFactors {
 +    pub current_performance: f64,
 +    pub network_demand: f64,
 +    pub seasonal_adjustment: f64,
 +    pub growth_factor: f64,
 +}
++
 +impl Default for EarningsRates {
 +    fn default() -> Self {
 +        Self {
 +            base_storage_rate: 20_000_000_000_000_000, // 0.02 tokens per GB per day
 +            uptime_bonus_rate: 1_000_000_000_000_000,  // 0.001 tokens per hour
 +            performance_bonus_rate: 5_000_000_000_000_000, // 0.005 tokens for high performance
 +            geographic_bonus_rate: 3_000_000_000_000_000, // 0.003 tokens for rare regions
 +            longevity_bonus_rate: 2_000_000_000_000_000, // 0.002 tokens longevity bonus
 +            network_contribution_rate: 1_000_000_000_000_000, // 0.001 tokens network contribution
 +        }
 +    }
 +}
++
 +impl Default for BonusStructure {
 +    fn default() -> Self {
 +        Self {
 +            uptime_tiers: vec![
 +                UptimeTier { threshold_percent: 99.5, multiplier: 2.0, name: "Platinum".to_string() },
 +                UptimeTier { threshold_percent: 98.0, multiplier: 1.5, name: "Gold".to_string() },
 +                UptimeTier { threshold_percent: 95.0, multiplier: 1.2, name: "Silver".to_string() },
 +                UptimeTier { threshold_percent: 90.0, multiplier: 1.0, name: "Bronze".to_string() },
 +            ],
 +            performance_multipliers: PerformanceMultipliers {
 +                excellent_speed: 1.3,
 +                good_speed: 1.1,
 +                average_speed: 1.0,
 +                low_response_time: 1.2,
 +                high_reliability: 1.25,
 +            },
 +            geographic_bonuses: HashMap::from([
 +                (GeographicRegion::Rare, 0.5),
 +                (GeographicRegion::Africa, 0.3),
 +                (GeographicRegion::SouthAmerica, 0.2),
 +                (GeographicRegion::Oceania, 0.2),
 +                (GeographicRegion::Asia, 0.1),
 +                (GeographicRegion::Europe, 0.05),
 +                (GeographicRegion::NorthAmerica, 0.0),
 +            ]),
 +            tenure_bonuses: vec![
 +                TenureTier { months: 24, multiplier: 1.5, name: "Veteran".to_string() },
 +                TenureTier { months: 12, multiplier: 1.3, name: "Experienced".to_string() },
 +                TenureTier { months: 6, multiplier: 1.15, name: "Established".to_string() },
 +                TenureTier { months: 3, multiplier: 1.05, name: "Regular".to_string() },
 +            ],
 +            network_health_bonus: 0.1, // 10% bonus when network is healthy
 +        }
 +    }
 +}
++
 +impl EarningsCalculator {
 +    /// Create new earnings calculator
 +    pub fn new() -> Self {
 +        Self {
 +            volunteer_metrics: HashMap::new(),
 +            rates: EarningsRates::default(),
 +            bonuses: BonusStructure::default(),
 +            performance_history: HashMap::new(),
 +            network_metrics: NetworkHealthMetrics {
 +                total_capacity_gb: 0,
 +                active_volunteers: 0,
 +                utilization_rate: 0.0,
 +                average_uptime: 0.0,
 +                geographic_diversity: 0.0,
 +                data_durability: 0.0,
 +            },
 +            daily_earnings: HashMap::new(),
 +        }
 +    }
++
 +    /// Update volunteer metrics
 +    pub fn update_volunteer_metrics(&mut self, metrics: VolunteerMetrics) {
 +        let volunteer_id = metrics.volunteer_id.clone();
++
 +        // Record performance history
 +        let record = PerformanceRecord {
 +            timestamp: Utc::now(),
 +            uptime_hours: metrics.uptime_hours_24h,
 +            storage_provided_gb: metrics.used_storage_gb,
 +            transfer_speed_mbps: metrics.transfer_speed_mbps,
 +            response_time_ms: metrics.response_time_ms,
 +            success_rate: if metrics.successful_transfers + metrics.failed_transfers > 0 {
 +                metrics.successful_transfers as f64 / (metrics.successful_transfers + metrics.failed_transfers) as f64
 +            } else {
 +                1.0
 +            },
 +            earnings_tokens: 0, // Will be calculated
 +            bonus_tokens: 0,
 +        };
++
 +        self.performance_history
 +            .entry(volunteer_id.clone())
 +            .or_insert_with(|| VecDeque::with_capacity(720)) // 30 days of hourly records
 +            .push_back(record);
++
 +        // Keep only last 30 days
 +        if let Some(history) = self.performance_history.get_mut(&volunteer_id) {
 +            while history.len() > 720 {
 +                history.pop_front();
 +            }
 +        }
++
 +        self.volunteer_metrics.insert(volunteer_id, metrics);
 +    }
++
 +    /// Calculate real-time earnings for a volunteer
 +    pub fn calculate_real_time_earnings(&self, volunteer_id: &str) -> Result<u64> {
 +        let metrics = self.volunteer_metrics.get(volunteer_id)
 +            .ok_or_else(|| anyhow::anyhow!("Volunteer metrics not found"))?;
++
 +        // Calculate base storage earnings
 +        let base_earnings = self.calculate_base_storage_earnings(metrics);
++
 +        // Calculate uptime bonus
 +        let uptime_bonus = self.calculate_uptime_bonus(metrics);
++
 +        // Calculate performance bonus
 +        let performance_bonus = self.calculate_performance_bonus(metrics);
++
 +        // Calculate geographic bonus
 +        let geographic_bonus = self.calculate_geographic_bonus(metrics);
++
 +        // Calculate longevity bonus
 +        let longevity_bonus = self.calculate_longevity_bonus(metrics);
++
 +        // Calculate network health bonus
 +        let network_bonus = self.calculate_network_health_bonus(base_earnings);
++
 +        let total_earnings = base_earnings + uptime_bonus + performance_bonus
 +            + geographic_bonus + longevity_bonus + network_bonus;
++
 +        Ok(total_earnings)
 +    }
++
 +    /// Calculate base storage earnings
 +    fn calculate_base_storage_earnings(&self, metrics: &VolunteerMetrics) -> u64 {
 +        // Earnings based on storage provided and utilization
 +        let utilization_factor = if metrics.total_storage_gb > 0 {
 +            metrics.used_storage_gb as f64 / metrics.total_storage_gb as f64
 +        } else {
 +            0.0
 +        };
++
 +        // Base rate * storage * utilization (with minimum guarantee)
 +        let base = metrics.total_storage_gb * self.rates.base_storage_rate;
 +        let utilization_earnings = (base as f64 * utilization_factor) as u64;
++
 +        // Guarantee at least 20% of base rate even with no utilization
 +        let minimum = base / 5;
++
 +        utilization_earnings.max(minimum)
 +    }
++
 +    /// Calculate uptime bonus
 +    fn calculate_uptime_bonus(&self, metrics: &VolunteerMetrics) -> u64 {
 +        let uptime_tier = self.bonuses.uptime_tiers.iter()
 +            .find(|tier| metrics.uptime_percentage >= tier.threshold_percent)
 +            .unwrap_or(&self.bonuses.uptime_tiers[self.bonuses.uptime_tiers.len() - 1]);
++
 +        let base_bonus = (metrics.uptime_hours_24h * self.rates.uptime_bonus_rate as f64) as u64;
 +        (base_bonus as f64 * uptime_tier.multiplier) as u64
 +    }
++
 +    /// Calculate performance bonus
 +    fn calculate_performance_bonus(&self, metrics: &VolunteerMetrics) -> u64 {
 +        let mut multiplier = 1.0;
++
 +        // Speed bonus
 +        if metrics.transfer_speed_mbps >= 100.0 {
 +            multiplier *= self.bonuses.performance_multipliers.excellent_speed;
 +        } else if metrics.transfer_speed_mbps >= 50.0 {
 +            multiplier *= self.bonuses.performance_multipliers.good_speed;
 +        } else if metrics.transfer_speed_mbps >= 10.0 {
 +            multiplier *= self.bonuses.performance_multipliers.average_speed;
 +        }
++
 +        // Response time bonus
 +        if metrics.response_time_ms < 100 {
 +            multiplier *= self.bonuses.performance_multipliers.low_response_time;
 +        }
++
 +        // Reliability bonus
 +        let success_rate = if metrics.successful_transfers + metrics.failed_transfers > 0 {
 +            metrics.successful_transfers as f64 / (metrics.successful_transfers + metrics.failed_transfers) as f64
 +        } else {
 +            1.0
 +        };
++
 +        if success_rate >= 0.99 {
 +            multiplier *= self.bonuses.performance_multipliers.high_reliability;
 +        }
++
 +        (self.rates.performance_bonus_rate as f64 * multiplier) as u64
 +    }
++
 +    /// Calculate geographic diversity bonus
 +    fn calculate_geographic_bonus(&self, metrics: &VolunteerMetrics) -> u64 {
 +        let bonus_multiplier = self.bonuses.geographic_bonuses
 +            .get(&metrics.geographic_region)
 +            .copied()
 +            .unwrap_or(0.0);
++
 +        (self.rates.geographic_bonus_rate as f64 * (1.0 + bonus_multiplier)) as u64
 +    }
++
 +    /// Calculate longevity bonus
 +    fn calculate_longevity_bonus(&self, metrics: &VolunteerMetrics) -> u64 {
 +        let months_active = (Utc::now() - metrics.joined_at).num_days() / 30;
++
 +        let tenure_tier = self.bonuses.tenure_bonuses.iter()
 +            .find(|tier| months_active >= tier.months as i64)
 +            .cloned()
 +            .unwrap_or(TenureTier { months: 0, multiplier: 1.0, name: "New".to_string() });
++
 +        (self.rates.longevity_bonus_rate as f64 * tenure_tier.multiplier) as u64
 +    }
++
 +    /// Calculate network health bonus
 +    fn calculate_network_health_bonus(&self, base_earnings: u64) -> u64 {
 +        // Bonus when network is performing well
 +        let health_score = self.calculate_network_health_score();
++
 +        if health_score >= 95.0 {
 +            (base_earnings as f64 * self.bonuses.network_health_bonus) as u64
 +        } else {
 +            0
 +        }
 +    }
++
 +    /// Calculate overall network health score
 +    fn calculate_network_health_score(&self) -> f64 {
 +        let metrics = &self.network_metrics;
++
 +        // Weighted health score
 +        let uptime_score = metrics.average_uptime.min(100.0);
 +        let diversity_score = metrics.geographic_diversity.min(100.0);
 +        let durability_score = metrics.data_durability.min(100.0);
++
 +        (uptime_score * 0.4 + diversity_score * 0.3 + durability_score * 0.3)
 +    }
++
 +    /// Calculate hourly earnings for a volunteer
 +    pub fn calculate_hourly_earnings(&self, volunteer_id: &str) -> Result<u64> {
 +        let daily_earnings = self.calculate_real_time_earnings(volunteer_id)?;
 +        Ok(daily_earnings / 24) // Hourly rate
 +    }
++
 +    /// Calculate earnings projection
 +    pub fn calculate_earnings_projection(&self, volunteer_id: &str) -> Result<EarningsProjection> {
 +        let daily_earnings = self.calculate_real_time_earnings(volunteer_id)?;
++
 +        // Get performance trend
 +        let performance_trend = self.calculate_performance_trend(volunteer_id)?;
++
 +        // Network demand factor (based on utilization)
 +        let demand_factor = (self.network_metrics.utilization_rate / 100.0).min(1.2); // Cap at 120%
++
 +        // Seasonal adjustment (placeholder - would use historical data)
 +        let seasonal_factor = 1.0;
++
 +        // Growth factor based on network expansion
 +        let growth_factor = if self.network_metrics.active_volunteers < 100 {
 +            1.2 // Early network bonus
 +        } else {
 +            1.0
 +        };
++
 +        let factors = ProjectionFactors {
 +            current_performance: performance_trend,
 +            network_demand: demand_factor,
 +            seasonal_adjustment: seasonal_factor,
 +            growth_factor,
 +        };
++
 +        let adjusted_daily = (daily_earnings as f64 * performance_trend * demand_factor * growth_factor) as u64;
++
 +        Ok(EarningsProjection {
 +            daily_estimate: adjusted_daily,
 +            weekly_estimate: adjusted_daily * 7,
 +            monthly_estimate: adjusted_daily * 30,
 +            annual_estimate: adjusted_daily * 365,
 +            factors,
 +        })
 +    }
++
 +    /// Calculate performance trend for projections
 +    fn calculate_performance_trend(&self, volunteer_id: &str) -> Result<f64> {
 +        let history = self.performance_history.get(volunteer_id)
 +            .ok_or_else(|| anyhow::anyhow!("No performance history found"))?;
++
 +        if history.len() < 2 {
 +            return Ok(1.0); // No trend data
 +        }
++
 +        // Calculate trend over last 7 days
 +        let recent_records: Vec<_> = history.iter().rev().take(168).collect(); // Last 7 days (hourly)
++
 +        if recent_records.len() < 24 {
 +            return Ok(1.0);
 +        }
++
 +        let recent_performance = recent_records.iter().take(24)
 +            .map(|r| r.success_rate * (r.transfer_speed_mbps / 50.0).min(2.0))
 +            .sum::<f64>() / 24.0;
++
 +        let older_performance = recent_records.iter().skip(24).take(24)
 +            .map(|r| r.success_rate * (r.transfer_speed_mbps / 50.0).min(2.0))
 +            .sum::<f64>() / 24.0;
++
 +        if older_performance > 0.0 {
 +            Ok((recent_performance / older_performance).max(0.5).min(2.0)) // Cap trend between 0.5x and 2x
 +        } else {
 +            Ok(1.0)
 +        }
 +    }
++
 +    /// Update daily earnings summary
 +    pub fn update_daily_earnings(&mut self, volunteer_id: &str) -> Result<()> {
 +        let metrics = self.volunteer_metrics.get(volunteer_id)
 +            .ok_or_else(|| anyhow::anyhow!("Volunteer metrics not found"))?;
++
 +        let today = Utc::now().date_naive();
 +        let key = format!("{}_{}", volunteer_id, today.format("%Y-%m-%d"));
++
 +        let base_earnings = self.calculate_base_storage_earnings(metrics);
 +        let uptime_bonus = self.calculate_uptime_bonus(metrics);
 +        let performance_bonus = self.calculate_performance_bonus(metrics);
 +        let geographic_bonus = self.calculate_geographic_bonus(metrics);
 +        let longevity_bonus = self.calculate_longevity_bonus(metrics);
 +        let network_bonus = self.calculate_network_health_bonus(base_earnings);
++
 +        let daily_earnings = DailyEarnings {
 +            date: Utc::now(),
 +            base_earnings,
 +            uptime_bonus,
 +            performance_bonus,
 +            geographic_bonus,
 +            longevity_bonus,
 +            network_bonus,
 +            total_earnings: base_earnings + uptime_bonus + performance_bonus
 +                + geographic_bonus + longevity_bonus + network_bonus,
 +            storage_gb_hours: metrics.used_storage_gb * 24, // GB-hours for the day
 +            actual_uptime_hours: metrics.uptime_hours_24h,
 +        };
++
 +        self.daily_earnings.insert(key, daily_earnings);
++
 +        Ok(())
 +    }
++
 +    /// Get earnings breakdown for display
 +    pub fn get_earnings_breakdown(&self, volunteer_id: &str) -> Result<HashMap<String, u64>> {
 +        let metrics = self.volunteer_metrics.get(volunteer_id)
 +            .ok_or_else(|| anyhow::anyhow!("Volunteer metrics not found"))?;
++
 +        let mut breakdown = HashMap::new();
 +        breakdown.insert("base_storage".to_string(), self.calculate_base_storage_earnings(metrics));
 +        breakdown.insert("uptime_bonus".to_string(), self.calculate_uptime_bonus(metrics));
 +        breakdown.insert("performance_bonus".to_string(), self.calculate_performance_bonus(metrics));
 +        breakdown.insert("geographic_bonus".to_string(), self.calculate_geographic_bonus(metrics));
 +        breakdown.insert("longevity_bonus".to_string(), self.calculate_longevity_bonus(metrics));
 +        breakdown.insert("network_bonus".to_string(), self.calculate_network_health_bonus(self.calculate_base_storage_earnings(metrics)));
++
 +        Ok(breakdown)
 +    }
++
 +    /// Update network metrics
 +    pub fn update_network_metrics(&mut self, metrics: NetworkHealthMetrics) {
 +        self.network_metrics = metrics;
 +    }
 +}
++
 +#[cfg(test)]
 +mod tests {
 +    use super::*;
++
 +    #[test]
 +    fn test_earnings_calculation() {
 +        let mut calculator = EarningsCalculator::new();
++
 +        let metrics = VolunteerMetrics {
 +            volunteer_id: "test_volunteer".to_string(),
 +            total_storage_gb: 100,
 +            available_storage_gb: 50,
 +            used_storage_gb: 50,
 +            uptime_hours_24h: 24.0,
 +            uptime_percentage: 100.0,
 +            response_time_ms: 50,
 +            transfer_speed_mbps: 100.0,
 +            successful_transfers: 100,
 +            failed_transfers: 0,
 +            geographic_region: GeographicRegion::Europe,
 +            connection_quality: ConnectionQuality::Excellent,
 +            reliability_score: 1.0,
 +            last_seen: Utc::now(),
 +            joined_at: Utc::now() - Duration::days(365),
 +        };
++
 +        calculator.update_volunteer_metrics(metrics);
++
 +        let earnings = calculator.calculate_real_time_earnings("test_volunteer").unwrap();
 +        assert!(earnings > 0);
++
 +        let breakdown = calculator.get_earnings_breakdown("test_volunteer").unwrap();
 +        assert!(breakdown.contains_key("base_storage"));
 +        assert!(breakdown.contains_key("uptime_bonus"));
 +    }
++
 +    #[test]
 +    fn test_performance_multipliers() {
 +        let calculator = EarningsCalculator::new();
++
 +        let high_performance_metrics = VolunteerMetrics {
 +            volunteer_id: "high_perf".to_string(),
 +            total_storage_gb: 100,
 +            available_storage_gb: 0,
 +            used_storage_gb: 100,
 +            uptime_hours_24h: 24.0,
 +            uptime_percentage: 99.9,
 +            response_time_ms: 25,
 +            transfer_speed_mbps: 150.0,
 +            successful_transfers: 1000,
 +            failed_transfers: 1,
 +            geographic_region: GeographicRegion::Rare,
 +            connection_quality: ConnectionQuality::Excellent,
 +            reliability_score: 1.0,
 +            last_seen: Utc::now(),
 +            joined_at: Utc::now() - Duration::days(730),
 +        };
++
 +        let high_perf_bonus = calculator.calculate_performance_bonus(&high_performance_metrics);
++
 +        let low_performance_metrics = VolunteerMetrics {
 +            volunteer_id: "low_perf".to_string(),
 +            total_storage_gb: 100,
 +            available_storage_gb: 80,
 +            used_storage_gb: 20,
 +            uptime_hours_24h: 20.0,
 +            uptime_percentage: 83.3,
 +            response_time_ms: 200,
 +            transfer_speed_mbps: 5.0,
 +            successful_transfers: 80,
 +            failed_transfers: 20,
 +            geographic_region: GeographicRegion::NorthAmerica,
 +            connection_quality: ConnectionQuality::Fair,
 +            reliability_score: 0.8,
 +            last_seen: Utc::now(),
 +            joined_at: Utc::now() - Duration::days(30),
 +        };
++
 +        let low_perf_bonus = calculator.calculate_performance_bonus(&low_performance_metrics);
++
 +        assert!(high_perf_bonus > low_perf_bonus);
 +    }
 +}

src/economics/market_maker.rsadded

 +//! Automated Market Maker for ZephyrCoin Price Stability
 +//!
 +//! Maintains stable token value through algorithmic trading and liquidity provision
++
 +use anyhow::Result;
 +use serde::{Deserialize, Serialize};
 +use std::collections::{HashMap, VecDeque};
 +use chrono::{DateTime, Utc, Duration};
++
 +/// Automated Market Maker for ZephyrCoin
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct ZephyrCoinAMM {
 +    /// Liquidity pools for different pairs
 +    pub pools: HashMap<TradingPair, LiquidityPool>,
 +    /// Target price in USD (stable value target)
 +    pub target_price_usd: f64,
 +    /// Price stability configuration
 +    pub stability_config: StabilityConfig,
 +    /// Trading history for price analysis
 +    pub price_history: VecDeque<PriceSnapshot>,
 +    /// Current reserves
 +    pub reserves: Reserves,
 +    /// Fee structure
 +    pub fees: FeeStructure,
 +}
++
 +#[derive(Debug, Clone, Hash, Eq, PartialEq, Serialize, Deserialize)]
 +pub enum TradingPair {
 +    ZEPH_USD,
 +    ZEPH_ETH,
 +    ZEPH_BTC,
 +    ZEPH_USDC,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct LiquidityPool {
 +    /// Pool reserves
 +    pub reserve_a: u64, // ZEPH tokens
 +    pub reserve_b: u64, // Other asset (in smallest units)
 +    /// Total liquidity provider shares
 +    pub total_shares: u64,
 +    /// Liquidity provider positions
 +    pub lp_positions: HashMap<String, LPPosition>,
 +    /// Pool fee rate (e.g., 0.003 for 0.3%)
 +    pub fee_rate: f64,
 +    /// Last price update
 +    pub last_update: DateTime<Utc>,
 +    /// Price impact protection
 +    pub max_slippage: f64,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct LPPosition {
 +    pub shares: u64,
 +    pub provided_at: DateTime<Utc>,
 +    pub initial_zeph: u64,
 +    pub initial_other: u64,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct StabilityConfig {
 +    /// Price deviation threshold for intervention (5%)
 +    pub intervention_threshold: f64,
 +    /// Maximum daily price change (10%)
 +    pub max_daily_change: f64,
 +    /// Rebalancing frequency (hours)
 +    pub rebalance_frequency: u32,
 +    /// Emergency circuit breaker threshold (20%)
 +    pub circuit_breaker_threshold: f64,
 +    /// Minimum liquidity ratio
 +    pub min_liquidity_ratio: f64,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct Reserves {
 +    /// ZEPH token reserves for market making
 +    pub zeph_reserve: u64,
 +    /// USD equivalent reserves
 +    pub usd_reserve: u64,
 +    /// Emergency reserves
 +    pub emergency_reserve: u64,
 +    /// Insurance fund
 +    pub insurance_fund: u64,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct FeeStructure {
 +    /// Trading fee (0.3%)
 +    pub trading_fee: f64,
 +    /// Stability fee for interventions (0.1%)
 +    pub stability_fee: f64,
 +    /// LP reward rate (daily APY)
 +    pub lp_reward_rate: f64,
 +    /// Protocol fee (goes to treasury)
 +    pub protocol_fee: f64,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct PriceSnapshot {
 +    pub timestamp: DateTime<Utc>,
 +    pub price_usd: f64,
 +    pub volume_24h: u64,
 +    pub liquidity_depth: u64,
 +    pub volatility: f64,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct TradeExecution {
 +    pub pair: TradingPair,
 +    pub amount_in: u64,
 +    pub amount_out: u64,
 +    pub price: f64,
 +    pub fee: u64,
 +    pub slippage: f64,
 +    pub timestamp: DateTime<Utc>,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub enum MarketOperation {
 +    Buy { amount_usd: u64 },
 +    Sell { amount_zeph: u64 },
 +    AddLiquidity { zeph_amount: u64, usd_amount: u64 },
 +    RemoveLiquidity { shares: u64 },
 +    Rebalance,
 +    EmergencyHalt,
 +}
++
 +impl Default for StabilityConfig {
 +    fn default() -> Self {
 +        Self {
 +            intervention_threshold: 0.05, // 5%
 +            max_daily_change: 0.10,       // 10%
 +            rebalance_frequency: 4,       // Every 4 hours
 +            circuit_breaker_threshold: 0.20, // 20%
 +            min_liquidity_ratio: 0.20,   // 20% min liquidity
 +        }
 +    }
 +}
++
 +impl Default for FeeStructure {
 +    fn default() -> Self {
 +        Self {
 +            trading_fee: 0.003,      // 0.3%
 +            stability_fee: 0.001,    // 0.1%
 +            lp_reward_rate: 0.05,    // 5% APY
 +            protocol_fee: 0.0005,    // 0.05%
 +        }
 +    }
 +}
++
 +impl ZephyrCoinAMM {
 +    /// Create new AMM with initial liquidity
 +    pub fn new(
 +        target_price_usd: f64,
 +        initial_zeph: u64,
 +        initial_usd: u64,
 +    ) -> Self {
 +        let mut pools = HashMap::new();
++
 +        // Initialize ZEPH/USD pool
 +        pools.insert(TradingPair::ZEPH_USD, LiquidityPool {
 +            reserve_a: initial_zeph,
 +            reserve_b: initial_usd,
 +            total_shares: (initial_zeph * initial_usd).integer_sqrt(),
 +            lp_positions: HashMap::new(),
 +            fee_rate: 0.003,
 +            last_update: Utc::now(),
 +            max_slippage: 0.05, // 5% max slippage
 +        });
++
 +        Self {
 +            pools,
 +            target_price_usd,
 +            stability_config: StabilityConfig::default(),
 +            price_history: VecDeque::with_capacity(1440), // 24 hours of minute data
 +            reserves: Reserves {
 +                zeph_reserve: initial_zeph / 2, // Keep 50% as reserves
 +                usd_reserve: initial_usd / 2,
 +                emergency_reserve: initial_zeph / 10, // 10% emergency
 +                insurance_fund: initial_usd / 20, // 5% insurance
 +            },
 +            fees: FeeStructure::default(),
 +        }
 +    }
++
 +    /// Get current price for a trading pair
 +    pub fn get_current_price(&self, pair: &TradingPair) -> Result<f64> {
 +        let pool = self.pools.get(pair)
 +            .ok_or_else(|| anyhow::anyhow!("Trading pair not found"))?;
++
 +        match pair {
 +            TradingPair::ZEPH_USD => {
 +                if pool.reserve_a == 0 {
 +                    return Err(anyhow::anyhow!("No ZEPH liquidity"));
 +                }
 +                Ok(pool.reserve_b as f64 / pool.reserve_a as f64)
 +            },
 +            _ => Err(anyhow::anyhow!("Price calculation not implemented for this pair")),
 +        }
 +    }
++
 +    /// Calculate price impact for a trade
 +    pub fn calculate_price_impact(&self, pair: &TradingPair, amount_in: u64, buy: bool) -> Result<f64> {
 +        let pool = self.pools.get(pair)
 +            .ok_or_else(|| anyhow::anyhow!("Trading pair not found"))?;
++
 +        let (reserve_in, reserve_out) = if buy {
 +            (pool.reserve_b, pool.reserve_a) // Buying ZEPH with USD
 +        } else {
 +            (pool.reserve_a, pool.reserve_b) // Selling ZEPH for USD
 +        };
++
 +        // Constant product formula: x * y = k
 +        let k = reserve_in * reserve_out;
 +        let new_reserve_in = reserve_in + amount_in;
 +        let new_reserve_out = k / new_reserve_in;
 +        let amount_out = reserve_out - new_reserve_out;
++
 +        // Calculate price impact
 +        let current_price = reserve_out as f64 / reserve_in as f64;
 +        let execution_price = amount_out as f64 / amount_in as f64;
 +        let price_impact = ((execution_price - current_price) / current_price).abs();
++
 +        Ok(price_impact)
 +    }
++
 +    /// Execute a swap with slippage protection
 +    pub fn execute_swap(
 +        &mut self,
 +        pair: TradingPair,
 +        amount_in: u64,
 +        min_amount_out: u64,
 +        buy: bool,
 +    ) -> Result<TradeExecution> {
 +        let pool = self.pools.get_mut(&pair)
 +            .ok_or_else(|| anyhow::anyhow!("Trading pair not found"))?;
++
 +        // Check price impact
 +        let price_impact = self.calculate_price_impact(&pair, amount_in, buy)?;
 +        if price_impact > pool.max_slippage {
 +            return Err(anyhow::anyhow!("Price impact too high: {:.2}%", price_impact * 100.0));
 +        }
++
 +        let (reserve_in, reserve_out) = if buy {
 +            (&mut pool.reserve_b, &mut pool.reserve_a)
 +        } else {
 +            (&mut pool.reserve_a, &mut pool.reserve_b)
 +        };
++
 +        // Calculate output amount with fee
 +        let amount_in_with_fee = (amount_in as f64 * (1.0 - pool.fee_rate)) as u64;
 +        let k = *reserve_in * *reserve_out;
 +        let new_reserve_in = *reserve_in + amount_in_with_fee;
 +        let new_reserve_out = k / new_reserve_in;
 +        let amount_out = *reserve_out - new_reserve_out;
++
 +        if amount_out < min_amount_out {
 +            return Err(anyhow::anyhow!("Slippage tolerance exceeded"));
 +        }
++
 +        // Update reserves
 +        *reserve_in += amount_in;
 +        *reserve_out = new_reserve_out;
++
 +        let execution_price = amount_out as f64 / amount_in as f64;
 +        let fee = amount_in - amount_in_with_fee;
++
 +        pool.last_update = Utc::now();
++
 +        Ok(TradeExecution {
 +            pair,
 +            amount_in,
 +            amount_out,
 +            price: execution_price,
 +            fee,
 +            slippage: price_impact,
 +            timestamp: Utc::now(),
 +        })
 +    }
++
 +    /// Add liquidity to a pool
 +    pub fn add_liquidity(
 +        &mut self,
 +        pair: TradingPair,
 +        user: String,
 +        amount_a: u64,
 +        amount_b: u64,
 +    ) -> Result<u64> {
 +        let pool = self.pools.get_mut(&pair)
 +            .ok_or_else(|| anyhow::anyhow!("Trading pair not found"))?;
++
 +        // Calculate optimal amounts based on current ratio
 +        let ratio = pool.reserve_b as f64 / pool.reserve_a as f64;
 +        let optimal_b = (amount_a as f64 * ratio) as u64;
++
 +        let (final_a, final_b) = if optimal_b <= amount_b {
 +            (amount_a, optimal_b)
 +        } else {
 +            let optimal_a = (amount_b as f64 / ratio) as u64;
 +            (optimal_a, amount_b)
 +        };
++
 +        // Calculate LP shares
 +        let liquidity = if pool.total_shares == 0 {
 +            (final_a * final_b).integer_sqrt()
 +        } else {
 +            std::cmp::min(
 +                final_a * pool.total_shares / pool.reserve_a,
 +                final_b * pool.total_shares / pool.reserve_b,
 +            )
 +        };
++
 +        // Update pool
 +        pool.reserve_a += final_a;
 +        pool.reserve_b += final_b;
 +        pool.total_shares += liquidity;
++
 +        // Record LP position
 +        pool.lp_positions.insert(user, LPPosition {
 +            shares: liquidity,
 +            provided_at: Utc::now(),
 +            initial_zeph: final_a,
 +            initial_other: final_b,
 +        });
++
 +        pool.last_update = Utc::now();
++
 +        Ok(liquidity)
 +    }
++
 +    /// Remove liquidity from a pool
 +    pub fn remove_liquidity(
 +        &mut self,
 +        pair: TradingPair,
 +        user: String,
 +        shares: u64,
 +    ) -> Result<(u64, u64)> {
 +        let pool = self.pools.get_mut(&pair)
 +            .ok_or_else(|| anyhow::anyhow!("Trading pair not found"))?;
++
 +        let position = pool.lp_positions.get_mut(&user)
 +            .ok_or_else(|| anyhow::anyhow!("No liquidity position found"))?;
++
 +        if position.shares < shares {
 +            return Err(anyhow::anyhow!("Insufficient LP shares"));
 +        }
++
 +        // Calculate withdrawal amounts
 +        let amount_a = shares * pool.reserve_a / pool.total_shares;
 +        let amount_b = shares * pool.reserve_b / pool.total_shares;
++
 +        // Update pool
 +        pool.reserve_a -= amount_a;
 +        pool.reserve_b -= amount_b;
 +        pool.total_shares -= shares;
++
 +        // Update position
 +        position.shares -= shares;
 +        if position.shares == 0 {
 +            pool.lp_positions.remove(&user);
 +        }
++
 +        pool.last_update = Utc::now();
++
 +        Ok((amount_a, amount_b))
 +    }
++
 +    /// Perform price stability intervention
 +    pub async fn perform_stability_intervention(&mut self) -> Result<Vec<MarketOperation>> {
 +        let current_price = self.get_current_price(&TradingPair::ZEPH_USD)?;
 +        let price_deviation = (current_price - self.target_price_usd) / self.target_price_usd;
++
 +        let mut operations = Vec::new();
++
 +        // Check if intervention is needed
 +        if price_deviation.abs() > self.stability_config.intervention_threshold {
 +            tracing::info!("Price deviation detected: {:.2}%, target: ${:.4}, current: ${:.4}",
 +                price_deviation * 100.0, self.target_price_usd, current_price);
++
 +            if price_deviation > 0.0 {
 +                // Price too high - sell ZEPH to decrease price
 +                let sell_amount = self.calculate_intervention_amount(price_deviation, false)?;
 +                operations.push(MarketOperation::Sell { amount_zeph: sell_amount });
 +            } else {
 +                // Price too low - buy ZEPH to increase price
 +                let buy_amount_usd = self.calculate_intervention_amount(price_deviation.abs(), true)?;
 +                operations.push(MarketOperation::Buy { amount_usd: buy_amount_usd });
 +            }
 +        }
++
 +        // Execute emergency halt if needed
 +        if price_deviation.abs() > self.stability_config.circuit_breaker_threshold {
 +            tracing::warn!("Emergency circuit breaker triggered at {:.2}% deviation", price_deviation * 100.0);
 +            operations.push(MarketOperation::EmergencyHalt);
 +        }
++
 +        Ok(operations)
 +    }
++
 +    /// Calculate intervention amount based on price deviation
 +    fn calculate_intervention_amount(&self, deviation: f64, is_buy: bool) -> Result<u64> {
 +        let pool = self.pools.get(&TradingPair::ZEPH_USD)
 +            .ok_or_else(|| anyhow::anyhow!("ZEPH/USD pool not found"))?;
++
 +        // Use a fraction of reserves based on deviation severity
 +        let intervention_factor = (deviation / self.stability_config.intervention_threshold).min(1.0);
++
 +        if is_buy {
 +            // Buy ZEPH with USD reserves
 +            let max_usd = self.reserves.usd_reserve / 10; // Max 10% of reserves per intervention
 +            Ok((max_usd as f64 * intervention_factor) as u64)
 +        } else {
 +            // Sell ZEPH from reserves
 +            let max_zeph = self.reserves.zeph_reserve / 10; // Max 10% of reserves per intervention
 +            Ok((max_zeph as f64 * intervention_factor) as u64)
 +        }
 +    }
++
 +    /// Update price history
 +    pub fn update_price_history(&mut self, price: f64, volume: u64) {
 +        let snapshot = PriceSnapshot {
 +            timestamp: Utc::now(),
 +            price_usd: price,
 +            volume_24h: volume,
 +            liquidity_depth: self.calculate_liquidity_depth(),
 +            volatility: self.calculate_volatility(),
 +        };
++
 +        self.price_history.push_back(snapshot);
++
 +        // Keep only last 24 hours
 +        while self.price_history.len() > 1440 {
 +            self.price_history.pop_front();
 +        }
 +    }
++
 +    /// Calculate current liquidity depth
 +    fn calculate_liquidity_depth(&self) -> u64 {
 +        self.pools.get(&TradingPair::ZEPH_USD)
 +            .map(|pool| pool.reserve_a + pool.reserve_b)
 +            .unwrap_or(0)
 +    }
++
 +    /// Calculate price volatility (24h)
 +    fn calculate_volatility(&self) -> f64 {
 +        if self.price_history.len() < 2 {
 +            return 0.0;
 +        }
++
 +        let prices: Vec<f64> = self.price_history.iter().map(|s| s.price_usd).collect();
 +        let mean = prices.iter().sum::<f64>() / prices.len() as f64;
 +        let variance = prices.iter()
 +            .map(|price| (price - mean).powi(2))
 +            .sum::<f64>() / prices.len() as f64;
++
 +        variance.sqrt() / mean // Coefficient of variation
 +    }
++
 +    /// Run automated market making loop
 +    pub async fn run_automated_trading(&mut self, interval_minutes: u64) -> Result<()> {
 +        let mut interval = tokio::time::interval(tokio::time::Duration::from_secs(interval_minutes * 60));
++
 +        loop {
 +            interval.tick().await;
++
 +            // Update current price
 +            if let Ok(price) = self.get_current_price(&TradingPair::ZEPH_USD) {
 +                self.update_price_history(price, 0); // Volume would be tracked separately
++
 +                // Perform stability intervention if needed
 +                let operations = self.perform_stability_intervention().await?;
++
 +                for operation in operations {
 +                    match operation {
 +                        MarketOperation::Buy { amount_usd } => {
 +                            self.execute_stability_buy(amount_usd).await?;
 +                        },
 +                        MarketOperation::Sell { amount_zeph } => {
 +                            self.execute_stability_sell(amount_zeph).await?;
 +                        },
 +                        MarketOperation::EmergencyHalt => {
 +                            self.emergency_halt().await?;
 +                            return Ok(()); // Stop trading
 +                        },
 +                        _ => {}, // Handle other operations as needed
 +                    }
 +                }
++
 +                // Rebalance if needed
 +                if self.should_rebalance().await? {
 +                    self.rebalance_pools().await?;
 +                }
 +            }
++
 +            tracing::debug!("AMM cycle complete");
 +        }
 +    }
++
 +    /// Execute stability buy operation
 +    async fn execute_stability_buy(&mut self, amount_usd: u64) -> Result<()> {
 +        if amount_usd > self.reserves.usd_reserve {
 +            return Err(anyhow::anyhow!("Insufficient USD reserves for stability buy"));
 +        }
++
 +        let trade = self.execute_swap(
 +            TradingPair::ZEPH_USD,
 +            amount_usd,
 +            0, // No minimum for stability operations
 +            true,
 +        )?;
++
 +        self.reserves.usd_reserve -= amount_usd;
 +        self.reserves.zeph_reserve += trade.amount_out;
++
 +        tracing::info!("Executed stability buy: {} USD -> {} ZEPH at ${:.4}",
 +            amount_usd, trade.amount_out, trade.price);
++
 +        Ok(())
 +    }
++
 +    /// Execute stability sell operation
 +    async fn execute_stability_sell(&mut self, amount_zeph: u64) -> Result<()> {
 +        if amount_zeph > self.reserves.zeph_reserve {
 +            return Err(anyhow::anyhow!("Insufficient ZEPH reserves for stability sell"));
 +        }
++
 +        let trade = self.execute_swap(
 +            TradingPair::ZEPH_USD,
 +            amount_zeph,
 +            0, // No minimum for stability operations
 +            false,
 +        )?;
++
 +        self.reserves.zeph_reserve -= amount_zeph;
 +        self.reserves.usd_reserve += trade.amount_out;
++
 +        tracing::info!("Executed stability sell: {} ZEPH -> {} USD at ${:.4}",
 +            amount_zeph, trade.amount_out, trade.price);
++
 +        Ok(())
 +    }
++
 +    /// Emergency halt trading
 +    async fn emergency_halt(&mut self) -> Result<()> {
 +        tracing::error!("Emergency halt activated - suspending all trading");
 +        // In real implementation, would pause all pools and notify operators
 +        Ok(())
 +    }
++
 +    /// Check if rebalancing is needed
 +    async fn should_rebalance(&self) -> Result<bool> {
 +        let last_rebalance = self.pools.get(&TradingPair::ZEPH_USD)
 +            .map(|pool| pool.last_update)
 +            .unwrap_or(Utc::now());
++
 +        let hours_since_rebalance = (Utc::now() - last_rebalance).num_hours();
 +        Ok(hours_since_rebalance >= self.stability_config.rebalance_frequency as i64)
 +    }
++
 +    /// Rebalance pools to maintain optimal ratios
 +    async fn rebalance_pools(&mut self) -> Result<()> {
 +        tracing::info!("Performing AMM rebalancing");
++
 +        // Rebalancing logic would optimize pool ratios
 +        // For now, just update timestamp
 +        if let Some(pool) = self.pools.get_mut(&TradingPair::ZEPH_USD) {
 +            pool.last_update = Utc::now();
 +        }
++
 +        Ok(())
 +    }
 +}
++
 +trait IntegerSqrt {
 +    fn integer_sqrt(self) -> Self;
 +}
++
 +impl IntegerSqrt for u64 {
 +    fn integer_sqrt(self) -> Self {
 +        if self < 2 {
 +            return self;
 +        }
++
 +        let mut x = self;
 +        let mut y = (x + 1) / 2;
++
 +        while y < x {
 +            x = y;
 +            y = (x + self / x) / 2;
 +        }
++
 +        x
 +    }
 +}
++
 +#[cfg(test)]
 +mod tests {
 +    use super::*;
++
 +    #[test]
 +    fn test_amm_creation() {
 +        let amm = ZephyrCoinAMM::new(0.10, 1_000_000, 100_000); // $0.10 target price
 +        assert_eq!(amm.target_price_usd, 0.10);
 +        assert!(amm.pools.contains_key(&TradingPair::ZEPH_USD));
 +    }
++
 +    #[test]
 +    fn test_price_calculation() {
 +        let amm = ZephyrCoinAMM::new(0.10, 1_000_000, 100_000);
 +        let price = amm.get_current_price(&TradingPair::ZEPH_USD).unwrap();
 +        assert_eq!(price, 0.10); // 100,000 / 1,000,000
 +    }
++
 +    #[tokio::test]
 +    async fn test_swap_execution() {
 +        let mut amm = ZephyrCoinAMM::new(0.10, 1_000_000, 100_000);
++
 +        // Buy 1000 ZEPH with USD
 +        let trade = amm.execute_swap(
 +            TradingPair::ZEPH_USD,
 +            100, // 100 USD
 +            950, // Minimum 950 ZEPH (allowing for slippage)
 +            true,
 +        ).unwrap();
++
 +        assert!(trade.amount_out >= 950);
 +        assert!(trade.fee > 0);
 +    }
 +}

src/economics/mod.rsadded

 +//! Economics Module
 +//!
 +//! Complete economic system for ZephyrFS including token economics, payments, and rewards
++
 +pub mod token_model;
 +pub mod zephyr_coin;
 +pub mod network_health_minter;
 +pub mod market_maker;
 +pub mod earnings_calculator;
 +pub mod payment_processor;
 +pub mod payout_scheduler;
 +pub mod performance_rewards;
++
 +pub use token_model::{TokenEconomicsManager, TokenEconomics, NetworkHealthMetrics, RewardReason};
 +pub use zephyr_coin::{ZephyrCoin, TokenEvent};
 +pub use network_health_minter::{NetworkHealthController, HealthBasedMinter};
 +pub use market_maker::{ZephyrCoinAMM, TradingPair, Currency as AMMCurrency};
 +pub use earnings_calculator::{EarningsCalculator, VolunteerMetrics, EarningsProjection};
 +pub use payment_processor::{PaymentProcessor, PaymentRequest, Currency, PaymentMethod};
 +pub use payout_scheduler::{PayoutScheduler, PayoutPreferences, PayoutFrequency};
 +pub use performance_rewards::{PerformanceRewardsSystem, PerformanceScore, Achievement, RewardTier};

src/economics/network_health_minter.rsadded

 +//! Network Health-Based Token Minting and Burning
 +//!
 +//! Automated token supply management based on ZephyrFS network metrics
++
 +use anyhow::Result;
 +use serde::{Deserialize, Serialize};
 +use std::collections::HashMap;
 +use chrono::{DateTime, Utc, Duration};
 +use tokio::time::{sleep, Duration as TokioDuration};
++
 +use super::token_model::{TokenEconomicsManager, NetworkHealthMetrics};
 +use super::zephyr_coin::{ZephyrCoin, TokenEvent};
++
 +/// Network health-based minting controller
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct HealthBasedMinter {
 +    /// Target network health thresholds
 +    pub health_thresholds: HealthThresholds,
 +    /// Minting rates based on health
 +    pub minting_rates: MintingRates,
 +    /// Burning policies
 +    pub burning_policies: BurningPolicies,
 +    /// Last operation timestamps
 +    pub last_operations: OperationTimestamps,
 +    /// Network performance history
 +    pub performance_history: Vec<PerformanceSnapshot>,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct HealthThresholds {
 +    /// Minimum uptime for minting (95%)
 +    pub min_uptime_percent: f64,
 +    /// Minimum geographic diversity (50%)
 +    pub min_geographic_diversity: f64,
 +    /// Minimum data durability (99.9%)
 +    pub min_data_durability: f64,
 +    /// Target utilization range (70-85%)
 +    pub target_utilization_min: f64,
 +    pub target_utilization_max: f64,
 +    /// Minimum active volunteers for rewards
 +    pub min_active_volunteers: u32,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct MintingRates {
 +    /// Base rate per healthy GB per day
 +    pub base_rate_per_gb: u64,
 +    /// Multipliers for health levels
 +    pub excellent_multiplier: f64, // >98% health
 +    pub good_multiplier: f64,      // 90-98% health
 +    pub fair_multiplier: f64,      // 80-90% health
 +    pub poor_multiplier: f64,      // <80% health (reduced/no minting)
 +    /// Bonus for rapid network growth
 +    pub growth_bonus_multiplier: f64,
 +    /// Emergency mint rate during network stress
 +    pub emergency_rate_multiplier: f64,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct BurningPolicies {
 +    /// Burn unused rewards after days
 +    pub unused_reward_burn_days: u32,
 +    /// Burn rate for idle tokens (percentage)
 +    pub idle_token_burn_rate: f64,
 +    /// Burn tokens during network congestion
 +    pub congestion_burn_enabled: bool,
 +    /// Maximum daily burn percentage
 +    pub max_daily_burn_percent: f64,
 +    /// Emergency burn during token oversupply
 +    pub emergency_burn_threshold: f64,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct OperationTimestamps {
 +    pub last_mint: DateTime<Utc>,
 +    pub last_burn: DateTime<Utc>,
 +    pub last_health_check: DateTime<Utc>,
 +    pub last_emergency_action: DateTime<Utc>,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct PerformanceSnapshot {
 +    pub timestamp: DateTime<Utc>,
 +    pub metrics: NetworkHealthMetrics,
 +    pub health_score: f64,
 +    pub tokens_minted: u64,
 +    pub tokens_burned: u64,
 +    pub active_rewards: u64,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub enum HealthStatus {
 +    Excellent, // >98% health score
 +    Good,      // 90-98% health score
 +    Fair,      // 80-90% health score
 +    Poor,      // <80% health score
 +    Emergency, // Critical network issues
 +}
++
 +impl Default for HealthThresholds {
 +    fn default() -> Self {
 +        Self {
 +            min_uptime_percent: 95.0,
 +            min_geographic_diversity: 50.0,
 +            min_data_durability: 99.9,
 +            target_utilization_min: 70.0,
 +            target_utilization_max: 85.0,
 +            min_active_volunteers: 10,
 +        }
 +    }
 +}
++
 +impl Default for MintingRates {
 +    fn default() -> Self {
 +        Self {
 +            base_rate_per_gb: 20_000_000_000_000_000, // 0.02 ZEPH per GB per day
 +            excellent_multiplier: 1.5,
 +            good_multiplier: 1.0,
 +            fair_multiplier: 0.7,
 +            poor_multiplier: 0.3,
 +            growth_bonus_multiplier: 1.2,
 +            emergency_rate_multiplier: 2.0,
 +        }
 +    }
 +}
++
 +impl Default for BurningPolicies {
 +    fn default() -> Self {
 +        Self {
 +            unused_reward_burn_days: 90,
 +            idle_token_burn_rate: 0.01, // 1% quarterly
 +            congestion_burn_enabled: true,
 +            max_daily_burn_percent: 0.5, // 0.5% max daily burn
 +            emergency_burn_threshold: 1.1, // 110% of target supply
 +        }
 +    }
 +}
++
 +impl Default for HealthBasedMinter {
 +    fn default() -> Self {
 +        Self {
 +            health_thresholds: HealthThresholds::default(),
 +            minting_rates: MintingRates::default(),
 +            burning_policies: BurningPolicies::default(),
 +            last_operations: OperationTimestamps {
 +                last_mint: Utc::now(),
 +                last_burn: Utc::now(),
 +                last_health_check: Utc::now(),
 +                last_emergency_action: Utc::now(),
 +            },
 +            performance_history: Vec::new(),
 +        }
 +    }
 +}
++
 +/// Network health-based token operations
 +pub struct NetworkHealthController {
 +    minter: HealthBasedMinter,
 +    token_manager: TokenEconomicsManager,
 +    zephyr_coin: ZephyrCoin,
 +    events: Vec<TokenEvent>,
 +}
++
 +impl NetworkHealthController {
 +    /// Create new health-based controller
 +    pub fn new(
 +        minter: HealthBasedMinter,
 +        token_manager: TokenEconomicsManager,
 +        zephyr_coin: ZephyrCoin,
 +    ) -> Self {
 +        Self {
 +            minter,
 +            token_manager,
 +            zephyr_coin,
 +            events: Vec::new(),
 +        }
 +    }
++
 +    /// Calculate network health score
 +    pub fn calculate_health_score(&self, metrics: &NetworkHealthMetrics) -> f64 {
 +        let uptime_score = (metrics.average_uptime / 100.0).min(1.0);
 +        let diversity_score = (metrics.geographic_diversity / 100.0).min(1.0);
 +        let durability_score = (metrics.data_durability / 100.0).min(1.0);
 +        let utilization_score = self.calculate_utilization_score(metrics.utilization_rate);
 +        let volunteer_score = self.calculate_volunteer_score(metrics.active_volunteers);
++
 +        // Weighted health score
 +        let weights = [0.25, 0.20, 0.25, 0.15, 0.15]; // uptime, diversity, durability, utilization, volunteers
 +        let scores = [uptime_score, diversity_score, durability_score, utilization_score, volunteer_score];
++
 +        scores.iter().zip(weights.iter())
 +            .map(|(score, weight)| score * weight)
 +            .sum::<f64>() * 100.0
 +    }
++
 +    /// Calculate utilization score (optimal range: 70-85%)
 +    fn calculate_utilization_score(&self, utilization: f64) -> f64 {
 +        let min = self.minter.health_thresholds.target_utilization_min;
 +        let max = self.minter.health_thresholds.target_utilization_max;
++
 +        if utilization >= min && utilization <= max {
 +            1.0 // Perfect utilization
 +        } else if utilization < min {
 +            utilization / min // Underutilized
 +        } else {
 +            // Overutilized - exponential penalty
 +            (1.0 / (1.0 + (utilization - max) / 10.0)).max(0.1)
 +        }
 +    }
++
 +    /// Calculate volunteer participation score
 +    fn calculate_volunteer_score(&self, volunteers: u32) -> f64 {
 +        let min = self.minter.health_thresholds.min_active_volunteers;
 +        if volunteers >= min {
 +            (volunteers as f64 / (min as f64 * 2.0)).min(1.0)
 +        } else {
 +            volunteers as f64 / min as f64
 +        }
 +    }
++
 +    /// Determine health status from score
 +    pub fn determine_health_status(&self, health_score: f64) -> HealthStatus {
 +        if health_score >= 98.0 {
 +            HealthStatus::Excellent
 +        } else if health_score >= 90.0 {
 +            HealthStatus::Good
 +        } else if health_score >= 80.0 {
 +            HealthStatus::Fair
 +        } else if health_score >= 50.0 {
 +            HealthStatus::Poor
 +        } else {
 +            HealthStatus::Emergency
 +        }
 +    }
++
 +    /// Execute health-based minting
 +    pub async fn execute_health_based_minting(&mut self, metrics: NetworkHealthMetrics) -> Result<u64> {
 +        let health_score = self.calculate_health_score(&metrics);
 +        let health_status = self.determine_health_status(health_score);
++
 +        // Determine minting multiplier based on health
 +        let multiplier = match health_status {
 +            HealthStatus::Excellent => self.minter.minting_rates.excellent_multiplier,
 +            HealthStatus::Good => self.minter.minting_rates.good_multiplier,
 +            HealthStatus::Fair => self.minter.minting_rates.fair_multiplier,
 +            HealthStatus::Poor => self.minter.minting_rates.poor_multiplier,
 +            HealthStatus::Emergency => 0.0, // No minting during emergency
 +        };
++
 +        // Calculate growth bonus
 +        let growth_bonus = self.calculate_growth_bonus(&metrics)?;
 +        let final_multiplier = multiplier * growth_bonus;
++
 +        // Calculate mint amount
 +        let daily_base = metrics.total_capacity_gb * self.minter.minting_rates.base_rate_per_gb;
 +        let mint_amount = (daily_base as f64 * final_multiplier) as u64;
++
 +        if mint_amount > 0 && matches!(health_status, HealthStatus::Excellent | HealthStatus::Good | HealthStatus::Fair) {
 +            // Execute minting through token contract
 +            let mint_event = self.zephyr_coin.mint("network_minter", "reward_pool", mint_amount)?;
 +            self.events.push(mint_event);
++
 +            // Update token manager
 +            self.token_manager.mint_rewards(mint_amount).await?;
++
 +            // Record performance snapshot
 +            self.record_performance_snapshot(metrics, health_score, mint_amount, 0).await;
++
 +            tracing::info!("Minted {} tokens based on network health score: {:.2}%",
 +                mint_amount, health_score);
++
 +            self.minter.last_operations.last_mint = Utc::now();
 +            return Ok(mint_amount);
 +        }
++
 +        Ok(0)
 +    }
++
 +    /// Calculate growth bonus multiplier
 +    fn calculate_growth_bonus(&self, metrics: &NetworkHealthMetrics) -> Result<f64> {
 +        if self.minter.performance_history.len() < 7 {
 +            return Ok(1.0); // No bonus without sufficient history
 +        }
++
 +        // Calculate 7-day growth rate
 +        let current_capacity = metrics.total_capacity_gb;
 +        let week_ago_capacity = self.minter.performance_history
 +            .iter()
 +            .rev()
 +            .nth(6)
 +            .map(|snapshot| snapshot.metrics.total_capacity_gb)
 +            .unwrap_or(current_capacity);
++
 +        if week_ago_capacity == 0 {
 +            return Ok(1.0);
 +        }
++
 +        let growth_rate = (current_capacity as f64 - week_ago_capacity as f64) / week_ago_capacity as f64;
++
 +        // Apply growth bonus for healthy growth (10-30% weekly)
 +        if growth_rate >= 0.1 && growth_rate <= 0.3 {
 +            Ok(self.minter.minting_rates.growth_bonus_multiplier)
 +        } else {
 +            Ok(1.0)
 +        }
 +    }
++
 +    /// Execute health-based burning
 +    pub async fn execute_health_based_burning(&mut self, metrics: NetworkHealthMetrics) -> Result<u64> {
 +        let mut total_burned = 0u64;
++
 +        // Burn unused rewards
 +        total_burned += self.burn_unused_rewards().await?;
++
 +        // Emergency burn if oversupply
 +        total_burned += self.emergency_burn_oversupply(&metrics).await?;
++
 +        // Congestion burn
 +        if self.minter.burning_policies.congestion_burn_enabled {
 +            total_burned += self.burn_for_congestion(&metrics).await?;
 +        }
++
 +        if total_burned > 0 {
 +            self.minter.last_operations.last_burn = Utc::now();
 +            tracing::info!("Burned {} tokens based on network conditions", total_burned);
 +        }
++
 +        Ok(total_burned)
 +    }
++
 +    /// Burn unused reward tokens
 +    async fn burn_unused_rewards(&mut self) -> Result<u64> {
 +        let days_since_last = (Utc::now() - self.minter.last_operations.last_burn).num_days();
++
 +        if days_since_last >= self.minter.burning_policies.unused_reward_burn_days as i64 {
 +            let burn_amount = self.token_manager.burn_unused_tokens().await?;
++
 +            if burn_amount > 0 {
 +                let burn_event = self.zephyr_coin.burn("network_burner", "reward_pool", burn_amount)?;
 +                self.events.push(burn_event);
 +            }
++
 +            return Ok(burn_amount);
 +        }
++
 +        Ok(0)
 +    }
++
 +    /// Emergency burn during token oversupply
 +    async fn emergency_burn_oversupply(&mut self, _metrics: &NetworkHealthMetrics) -> Result<u64> {
 +        let current_supply = self.zephyr_coin.total_supply;
 +        let target_supply = 21_000_000 * 10_u64.pow(18); // 21M tokens
 +        let oversupply_threshold = (target_supply as f64 * self.minter.burning_policies.emergency_burn_threshold) as u64;
++
 +        if current_supply > oversupply_threshold {
 +            let excess = current_supply - target_supply;
 +            let burn_amount = (excess as f64 * 0.1) as u64; // Burn 10% of excess
++
 +            let max_daily_burn = (current_supply as f64 * self.minter.burning_policies.max_daily_burn_percent / 100.0) as u64;
 +            let final_burn = burn_amount.min(max_daily_burn);
++
 +            if final_burn > 0 {
 +                let burn_event = self.zephyr_coin.burn("emergency_burner", "reward_pool", final_burn)?;
 +                self.events.push(burn_event);
++
 +                tracing::warn!("Emergency burn of {} tokens due to oversupply", final_burn);
 +                return Ok(final_burn);
 +            }
 +        }
++
 +        Ok(0)
 +    }
++
 +    /// Burn tokens during network congestion
 +    async fn burn_for_congestion(&mut self, metrics: &NetworkHealthMetrics) -> Result<u64> {
 +        // Burn if utilization > 95% to incentivize capacity expansion
 +        if metrics.utilization_rate > 95.0 {
 +            let daily_rewards = metrics.total_capacity_gb * self.minter.minting_rates.base_rate_per_gb;
 +            let congestion_burn = (daily_rewards as f64 * 0.05) as u64; // 5% of daily rewards
++
 +            if congestion_burn > 0 {
 +                let burn_event = self.zephyr_coin.burn("congestion_burner", "reward_pool", congestion_burn)?;
 +                self.events.push(burn_event);
++
 +                tracing::info!("Congestion burn of {} tokens (utilization: {:.1}%)",
 +                    congestion_burn, metrics.utilization_rate);
 +                return Ok(congestion_burn);
 +            }
 +        }
++
 +        Ok(0)
 +    }
++
 +    /// Record performance snapshot
 +    async fn record_performance_snapshot(
 +        &mut self,
 +        metrics: NetworkHealthMetrics,
 +        health_score: f64,
 +        tokens_minted: u64,
 +        tokens_burned: u64,
 +    ) {
 +        let snapshot = PerformanceSnapshot {
 +            timestamp: Utc::now(),
 +            metrics,
 +            health_score,
 +            tokens_minted,
 +            tokens_burned,
 +            active_rewards: self.token_manager.get_supply_status().reward_pool,
 +        };
++
 +        self.minter.performance_history.push(snapshot);
++
 +        // Keep only last 30 days of history
 +        if self.minter.performance_history.len() > 30 {
 +            self.minter.performance_history.remove(0);
 +        }
 +    }
++
 +    /// Run automated health monitoring loop
 +    pub async fn run_health_monitor(&mut self, check_interval_hours: u64) -> Result<()> {
 +        let mut interval = tokio::time::interval(TokioDuration::from_secs(check_interval_hours * 3600));
++
 +        loop {
 +            interval.tick().await;
++
 +            // Get current network metrics (would be fetched from network in real implementation)
 +            let metrics = self.get_current_network_metrics().await?;
++
 +            // Update token manager with current metrics
 +            self.token_manager.update_network_metrics(metrics.clone());
++
 +            // Execute health-based operations
 +            let minted = self.execute_health_based_minting(metrics.clone()).await?;
 +            let burned = self.execute_health_based_burning(metrics.clone()).await?;
++
 +            // Perform token manager adjustments
 +            self.token_manager.perform_supply_adjustment().await?;
++
 +            self.minter.last_operations.last_health_check = Utc::now();
++
 +            tracing::info!("Health check complete: minted={}, burned={}", minted, burned);
 +        }
 +    }
++
 +    /// Get current network metrics (placeholder - would fetch from actual network)
 +    async fn get_current_network_metrics(&self) -> Result<NetworkHealthMetrics> {
 +        // This would fetch real metrics from the ZephyrFS network
 +        Ok(NetworkHealthMetrics {
 +            total_capacity_gb: 1000,
 +            active_volunteers: 50,
 +            utilization_rate: 75.0,
 +            average_uptime: 96.5,
 +            geographic_diversity: 65.0,
 +            data_durability: 99.95,
 +        })
 +    }
++
 +    /// Get recent events
 +    pub fn get_recent_events(&self) -> &[TokenEvent] {
 +        &self.events
 +    }
++
 +    /// Get performance history
 +    pub fn get_performance_history(&self) -> &[PerformanceSnapshot] {
 +        &self.minter.performance_history
 +    }
 +}
++
 +#[cfg(test)]
 +mod tests {
 +    use super::*;
 +    use crate::economics::token_model::TokenEconomics;
++
 +    #[tokio::test]
 +    async fn test_health_score_calculation() {
 +        let minter = HealthBasedMinter::default();
 +        let token_manager = TokenEconomicsManager::new(TokenEconomics::default());
 +        let zephyr_coin = ZephyrCoin::new("test_owner".to_string(), 0);
 +        let controller = NetworkHealthController::new(minter, token_manager, zephyr_coin);
++
 +        let metrics = NetworkHealthMetrics {
 +            total_capacity_gb: 1000,
 +            active_volunteers: 25,
 +            utilization_rate: 75.0,
 +            average_uptime: 96.0,
 +            geographic_diversity: 60.0,
 +            data_durability: 99.9,
 +        };
++
 +        let health_score = controller.calculate_health_score(&metrics);
 +        assert!(health_score >= 80.0); // Should be "Good" or better
 +        assert!(health_score <= 100.0);
 +    }
++
 +    #[tokio::test]
 +    async fn test_health_based_minting() {
 +        let minter = HealthBasedMinter::default();
 +        let token_manager = TokenEconomicsManager::new(TokenEconomics::default());
 +        let mut zephyr_coin = ZephyrCoin::new("test_owner".to_string(), 0);
 +        zephyr_coin.add_minter("test_owner", "network_minter").unwrap();
++
 +        let mut controller = NetworkHealthController::new(minter, token_manager, zephyr_coin);
++
 +        let metrics = NetworkHealthMetrics {
 +            total_capacity_gb: 100,
 +            active_volunteers: 15,
 +            utilization_rate: 75.0,
 +            average_uptime: 98.0,
 +            geographic_diversity: 70.0,
 +            data_durability: 99.95,
 +        };
++
 +        let minted = controller.execute_health_based_minting(metrics).await.unwrap();
 +        assert!(minted > 0);
 +    }
 +}

src/economics/payment_processor.rsadded

 +//! Multi-Currency Payment Processing Engine
 +//!
 +//! Handles payouts in multiple currencies for ZephyrFS volunteers
++
 +use anyhow::Result;
 +use serde::{Deserialize, Serialize};
 +use std::collections::{HashMap, VecDeque};
 +use chrono::{DateTime, Utc, Duration};
++
 +/// Multi-currency payment processor
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct PaymentProcessor {
 +    /// Supported payment methods
 +    pub payment_methods: HashMap<PaymentMethod, PaymentMethodConfig>,
 +    /// Exchange rates for currency conversion
 +    pub exchange_rates: HashMap<Currency, f64>,
 +    /// Payment processing fees
 +    pub fee_structure: PaymentFeeStructure,
 +    /// Pending payments queue
 +    pub pending_payments: VecDeque<PaymentRequest>,
 +    /// Payment history
 +    pub payment_history: HashMap<String, Vec<PaymentRecord>>,
 +    /// Minimum payout thresholds
 +    pub min_payout_thresholds: HashMap<Currency, u64>,
 +    /// Processor configuration
 +    pub config: ProcessorConfig,
 +}
++
 +#[derive(Debug, Clone, Hash, Eq, PartialEq, Serialize, Deserialize)]
 +pub enum PaymentMethod {
 +    Cryptocurrency(CryptoNetwork),
 +    BankTransfer(BankTransferType),
 +    DigitalWallet(WalletProvider),
 +    StableCoin(StableCoinType),
 +}
++
 +#[derive(Debug, Clone, Hash, Eq, PartialEq, Serialize, Deserialize)]
 +pub enum CryptoNetwork {
 +    Bitcoin,
 +    Ethereum,
 +    Polygon,
 +    BinanceSmartChain,
 +    Solana,
 +    Cardano,
 +    ZephyrCoin, // Native token
 +}
++
 +#[derive(Debug, Clone, Hash, Eq, PartialEq, Serialize, Deserialize)]
 +pub enum BankTransferType {
 +    ACH,        // US
 +    SEPA,       // Europe
 +    FasterPayments, // UK
 +    Interac,    // Canada
 +    PIX,        // Brazil
 +    UPI,        // India
 +}
++
 +#[derive(Debug, Clone, Hash, Eq, PartialEq, Serialize, Deserialize)]
 +pub enum WalletProvider {
 +    PayPal,
 +    Wise,
 +    Revolut,
 +    CashApp,
 +    Venmo,
 +    Zelle,
 +}
++
 +#[derive(Debug, Clone, Hash, Eq, PartialEq, Serialize, Deserialize)]
 +pub enum StableCoinType {
 +    USDC,
 +    USDT,
 +    DAI,
 +    BUSD,
 +}
++
 +#[derive(Debug, Clone, Hash, Eq, PartialEq, Serialize, Deserialize)]
 +pub enum Currency {
 +    USD,
 +    EUR,
 +    GBP,
 +    CAD,
 +    AUD,
 +    BRL,
 +    INR,
 +    JPY,
 +    ZephyrCoin,
 +    Bitcoin,
 +    Ethereum,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct PaymentMethodConfig {
 +    pub enabled: bool,
 +    pub min_amount: u64,
 +    pub max_amount: u64,
 +    pub processing_time_hours: u32,
 +    pub supported_currencies: Vec<Currency>,
 +    pub geographic_restrictions: Vec<String>, // ISO country codes
 +    pub requires_kyc: bool,
 +    pub fee_structure: MethodFeeStructure,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct MethodFeeStructure {
 +    pub fixed_fee: u64,     // Fixed fee in cents/wei
 +    pub percentage_fee: f64, // Percentage fee (0.01 = 1%)
 +    pub network_fee: u64,   // Blockchain network fees
 +    pub exchange_fee: f64,  // Currency conversion fee
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct PaymentFeeStructure {
 +    /// Base processing fee (0.5%)
 +    pub base_processing_fee: f64,
 +    /// Currency conversion fees
 +    pub conversion_fees: HashMap<Currency, f64>,
 +    /// Express processing fee (1%)
 +    pub express_fee: f64,
 +    /// KYC verification fee
 +    pub kyc_fee: u64,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct PaymentRequest {
 +    pub request_id: String,
 +    pub volunteer_id: String,
 +    pub amount_tokens: u64,
 +    pub target_currency: Currency,
 +    pub payment_method: PaymentMethod,
 +    pub recipient_info: RecipientInfo,
 +    pub priority: PaymentPriority,
 +    pub created_at: DateTime<Utc>,
 +    pub scheduled_for: Option<DateTime<Utc>>,
 +    pub metadata: HashMap<String, String>,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct RecipientInfo {
 +    pub wallet_address: Option<String>,
 +    pub bank_account: Option<BankAccountInfo>,
 +    pub digital_wallet: Option<DigitalWalletInfo>,
 +    pub kyc_verified: bool,
 +    pub tax_info: Option<TaxInfo>,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct BankAccountInfo {
 +    pub account_holder: String,
 +    pub account_number: String,
 +    pub routing_number: String,
 +    pub bank_name: String,
 +    pub swift_code: Option<String>,
 +    pub iban: Option<String>,
 +    pub country_code: String,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct DigitalWalletInfo {
 +    pub provider: WalletProvider,
 +    pub wallet_id: String,
 +    pub verified: bool,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct TaxInfo {
 +    pub tax_id: String,
 +    pub tax_country: String,
 +    pub tax_exempt: bool,
 +    pub withholding_rate: f64,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub enum PaymentPriority {
 +    Standard,
 +    Express,
 +    Immediate,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct PaymentRecord {
 +    pub payment_id: String,
 +    pub request_id: String,
 +    pub volunteer_id: String,
 +    pub amount_tokens: u64,
 +    pub amount_paid: u64,
 +    pub currency: Currency,
 +    pub payment_method: PaymentMethod,
 +    pub status: PaymentStatus,
 +    pub fees_paid: u64,
 +    pub exchange_rate: f64,
 +    pub processed_at: DateTime<Utc>,
 +    pub confirmation_hash: Option<String>,
 +    pub error_message: Option<String>,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub enum PaymentStatus {
 +    Pending,
 +    Processing,
 +    Completed,
 +    Failed,
 +    Cancelled,
 +    RequiresAction,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct ProcessorConfig {
 +    pub batch_processing_enabled: bool,
 +    pub batch_size: usize,
 +    pub processing_interval_minutes: u32,
 +    pub max_retries: u32,
 +    pub retry_delay_minutes: u32,
 +    pub auto_currency_conversion: bool,
 +    pub fraud_detection_enabled: bool,
 +}
++
 +impl Default for PaymentFeeStructure {
 +    fn default() -> Self {
 +        let mut conversion_fees = HashMap::new();
 +        conversion_fees.insert(Currency::USD, 0.005);
 +        conversion_fees.insert(Currency::EUR, 0.005);
 +        conversion_fees.insert(Currency::GBP, 0.005);
 +        conversion_fees.insert(Currency::Bitcoin, 0.01);
 +        conversion_fees.insert(Currency::Ethereum, 0.008);
 +        conversion_fees.insert(Currency::ZephyrCoin, 0.0);
++
 +        Self {
 +            base_processing_fee: 0.005, // 0.5%
 +            conversion_fees,
 +            express_fee: 0.01, // 1%
 +            kyc_fee: 500, // $5 equivalent
 +        }
 +    }
 +}
++
 +impl Default for ProcessorConfig {
 +    fn default() -> Self {
 +        Self {
 +            batch_processing_enabled: true,
 +            batch_size: 100,
 +            processing_interval_minutes: 30,
 +            max_retries: 3,
 +            retry_delay_minutes: 60,
 +            auto_currency_conversion: true,
 +            fraud_detection_enabled: true,
 +        }
 +    }
 +}
++
 +impl PaymentProcessor {
 +    /// Create new payment processor
 +    pub fn new() -> Self {
 +        let mut processor = Self {
 +            payment_methods: HashMap::new(),
 +            exchange_rates: HashMap::new(),
 +            fee_structure: PaymentFeeStructure::default(),
 +            pending_payments: VecDeque::new(),
 +            payment_history: HashMap::new(),
 +            min_payout_thresholds: HashMap::new(),
 +            config: ProcessorConfig::default(),
 +        };
++
 +        processor.initialize_payment_methods();
 +        processor.initialize_exchange_rates();
 +        processor.initialize_payout_thresholds();
++
 +        processor
 +    }
++
 +    /// Initialize supported payment methods
 +    fn initialize_payment_methods(&mut self) {
 +        // Cryptocurrency methods
 +        self.payment_methods.insert(
 +            PaymentMethod::Cryptocurrency(CryptoNetwork::ZephyrCoin),
 +            PaymentMethodConfig {
 +                enabled: true,
 +                min_amount: 1_000_000_000_000_000_000, // 1 ZEPH
 +                max_amount: 1_000_000 * 1_000_000_000_000_000_000, // 1M ZEPH
 +                processing_time_hours: 1,
 +                supported_currencies: vec![Currency::ZephyrCoin],
 +                geographic_restrictions: vec![],
 +                requires_kyc: false,
 +                fee_structure: MethodFeeStructure {
 +                    fixed_fee: 0,
 +                    percentage_fee: 0.0,
 +                    network_fee: 100_000_000_000_000, // 0.0001 ZEPH
 +                    exchange_fee: 0.0,
 +                },
 +            },
 +        );
++
 +        self.payment_methods.insert(
 +            PaymentMethod::Cryptocurrency(CryptoNetwork::Ethereum),
 +            PaymentMethodConfig {
 +                enabled: true,
 +                min_amount: 10_000_000_000_000_000, // 0.01 ETH
 +                max_amount: 1000 * 1_000_000_000_000_000_000, // 1000 ETH
 +                processing_time_hours: 1,
 +                supported_currencies: vec![Currency::Ethereum, Currency::USD],
 +                geographic_restrictions: vec![],
 +                requires_kyc: false,
 +                fee_structure: MethodFeeStructure {
 +                    fixed_fee: 0,
 +                    percentage_fee: 0.003,
 +                    network_fee: 5_000_000_000_000_000, // ~$10 gas fee
 +                    exchange_fee: 0.005,
 +                },
 +            },
 +        );
++
 +        // Bank transfer methods
 +        self.payment_methods.insert(
 +            PaymentMethod::BankTransfer(BankTransferType::ACH),
 +            PaymentMethodConfig {
 +                enabled: true,
 +                min_amount: 1000, // $10
 +                max_amount: 1_000_000_00, // $10,000
 +                processing_time_hours: 48,
 +                supported_currencies: vec![Currency::USD],
 +                geographic_restrictions: vec!["US".to_string()],
 +                requires_kyc: true,
 +                fee_structure: MethodFeeStructure {
 +                    fixed_fee: 100, // $1
 +                    percentage_fee: 0.001,
 +                    network_fee: 0,
 +                    exchange_fee: 0.005,
 +                },
 +            },
 +        );
++
 +        self.payment_methods.insert(
 +            PaymentMethod::BankTransfer(BankTransferType::SEPA),
 +            PaymentMethodConfig {
 +                enabled: true,
 +                min_amount: 1000, // €10
 +                max_amount: 1_000_000_00, // €10,000
 +                processing_time_hours: 24,
 +                supported_currencies: vec![Currency::EUR],
 +                geographic_restrictions: vec!["EU".to_string()],
 +                requires_kyc: true,
 +                fee_structure: MethodFeeStructure {
 +                    fixed_fee: 50, // €0.50
 +                    percentage_fee: 0.001,
 +                    network_fee: 0,
 +                    exchange_fee: 0.005,
 +                },
 +            },
 +        );
++
 +        // Digital wallet methods
 +        self.payment_methods.insert(
 +            PaymentMethod::DigitalWallet(WalletProvider::PayPal),
 +            PaymentMethodConfig {
 +                enabled: true,
 +                min_amount: 500, // $5
 +                max_amount: 500_000_00, // $5,000
 +                processing_time_hours: 2,
 +                supported_currencies: vec![Currency::USD, Currency::EUR, Currency::GBP],
 +                geographic_restrictions: vec![], // Global
 +                requires_kyc: true,
 +                fee_structure: MethodFeeStructure {
 +                    fixed_fee: 30, // $0.30
 +                    percentage_fee: 0.029, // 2.9%
 +                    network_fee: 0,
 +                    exchange_fee: 0.035, // 3.5% for currency conversion
 +                },
 +            },
 +        );
++
 +        // Stablecoin methods
 +        self.payment_methods.insert(
 +            PaymentMethod::StableCoin(StableCoinType::USDC),
 +            PaymentMethodConfig {
 +                enabled: true,
 +                min_amount: 1_000_000, // 1 USDC
 +                max_amount: 100_000 * 1_000_000, // 100k USDC
 +                processing_time_hours: 1,
 +                supported_currencies: vec![Currency::USD],
 +                geographic_restrictions: vec![],
 +                requires_kyc: false,
 +                fee_structure: MethodFeeStructure {
 +                    fixed_fee: 0,
 +                    percentage_fee: 0.001,
 +                    network_fee: 2_000_000_000_000_000, // ~$2 gas fee
 +                    exchange_fee: 0.001,
 +                },
 +            },
 +        );
 +    }
++
 +    /// Initialize exchange rates (would fetch from APIs in production)
 +    fn initialize_exchange_rates(&mut self) {
 +        self.exchange_rates.insert(Currency::ZephyrCoin, 0.10); // $0.10 per ZEPH
 +        self.exchange_rates.insert(Currency::USD, 1.0);
 +        self.exchange_rates.insert(Currency::EUR, 0.85);
 +        self.exchange_rates.insert(Currency::GBP, 0.73);
 +        self.exchange_rates.insert(Currency::Bitcoin, 45000.0);
 +        self.exchange_rates.insert(Currency::Ethereum, 2500.0);
 +    }
++
 +    /// Initialize minimum payout thresholds
 +    fn initialize_payout_thresholds(&mut self) {
 +        self.min_payout_thresholds.insert(Currency::ZephyrCoin, 10 * 1_000_000_000_000_000_000); // 10 ZEPH
 +        self.min_payout_thresholds.insert(Currency::USD, 1000); // $10
 +        self.min_payout_thresholds.insert(Currency::EUR, 850); // €8.50
 +        self.min_payout_thresholds.insert(Currency::Bitcoin, 22222); // ~$10 worth
 +        self.min_payout_thresholds.insert(Currency::Ethereum, 400000); // ~$10 worth
 +    }
++
 +    /// Submit payment request
 +    pub fn submit_payment_request(&mut self, mut request: PaymentRequest) -> Result<String> {
 +        // Validate payment method
 +        let method_config = self.payment_methods.get(&request.payment_method)
 +            .ok_or_else(|| anyhow::anyhow!("Payment method not supported"))?;
++
 +        if !method_config.enabled {
 +            return Err(anyhow::anyhow!("Payment method temporarily disabled"));
 +        }
++
 +        // Convert amount to target currency
 +        let amount_in_currency = self.convert_tokens_to_currency(
 +            request.amount_tokens,
 +            &request.target_currency,
 +        )?;
++
 +        // Check minimum threshold
 +        if let Some(&min_threshold) = self.min_payout_thresholds.get(&request.target_currency) {
 +            if amount_in_currency < min_threshold {
 +                return Err(anyhow::anyhow!(
 +                    "Amount below minimum payout threshold: {} < {}",
 +                    amount_in_currency, min_threshold
 +                ));
 +            }
 +        }
++
 +        // Check method limits
 +        if amount_in_currency < method_config.min_amount || amount_in_currency > method_config.max_amount {
 +            return Err(anyhow::anyhow!(
 +                "Amount outside payment method limits: {} not in [{}, {}]",
 +                amount_in_currency, method_config.min_amount, method_config.max_amount
 +            ));
 +        }
++
 +        // Validate recipient info
 +        self.validate_recipient_info(&request.recipient_info, &request.payment_method)?;
++
 +        // Generate request ID
 +        request.request_id = format!("pay_{}_{}",
 +            chrono::Utc::now().timestamp(),
 +            &request.volunteer_id[..8]
 +        );
++
 +        self.pending_payments.push_back(request.clone());
++
 +        tracing::info!("Payment request submitted: {} for {} tokens",
 +            request.request_id, request.amount_tokens);
++
 +        Ok(request.request_id)
 +    }
++
 +    /// Convert tokens to target currency
 +    fn convert_tokens_to_currency(&self, tokens: u64, target_currency: &Currency) -> Result<u64> {
 +        if *target_currency == Currency::ZephyrCoin {
 +            return Ok(tokens);
 +        }
++
 +        let zeph_rate = self.exchange_rates.get(&Currency::ZephyrCoin)
 +            .ok_or_else(|| anyhow::anyhow!("ZephyrCoin exchange rate not available"))?;
++
 +        let target_rate = self.exchange_rates.get(target_currency)
 +            .ok_or_else(|| anyhow::anyhow!("Target currency exchange rate not available"))?;
++
 +        // Convert tokens to USD value, then to target currency
 +        let usd_value = (tokens as f64 / 1_000_000_000_000_000_000.0) * zeph_rate;
 +        let target_value = usd_value / target_rate;
++
 +        // Convert to smallest units (cents, wei, etc.)
 +        let target_amount = match target_currency {
 +            Currency::USD | Currency::EUR | Currency::GBP => (target_value * 100.0) as u64,
 +            Currency::Bitcoin => (target_value * 100_000_000.0) as u64, // Satoshis
 +            Currency::Ethereum => (target_value * 1_000_000_000_000_000_000.0) as u64, // Wei
 +            _ => (target_value * 1_000_000.0) as u64, // Default 6 decimals
 +        };
++
 +        Ok(target_amount)
 +    }
++
 +    /// Validate recipient information
 +    fn validate_recipient_info(&self, info: &RecipientInfo, method: &PaymentMethod) -> Result<()> {
 +        match method {
 +            PaymentMethod::Cryptocurrency(_) => {
 +                if info.wallet_address.is_none() {
 +                    return Err(anyhow::anyhow!("Wallet address required for crypto payments"));
 +                }
 +            },
 +            PaymentMethod::BankTransfer(_) => {
 +                if info.bank_account.is_none() {
 +                    return Err(anyhow::anyhow!("Bank account info required for bank transfers"));
 +                }
 +                if !info.kyc_verified {
 +                    return Err(anyhow::anyhow!("KYC verification required for bank transfers"));
 +                }
 +            },
 +            PaymentMethod::DigitalWallet(_) => {
 +                if info.digital_wallet.is_none() {
 +                    return Err(anyhow::anyhow!("Digital wallet info required"));
 +                }
 +            },
 +            PaymentMethod::StableCoin(_) => {
 +                if info.wallet_address.is_none() {
 +                    return Err(anyhow::anyhow!("Wallet address required for stablecoin payments"));
 +                }
 +            },
 +        }
++
 +        Ok(())
 +    }
++
 +    /// Process pending payments
 +    pub async fn process_pending_payments(&mut self) -> Result<Vec<PaymentRecord>> {
 +        let mut processed = Vec::new();
 +        let batch_size = if self.config.batch_processing_enabled {
 +            self.config.batch_size
 +        } else {
 +            1
 +        };
++
 +        for _ in 0..batch_size {
 +            if let Some(request) = self.pending_payments.pop_front() {
 +                // Check if scheduled for future
 +                if let Some(scheduled_time) = request.scheduled_for {
 +                    if Utc::now() < scheduled_time {
 +                        // Put back in queue
 +                        self.pending_payments.push_front(request);
 +                        break;
 +                    }
 +                }
++
 +                match self.process_single_payment(request).await {
 +                    Ok(record) => {
 +                        processed.push(record.clone());
++
 +                        // Add to history
 +                        self.payment_history
 +                            .entry(record.volunteer_id.clone())
 +                            .or_insert_with(Vec::new)
 +                            .push(record);
 +                    },
 +                    Err(e) => {
 +                        tracing::error!("Payment processing failed: {}", e);
 +                        // Could implement retry logic here
 +                    }
 +                }
 +            } else {
 +                break;
 +            }
 +        }
++
 +        Ok(processed)
 +    }
++
 +    /// Process single payment
 +    async fn process_single_payment(&self, request: PaymentRequest) -> Result<PaymentRecord> {
 +        let payment_id = format!("tx_{}_{}",
 +            chrono::Utc::now().timestamp_millis(),
 +            &request.volunteer_id[..6]
 +        );
++
 +        // Calculate fees
 +        let fees = self.calculate_payment_fees(&request)?;
++
 +        // Convert amount
 +        let amount_in_currency = self.convert_tokens_to_currency(
 +            request.amount_tokens,
 +            &request.target_currency,
 +        )?;
++
 +        let net_amount = amount_in_currency.saturating_sub(fees.total_fee);
++
 +        // Execute payment based on method
 +        let (status, confirmation_hash, error_message) = match request.payment_method {
 +            PaymentMethod::Cryptocurrency(_) => {
 +                self.execute_crypto_payment(&request, net_amount).await?
 +            },
 +            PaymentMethod::BankTransfer(_) => {
 +                self.execute_bank_transfer(&request, net_amount).await?
 +            },
 +            PaymentMethod::DigitalWallet(_) => {
 +                self.execute_wallet_payment(&request, net_amount).await?
 +            },
 +            PaymentMethod::StableCoin(_) => {
 +                self.execute_stablecoin_payment(&request, net_amount).await?
 +            },
 +        };
++
 +        let record = PaymentRecord {
 +            payment_id,
 +            request_id: request.request_id,
 +            volunteer_id: request.volunteer_id,
 +            amount_tokens: request.amount_tokens,
 +            amount_paid: net_amount,
 +            currency: request.target_currency,
 +            payment_method: request.payment_method,
 +            status,
 +            fees_paid: fees.total_fee,
 +            exchange_rate: self.get_exchange_rate(&Currency::ZephyrCoin, &request.target_currency)?,
 +            processed_at: Utc::now(),
 +            confirmation_hash,
 +            error_message,
 +        };
++
 +        tracing::info!("Payment processed: {} - {} {:?}",
 +            record.payment_id, record.amount_paid, record.currency);
++
 +        Ok(record)
 +    }
++
 +    /// Calculate payment fees
 +    fn calculate_payment_fees(&self, request: &PaymentRequest) -> Result<PaymentFees> {
 +        let method_config = self.payment_methods.get(&request.payment_method)
 +            .ok_or_else(|| anyhow::anyhow!("Payment method not found"))?;
++
 +        let amount_in_currency = self.convert_tokens_to_currency(
 +            request.amount_tokens,
 +            &request.target_currency,
 +        )?;
++
 +        let base_fee = (amount_in_currency as f64 * self.fee_structure.base_processing_fee) as u64;
 +        let method_percentage_fee = (amount_in_currency as f64 * method_config.fee_structure.percentage_fee) as u64;
 +        let method_fixed_fee = method_config.fee_structure.fixed_fee;
 +        let network_fee = method_config.fee_structure.network_fee;
++
 +        let exchange_fee = if request.target_currency != Currency::ZephyrCoin {
 +            let exchange_rate = method_config.fee_structure.exchange_fee;
 +            (amount_in_currency as f64 * exchange_rate) as u64
 +        } else {
 +            0
 +        };
++
 +        let express_fee = if matches!(request.priority, PaymentPriority::Express | PaymentPriority::Immediate) {
 +            (amount_in_currency as f64 * self.fee_structure.express_fee) as u64
 +        } else {
 +            0
 +        };
++
 +        let total_fee = base_fee + method_percentage_fee + method_fixed_fee + network_fee + exchange_fee + express_fee;
++
 +        Ok(PaymentFees {
 +            base_fee,
 +            method_percentage_fee,
 +            method_fixed_fee,
 +            network_fee,
 +            exchange_fee,
 +            express_fee,
 +            total_fee,
 +        })
 +    }
++
 +    /// Execute cryptocurrency payment
 +    async fn execute_crypto_payment(
 +        &self,
 +        request: &PaymentRequest,
 +        amount: u64,
 +    ) -> Result<(PaymentStatus, Option<String>, Option<String>)> {
 +        // Simulate crypto transaction
 +        tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
++
 +        let confirmation_hash = format!("0x{:x}", rand::random::<u64>());
++
 +        Ok((PaymentStatus::Completed, Some(confirmation_hash), None))
 +    }
++
 +    /// Execute bank transfer
 +    async fn execute_bank_transfer(
 +        &self,
 +        request: &PaymentRequest,
 +        amount: u64,
 +    ) -> Result<(PaymentStatus, Option<String>, Option<String>)> {
 +        // Simulate bank transfer processing
 +        tokio::time::sleep(tokio::time::Duration::from_millis(500)).await;
++
 +        let reference = format!("TXN{}", chrono::Utc::now().timestamp());
++
 +        Ok((PaymentStatus::Processing, Some(reference), None))
 +    }
++
 +    /// Execute digital wallet payment
 +    async fn execute_wallet_payment(
 +        &self,
 +        request: &PaymentRequest,
 +        amount: u64,
 +    ) -> Result<(PaymentStatus, Option<String>, Option<String>)> {
 +        // Simulate wallet payment
 +        tokio::time::sleep(tokio::time::Duration::from_millis(200)).await;
++
 +        let transaction_id = format!("WLT{}", chrono::Utc::now().timestamp());
++
 +        Ok((PaymentStatus::Completed, Some(transaction_id), None))
 +    }
++
 +    /// Execute stablecoin payment
 +    async fn execute_stablecoin_payment(
 +        &self,
 +        request: &PaymentRequest,
 +        amount: u64,
 +    ) -> Result<(PaymentStatus, Option<String>, Option<String>)> {
 +        // Simulate stablecoin transfer
 +        tokio::time::sleep(tokio::time::Duration::from_millis(150)).await;
++
 +        let tx_hash = format!("0x{:x}", rand::random::<u64>());
++
 +        Ok((PaymentStatus::Completed, Some(tx_hash), None))
 +    }
++
 +    /// Get exchange rate between currencies
 +    fn get_exchange_rate(&self, from: &Currency, to: &Currency) -> Result<f64> {
 +        if from == to {
 +            return Ok(1.0);
 +        }
++
 +        let from_rate = self.exchange_rates.get(from)
 +            .ok_or_else(|| anyhow::anyhow!("Exchange rate not found for {:?}", from))?;
++
 +        let to_rate = self.exchange_rates.get(to)
 +            .ok_or_else(|| anyhow::anyhow!("Exchange rate not found for {:?}", to))?;
++
 +        Ok(from_rate / to_rate)
 +    }
++
 +    /// Get payment history for volunteer
 +    pub fn get_payment_history(&self, volunteer_id: &str) -> Vec<&PaymentRecord> {
 +        self.payment_history.get(volunteer_id)
 +            .map(|records| records.iter().collect())
 +            .unwrap_or_default()
 +    }
++
 +    /// Update exchange rates
 +    pub fn update_exchange_rates(&mut self, rates: HashMap<Currency, f64>) {
 +        for (currency, rate) in rates {
 +            self.exchange_rates.insert(currency, rate);
 +        }
 +    }
++
 +    /// Get supported payment methods for region
 +    pub fn get_supported_methods(&self, country_code: &str) -> Vec<&PaymentMethod> {
 +        self.payment_methods.iter()
 +            .filter(|(_, config)| {
 +                config.enabled &&
 +                (config.geographic_restrictions.is_empty() ||
 +                 config.geographic_restrictions.contains(&country_code.to_string()))
 +            })
 +            .map(|(method, _)| method)
 +            .collect()
 +    }
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +struct PaymentFees {
 +    pub base_fee: u64,
 +    pub method_percentage_fee: u64,
 +    pub method_fixed_fee: u64,
 +    pub network_fee: u64,
 +    pub exchange_fee: u64,
 +    pub express_fee: u64,
 +    pub total_fee: u64,
 +}
++
 +#[cfg(test)]
 +mod tests {
 +    use super::*;
++
 +    #[test]
 +    fn test_payment_processor_creation() {
 +        let processor = PaymentProcessor::new();
 +        assert!(!processor.payment_methods.is_empty());
 +        assert!(!processor.exchange_rates.is_empty());
 +    }
++
 +    #[tokio::test]
 +    async fn test_payment_submission() {
 +        let mut processor = PaymentProcessor::new();
++
 +        let request = PaymentRequest {
 +            request_id: String::new(),
 +            volunteer_id: "test_volunteer".to_string(),
 +            amount_tokens: 100 * 1_000_000_000_000_000_000, // 100 ZEPH
 +            target_currency: Currency::USD,
 +            payment_method: PaymentMethod::DigitalWallet(WalletProvider::PayPal),
 +            recipient_info: RecipientInfo {
 +                wallet_address: None,
 +                bank_account: None,
 +                digital_wallet: Some(DigitalWalletInfo {
 +                    provider: WalletProvider::PayPal,
 +                    wallet_id: "test@example.com".to_string(),
 +                    verified: true,
 +                }),
 +                kyc_verified: true,
 +                tax_info: None,
 +            },
 +            priority: PaymentPriority::Standard,
 +            created_at: Utc::now(),
 +            scheduled_for: None,
 +            metadata: HashMap::new(),
 +        };
++
 +        let request_id = processor.submit_payment_request(request).unwrap();
 +        assert!(!request_id.is_empty());
 +        assert_eq!(processor.pending_payments.len(), 1);
 +    }
++
 +    #[test]
 +    fn test_currency_conversion() {
 +        let processor = PaymentProcessor::new();
 +        let tokens = 100 * 1_000_000_000_000_000_000; // 100 ZEPH
++
 +        let usd_amount = processor.convert_tokens_to_currency(tokens, &Currency::USD).unwrap();
 +        assert_eq!(usd_amount, 1000); // $10.00 (100 ZEPH * $0.10 * 100 cents)
++
 +        let zeph_amount = processor.convert_tokens_to_currency(tokens, &Currency::ZephyrCoin).unwrap();
 +        assert_eq!(zeph_amount, tokens); // Same amount in ZEPH
 +    }
 +}

src/economics/payout_scheduler.rsadded

 +//! Automated Payout Scheduling System
 +//!
 +//! Manages scheduled payouts for ZephyrFS volunteers with configurable intervals
++
 +use anyhow::Result;
 +use serde::{Deserialize, Serialize};
 +use std::collections::{HashMap, BTreeMap};
 +use chrono::{DateTime, Utc, Duration, Weekday, TimeZone};
 +use tokio::time::{sleep, Duration as TokioDuration};
++
 +use super::payment_processor::{PaymentProcessor, PaymentRequest, Currency, PaymentMethod, RecipientInfo, PaymentPriority};
 +use super::earnings_calculator::EarningsCalculator;
++
 +/// Automated payout scheduler
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct PayoutScheduler {
 +    /// Volunteer payout preferences
 +    pub volunteer_preferences: HashMap<String, PayoutPreferences>,
 +    /// Scheduled payouts
 +    pub scheduled_payouts: BTreeMap<DateTime<Utc>, ScheduledPayout>,
 +    /// Payout policies and rules
 +    pub policies: PayoutPolicies,
 +    /// Accumulated earnings per volunteer
 +    pub accumulated_earnings: HashMap<String, AccumulatedEarnings>,
 +    /// Schedule configuration
 +    pub schedule_config: ScheduleConfig,
 +    /// Performance tracking
 +    pub payout_history: HashMap<String, Vec<PayoutEvent>>,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct PayoutPreferences {
 +    pub volunteer_id: String,
 +    pub frequency: PayoutFrequency,
 +    pub preferred_currency: Currency,
 +    pub preferred_method: PaymentMethod,
 +    pub recipient_info: RecipientInfo,
 +    pub minimum_threshold: u64,
 +    pub auto_payout_enabled: bool,
 +    pub timezone: String,
 +    pub preferred_day: Option<Weekday>,
 +    pub preferred_hour: u8, // 0-23
 +    pub priority: PaymentPriority,
 +    pub split_payments: Option<SplitPaymentConfig>,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub enum PayoutFrequency {
 +    Daily,
 +    Weekly,
 +    BiWeekly,
 +    Monthly,
 +    Quarterly,
 +    Manual, // Only manual payouts
 +    Threshold(u64), // Pay when threshold reached
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct SplitPaymentConfig {
 +    pub enabled: bool,
 +    pub primary_percentage: f64, // 0.0-1.0
 +    pub primary_method: PaymentMethod,
 +    pub secondary_method: PaymentMethod,
 +    pub secondary_currency: Currency,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct ScheduledPayout {
 +    pub payout_id: String,
 +    pub volunteer_id: String,
 +    pub amount_tokens: u64,
 +    pub target_currency: Currency,
 +    pub payment_method: PaymentMethod,
 +    pub recipient_info: RecipientInfo,
 +    pub scheduled_time: DateTime<Utc>,
 +    pub created_at: DateTime<Utc>,
 +    pub priority: PaymentPriority,
 +    pub recurring: bool,
 +    pub next_occurrence: Option<DateTime<Utc>>,
 +    pub metadata: HashMap<String, String>,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct PayoutPolicies {
 +    /// Minimum time between payouts (hours)
 +    pub min_payout_interval_hours: u32,
 +    /// Maximum accumulated earnings before forced payout
 +    pub max_accumulated_tokens: u64,
 +    /// Grace period for failed payments (hours)
 +    pub payment_retry_grace_hours: u32,
 +    /// Automatic threshold adjustment
 +    pub auto_adjust_thresholds: bool,
 +    /// Holiday/weekend handling
 +    pub holiday_handling: HolidayHandling,
 +    /// Risk management
 +    pub risk_controls: RiskControls,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct HolidayHandling {
 +    pub skip_weekends: bool,
 +    pub skip_holidays: bool,
 +    pub advance_before_holiday: bool,
 +    pub supported_regions: Vec<String>,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct RiskControls {
 +    pub max_daily_payout_per_volunteer: u64,
 +    pub max_total_daily_payouts: u64,
 +    pub suspicious_activity_threshold: f64,
 +    pub require_additional_verification: bool,
 +    pub fraud_detection_enabled: bool,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct AccumulatedEarnings {
 +    pub volunteer_id: String,
 +    pub total_tokens: u64,
 +    pub last_payout: Option<DateTime<Utc>>,
 +    pub accumulation_start: DateTime<Utc>,
 +    pub daily_breakdown: HashMap<String, u64>, // date -> earnings
 +    pub bonus_tokens: u64,
 +    pub pending_taxes: u64,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct ScheduleConfig {
 +    pub processing_interval_minutes: u32,
 +    pub lookahead_hours: u32,
 +    pub batch_processing: bool,
 +    pub max_concurrent_payouts: usize,
 +    pub retry_failed_payouts: bool,
 +    pub notification_enabled: bool,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct PayoutEvent {
 +    pub event_id: String,
 +    pub payout_id: String,
 +    pub volunteer_id: String,
 +    pub event_type: PayoutEventType,
 +    pub amount: u64,
 +    pub currency: Currency,
 +    pub timestamp: DateTime<Utc>,
 +    pub success: bool,
 +    pub error_message: Option<String>,
 +    pub payment_reference: Option<String>,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub enum PayoutEventType {
 +    Scheduled,
 +    ThresholdReached,
 +    Manual,
 +    Emergency,
 +    Retry,
 +}
++
 +impl Default for PayoutPolicies {
 +    fn default() -> Self {
 +        Self {
 +            min_payout_interval_hours: 24,
 +            max_accumulated_tokens: 1000 * 1_000_000_000_000_000_000, // 1000 ZEPH
 +            payment_retry_grace_hours: 72,
 +            auto_adjust_thresholds: true,
 +            holiday_handling: HolidayHandling {
 +                skip_weekends: false,
 +                skip_holidays: true,
 +                advance_before_holiday: true,
 +                supported_regions: vec!["US".to_string(), "EU".to_string()],
 +            },
 +            risk_controls: RiskControls {
 +                max_daily_payout_per_volunteer: 10000 * 1_000_000_000_000_000_000, // 10k ZEPH
 +                max_total_daily_payouts: 100000 * 1_000_000_000_000_000_000, // 100k ZEPH
 +                suspicious_activity_threshold: 5.0, // 5x normal activity
 +                require_additional_verification: false,
 +                fraud_detection_enabled: true,
 +            },
 +        }
 +    }
 +}
++
 +impl Default for ScheduleConfig {
 +    fn default() -> Self {
 +        Self {
 +            processing_interval_minutes: 15,
 +            lookahead_hours: 24,
 +            batch_processing: true,
 +            max_concurrent_payouts: 10,
 +            retry_failed_payouts: true,
 +            notification_enabled: true,
 +        }
 +    }
 +}
++
 +impl PayoutScheduler {
 +    /// Create new payout scheduler
 +    pub fn new() -> Self {
 +        Self {
 +            volunteer_preferences: HashMap::new(),
 +            scheduled_payouts: BTreeMap::new(),
 +            policies: PayoutPolicies::default(),
 +            accumulated_earnings: HashMap::new(),
 +            schedule_config: ScheduleConfig::default(),
 +            payout_history: HashMap::new(),
 +        }
 +    }
++
 +    /// Set volunteer payout preferences
 +    pub fn set_volunteer_preferences(&mut self, preferences: PayoutPreferences) {
 +        let volunteer_id = preferences.volunteer_id.clone();
 +        self.volunteer_preferences.insert(volunteer_id.clone(), preferences);
++
 +        // Initialize accumulated earnings if needed
 +        if !self.accumulated_earnings.contains_key(&volunteer_id) {
 +            self.accumulated_earnings.insert(volunteer_id.clone(), AccumulatedEarnings {
 +                volunteer_id,
 +                total_tokens: 0,
 +                last_payout: None,
 +                accumulation_start: Utc::now(),
 +                daily_breakdown: HashMap::new(),
 +                bonus_tokens: 0,
 +                pending_taxes: 0,
 +            });
 +        }
++
 +        tracing::info!("Updated payout preferences for volunteer: {}", volunteer_id);
 +    }
++
 +    /// Add earnings to volunteer's accumulated total
 +    pub fn add_earnings(&mut self, volunteer_id: &str, tokens: u64, bonus_tokens: u64) -> Result<()> {
 +        let accumulated = self.accumulated_earnings.get_mut(volunteer_id)
 +            .ok_or_else(|| anyhow::anyhow!("Volunteer not found in earnings tracker"))?;
++
 +        accumulated.total_tokens += tokens;
 +        accumulated.bonus_tokens += bonus_tokens;
++
 +        // Track daily breakdown
 +        let today = Utc::now().date_naive().to_string();
 +        *accumulated.daily_breakdown.entry(today).or_insert(0) += tokens;
++
 +        // Check if threshold payout should be triggered
 +        if let Some(preferences) = self.volunteer_preferences.get(volunteer_id) {
 +            if let PayoutFrequency::Threshold(threshold) = preferences.frequency {
 +                if accumulated.total_tokens >= threshold {
 +                    self.schedule_threshold_payout(volunteer_id)?;
 +                }
 +            }
++
 +            // Check maximum accumulation policy
 +            if accumulated.total_tokens >= self.policies.max_accumulated_tokens {
 +                self.schedule_emergency_payout(volunteer_id)?;
 +            }
 +        }
++
 +        tracing::debug!("Added {} tokens to {}, total: {}",
 +            tokens, volunteer_id, accumulated.total_tokens);
++
 +        Ok(())
 +    }
++
 +    /// Schedule threshold-based payout
 +    fn schedule_threshold_payout(&mut self, volunteer_id: &str) -> Result<()> {
 +        let preferences = self.volunteer_preferences.get(volunteer_id)
 +            .ok_or_else(|| anyhow::anyhow!("Volunteer preferences not found"))?;
++
 +        let accumulated = self.accumulated_earnings.get(volunteer_id)
 +            .ok_or_else(|| anyhow::anyhow!("Accumulated earnings not found"))?;
++
 +        let payout = ScheduledPayout {
 +            payout_id: format!("threshold_{}_{}", volunteer_id, Utc::now().timestamp()),
 +            volunteer_id: volunteer_id.to_string(),
 +            amount_tokens: accumulated.total_tokens,
 +            target_currency: preferences.preferred_currency.clone(),
 +            payment_method: preferences.preferred_method.clone(),
 +            recipient_info: preferences.recipient_info.clone(),
 +            scheduled_time: self.calculate_next_payout_time(preferences)?,
 +            created_at: Utc::now(),
 +            priority: preferences.priority.clone(),
 +            recurring: false,
 +            next_occurrence: None,
 +            metadata: HashMap::from([
 +                ("trigger".to_string(), "threshold".to_string()),
 +                ("threshold".to_string(), preferences.minimum_threshold.to_string()),
 +            ]),
 +        };
++
 +        self.scheduled_payouts.insert(payout.scheduled_time, payout);
++
 +        tracing::info!("Scheduled threshold payout for {}: {} tokens",
 +            volunteer_id, accumulated.total_tokens);
++
 +        Ok(())
 +    }
++
 +    /// Schedule emergency payout for max accumulation
 +    fn schedule_emergency_payout(&mut self, volunteer_id: &str) -> Result<()> {
 +        let preferences = self.volunteer_preferences.get(volunteer_id)
 +            .ok_or_else(|| anyhow::anyhow!("Volunteer preferences not found"))?;
++
 +        let accumulated = self.accumulated_earnings.get(volunteer_id)
 +            .ok_or_else(|| anyhow::anyhow!("Accumulated earnings not found"))?;
++
 +        let payout = ScheduledPayout {
 +            payout_id: format!("emergency_{}_{}", volunteer_id, Utc::now().timestamp()),
 +            volunteer_id: volunteer_id.to_string(),
 +            amount_tokens: accumulated.total_tokens,
 +            target_currency: preferences.preferred_currency.clone(),
 +            payment_method: preferences.preferred_method.clone(),
 +            recipient_info: preferences.recipient_info.clone(),
 +            scheduled_time: Utc::now() + Duration::hours(1), // Emergency: 1 hour delay
 +            created_at: Utc::now(),
 +            priority: PaymentPriority::Immediate,
 +            recurring: false,
 +            next_occurrence: None,
 +            metadata: HashMap::from([
 +                ("trigger".to_string(), "emergency".to_string()),
 +                ("reason".to_string(), "max_accumulation".to_string()),
 +            ]),
 +        };
++
 +        self.scheduled_payouts.insert(payout.scheduled_time, payout);
++
 +        tracing::warn!("Scheduled emergency payout for {}: {} tokens (max accumulation)",
 +            volunteer_id, accumulated.total_tokens);
++
 +        Ok(())
 +    }
++
 +    /// Calculate next payout time based on preferences
 +    fn calculate_next_payout_time(&self, preferences: &PayoutPreferences) -> Result<DateTime<Utc>> {
 +        let now = Utc::now();
 +        let base_time = match preferences.frequency {
 +            PayoutFrequency::Daily => now + Duration::days(1),
 +            PayoutFrequency::Weekly => now + Duration::weeks(1),
 +            PayoutFrequency::BiWeekly => now + Duration::weeks(2),
 +            PayoutFrequency::Monthly => now + Duration::days(30),
 +            PayoutFrequency::Quarterly => now + Duration::days(90),
 +            PayoutFrequency::Threshold(_) => now + Duration::hours(1), // Immediate
 +            PayoutFrequency::Manual => return Err(anyhow::anyhow!("Manual payouts don't have scheduled times")),
 +        };
++
 +        // Adjust for preferred day and hour
 +        let mut adjusted_time = base_time;
++
 +        // Set preferred hour
 +        let target_hour = preferences.preferred_hour;
 +        adjusted_time = adjusted_time
 +            .with_hour(target_hour)
 +            .and_then(|dt| dt.with_minute(0))
 +            .and_then(|dt| dt.with_second(0))
 +            .ok_or_else(|| anyhow::anyhow!("Invalid time adjustment"))?;
++
 +        // Adjust for preferred day of week (for weekly/biweekly)
 +        if let Some(preferred_day) = preferences.preferred_day {
 +            if matches!(preferences.frequency, PayoutFrequency::Weekly | PayoutFrequency::BiWeekly) {
 +                let current_weekday = adjusted_time.weekday();
 +                let days_until_preferred = (preferred_day.number_from_monday() as i64
 +                    - current_weekday.number_from_monday() as i64 + 7) % 7;
++
 +                if days_until_preferred > 0 {
 +                    adjusted_time += Duration::days(days_until_preferred);
 +                }
 +            }
 +        }
++
 +        // Handle holidays and weekends
 +        adjusted_time = self.adjust_for_holidays(adjusted_time);
++
 +        Ok(adjusted_time)
 +    }
++
 +    /// Adjust payout time for holidays and weekends
 +    fn adjust_for_holidays(&self, mut payout_time: DateTime<Utc>) -> DateTime<Utc> {
 +        let holiday_config = &self.policies.holiday_handling;
++
 +        // Skip weekends if configured
 +        if holiday_config.skip_weekends {
 +            let weekday = payout_time.weekday();
 +            if weekday == Weekday::Sat {
 +                payout_time += Duration::days(2); // Move to Monday
 +            } else if weekday == Weekday::Sun {
 +                payout_time += Duration::days(1); // Move to Monday
 +            }
 +        }
++
 +        // Skip holidays (simplified - would use real holiday calendar in production)
 +        if holiday_config.skip_holidays {
 +            // Example: Skip December 25th
 +            if payout_time.month() == 12 && payout_time.day() == 25 {
 +                payout_time += Duration::days(1);
 +            }
 +        }
++
 +        payout_time
 +    }
++
 +    /// Generate recurring payouts for all volunteers
 +    pub fn generate_recurring_payouts(&mut self) -> Result<usize> {
 +        let mut created_count = 0;
 +        let now = Utc::now();
 +        let lookahead = now + Duration::hours(self.schedule_config.lookahead_hours as i64);
++
 +        for (volunteer_id, preferences) in &self.volunteer_preferences.clone() {
 +            if !preferences.auto_payout_enabled {
 +                continue;
 +            }
++
 +            let accumulated = self.accumulated_earnings.get(volunteer_id)
 +                .ok_or_else(|| anyhow::anyhow!("Accumulated earnings not found for {}", volunteer_id))?;
++
 +            // Check if volunteer has earnings to pay out
 +            if accumulated.total_tokens < preferences.minimum_threshold {
 +                continue;
 +            }
++
 +            // Check if last payout was recent enough
 +            if let Some(last_payout) = accumulated.last_payout {
 +                let hours_since_last = (now - last_payout).num_hours();
 +                if hours_since_last < self.policies.min_payout_interval_hours as i64 {
 +                    continue;
 +                }
 +            }
++
 +            // Calculate next payout time
 +            let next_payout_time = self.calculate_next_payout_time(preferences)?;
++
 +            // Only schedule if within lookahead window
 +            if next_payout_time <= lookahead {
 +                // Check if already scheduled
 +                let already_scheduled = self.scheduled_payouts.values()
 +                    .any(|payout| payout.volunteer_id == *volunteer_id && !payout.recurring);
++
 +                if !already_scheduled {
 +                    let payout = self.create_scheduled_payout(volunteer_id, preferences, accumulated)?;
 +                    self.scheduled_payouts.insert(payout.scheduled_time, payout);
 +                    created_count += 1;
 +                }
 +            }
 +        }
++
 +        if created_count > 0 {
 +            tracing::info!("Generated {} recurring payouts", created_count);
 +        }
++
 +        Ok(created_count)
 +    }
++
 +    /// Create scheduled payout from preferences and earnings
 +    fn create_scheduled_payout(
 +        &self,
 +        volunteer_id: &str,
 +        preferences: &PayoutPreferences,
 +        accumulated: &AccumulatedEarnings,
 +    ) -> Result<ScheduledPayout> {
 +        let payout_time = self.calculate_next_payout_time(preferences)?;
++
 +        // Handle split payments
 +        let (amount, method, currency) = if let Some(split_config) = &preferences.split_payments {
 +            if split_config.enabled {
 +                // For now, use primary payment - secondary would be handled separately
 +                let primary_amount = (accumulated.total_tokens as f64 * split_config.primary_percentage) as u64;
 +                (primary_amount, split_config.primary_method.clone(), preferences.preferred_currency.clone())
 +            } else {
 +                (accumulated.total_tokens, preferences.preferred_method.clone(), preferences.preferred_currency.clone())
 +            }
 +        } else {
 +            (accumulated.total_tokens, preferences.preferred_method.clone(), preferences.preferred_currency.clone())
 +        };
++
 +        Ok(ScheduledPayout {
 +            payout_id: format!("sched_{}_{}", volunteer_id, payout_time.timestamp()),
 +            volunteer_id: volunteer_id.to_string(),
 +            amount_tokens: amount,
 +            target_currency: currency,
 +            payment_method: method,
 +            recipient_info: preferences.recipient_info.clone(),
 +            scheduled_time: payout_time,
 +            created_at: Utc::now(),
 +            priority: preferences.priority.clone(),
 +            recurring: true,
 +            next_occurrence: Some(self.calculate_next_recurring_time(preferences, payout_time)?),
 +            metadata: HashMap::from([
 +                ("trigger".to_string(), "recurring".to_string()),
 +                ("frequency".to_string(), format!("{:?}", preferences.frequency)),
 +            ]),
 +        })
 +    }
++
 +    /// Calculate next occurrence for recurring payout
 +    fn calculate_next_recurring_time(
 +        &self,
 +        preferences: &PayoutPreferences,
 +        current_time: DateTime<Utc>,
 +    ) -> Result<DateTime<Utc>> {
 +        let next_time = match preferences.frequency {
 +            PayoutFrequency::Daily => current_time + Duration::days(1),
 +            PayoutFrequency::Weekly => current_time + Duration::weeks(1),
 +            PayoutFrequency::BiWeekly => current_time + Duration::weeks(2),
 +            PayoutFrequency::Monthly => current_time + Duration::days(30),
 +            PayoutFrequency::Quarterly => current_time + Duration::days(90),
 +            _ => return Err(anyhow::anyhow!("Frequency doesn't support recurring")),
 +        };
++
 +        Ok(self.adjust_for_holidays(next_time))
 +    }
++
 +    /// Process due payouts
 +    pub async fn process_due_payouts(
 +        &mut self,
 +        payment_processor: &mut PaymentProcessor,
 +    ) -> Result<Vec<PayoutEvent>> {
 +        let now = Utc::now();
 +        let mut events = Vec::new();
++
 +        // Collect due payouts
 +        let due_payouts: Vec<_> = self.scheduled_payouts
 +            .range(..=now)
 +            .map(|(_, payout)| payout.clone())
 +            .collect();
++
 +        for payout in due_payouts {
 +            // Remove from scheduled
 +            self.scheduled_payouts.remove(&payout.scheduled_time);
++
 +            // Process payout
 +            let event = self.process_single_payout(payout, payment_processor).await?;
 +            events.push(event.clone());
++
 +            // Record in history
 +            self.payout_history
 +                .entry(event.volunteer_id.clone())
 +                .or_insert_with(Vec::new)
 +                .push(event);
 +        }
++
 +        Ok(events)
 +    }
++
 +    /// Process single payout
 +    async fn process_single_payout(
 +        &mut self,
 +        payout: ScheduledPayout,
 +        payment_processor: &mut PaymentProcessor,
 +    ) -> Result<PayoutEvent> {
 +        let event_id = format!("event_{}_{}", payout.volunteer_id, Utc::now().timestamp_millis());
++
 +        // Apply risk controls
 +        if let Err(risk_error) = self.check_risk_controls(&payout) {
 +            let event = PayoutEvent {
 +                event_id,
 +                payout_id: payout.payout_id,
 +                volunteer_id: payout.volunteer_id,
 +                event_type: PayoutEventType::Scheduled,
 +                amount: payout.amount_tokens,
 +                currency: payout.target_currency,
 +                timestamp: Utc::now(),
 +                success: false,
 +                error_message: Some(risk_error.to_string()),
 +                payment_reference: None,
 +            };
++
 +            tracing::warn!("Payout blocked by risk controls: {}", risk_error);
 +            return Ok(event);
 +        }
++
 +        // Create payment request
 +        let payment_request = PaymentRequest {
 +            request_id: payout.payout_id.clone(),
 +            volunteer_id: payout.volunteer_id.clone(),
 +            amount_tokens: payout.amount_tokens,
 +            target_currency: payout.target_currency.clone(),
 +            payment_method: payout.payment_method.clone(),
 +            recipient_info: payout.recipient_info.clone(),
 +            priority: payout.priority.clone(),
 +            created_at: Utc::now(),
 +            scheduled_for: None,
 +            metadata: payout.metadata.clone(),
 +        };
++
 +        // Submit to payment processor
 +        match payment_processor.submit_payment_request(payment_request) {
 +            Ok(payment_reference) => {
 +                // Update accumulated earnings
 +                if let Some(accumulated) = self.accumulated_earnings.get_mut(&payout.volunteer_id) {
 +                    accumulated.total_tokens = accumulated.total_tokens.saturating_sub(payout.amount_tokens);
 +                    accumulated.last_payout = Some(Utc::now());
 +                }
++
 +                // Schedule next occurrence if recurring
 +                if payout.recurring {
 +                    if let Some(next_time) = payout.next_occurrence {
 +                        let mut next_payout = payout.clone();
 +                        next_payout.payout_id = format!("sched_{}_{}", payout.volunteer_id, next_time.timestamp());
 +                        next_payout.scheduled_time = next_time;
 +                        next_payout.created_at = Utc::now();
++
 +                        // Calculate next occurrence after this one
 +                        if let Some(preferences) = self.volunteer_preferences.get(&payout.volunteer_id) {
 +                            next_payout.next_occurrence = self.calculate_next_recurring_time(preferences, next_time).ok();
 +                        }
++
 +                        self.scheduled_payouts.insert(next_time, next_payout);
 +                    }
 +                }
++
 +                let event = PayoutEvent {
 +                    event_id,
 +                    payout_id: payout.payout_id,
 +                    volunteer_id: payout.volunteer_id,
 +                    event_type: PayoutEventType::Scheduled,
 +                    amount: payout.amount_tokens,
 +                    currency: payout.target_currency,
 +                    timestamp: Utc::now(),
 +                    success: true,
 +                    error_message: None,
 +                    payment_reference: Some(payment_reference),
 +                };
++
 +                tracing::info!("Payout processed successfully: {} tokens to {}",
 +                    payout.amount_tokens, payout.volunteer_id);
++
 +                Ok(event)
 +            },
 +            Err(e) => {
 +                let event = PayoutEvent {
 +                    event_id,
 +                    payout_id: payout.payout_id,
 +                    volunteer_id: payout.volunteer_id,
 +                    event_type: PayoutEventType::Scheduled,
 +                    amount: payout.amount_tokens,
 +                    currency: payout.target_currency,
 +                    timestamp: Utc::now(),
 +                    success: false,
 +                    error_message: Some(e.to_string()),
 +                    payment_reference: None,
 +                };
++
 +                tracing::error!("Payout failed: {}", e);
++
 +                // Schedule retry if configured
 +                if self.schedule_config.retry_failed_payouts {
 +                    self.schedule_payout_retry(payout)?;
 +                }
++
 +                Ok(event)
 +            }
 +        }
 +    }
++
 +    /// Check risk controls for payout
 +    fn check_risk_controls(&self, payout: &ScheduledPayout) -> Result<()> {
 +        let risk_controls = &self.policies.risk_controls;
++
 +        // Check daily limit per volunteer
 +        if payout.amount_tokens > risk_controls.max_daily_payout_per_volunteer {
 +            return Err(anyhow::anyhow!("Exceeds daily payout limit per volunteer"));
 +        }
++
 +        // Check total daily payouts
 +        let today = Utc::now().date_naive();
 +        let today_payouts: u64 = self.payout_history
 +            .values()
 +            .flatten()
 +            .filter(|event| event.timestamp.date_naive() == today && event.success)
 +            .map(|event| event.amount)
 +            .sum();
++
 +        if today_payouts + payout.amount_tokens > risk_controls.max_total_daily_payouts {
 +            return Err(anyhow::anyhow!("Exceeds total daily payout limit"));
 +        }
++
 +        // Check for suspicious activity
 +        if risk_controls.fraud_detection_enabled {
 +            let volunteer_history = self.payout_history.get(&payout.volunteer_id);
 +            if let Some(history) = volunteer_history {
 +                if history.len() > 1 {
 +                    let recent_average = history.iter()
 +                        .rev()
 +                        .take(10)
 +                        .map(|e| e.amount)
 +                        .sum::<u64>() / 10.min(history.len()) as u64;
++
 +                    let activity_ratio = payout.amount_tokens as f64 / recent_average as f64;
 +                    if activity_ratio > risk_controls.suspicious_activity_threshold {
 +                        return Err(anyhow::anyhow!("Suspicious activity detected: {}x normal amount", activity_ratio));
 +                    }
 +                }
 +            }
 +        }
++
 +        Ok(())
 +    }
++
 +    /// Schedule retry for failed payout
 +    fn schedule_payout_retry(&mut self, mut payout: ScheduledPayout) -> Result<()> {
 +        let retry_time = Utc::now() + Duration::hours(self.policies.payment_retry_grace_hours as i64);
++
 +        payout.payout_id = format!("retry_{}_{}", payout.volunteer_id, retry_time.timestamp());
 +        payout.scheduled_time = retry_time;
 +        payout.priority = PaymentPriority::Express; // Higher priority for retries
 +        payout.metadata.insert("retry".to_string(), "true".to_string());
++
 +        self.scheduled_payouts.insert(retry_time, payout);
++
 +        Ok(())
 +    }
++
 +    /// Run automated payout processing loop
 +    pub async fn run_automated_processing(
 +        &mut self,
 +        mut payment_processor: PaymentProcessor,
 +        mut earnings_calculator: EarningsCalculator,
 +    ) -> Result<()> {
 +        let mut interval = tokio::time::interval(
 +            TokioDuration::from_secs(self.schedule_config.processing_interval_minutes as u64 * 60)
 +        );
++
 +        loop {
 +            interval.tick().await;
++
 +            // Generate recurring payouts
 +            if let Err(e) = self.generate_recurring_payouts() {
 +                tracing::error!("Failed to generate recurring payouts: {}", e);
 +            }
++
 +            // Process due payouts
 +            match self.process_due_payouts(&mut payment_processor).await {
 +                Ok(events) => {
 +                    if !events.is_empty() {
 +                        tracing::info!("Processed {} payouts", events.len());
 +                    }
 +                },
 +                Err(e) => {
 +                    tracing::error!("Failed to process payouts: {}", e);
 +                }
 +            }
++
 +            // Update accumulated earnings from calculator
 +            // This would be integrated with the earnings calculator in a real implementation
++
 +            tracing::debug!("Payout processing cycle complete");
 +        }
 +    }
++
 +    /// Get payout history for volunteer
 +    pub fn get_payout_history(&self, volunteer_id: &str) -> Vec<&PayoutEvent> {
 +        self.payout_history.get(volunteer_id)
 +            .map(|events| events.iter().collect())
 +            .unwrap_or_default()
 +    }
++
 +    /// Get upcoming payouts for volunteer
 +    pub fn get_upcoming_payouts(&self, volunteer_id: &str) -> Vec<&ScheduledPayout> {
 +        self.scheduled_payouts.values()
 +            .filter(|payout| payout.volunteer_id == volunteer_id)
 +            .collect()
 +    }
++
 +    /// Manual payout trigger
 +    pub async fn trigger_manual_payout(
 +        &mut self,
 +        volunteer_id: &str,
 +        payment_processor: &mut PaymentProcessor,
 +    ) -> Result<PayoutEvent> {
 +        let preferences = self.volunteer_preferences.get(volunteer_id)
 +            .ok_or_else(|| anyhow::anyhow!("Volunteer preferences not found"))?;
++
 +        let accumulated = self.accumulated_earnings.get(volunteer_id)
 +            .ok_or_else(|| anyhow::anyhow!("Accumulated earnings not found"))?;
++
 +        if accumulated.total_tokens < preferences.minimum_threshold {
 +            return Err(anyhow::anyhow!("Below minimum payout threshold"));
 +        }
++
 +        let payout = ScheduledPayout {
 +            payout_id: format!("manual_{}_{}", volunteer_id, Utc::now().timestamp()),
 +            volunteer_id: volunteer_id.to_string(),
 +            amount_tokens: accumulated.total_tokens,
 +            target_currency: preferences.preferred_currency.clone(),
 +            payment_method: preferences.preferred_method.clone(),
 +            recipient_info: preferences.recipient_info.clone(),
 +            scheduled_time: Utc::now(),
 +            created_at: Utc::now(),
 +            priority: PaymentPriority::Express,
 +            recurring: false,
 +            next_occurrence: None,
 +            metadata: HashMap::from([
 +                ("trigger".to_string(), "manual".to_string()),
 +            ]),
 +        };
++
 +        self.process_single_payout(payout, payment_processor).await
 +    }
 +}
++
 +#[cfg(test)]
 +mod tests {
 +    use super::*;
 +    use crate::economics::payment_processor::{PaymentMethod, WalletProvider, RecipientInfo, DigitalWalletInfo};
++
 +    #[test]
 +    fn test_payout_scheduler_creation() {
 +        let scheduler = PayoutScheduler::new();
 +        assert!(scheduler.volunteer_preferences.is_empty());
 +        assert!(scheduler.scheduled_payouts.is_empty());
 +    }
++
 +    #[test]
 +    fn test_earnings_accumulation() {
 +        let mut scheduler = PayoutScheduler::new();
++
 +        // Set up volunteer preferences
 +        let preferences = PayoutPreferences {
 +            volunteer_id: "test_volunteer".to_string(),
 +            frequency: PayoutFrequency::Weekly,
 +            preferred_currency: Currency::USD,
 +            preferred_method: PaymentMethod::DigitalWallet(WalletProvider::PayPal),
 +            recipient_info: RecipientInfo {
 +                wallet_address: None,
 +                bank_account: None,
 +                digital_wallet: Some(DigitalWalletInfo {
 +                    provider: WalletProvider::PayPal,
 +                    wallet_id: "test@example.com".to_string(),
 +                    verified: true,
 +                }),
 +                kyc_verified: true,
 +                tax_info: None,
 +            },
 +            minimum_threshold: 10 * 1_000_000_000_000_000_000, // 10 ZEPH
 +            auto_payout_enabled: true,
 +            timezone: "UTC".to_string(),
 +            preferred_day: Some(Weekday::Fri),
 +            preferred_hour: 14,
 +            priority: PaymentPriority::Standard,
 +            split_payments: None,
 +        };
++
 +        scheduler.set_volunteer_preferences(preferences);
++
 +        // Add earnings
 +        scheduler.add_earnings("test_volunteer", 5 * 1_000_000_000_000_000_000, 0).unwrap();
++
 +        let accumulated = scheduler.accumulated_earnings.get("test_volunteer").unwrap();
 +        assert_eq!(accumulated.total_tokens, 5 * 1_000_000_000_000_000_000);
 +    }
++
 +    #[test]
 +    fn test_threshold_payout_trigger() {
 +        let mut scheduler = PayoutScheduler::new();
++
 +        let preferences = PayoutPreferences {
 +            volunteer_id: "test_volunteer".to_string(),
 +            frequency: PayoutFrequency::Threshold(10 * 1_000_000_000_000_000_000), // 10 ZEPH threshold
 +            preferred_currency: Currency::ZephyrCoin,
 +            preferred_method: PaymentMethod::DigitalWallet(WalletProvider::PayPal),
 +            recipient_info: RecipientInfo {
 +                wallet_address: None,
 +                bank_account: None,
 +                digital_wallet: Some(DigitalWalletInfo {
 +                    provider: WalletProvider::PayPal,
 +                    wallet_id: "test@example.com".to_string(),
 +                    verified: true,
 +                }),
 +                kyc_verified: true,
 +                tax_info: None,
 +            },
 +            minimum_threshold: 10 * 1_000_000_000_000_000_000,
 +            auto_payout_enabled: true,
 +            timezone: "UTC".to_string(),
 +            preferred_day: None,
 +            preferred_hour: 12,
 +            priority: PaymentPriority::Standard,
 +            split_payments: None,
 +        };
++
 +        scheduler.set_volunteer_preferences(preferences);
++
 +        // Add earnings that exceed threshold
 +        scheduler.add_earnings("test_volunteer", 15 * 1_000_000_000_000_000_000, 0).unwrap();
++
 +        // Should have scheduled a payout
 +        assert!(!scheduler.scheduled_payouts.is_empty());
 +    }
 +}

src/economics/performance_rewards.rsadded

1034 lines changed — click to load

 +//! Performance-Based Rewards System
 +//!
 +//! Advanced reward system that incentivizes excellence and network contribution
++
 +use anyhow::Result;
 +use serde::{Deserialize, Serialize};
 +use std::collections::{HashMap, VecDeque};
 +use chrono::{DateTime, Utc, Duration};
++
 +use super::token_model::{RewardReason, NetworkHealthMetrics};
 +use super::earnings_calculator::{VolunteerMetrics, GeographicRegion, ConnectionQuality};
++
 +/// Performance-based rewards manager
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct PerformanceRewardsSystem {
 +    /// Performance scoring configuration
 +    pub scoring_config: ScoringConfiguration,
 +    /// Reward tier definitions
 +    pub reward_tiers: Vec<RewardTier>,
 +    /// Achievement system
 +    pub achievements: HashMap<String, Achievement>,
 +    /// Volunteer performance tracking
 +    pub volunteer_scores: HashMap<String, PerformanceScore>,
 +    /// Leaderboards and competitions
 +    pub leaderboards: HashMap<String, Leaderboard>,
 +    /// Special events and challenges
 +    pub active_challenges: HashMap<String, Challenge>,
 +    /// Reward multipliers and boosts
 +    pub active_multipliers: HashMap<String, RewardMultiplier>,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct ScoringConfiguration {
 +    /// Weight factors for different metrics
 +    pub uptime_weight: f64,
 +    pub speed_weight: f64,
 +    pub reliability_weight: f64,
 +    pub longevity_weight: f64,
 +    pub contribution_weight: f64,
 +    pub diversity_weight: f64,
++
 +    /// Performance windows
 +    pub daily_window_hours: u32,
 +    pub weekly_window_days: u32,
 +    pub monthly_window_days: u32,
++
 +    /// Scoring thresholds
 +    pub excellent_threshold: f64,
 +    pub good_threshold: f64,
 +    pub average_threshold: f64,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct RewardTier {
 +    pub tier_name: String,
 +    pub min_score: f64,
 +    pub max_score: f64,
 +    pub multiplier: f64,
 +    pub badge_icon: String,
 +    pub color: String,
 +    pub benefits: Vec<TierBenefit>,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct TierBenefit {
 +    pub benefit_type: BenefitType,
 +    pub value: f64,
 +    pub description: String,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub enum BenefitType {
 +    EarningsMultiplier,
 +    PrioritySupport,
 +    EarlyAccess,
 +    ReducedFees,
 +    BonusPayouts,
 +    ExclusiveFeatures,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct Achievement {
 +    pub achievement_id: String,
 +    pub name: String,
 +    pub description: String,
 +    pub icon: String,
 +    pub rarity: AchievementRarity,
 +    pub requirements: AchievementRequirements,
 +    pub reward_tokens: u64,
 +    pub reward_multiplier: f64,
 +    pub one_time: bool,
 +    pub unlocked_by: Vec<String>, // volunteer IDs
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub enum AchievementRarity {
 +    Common,
 +    Uncommon,
 +    Rare,
 +    Epic,
 +    Legendary,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct AchievementRequirements {
 +    pub min_uptime_percentage: Option<f64>,
 +    pub min_storage_gb: Option<u64>,
 +    pub min_speed_mbps: Option<f64>,
 +    pub min_reliability_score: Option<f64>,
 +    pub min_days_active: Option<u32>,
 +    pub geographic_requirements: Option<Vec<GeographicRegion>>,
 +    pub network_contribution: Option<f64>,
 +    pub custom_conditions: Vec<CustomCondition>,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct CustomCondition {
 +    pub condition_type: String,
 +    pub target_value: f64,
 +    pub description: String,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct PerformanceScore {
 +    pub volunteer_id: String,
 +    pub overall_score: f64,
 +    pub component_scores: ComponentScores,
 +    pub tier: String,
 +    pub rank: u32,
 +    pub percentile: f64,
 +    pub trend: ScoreTrend,
 +    pub last_updated: DateTime<Utc>,
 +    pub achievements: Vec<String>,
 +    pub active_multipliers: Vec<String>,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct ComponentScores {
 +    pub uptime_score: f64,
 +    pub speed_score: f64,
 +    pub reliability_score: f64,
 +    pub longevity_score: f64,
 +    pub contribution_score: f64,
 +    pub diversity_score: f64,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub enum ScoreTrend {
 +    Improving,
 +    Stable,
 +    Declining,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct Leaderboard {
 +    pub leaderboard_id: String,
 +    pub name: String,
 +    pub description: String,
 +    pub metric: LeaderboardMetric,
 +    pub timeframe: LeaderboardTimeframe,
 +    pub entries: Vec<LeaderboardEntry>,
 +    pub rewards: LeaderboardRewards,
 +    pub last_updated: DateTime<Utc>,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub enum LeaderboardMetric {
 +    OverallScore,
 +    Uptime,
 +    Speed,
 +    Reliability,
 +    StorageProvided,
 +    EarningsPerGB,
 +    NetworkContribution,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub enum LeaderboardTimeframe {
 +    Daily,
 +    Weekly,
 +    Monthly,
 +    AllTime,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct LeaderboardEntry {
 +    pub rank: u32,
 +    pub volunteer_id: String,
 +    pub display_name: String,
 +    pub value: f64,
 +    pub tier: String,
 +    pub change_from_previous: i32,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct LeaderboardRewards {
 +    pub top_1_reward: u64,
 +    pub top_5_reward: u64,
 +    pub top_10_reward: u64,
 +    pub top_50_reward: u64,
 +    pub participation_reward: u64,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct Challenge {
 +    pub challenge_id: String,
 +    pub name: String,
 +    pub description: String,
 +    pub challenge_type: ChallengeType,
 +    pub start_time: DateTime<Utc>,
 +    pub end_time: DateTime<Utc>,
 +    pub requirements: ChallengeRequirements,
 +    pub rewards: ChallengeRewards,
 +    pub participants: HashMap<String, ChallengeProgress>,
 +    pub max_participants: Option<u32>,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub enum ChallengeType {
 +    UptimeChallenge,
 +    SpeedChallenge,
 +    StorageChallenge,
 +    CommunityChallenge,
 +    SpecialEvent,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct ChallengeRequirements {
 +    pub target_metric: String,
 +    pub target_value: f64,
 +    pub duration_days: u32,
 +    pub min_participation_days: u32,
 +    pub geographic_restrictions: Option<Vec<GeographicRegion>>,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct ChallengeRewards {
 +    pub completion_reward: u64,
 +    pub milestone_rewards: Vec<MilestoneReward>,
 +    pub leaderboard_rewards: Option<LeaderboardRewards>,
 +    pub exclusive_achievement: Option<String>,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct MilestoneReward {
 +    pub milestone_percentage: f64,
 +    pub reward_tokens: u64,
 +    pub title: String,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct ChallengeProgress {
 +    pub volunteer_id: String,
 +    pub joined_at: DateTime<Utc>,
 +    pub current_progress: f64,
 +    pub milestones_achieved: Vec<u32>,
 +    pub daily_contributions: HashMap<String, f64>, // date -> contribution
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct RewardMultiplier {
 +    pub multiplier_id: String,
 +    pub name: String,
 +    pub description: String,
 +    pub multiplier_value: f64,
 +    pub applicable_to: Vec<String>, // volunteer IDs or "all"
 +    pub start_time: DateTime<Utc>,
 +    pub end_time: DateTime<Utc>,
 +    pub conditions: MultiplierConditions,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct MultiplierConditions {
 +    pub min_tier: Option<String>,
 +    pub geographic_regions: Option<Vec<GeographicRegion>>,
 +    pub time_of_day: Option<(u8, u8)>, // (start_hour, end_hour)
 +    pub min_performance_score: Option<f64>,
 +    pub network_health_threshold: Option<f64>,
 +}
++
 +impl Default for ScoringConfiguration {
 +    fn default() -> Self {
 +        Self {
 +            uptime_weight: 0.25,
 +            speed_weight: 0.20,
 +            reliability_weight: 0.20,
 +            longevity_weight: 0.15,
 +            contribution_weight: 0.15,
 +            diversity_weight: 0.05,
 +            daily_window_hours: 24,
 +            weekly_window_days: 7,
 +            monthly_window_days: 30,
 +            excellent_threshold: 90.0,
 +            good_threshold: 75.0,
 +            average_threshold: 60.0,
 +        }
 +    }
 +}
++
 +impl PerformanceRewardsSystem {
 +    /// Create new performance rewards system
 +    pub fn new() -> Self {
 +        let mut system = Self {
 +            scoring_config: ScoringConfiguration::default(),
 +            reward_tiers: Vec::new(),
 +            achievements: HashMap::new(),
 +            volunteer_scores: HashMap::new(),
 +            leaderboards: HashMap::new(),
 +            active_challenges: HashMap::new(),
 +            active_multipliers: HashMap::new(),
 +        };
++
 +        system.initialize_reward_tiers();
 +        system.initialize_achievements();
 +        system.initialize_leaderboards();
++
 +        system
 +    }
++
 +    /// Initialize reward tiers
 +    fn initialize_reward_tiers(&mut self) {
 +        self.reward_tiers = vec![
 +            RewardTier {
 +                tier_name: "Diamond".to_string(),
 +                min_score: 95.0,
 +                max_score: 100.0,
 +                multiplier: 2.0,
 +                badge_icon: "💎".to_string(),
 +                color: "#B9F2FF".to_string(),
 +                benefits: vec![
 +                    TierBenefit {
 +                        benefit_type: BenefitType::EarningsMultiplier,
 +                        value: 2.0,
 +                        description: "2x earnings multiplier".to_string(),
 +                    },
 +                    TierBenefit {
 +                        benefit_type: BenefitType::PrioritySupport,
 +                        value: 1.0,
 +                        description: "Priority customer support".to_string(),
 +                    },
 +                    TierBenefit {
 +                        benefit_type: BenefitType::ReducedFees,
 +                        value: 0.5,
 +                        description: "50% reduced fees".to_string(),
 +                    },
 +                ],
 +            },
 +            RewardTier {
 +                tier_name: "Platinum".to_string(),
 +                min_score: 85.0,
 +                max_score: 95.0,
 +                multiplier: 1.7,
 +                badge_icon: "🏆".to_string(),
 +                color: "#E5E4E2".to_string(),
 +                benefits: vec![
 +                    TierBenefit {
 +                        benefit_type: BenefitType::EarningsMultiplier,
 +                        value: 1.7,
 +                        description: "1.7x earnings multiplier".to_string(),
 +                    },
 +                    TierBenefit {
 +                        benefit_type: BenefitType::EarlyAccess,
 +                        value: 1.0,
 +                        description: "Early access to new features".to_string(),
 +                    },
 +                ],
 +            },
 +            RewardTier {
 +                tier_name: "Gold".to_string(),
 +                min_score: 75.0,
 +                max_score: 85.0,
 +                multiplier: 1.4,
 +                badge_icon: "🥇".to_string(),
 +                color: "#FFD700".to_string(),
 +                benefits: vec![
 +                    TierBenefit {
 +                        benefit_type: BenefitType::EarningsMultiplier,
 +                        value: 1.4,
 +                        description: "1.4x earnings multiplier".to_string(),
 +                    },
 +                    TierBenefit {
 +                        benefit_type: BenefitType::BonusPayouts,
 +                        value: 0.1,
 +                        description: "10% bonus payouts".to_string(),
 +                    },
 +                ],
 +            },
 +            RewardTier {
 +                tier_name: "Silver".to_string(),
 +                min_score: 60.0,
 +                max_score: 75.0,
 +                multiplier: 1.2,
 +                badge_icon: "🥈".to_string(),
 +                color: "#C0C0C0".to_string(),
 +                benefits: vec![
 +                    TierBenefit {
 +                        benefit_type: BenefitType::EarningsMultiplier,
 +                        value: 1.2,
 +                        description: "1.2x earnings multiplier".to_string(),
 +                    },
 +                ],
 +            },
 +            RewardTier {
 +                tier_name: "Bronze".to_string(),
 +                min_score: 40.0,
 +                max_score: 60.0,
 +                multiplier: 1.0,
 +                badge_icon: "🥉".to_string(),
 +                color: "#CD7F32".to_string(),
 +                benefits: vec![
 +                    TierBenefit {
 +                        benefit_type: BenefitType::EarningsMultiplier,
 +                        value: 1.0,
 +                        description: "Standard earnings".to_string(),
 +                    },
 +                ],
 +            },
 +            RewardTier {
 +                tier_name: "Newcomer".to_string(),
 +                min_score: 0.0,
 +                max_score: 40.0,
 +                multiplier: 0.8,
 +                badge_icon: "🌱".to_string(),
 +                color: "#90EE90".to_string(),
 +                benefits: vec![
 +                    TierBenefit {
 +                        benefit_type: BenefitType::EarningsMultiplier,
 +                        value: 0.8,
 +                        description: "Learning bonus - 80% earnings while improving".to_string(),
 +                    },
 +                ],
 +            },
 +        ];
 +    }
++
 +    /// Initialize achievements
 +    fn initialize_achievements(&mut self) {
 +        let achievements = vec![
 +            Achievement {
 +                achievement_id: "first_week".to_string(),
 +                name: "First Week Warrior".to_string(),
 +                description: "Complete your first week as a volunteer".to_string(),
 +                icon: "🎯".to_string(),
 +                rarity: AchievementRarity::Common,
 +                requirements: AchievementRequirements {
 +                    min_days_active: Some(7),
 +                    min_uptime_percentage: Some(80.0),
 +                    ..Default::default()
 +                },
 +                reward_tokens: 5 * 1_000_000_000_000_000_000, // 5 ZEPH
 +                reward_multiplier: 1.1,
 +                one_time: true,
 +                unlocked_by: Vec::new(),
 +            },
 +            Achievement {
 +                achievement_id: "speed_demon".to_string(),
 +                name: "Speed Demon".to_string(),
 +                description: "Achieve transfer speeds over 100 Mbps".to_string(),
 +                icon: "⚡".to_string(),
 +                rarity: AchievementRarity::Uncommon,
 +                requirements: AchievementRequirements {
 +                    min_speed_mbps: Some(100.0),
 +                    min_reliability_score: Some(95.0),
 +                    ..Default::default()
 +                },
 +                reward_tokens: 10 * 1_000_000_000_000_000_000, // 10 ZEPH
 +                reward_multiplier: 1.2,
 +                one_time: false,
 +                unlocked_by: Vec::new(),
 +            },
 +            Achievement {
 +                achievement_id: "reliability_champion".to_string(),
 +                name: "Reliability Champion".to_string(),
 +                description: "Maintain 99.9% uptime for 30 days".to_string(),
 +                icon: "🛡️".to_string(),
 +                rarity: AchievementRarity::Rare,
 +                requirements: AchievementRequirements {
 +                    min_uptime_percentage: Some(99.9),
 +                    min_days_active: Some(30),
 +                    min_reliability_score: Some(99.0),
 +                    ..Default::default()
 +                },
 +                reward_tokens: 25 * 1_000_000_000_000_000_000, // 25 ZEPH
 +                reward_multiplier: 1.5,
 +                one_time: false,
 +                unlocked_by: Vec::new(),
 +            },
 +            Achievement {
 +                achievement_id: "global_pioneer".to_string(),
 +                name: "Global Pioneer".to_string(),
 +                description: "First volunteer in an underrepresented region".to_string(),
 +                icon: "🌍".to_string(),
 +                rarity: AchievementRarity::Epic,
 +                requirements: AchievementRequirements {
 +                    geographic_requirements: Some(vec![GeographicRegion::Rare]),
 +                    min_days_active: Some(7),
 +                    ..Default::default()
 +                },
 +                reward_tokens: 50 * 1_000_000_000_000_000_000, // 50 ZEPH
 +                reward_multiplier: 2.0,
 +                one_time: true,
 +                unlocked_by: Vec::new(),
 +            },
 +            Achievement {
 +                achievement_id: "the_vault".to_string(),
 +                name: "The Vault".to_string(),
 +                description: "Provide 10TB of storage capacity".to_string(),
 +                icon: "🏛️".to_string(),
 +                rarity: AchievementRarity::Legendary,
 +                requirements: AchievementRequirements {
 +                    min_storage_gb: Some(10_000),
 +                    min_uptime_percentage: Some(95.0),
 +                    min_days_active: Some(90),
 +                    ..Default::default()
 +                },
 +                reward_tokens: 100 * 1_000_000_000_000_000_000, // 100 ZEPH
 +                reward_multiplier: 3.0,
 +                one_time: true,
 +                unlocked_by: Vec::new(),
 +            },
 +        ];
++
 +        for achievement in achievements {
 +            self.achievements.insert(achievement.achievement_id.clone(), achievement);
 +        }
 +    }
++
 +    /// Initialize leaderboards
 +    fn initialize_leaderboards(&mut self) {
 +        let leaderboards = vec![
 +            Leaderboard {
 +                leaderboard_id: "overall_weekly".to_string(),
 +                name: "Weekly Champions".to_string(),
 +                description: "Top performers this week".to_string(),
 +                metric: LeaderboardMetric::OverallScore,
 +                timeframe: LeaderboardTimeframe::Weekly,
 +                entries: Vec::new(),
 +                rewards: LeaderboardRewards {
 +                    top_1_reward: 50 * 1_000_000_000_000_000_000,
 +                    top_5_reward: 20 * 1_000_000_000_000_000_000,
 +                    top_10_reward: 10 * 1_000_000_000_000_000_000,
 +                    top_50_reward: 5 * 1_000_000_000_000_000_000,
 +                    participation_reward: 1 * 1_000_000_000_000_000_000,
 +                },
 +                last_updated: Utc::now(),
 +            },
 +            Leaderboard {
 +                leaderboard_id: "speed_monthly".to_string(),
 +                name: "Speed Masters".to_string(),
 +                description: "Fastest transfer speeds this month".to_string(),
 +                metric: LeaderboardMetric::Speed,
 +                timeframe: LeaderboardTimeframe::Monthly,
 +                entries: Vec::new(),
 +                rewards: LeaderboardRewards {
 +                    top_1_reward: 100 * 1_000_000_000_000_000_000,
 +                    top_5_reward: 40 * 1_000_000_000_000_000_000,
 +                    top_10_reward: 20 * 1_000_000_000_000_000_000,
 +                    top_50_reward: 10 * 1_000_000_000_000_000_000,
 +                    participation_reward: 2 * 1_000_000_000_000_000_000,
 +                },
 +                last_updated: Utc::now(),
 +            },
 +        ];
++
 +        for leaderboard in leaderboards {
 +            self.leaderboards.insert(leaderboard.leaderboard_id.clone(), leaderboard);
 +        }
 +    }
++
 +    /// Calculate comprehensive performance score
 +    pub fn calculate_performance_score(&self, metrics: &VolunteerMetrics, network_metrics: &NetworkHealthMetrics) -> Result<PerformanceScore> {
 +        let config = &self.scoring_config;
++
 +        // Calculate component scores
 +        let uptime_score = self.calculate_uptime_score(metrics)?;
 +        let speed_score = self.calculate_speed_score(metrics)?;
 +        let reliability_score = self.calculate_reliability_score(metrics)?;
 +        let longevity_score = self.calculate_longevity_score(metrics)?;
 +        let contribution_score = self.calculate_contribution_score(metrics, network_metrics)?;
 +        let diversity_score = self.calculate_diversity_score(metrics)?;
++
 +        let component_scores = ComponentScores {
 +            uptime_score,
 +            speed_score,
 +            reliability_score,
 +            longevity_score,
 +            contribution_score,
 +            diversity_score,
 +        };
++
 +        // Calculate weighted overall score
 +        let overall_score = uptime_score * config.uptime_weight
 +            + speed_score * config.speed_weight
 +            + reliability_score * config.reliability_weight
 +            + longevity_score * config.longevity_weight
 +            + contribution_score * config.contribution_weight
 +            + diversity_score * config.diversity_weight;
++
 +        // Determine tier
 +        let tier = self.determine_tier(overall_score);
++
 +        // Calculate trend (simplified - would use historical data)
 +        let trend = ScoreTrend::Stable;
++
 +        // Get achievements
 +        let achievements = self.check_achievements(metrics)?;
++
 +        // Get active multipliers
 +        let active_multipliers = self.get_active_multipliers(&metrics.volunteer_id);
++
 +        Ok(PerformanceScore {
 +            volunteer_id: metrics.volunteer_id.clone(),
 +            overall_score,
 +            component_scores,
 +            tier,
 +            rank: 0, // Would be calculated during ranking
 +            percentile: 0.0, // Would be calculated during ranking
 +            trend,
 +            last_updated: Utc::now(),
 +            achievements,
 +            active_multipliers,
 +        })
 +    }
++
 +    /// Calculate uptime score
 +    fn calculate_uptime_score(&self, metrics: &VolunteerMetrics) -> Result<f64> {
 +        // Perfect score at 99.9% uptime, linear scaling below
 +        let uptime = metrics.uptime_percentage;
 +        let score = if uptime >= 99.9 {
 +            100.0
 +        } else if uptime >= 95.0 {
 +            80.0 + (uptime - 95.0) * 4.0 // 80-100 range for 95-99.9%
 +        } else if uptime >= 80.0 {
 +            50.0 + (uptime - 80.0) * 2.0 // 50-80 range for 80-95%
 +        } else {
 +            uptime * 0.625 // 0-50 range for 0-80%
 +        };
++
 +        Ok(score.min(100.0))
 +    }
++
 +    /// Calculate speed score
 +    fn calculate_speed_score(&self, metrics: &VolunteerMetrics) -> Result<f64> {
 +        let speed = metrics.transfer_speed_mbps;
 +        let score = if speed >= 100.0 {
 +            100.0
 +        } else if speed >= 50.0 {
 +            75.0 + (speed - 50.0) * 0.5 // 75-100 for 50-100 Mbps
 +        } else if speed >= 10.0 {
 +            40.0 + (speed - 10.0) * 0.875 // 40-75 for 10-50 Mbps
 +        } else {
 +            speed * 4.0 // 0-40 for 0-10 Mbps
 +        };
++
 +        Ok(score.min(100.0))
 +    }
++
 +    /// Calculate reliability score
 +    fn calculate_reliability_score(&self, metrics: &VolunteerMetrics) -> Result<f64> {
 +        let total_transfers = metrics.successful_transfers + metrics.failed_transfers;
 +        if total_transfers == 0 {
 +            return Ok(100.0); // New volunteers get perfect score
 +        }
++
 +        let success_rate = metrics.successful_transfers as f64 / total_transfers as f64;
 +        let response_time_factor = if metrics.response_time_ms <= 100 {
 +            1.0
 +        } else if metrics.response_time_ms <= 500 {
 +            0.9
 +        } else {
 +            0.8
 +        };
++
 +        let score = success_rate * 100.0 * response_time_factor;
 +        Ok(score.min(100.0))
 +    }
++
 +    /// Calculate longevity score
 +    fn calculate_longevity_score(&self, metrics: &VolunteerMetrics) -> Result<f64> {
 +        let days_active = (Utc::now() - metrics.joined_at).num_days();
 +        let score = if days_active >= 365 {
 +            100.0
 +        } else if days_active >= 90 {
 +            70.0 + (days_active - 90) as f64 * 30.0 / 275.0
 +        } else if days_active >= 30 {
 +            40.0 + (days_active - 30) as f64 * 30.0 / 60.0
 +        } else if days_active >= 7 {
 +            20.0 + (days_active - 7) as f64 * 20.0 / 23.0
 +        } else {
 +            days_active as f64 * 20.0 / 7.0
 +        };
++
 +        Ok(score.min(100.0))
 +    }
++
 +    /// Calculate contribution score
 +    fn calculate_contribution_score(&self, metrics: &VolunteerMetrics, network_metrics: &NetworkHealthMetrics) -> Result<f64> {
 +        if network_metrics.total_capacity_gb == 0 {
 +            return Ok(0.0);
 +        }
++
 +        let contribution_percentage = metrics.total_storage_gb as f64 / network_metrics.total_capacity_gb as f64 * 100.0;
 +        let utilization_factor = if metrics.total_storage_gb > 0 {
 +            metrics.used_storage_gb as f64 / metrics.total_storage_gb as f64
 +        } else {
 +            0.0
 +        };
++
 +        // Score based on both absolute contribution and utilization
 +        let base_score = contribution_percentage * 1000.0; // Scale up
 +        let utilization_bonus = utilization_factor * 20.0; // Up to 20 point bonus
++
 +        let score = (base_score + utilization_bonus).min(100.0);
 +        Ok(score)
 +    }
++
 +    /// Calculate diversity score
 +    fn calculate_diversity_score(&self, metrics: &VolunteerMetrics) -> Result<f64> {
 +        let region_bonus = match metrics.geographic_region {
 +            GeographicRegion::Rare => 100.0,
 +            GeographicRegion::Africa => 80.0,
 +            GeographicRegion::SouthAmerica => 70.0,
 +            GeographicRegion::Oceania => 70.0,
 +            GeographicRegion::Asia => 60.0,
 +            GeographicRegion::Europe => 40.0,
 +            GeographicRegion::NorthAmerica => 30.0,
 +        };
++
 +        let connection_bonus = match metrics.connection_quality {
 +            ConnectionQuality::Excellent => 20.0,
 +            ConnectionQuality::Good => 15.0,
 +            ConnectionQuality::Fair => 10.0,
 +            ConnectionQuality::Poor => 5.0,
 +        };
++
 +        Ok((region_bonus + connection_bonus).min(100.0))
 +    }
++
 +    /// Determine performance tier
 +    fn determine_tier(&self, score: f64) -> String {
 +        for tier in &self.reward_tiers {
 +            if score >= tier.min_score && score <= tier.max_score {
 +                return tier.tier_name.clone();
 +            }
 +        }
 +        "Unranked".to_string()
 +    }
++
 +    /// Check for new achievements
 +    fn check_achievements(&self, metrics: &VolunteerMetrics) -> Result<Vec<String>> {
 +        let mut unlocked_achievements = Vec::new();
++
 +        for (achievement_id, achievement) in &self.achievements {
 +            if achievement.unlocked_by.contains(&metrics.volunteer_id) && achievement.one_time {
 +                continue; // Already unlocked
 +            }
++
 +            let mut meets_requirements = true;
 +            let reqs = &achievement.requirements;
++
 +            // Check uptime requirement
 +            if let Some(min_uptime) = reqs.min_uptime_percentage {
 +                if metrics.uptime_percentage < min_uptime {
 +                    meets_requirements = false;
 +                }
 +            }
++
 +            // Check storage requirement
 +            if let Some(min_storage) = reqs.min_storage_gb {
 +                if metrics.total_storage_gb < min_storage {
 +                    meets_requirements = false;
 +                }
 +            }
++
 +            // Check speed requirement
 +            if let Some(min_speed) = reqs.min_speed_mbps {
 +                if metrics.transfer_speed_mbps < min_speed {
 +                    meets_requirements = false;
 +                }
 +            }
++
 +            // Check reliability requirement
 +            if let Some(min_reliability) = reqs.min_reliability_score {
 +                if metrics.reliability_score < min_reliability {
 +                    meets_requirements = false;
 +                }
 +            }
++
 +            // Check days active requirement
 +            if let Some(min_days) = reqs.min_days_active {
 +                let days_active = (Utc::now() - metrics.joined_at).num_days();
 +                if days_active < min_days as i64 {
 +                    meets_requirements = false;
 +                }
 +            }
++
 +            // Check geographic requirements
 +            if let Some(ref required_regions) = reqs.geographic_requirements {
 +                if !required_regions.contains(&metrics.geographic_region) {
 +                    meets_requirements = false;
 +                }
 +            }
++
 +            if meets_requirements {
 +                unlocked_achievements.push(achievement_id.clone());
 +            }
 +        }
++
 +        Ok(unlocked_achievements)
 +    }
++
 +    /// Get active multipliers for volunteer
 +    fn get_active_multipliers(&self, volunteer_id: &str) -> Vec<String> {
 +        let now = Utc::now();
++
 +        self.active_multipliers
 +            .values()
 +            .filter(|multiplier| {
 +                // Check if still active
 +                if now < multiplier.start_time || now > multiplier.end_time {
 +                    return false;
 +                }
++
 +                // Check if applies to this volunteer
 +                multiplier.applicable_to.contains(&"all".to_string()) ||
 +                multiplier.applicable_to.contains(volunteer_id)
 +            })
 +            .map(|multiplier| multiplier.multiplier_id.clone())
 +            .collect()
 +    }
++
 +    /// Update volunteer score
 +    pub fn update_volunteer_score(&mut self, volunteer_id: String, score: PerformanceScore) {
 +        self.volunteer_scores.insert(volunteer_id, score);
 +    }
++
 +    /// Calculate reward multiplier for volunteer
 +    pub fn calculate_reward_multiplier(&self, volunteer_id: &str) -> f64 {
 +        let base_multiplier = if let Some(score) = self.volunteer_scores.get(volunteer_id) {
 +            // Get tier multiplier
 +            let tier_multiplier = self.reward_tiers
 +                .iter()
 +                .find(|tier| tier.tier_name == score.tier)
 +                .map(|tier| tier.multiplier)
 +                .unwrap_or(1.0);
++
 +            // Add achievement multipliers
 +            let achievement_multiplier: f64 = score.achievements
 +                .iter()
 +                .filter_map(|achievement_id| self.achievements.get(achievement_id))
 +                .map(|achievement| achievement.reward_multiplier - 1.0)
 +                .sum::<f64>() + 1.0;
++
 +            tier_multiplier * achievement_multiplier
 +        } else {
 +            1.0
 +        };
++
 +        // Apply active multipliers
 +        let active_multiplier: f64 = self.active_multipliers
 +            .values()
 +            .filter(|multiplier| {
 +                let now = Utc::now();
 +                now >= multiplier.start_time && now <= multiplier.end_time &&
 +                (multiplier.applicable_to.contains(&"all".to_string()) ||
 +                 multiplier.applicable_to.contains(volunteer_id))
 +            })
 +            .map(|multiplier| multiplier.multiplier_value)
 +            .product();
++
 +        base_multiplier * active_multiplier
 +    }
++
 +    /// Update leaderboards
 +    pub fn update_leaderboards(&mut self) -> Result<()> {
 +        for leaderboard in self.leaderboards.values_mut() {
 +            let mut entries: Vec<LeaderboardEntry> = self.volunteer_scores
 +                .values()
 +                .map(|score| {
 +                    let value = match leaderboard.metric {
 +                        LeaderboardMetric::OverallScore => score.overall_score,
 +                        LeaderboardMetric::Uptime => score.component_scores.uptime_score,
 +                        LeaderboardMetric::Speed => score.component_scores.speed_score,
 +                        LeaderboardMetric::Reliability => score.component_scores.reliability_score,
 +                        LeaderboardMetric::StorageProvided => score.component_scores.contribution_score,
 +                        LeaderboardMetric::EarningsPerGB => score.overall_score, // Simplified
 +                        LeaderboardMetric::NetworkContribution => score.component_scores.contribution_score,
 +                    };
++
 +                    LeaderboardEntry {
 +                        rank: 0, // Will be set after sorting
 +                        volunteer_id: score.volunteer_id.clone(),
 +                        display_name: format!("Volunteer_{}", &score.volunteer_id[..8]),
 +                        value,
 +                        tier: score.tier.clone(),
 +                        change_from_previous: 0, // Would track changes
 +                    }
 +                })
 +                .collect();
++
 +            // Sort by value (descending)
 +            entries.sort_by(|a, b| b.value.partial_cmp(&a.value).unwrap_or(std::cmp::Ordering::Equal));
++
 +            // Assign ranks
 +            for (index, entry) in entries.iter_mut().enumerate() {
 +                entry.rank = (index + 1) as u32;
 +            }
++
 +            leaderboard.entries = entries;
 +            leaderboard.last_updated = Utc::now();
 +        }
++
 +        Ok(())
 +    }
++
 +    /// Create new challenge
 +    pub fn create_challenge(&mut self, challenge: Challenge) -> Result<()> {
 +        let challenge_id = challenge.challenge_id.clone();
 +        self.active_challenges.insert(challenge_id, challenge);
 +        Ok(())
 +    }
++
 +    /// Add reward multiplier
 +    pub fn add_reward_multiplier(&mut self, multiplier: RewardMultiplier) -> Result<()> {
 +        let multiplier_id = multiplier.multiplier_id.clone();
 +        self.active_multipliers.insert(multiplier_id, multiplier);
 +        Ok(())
 +    }
++
 +    /// Get volunteer's current tier and benefits
 +    pub fn get_volunteer_tier_info(&self, volunteer_id: &str) -> Option<(String, Vec<TierBenefit>)> {
 +        let score = self.volunteer_scores.get(volunteer_id)?;
 +        let tier = self.reward_tiers
 +            .iter()
 +            .find(|t| t.tier_name == score.tier)?;
++
 +        Some((tier.tier_name.clone(), tier.benefits.clone()))
 +    }
++
 +    /// Get leaderboard for display
 +    pub fn get_leaderboard(&self, leaderboard_id: &str) -> Option<&Leaderboard> {
 +        self.leaderboards.get(leaderboard_id)
 +    }
 +}
++
 +impl Default for AchievementRequirements {
 +    fn default() -> Self {
 +        Self {
 +            min_uptime_percentage: None,
 +            min_storage_gb: None,
 +            min_speed_mbps: None,
 +            min_reliability_score: None,
 +            min_days_active: None,
 +            geographic_requirements: None,
 +            network_contribution: None,
 +            custom_conditions: Vec::new(),
 +        }
 +    }
 +}
++
 +#[cfg(test)]
 +mod tests {
 +    use super::*;
++
 +    #[test]
 +    fn test_performance_rewards_system() {
 +        let system = PerformanceRewardsSystem::new();
 +        assert!(!system.reward_tiers.is_empty());
 +        assert!(!system.achievements.is_empty());
 +        assert!(!system.leaderboards.is_empty());
 +    }
++
 +    #[test]
 +    fn test_score_calculation() {
 +        let system = PerformanceRewardsSystem::new();
++
 +        let metrics = VolunteerMetrics {
 +            volunteer_id: "test_volunteer".to_string(),
 +            total_storage_gb: 100,
 +            available_storage_gb: 50,
 +            used_storage_gb: 50,
 +            uptime_hours_24h: 24.0,
 +            uptime_percentage: 99.5,
 +            response_time_ms: 50,
 +            transfer_speed_mbps: 100.0,
 +            successful_transfers: 1000,
 +            failed_transfers: 5,
 +            geographic_region: GeographicRegion::Europe,
 +            connection_quality: ConnectionQuality::Excellent,
 +            reliability_score: 99.5,
 +            last_seen: Utc::now(),
 +            joined_at: Utc::now() - Duration::days(365),
 +        };
++
 +        let network_metrics = NetworkHealthMetrics {
 +            total_capacity_gb: 10000,
 +            active_volunteers: 100,
 +            utilization_rate: 75.0,
 +            average_uptime: 95.0,
 +            geographic_diversity: 70.0,
 +            data_durability: 99.9,
 +        };
++
 +        let score = system.calculate_performance_score(&metrics, &network_metrics).unwrap();
 +        assert!(score.overall_score > 80.0); // Should be high-performing
 +        assert_eq!(score.tier, "Platinum"); // Should be in a high tier
 +    }
++
 +    #[test]
 +    fn test_achievement_checking() {
 +        let system = PerformanceRewardsSystem::new();
++
 +        let high_speed_metrics = VolunteerMetrics {
 +            volunteer_id: "speed_test".to_string(),
 +            total_storage_gb: 100,
 +            available_storage_gb: 0,
 +            used_storage_gb: 100,
 +            uptime_hours_24h: 24.0,
 +            uptime_percentage: 99.0,
 +            response_time_ms: 25,
 +            transfer_speed_mbps: 150.0,
 +            successful_transfers: 1000,
 +            failed_transfers: 1,
 +            geographic_region: GeographicRegion::NorthAmerica,
 +            connection_quality: ConnectionQuality::Excellent,
 +            reliability_score: 99.9,
 +            last_seen: Utc::now(),
 +            joined_at: Utc::now() - Duration::days(30),
 +        };
++
 +        let achievements = system.check_achievements(&high_speed_metrics).unwrap();
 +        assert!(achievements.contains(&"speed_demon".to_string()));
 +    }
 +}

src/economics/token_model.rsadded

 +//! ZephyrCoin Token Economics Model
 +//!
 +//! Sustainable token supply with network-health-based mechanisms
++
 +use anyhow::Result;
 +use serde::{Deserialize, Serialize};
 +use std::collections::HashMap;
 +use chrono::{DateTime, Utc, Duration};
++
 +/// ZephyrCoin token economics configuration
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct TokenEconomics {
 +    /// Total supply cap (21M tokens, Bitcoin-inspired scarcity)
 +    pub max_supply: u64,
 +    /// Current circulating supply
 +    pub circulating_supply: u64,
 +    /// Tokens reserved for ecosystem development (10%)
 +    pub ecosystem_reserve: u64,
 +    /// Tokens allocated for volunteer rewards (70%)
 +    pub volunteer_rewards_pool: u64,
 +    /// Tokens for network maintenance and operations (20%)
 +    pub operations_pool: u64,
 +    /// Minimum network capacity before token minting
 +    pub min_network_capacity_gb: u64,
 +    /// Base reward rate per GB per day (in wei-equivalent)
 +    pub base_reward_rate: u64,
 +    /// Inflation rate control parameters
 +    pub inflation_control: InflationControl,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct InflationControl {
 +    /// Maximum annual inflation rate (2.5%)
 +    pub max_annual_inflation: f64,
 +    /// Target network growth rate (20% monthly)
 +    pub target_network_growth: f64,
 +    /// Supply adjustment frequency (weekly)
 +    pub adjustment_frequency_days: u32,
 +    /// Burn rate for unused tokens (quarterly)
 +    pub burn_rate: f64,
 +}
++
 +/// Token supply management
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct TokenSupply {
 +    /// Available tokens for immediate rewards
 +    pub reward_pool: u64,
 +    /// Tokens locked for future minting
 +    pub locked_reserve: u64,
 +    /// Burned tokens (deflationary mechanism)
 +    pub burned_tokens: u64,
 +    /// Last supply adjustment timestamp
 +    pub last_adjustment: DateTime<Utc>,
 +}
++
 +/// Network health metrics for token economics
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct NetworkHealthMetrics {
 +    /// Total network storage capacity in GB
 +    pub total_capacity_gb: u64,
 +    /// Active volunteer nodes
 +    pub active_volunteers: u32,
 +    /// Network utilization percentage (0-100)
 +    pub utilization_rate: f64,
 +    /// Average node uptime percentage
 +    pub average_uptime: f64,
 +    /// Geographic distribution score (0-100)
 +    pub geographic_diversity: f64,
 +    /// Data durability percentage
 +    pub data_durability: f64,
 +}
++
 +/// Token economics manager
 +pub struct TokenEconomicsManager {
 +    config: TokenEconomics,
 +    supply: TokenSupply,
 +    health_metrics: NetworkHealthMetrics,
 +    reward_history: HashMap<String, Vec<RewardRecord>>,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct RewardRecord {
 +    pub volunteer_id: String,
 +    pub amount: u64,
 +    pub earned_at: DateTime<Utc>,
 +    pub reason: RewardReason,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub enum RewardReason {
 +    StorageProvision { gb_days: u64 },
 +    UptimeBonus { uptime_hours: u32 },
 +    PerformanceBonus { score: f64 },
 +    GeographicDiversity,
 +    NetworkStabilization,
 +}
++
 +impl Default for TokenEconomics {
 +    fn default() -> Self {
 +        Self {
 +            max_supply: 21_000_000 * 1_000_000_000_000_000_000, // 21M tokens with 18 decimals
 +            circulating_supply: 0,
 +            ecosystem_reserve: 2_100_000 * 1_000_000_000_000_000_000, // 10%
 +            volunteer_rewards_pool: 14_700_000 * 1_000_000_000_000_000_000, // 70%
 +            operations_pool: 4_200_000 * 1_000_000_000_000_000_000, // 20%
 +            min_network_capacity_gb: 100, // Start rewards at 100GB network capacity
 +            base_reward_rate: 20_000_000_000_000_000, // 0.02 tokens per GB per day
 +            inflation_control: InflationControl {
 +                max_annual_inflation: 0.025, // 2.5%
 +                target_network_growth: 0.20, // 20%
 +                adjustment_frequency_days: 7,
 +                burn_rate: 0.01, // 1% quarterly burn of unused tokens
 +            },
 +        }
 +    }
 +}
++
 +impl TokenEconomicsManager {
 +    /// Create new token economics manager
 +    pub fn new(config: TokenEconomics) -> Self {
 +        Self {
 +            config,
 +            supply: TokenSupply {
 +                reward_pool: 0,
 +                locked_reserve: config.volunteer_rewards_pool,
 +                burned_tokens: 0,
 +                last_adjustment: Utc::now(),
 +            },
 +            health_metrics: NetworkHealthMetrics {
 +                total_capacity_gb: 0,
 +                active_volunteers: 0,
 +                utilization_rate: 0.0,
 +                average_uptime: 0.0,
 +                geographic_diversity: 0.0,
 +                data_durability: 0.0,
 +            },
 +            reward_history: HashMap::new(),
 +        }
 +    }
++
 +    /// Calculate sustainable token release rate
 +    pub fn calculate_token_release_rate(&self) -> Result<u64> {
 +        // Base release tied to network growth
 +        let network_growth_factor = self.calculate_network_growth_factor()?;
 +        let utilization_factor = (self.health_metrics.utilization_rate / 100.0).min(1.0);
 +        let quality_factor = self.calculate_network_quality_factor();
++
 +        // Release rate formula: base_rate * growth_factor * utilization_factor * quality_factor
 +        let daily_release = (self.config.base_reward_rate as f64
 +            * self.health_metrics.total_capacity_gb as f64
 +            * network_growth_factor
 +            * utilization_factor
 +            * quality_factor) as u64;
++
 +        // Cap by inflation control
 +        let max_daily_inflation = self.calculate_max_daily_inflation()?;
 +        Ok(daily_release.min(max_daily_inflation))
 +    }
++
 +    /// Calculate network growth factor for token release
 +    fn calculate_network_growth_factor(&self) -> Result<f64> {
 +        // Encourage growth but prevent runaway inflation
 +        let growth_factor = if self.health_metrics.total_capacity_gb < 1000 {
 +            2.0 // High incentive for early adoption
 +        } else if self.health_metrics.total_capacity_gb < 10000 {
 +            1.5 // Moderate incentive for scaling
 +        } else {
 +            1.0 // Stable rewards for mature network
 +        };
++
 +        Ok(growth_factor)
 +    }
++
 +    /// Calculate network quality factor
 +    fn calculate_network_quality_factor(&self) -> f64 {
 +        let uptime_factor = self.health_metrics.average_uptime / 100.0;
 +        let diversity_factor = self.health_metrics.geographic_diversity / 100.0;
 +        let durability_factor = self.health_metrics.data_durability / 100.0;
++
 +        // Weighted average: uptime (40%), diversity (30%), durability (30%)
 +        (uptime_factor * 0.4 + diversity_factor * 0.3 + durability_factor * 0.3).max(0.1)
 +    }
++
 +    /// Calculate maximum daily inflation allowed
 +    fn calculate_max_daily_inflation(&self) -> Result<u64> {
 +        let annual_max = (self.config.circulating_supply as f64
 +            * self.config.inflation_control.max_annual_inflation) as u64;
 +        Ok(annual_max / 365)
 +    }
++
 +    /// Mint new tokens for rewards
 +    pub async fn mint_rewards(&mut self, amount: u64) -> Result<()> {
 +        // Verify supply constraints
 +        if self.config.circulating_supply + amount > self.config.max_supply {
 +            return Err(anyhow::anyhow!("Minting would exceed maximum supply"));
 +        }
++
 +        // Verify inflation constraints
 +        let max_daily = self.calculate_max_daily_inflation()?;
 +        if amount > max_daily {
 +            return Err(anyhow::anyhow!("Minting exceeds daily inflation limit"));
 +        }
++
 +        // Mint tokens
 +        self.supply.reward_pool += amount;
 +        self.config.circulating_supply += amount;
 +        self.supply.locked_reserve = self.supply.locked_reserve.saturating_sub(amount);
++
 +        tracing::info!("Minted {} tokens for rewards. Circulating supply: {}",
 +            amount, self.config.circulating_supply);
++
 +        Ok(())
 +    }
++
 +    /// Burn unused tokens (deflationary mechanism)
 +    pub async fn burn_unused_tokens(&mut self) -> Result<u64> {
 +        let days_since_adjustment = (Utc::now() - self.supply.last_adjustment).num_days();
++
 +        // Quarterly burn
 +        if days_since_adjustment >= 90 {
 +            let burn_amount = (self.supply.reward_pool as f64
 +                * self.config.inflation_control.burn_rate) as u64;
++
 +            if burn_amount > 0 {
 +                self.supply.reward_pool = self.supply.reward_pool.saturating_sub(burn_amount);
 +                self.supply.burned_tokens += burn_amount;
 +                self.config.circulating_supply = self.config.circulating_supply.saturating_sub(burn_amount);
++
 +                tracing::info!("Burned {} unused tokens. Total burned: {}",
 +                    burn_amount, self.supply.burned_tokens);
++
 +                return Ok(burn_amount);
 +            }
 +        }
++
 +        Ok(0)
 +    }
++
 +    /// Calculate reward for volunteer
 +    pub fn calculate_volunteer_reward(
 +        &self,
 +        volunteer_id: &str,
 +        storage_gb: u64,
 +        uptime_hours: u32,
 +        performance_score: f64
 +    ) -> Result<u64> {
 +        // Base storage reward
 +        let storage_reward = storage_gb * self.config.base_reward_rate;
++
 +        // Uptime bonus (up to 50% extra)
 +        let uptime_bonus = if uptime_hours >= 24 {
 +            (storage_reward as f64 * 0.5) as u64
 +        } else {
 +            (storage_reward as f64 * (uptime_hours as f64 / 24.0) * 0.5) as u64
 +        };
++
 +        // Performance bonus (up to 25% extra)
 +        let performance_bonus = (storage_reward as f64 * performance_score * 0.25) as u64;
++
 +        // Geographic diversity bonus
 +        let diversity_bonus = if self.is_rare_location(volunteer_id) {
 +            (storage_reward as f64 * 0.15) as u64
 +        } else {
 +            0
 +        };
++
 +        let total_reward = storage_reward + uptime_bonus + performance_bonus + diversity_bonus;
++
 +        // Ensure we have enough tokens in reward pool
 +        if total_reward > self.supply.reward_pool {
 +            return Err(anyhow::anyhow!("Insufficient tokens in reward pool"));
 +        }
++
 +        Ok(total_reward)
 +    }
++
 +    /// Check if volunteer is in a geographically rare location
 +    fn is_rare_location(&self, _volunteer_id: &str) -> bool {
 +        // Placeholder for geographic diversity calculation
 +        // Would integrate with actual geographic distribution data
 +        false
 +    }
++
 +    /// Distribute reward to volunteer
 +    pub async fn distribute_reward(
 +        &mut self,
 +        volunteer_id: String,
 +        amount: u64,
 +        reason: RewardReason
 +    ) -> Result<()> {
 +        if amount > self.supply.reward_pool {
 +            return Err(anyhow::anyhow!("Insufficient reward pool balance"));
 +        }
++
 +        // Deduct from reward pool
 +        self.supply.reward_pool -= amount;
++
 +        // Record reward
 +        let record = RewardRecord {
 +            volunteer_id: volunteer_id.clone(),
 +            amount,
 +            earned_at: Utc::now(),
 +            reason,
 +        };
++
 +        self.reward_history.entry(volunteer_id)
 +            .or_insert_with(Vec::new)
 +            .push(record);
++
 +        tracing::info!("Distributed {} tokens to volunteer. Remaining pool: {}",
 +            amount, self.supply.reward_pool);
++
 +        Ok(())
 +    }
++
 +    /// Update network health metrics
 +    pub fn update_network_metrics(&mut self, metrics: NetworkHealthMetrics) {
 +        self.health_metrics = metrics;
 +    }
++
 +    /// Get current token supply status
 +    pub fn get_supply_status(&self) -> TokenSupply {
 +        self.supply.clone()
 +    }
++
 +    /// Get total value locked in the system
 +    pub fn get_total_value_locked(&self) -> u64 {
 +        self.supply.reward_pool + self.supply.locked_reserve
 +    }
++
 +    /// Perform periodic supply adjustment
 +    pub async fn perform_supply_adjustment(&mut self) -> Result<()> {
 +        let days_since_adjustment = (Utc::now() - self.supply.last_adjustment).num_days();
++
 +        if days_since_adjustment >= self.config.inflation_control.adjustment_frequency_days as i64 {
 +            // Calculate and mint new rewards based on network health
 +            let daily_release = self.calculate_token_release_rate()?;
 +            let adjustment_amount = daily_release * days_since_adjustment as u64;
++
 +            if adjustment_amount > 0 {
 +                self.mint_rewards(adjustment_amount).await?;
 +            }
++
 +            // Perform quarterly burn
 +            self.burn_unused_tokens().await?;
++
 +            self.supply.last_adjustment = Utc::now();
++
 +            tracing::info!("Performed supply adjustment: +{} tokens", adjustment_amount);
 +        }
++
 +        Ok(())
 +    }
 +}
++
 +#[cfg(test)]
 +mod tests {
 +    use super::*;
++
 +    #[tokio::test]
 +    async fn test_token_economics_basic() {
 +        let config = TokenEconomics::default();
 +        let mut manager = TokenEconomicsManager::new(config);
++
 +        // Test initial state
 +        assert_eq!(manager.get_supply_status().reward_pool, 0);
 +        assert_eq!(manager.config.circulating_supply, 0);
++
 +        // Test minting
 +        manager.mint_rewards(1000).await.unwrap();
 +        assert_eq!(manager.get_supply_status().reward_pool, 1000);
 +        assert_eq!(manager.config.circulating_supply, 1000);
 +    }
++
 +    #[tokio::test]
 +    async fn test_reward_calculation() {
 +        let config = TokenEconomics::default();
 +        let manager = TokenEconomicsManager::new(config);
++
 +        let reward = manager.calculate_volunteer_reward("test_volunteer", 10, 24, 0.8).unwrap();
++
 +        // Base: 10 GB * 0.02 tokens = 0.2 tokens
 +        // Uptime bonus: 50% of base = 0.1 tokens
 +        // Performance bonus: 80% * 25% of base = 0.04 tokens
 +        // Total should be around 0.34 tokens (in wei)
 +        assert!(reward > 0);
 +    }
++
 +    #[tokio::test]
 +    async fn test_supply_constraints() {
 +        let mut config = TokenEconomics::default();
 +        config.max_supply = 1000; // Small cap for testing
 +        let mut manager = TokenEconomicsManager::new(config);
++
 +        // Should fail when exceeding max supply
 +        assert!(manager.mint_rewards(2000).await.is_err());
 +    }
 +}

src/economics/zephyr_coin.rsadded

 +//! ZephyrCoin Smart Contract Implementation
 +//!
 +//! ERC-20 compatible token for ZephyrFS network incentives
++
 +use anyhow::Result;
 +use serde::{Deserialize, Serialize};
 +use std::collections::HashMap;
 +use chrono::{DateTime, Utc};
++
 +/// ZephyrCoin token contract state
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct ZephyrCoin {
 +    /// Token metadata
 +    pub name: String,
 +    pub symbol: String,
 +    pub decimals: u8,
 +    pub total_supply: u64,
++
 +    /// Balance tracking
 +    pub balances: HashMap<String, u64>,
 +    pub allowances: HashMap<String, HashMap<String, u64>>,
++
 +    /// ZephyrFS-specific features
 +    pub contract_owner: String,
 +    pub minters: HashMap<String, bool>,
 +    pub burners: HashMap<String, bool>,
 +    pub paused: bool,
++
 +    /// Economic controls
 +    pub daily_mint_limit: u64,
 +    pub daily_minted: u64,
 +    pub last_mint_reset: DateTime<Utc>,
++
 +    /// Staking and governance
 +    pub staked_balances: HashMap<String, StakedBalance>,
 +    pub governance_proposals: HashMap<u64, GovernanceProposal>,
 +    pub proposal_counter: u64,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct StakedBalance {
 +    pub amount: u64,
 +    pub staked_at: DateTime<Utc>,
 +    pub unlock_time: DateTime<Utc>,
 +    pub rewards_claimed: u64,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct GovernanceProposal {
 +    pub id: u64,
 +    pub proposer: String,
 +    pub title: String,
 +    pub description: String,
 +    pub target_contract: Option<String>,
 +    pub call_data: Option<Vec<u8>>,
 +    pub created_at: DateTime<Utc>,
 +    pub voting_ends_at: DateTime<Utc>,
 +    pub votes_for: u64,
 +    pub votes_against: u64,
 +    pub executed: bool,
 +    pub voters: HashMap<String, Vote>,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub enum Vote {
 +    For(u64),    // Amount of tokens voted
 +    Against(u64),
 +}
++
 +/// ERC-20 Events
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub enum TokenEvent {
 +    Transfer {
 +        from: String,
 +        to: String,
 +        value: u64,
 +    },
 +    Approval {
 +        owner: String,
 +        spender: String,
 +        value: u64,
 +    },
 +    Mint {
 +        to: String,
 +        value: u64,
 +    },
 +    Burn {
 +        from: String,
 +        value: u64,
 +    },
 +    Stake {
 +        user: String,
 +        amount: u64,
 +        duration_days: u32,
 +    },
 +    Unstake {
 +        user: String,
 +        amount: u64,
 +        rewards: u64,
 +    },
 +    ProposalCreated {
 +        id: u64,
 +        proposer: String,
 +        title: String,
 +    },
 +    VoteCast {
 +        proposal_id: u64,
 +        voter: String,
 +        support: bool,
 +        weight: u64,
 +    },
 +}
++
 +impl Default for ZephyrCoin {
 +    fn default() -> Self {
 +        Self {
 +            name: "ZephyrCoin".to_string(),
 +            symbol: "ZEPH".to_string(),
 +            decimals: 18,
 +            total_supply: 0,
 +            balances: HashMap::new(),
 +            allowances: HashMap::new(),
 +            contract_owner: String::new(),
 +            minters: HashMap::new(),
 +            burners: HashMap::new(),
 +            paused: false,
 +            daily_mint_limit: 1_000_000 * 10_u64.pow(18), // 1M tokens per day max
 +            daily_minted: 0,
 +            last_mint_reset: Utc::now(),
 +            staked_balances: HashMap::new(),
 +            governance_proposals: HashMap::new(),
 +            proposal_counter: 0,
 +        }
 +    }
 +}
++
 +impl ZephyrCoin {
 +    /// Initialize new ZephyrCoin contract
 +    pub fn new(owner: String, initial_supply: u64) -> Self {
 +        let mut coin = Self::default();
 +        coin.contract_owner = owner.clone();
 +        coin.total_supply = initial_supply;
 +        coin.balances.insert(owner.clone(), initial_supply);
 +        coin.minters.insert(owner, true);
 +        coin
 +    }
++
 +    /// ERC-20: Get balance of account
 +    pub fn balance_of(&self, account: &str) -> u64 {
 +        self.balances.get(account).copied().unwrap_or(0)
 +    }
++
 +    /// ERC-20: Transfer tokens
 +    pub fn transfer(&mut self, from: &str, to: &str, amount: u64) -> Result<TokenEvent> {
 +        self.require_not_paused()?;
++
 +        let from_balance = self.balance_of(from);
 +        if from_balance < amount {
 +            return Err(anyhow::anyhow!("Insufficient balance"));
 +        }
++
 +        self.balances.insert(from.to_string(), from_balance - amount);
 +        let to_balance = self.balance_of(to);
 +        self.balances.insert(to.to_string(), to_balance + amount);
++
 +        Ok(TokenEvent::Transfer {
 +            from: from.to_string(),
 +            to: to.to_string(),
 +            value: amount,
 +        })
 +    }
++
 +    /// ERC-20: Approve spender
 +    pub fn approve(&mut self, owner: &str, spender: &str, amount: u64) -> Result<TokenEvent> {
 +        self.require_not_paused()?;
++
 +        self.allowances
 +            .entry(owner.to_string())
 +            .or_insert_with(HashMap::new)
 +            .insert(spender.to_string(), amount);
++
 +        Ok(TokenEvent::Approval {
 +            owner: owner.to_string(),
 +            spender: spender.to_string(),
 +            value: amount,
 +        })
 +    }
++
 +    /// ERC-20: Transfer from approved amount
 +    pub fn transfer_from(&mut self, spender: &str, from: &str, to: &str, amount: u64) -> Result<TokenEvent> {
 +        self.require_not_paused()?;
++
 +        // Check allowance
 +        let allowance = self.allowances
 +            .get(from)
 +            .and_then(|allowances| allowances.get(spender))
 +            .copied()
 +            .unwrap_or(0);
++
 +        if allowance < amount {
 +            return Err(anyhow::anyhow!("Insufficient allowance"));
 +        }
++
 +        // Update allowance
 +        self.allowances
 +            .get_mut(from)
 +            .unwrap()
 +            .insert(spender.to_string(), allowance - amount);
++
 +        // Perform transfer
 +        self.transfer(from, to, amount)
 +    }
++
 +    /// ERC-20: Get allowance
 +    pub fn allowance(&self, owner: &str, spender: &str) -> u64 {
 +        self.allowances
 +            .get(owner)
 +            .and_then(|allowances| allowances.get(spender))
 +            .copied()
 +            .unwrap_or(0)
 +    }
++
 +    /// Mint new tokens (ZephyrFS-specific)
 +    pub fn mint(&mut self, caller: &str, to: &str, amount: u64) -> Result<TokenEvent> {
 +        self.require_not_paused()?;
 +        self.require_minter(caller)?;
 +        self.check_mint_limits(amount)?;
++
 +        self.total_supply += amount;
 +        let balance = self.balance_of(to);
 +        self.balances.insert(to.to_string(), balance + amount);
++
 +        // Update daily mint tracking
 +        self.daily_minted += amount;
++
 +        Ok(TokenEvent::Mint {
 +            to: to.to_string(),
 +            value: amount,
 +        })
 +    }
++
 +    /// Burn tokens (ZephyrFS-specific)
 +    pub fn burn(&mut self, caller: &str, from: &str, amount: u64) -> Result<TokenEvent> {
 +        self.require_not_paused()?;
 +        self.require_burner(caller)?;
++
 +        let balance = self.balance_of(from);
 +        if balance < amount {
 +            return Err(anyhow::anyhow!("Insufficient balance to burn"));
 +        }
++
 +        self.total_supply -= amount;
 +        self.balances.insert(from.to_string(), balance - amount);
++
 +        Ok(TokenEvent::Burn {
 +            from: from.to_string(),
 +            value: amount,
 +        })
 +    }
++
 +    /// Stake tokens for governance and rewards
 +    pub fn stake(&mut self, user: &str, amount: u64, duration_days: u32) -> Result<TokenEvent> {
 +        self.require_not_paused()?;
++
 +        let balance = self.balance_of(user);
 +        if balance < amount {
 +            return Err(anyhow::anyhow!("Insufficient balance to stake"));
 +        }
++
 +        // Lock tokens
 +        self.balances.insert(user.to_string(), balance - amount);
++
 +        // Add to staking
 +        let unlock_time = Utc::now() + chrono::Duration::days(duration_days as i64);
 +        let staked = StakedBalance {
 +            amount,
 +            staked_at: Utc::now(),
 +            unlock_time,
 +            rewards_claimed: 0,
 +        };
++
 +        self.staked_balances.insert(user.to_string(), staked);
++
 +        Ok(TokenEvent::Stake {
 +            user: user.to_string(),
 +            amount,
 +            duration_days,
 +        })
 +    }
++
 +    /// Unstake tokens after lock period
 +    pub fn unstake(&mut self, user: &str) -> Result<TokenEvent> {
 +        self.require_not_paused()?;
++
 +        let staked = self.staked_balances.get(user)
 +            .ok_or_else(|| anyhow::anyhow!("No staked balance found"))?;
++
 +        if Utc::now() < staked.unlock_time {
 +            return Err(anyhow::anyhow!("Tokens still locked"));
 +        }
++
 +        // Calculate staking rewards (5% APY)
 +        let staking_duration = (Utc::now() - staked.staked_at).num_days();
 +        let rewards = (staked.amount as f64 * 0.05 * staking_duration as f64 / 365.0) as u64;
++
 +        // Return staked amount + rewards
 +        let balance = self.balance_of(user);
 +        self.balances.insert(user.to_string(), balance + staked.amount + rewards);
++
 +        // Mint rewards
 +        self.total_supply += rewards;
++
 +        // Remove from staking
 +        self.staked_balances.remove(user);
++
 +        Ok(TokenEvent::Unstake {
 +            user: user.to_string(),
 +            amount: staked.amount,
 +            rewards,
 +        })
 +    }
++
 +    /// Create governance proposal
 +    pub fn create_proposal(
 +        &mut self,
 +        proposer: &str,
 +        title: String,
 +        description: String,
 +        target_contract: Option<String>,
 +        call_data: Option<Vec<u8>>,
 +        voting_duration_days: u32,
 +    ) -> Result<TokenEvent> {
 +        self.require_not_paused()?;
++
 +        // Require minimum stake to propose (10,000 ZEPH)
 +        let min_stake = 10_000 * 10_u64.pow(18);
 +        let staked = self.staked_balances.get(proposer)
 +            .ok_or_else(|| anyhow::anyhow!("Must stake tokens to propose"))?;
++
 +        if staked.amount < min_stake {
 +            return Err(anyhow::anyhow!("Insufficient stake to create proposal"));
 +        }
++
 +        self.proposal_counter += 1;
 +        let proposal = GovernanceProposal {
 +            id: self.proposal_counter,
 +            proposer: proposer.to_string(),
 +            title: title.clone(),
 +            description,
 +            target_contract,
 +            call_data,
 +            created_at: Utc::now(),
 +            voting_ends_at: Utc::now() + chrono::Duration::days(voting_duration_days as i64),
 +            votes_for: 0,
 +            votes_against: 0,
 +            executed: false,
 +            voters: HashMap::new(),
 +        };
++
 +        self.governance_proposals.insert(self.proposal_counter, proposal);
++
 +        Ok(TokenEvent::ProposalCreated {
 +            id: self.proposal_counter,
 +            proposer: proposer.to_string(),
 +            title,
 +        })
 +    }
++
 +    /// Vote on governance proposal
 +    pub fn vote(&mut self, voter: &str, proposal_id: u64, support: bool) -> Result<TokenEvent> {
 +        self.require_not_paused()?;
++
 +        let proposal = self.governance_proposals.get_mut(&proposal_id)
 +            .ok_or_else(|| anyhow::anyhow!("Proposal not found"))?;
++
 +        if Utc::now() > proposal.voting_ends_at {
 +            return Err(anyhow::anyhow!("Voting period ended"));
 +        }
++
 +        if proposal.voters.contains_key(voter) {
 +            return Err(anyhow::anyhow!("Already voted"));
 +        }
++
 +        // Voting weight = staked tokens
 +        let staked = self.staked_balances.get(voter)
 +            .ok_or_else(|| anyhow::anyhow!("Must stake tokens to vote"))?;
++
 +        let weight = staked.amount;
++
 +        if support {
 +            proposal.votes_for += weight;
 +            proposal.voters.insert(voter.to_string(), Vote::For(weight));
 +        } else {
 +            proposal.votes_against += weight;
 +            proposal.voters.insert(voter.to_string(), Vote::Against(weight));
 +        }
++
 +        Ok(TokenEvent::VoteCast {
 +            proposal_id,
 +            voter: voter.to_string(),
 +            support,
 +            weight,
 +        })
 +    }
++
 +    /// Add minter role
 +    pub fn add_minter(&mut self, caller: &str, minter: &str) -> Result<()> {
 +        self.require_owner(caller)?;
 +        self.minters.insert(minter.to_string(), true);
 +        Ok(())
 +    }
++
 +    /// Add burner role
 +    pub fn add_burner(&mut self, caller: &str, burner: &str) -> Result<()> {
 +        self.require_owner(caller)?;
 +        self.burners.insert(burner.to_string(), true);
 +        Ok(())
 +    }
++
 +    /// Pause contract
 +    pub fn pause(&mut self, caller: &str) -> Result<()> {
 +        self.require_owner(caller)?;
 +        self.paused = true;
 +        Ok(())
 +    }
++
 +    /// Unpause contract
 +    pub fn unpause(&mut self, caller: &str) -> Result<()> {
 +        self.require_owner(caller)?;
 +        self.paused = false;
 +        Ok(())
 +    }
++
 +    /// Get staked balance
 +    pub fn get_staked_balance(&self, user: &str) -> Option<&StakedBalance> {
 +        self.staked_balances.get(user)
 +    }
++
 +    /// Get proposal
 +    pub fn get_proposal(&self, proposal_id: u64) -> Option<&GovernanceProposal> {
 +        self.governance_proposals.get(&proposal_id)
 +    }
++
 +    /// Check and reset daily mint limits
 +    fn check_mint_limits(&mut self, amount: u64) -> Result<()> {
 +        let now = Utc::now();
++
 +        // Reset daily counter if new day
 +        if (now - self.last_mint_reset).num_days() >= 1 {
 +            self.daily_minted = 0;
 +            self.last_mint_reset = now;
 +        }
++
 +        if self.daily_minted + amount > self.daily_mint_limit {
 +            return Err(anyhow::anyhow!("Daily mint limit exceeded"));
 +        }
++
 +        Ok(())
 +    }
++
 +    fn require_owner(&self, caller: &str) -> Result<()> {
 +        if caller != self.contract_owner {
 +            return Err(anyhow::anyhow!("Only owner can call this function"));
 +        }
 +        Ok(())
 +    }
++
 +    fn require_minter(&self, caller: &str) -> Result<()> {
 +        if !self.minters.get(caller).unwrap_or(&false) {
 +            return Err(anyhow::anyhow!("Only minters can call this function"));
 +        }
 +        Ok(())
 +    }
++
 +    fn require_burner(&self, caller: &str) -> Result<()> {
 +        if !self.burners.get(caller).unwrap_or(&false) {
 +            return Err(anyhow::anyhow!("Only burners can call this function"));
 +        }
 +        Ok(())
 +    }
++
 +    fn require_not_paused(&self) -> Result<()> {
 +        if self.paused {
 +            return Err(anyhow::anyhow!("Contract is paused"));
 +        }
 +        Ok(())
 +    }
 +}
++
 +#[cfg(test)]
 +mod tests {
 +    use super::*;
++
 +    #[test]
 +    fn test_zephyr_coin_basic() {
 +        let owner = "owner".to_string();
 +        let initial_supply = 1000 * 10_u64.pow(18);
 +        let mut coin = ZephyrCoin::new(owner.clone(), initial_supply);
++
 +        assert_eq!(coin.balance_of(&owner), initial_supply);
 +        assert_eq!(coin.total_supply, initial_supply);
 +    }
++
 +    #[test]
 +    fn test_transfer() {
 +        let owner = "owner".to_string();
 +        let recipient = "recipient".to_string();
 +        let mut coin = ZephyrCoin::new(owner.clone(), 1000);
++
 +        let event = coin.transfer(&owner, &recipient, 100).unwrap();
++
 +        assert_eq!(coin.balance_of(&owner), 900);
 +        assert_eq!(coin.balance_of(&recipient), 100);
++
 +        match event {
 +            TokenEvent::Transfer { from, to, value } => {
 +                assert_eq!(from, owner);
 +                assert_eq!(to, recipient);
 +                assert_eq!(value, 100);
 +            }
 +            _ => panic!("Expected Transfer event"),
 +        }
 +    }
++
 +    #[test]
 +    fn test_staking() {
 +        let owner = "owner".to_string();
 +        let mut coin = ZephyrCoin::new(owner.clone(), 1000);
++
 +        coin.stake(&owner, 500, 30).unwrap();
++
 +        assert_eq!(coin.balance_of(&owner), 500);
 +        let staked = coin.get_staked_balance(&owner).unwrap();
 +        assert_eq!(staked.amount, 500);
 +    }
++
 +    #[test]
 +    fn test_governance() {
 +        let owner = "owner".to_string();
 +        let mut coin = ZephyrCoin::new(owner.clone(), 100_000 * 10_u64.pow(18));
++
 +        // Stake tokens for governance
 +        coin.stake(&owner, 50_000 * 10_u64.pow(18), 365).unwrap();
++
 +        // Create proposal
 +        coin.create_proposal(
 +            &owner,
 +            "Test Proposal".to_string(),
 +            "A test governance proposal".to_string(),
 +            None,
 +            None,
 +            7,
 +        ).unwrap();
++
 +        // Vote on proposal
 +        coin.vote(&owner, 1, true).unwrap();
++
 +        let proposal = coin.get_proposal(1).unwrap();
 +        assert_eq!(proposal.votes_for, 50_000 * 10_u64.pow(18));
 +    }
 +}

src/lib.rsmodified

  pub mod audit;
  pub mod proof;
 +// Phase 5.1: Economic Foundation & Token System
 +pub mod economics;
 +pub mod allocation;
++
  pub use crypto::{
      ZephyrCrypto, CryptoParams, ScryptParams, AesParams, HashParams,
      ContentHasher, VerificationHasher, EncryptedData, ContentId, HashAlgorithm
      UnifiedProofManager, UnifiedProofConfig, ComprehensiveChallenge,
      ComprehensiveVerificationResult as ProofVerificationResult, ProofStatistics
  };
++
 +// Phase 5.1: Economic system exports
 +pub use economics::{
 +    TokenEconomicsManager, ZephyrCoin, NetworkHealthController, ZephyrCoinAMM,
 +    EarningsCalculator, PaymentProcessor, PayoutScheduler, PerformanceRewardsSystem
 +};
 +pub use allocation::{
 +    DemocraticAllocationManager, AllocationStrategy, AllocationQuality
 +};