Validator Selection

1pub struct ValidatorMetrics {
2    /// Historical uptime percentage
3    pub uptime: f64,
4    
5    /// Block production skip rate
6    pub skip_rate: f64,
7    
8    /// Vote credits in current epoch
9    pub epoch_credits: u64,
10    
11    /// Commission percentage
12    pub commission: u8,
13    
14    /// Version information
15    pub version: Version,
16    
17    /// Last update timestamp
18    pub last_update: i64,
19}
20
21impl ValidatorMetrics {
22    pub fn update_metrics(
23        &mut self,
24        vote_account: &VoteAccount,
25        current_epoch: u64,
26    ) -> ProgramResult {
27        // Update uptime
28        self.uptime = self.calculate_uptime(vote_account)?;
29        
30        // Update skip rate
31        self.skip_rate = self.calculate_skip_rate(vote_account)?;
32        
33        // Update epoch credits
34        self.epoch_credits = vote_account
35            .epoch_credits
36            .iter()
37            .find(|(epoch, ..)| *epoch == current_epoch)
38            .map(|(_, credits, _)| *credits)
39            .unwrap_or(0);
40            
41        // Update timestamp
42        self.last_update = Clock::get()?.unix_timestamp;
43        
44        Ok(())
45    }
46    
47    fn calculate_uptime(&self, vote_account: &VoteAccount) -> Result<f64, ProgramError> {
48        let recent_slots = vote_account.recent_slots()?;
49        let total_slots = recent_slots.len() as f64;
50        let active_slots = recent_slots
51            .iter()
52            .filter(|slot| slot.is_active())
53            .count() as f64;
54            
55        Ok(active_slots / total_slots)
56    }
57    
58    fn calculate_skip_rate(&self, vote_account: &VoteAccount) -> Result<f64, ProgramError> {
59        let recent_blocks = vote_account.recent_blocks()?;
60        let total_blocks = recent_blocks.len() as f64;
61        let skipped_blocks = recent_blocks
62            .iter()
63            .filter(|block| block.is_skipped())
64            .count() as f64;
65            
66        Ok(skipped_blocks / total_blocks)
67    }
68}

1pub struct RiskAssessment {
2    /// Security score (0-100)
3    pub security_score: u8,
4    
5    /// Stability score (0-100)
6    pub stability_score: u8,
7    
8    /// Risk factors
9    pub risk_factors: Vec<RiskFactor>,
10    
11    /// Last assessment timestamp
12    pub last_assessment: i64,
13}
14
15impl RiskAssessment {
16    pub fn assess_validator_risk(
17        &self,
18        validator: &ValidatorInfo,
19        network_stats: &NetworkStats,
20    ) -> Result<RiskScore, ProgramError> {
21        let mut risk_score = RiskScore::default();
22        
23        // Assess security risks
24        risk_score.security = self.assess_security(validator)?;
25        
26        // Assess stability risks
27        risk_score.stability = self.assess_stability(validator, network_stats)?;
28        
29        // Calculate concentration risk
30        risk_score.concentration = self.calculate_concentration_risk(
31            validator,
32            network_stats,
33        )?;
34        
35        // Check for critical risk factors
36        self.check_critical_risks(validator, &mut risk_score)?;
37        
38        Ok(risk_score)
39    }
40    
41    fn assess_security(&self, validator: &ValidatorInfo) -> Result<u8, ProgramError> {
42        let mut score = 100u8;
43        
44        // Check software version
45        if validator.version < self.min_required_version {
46            score = score.saturating_sub(20);
47        }
48        
49        // Check infrastructure security
50        if !validator.meets_security_requirements() {
51            score = score.saturating_sub(30);
52        }
53        
54        // Check slashing history
55        if validator.has_recent_slashing() {
56            score = score.saturating_sub(50);
57        }
58        
59        Ok(score)
60    }
61    
62    fn assess_stability(
63        &self,
64        validator: &ValidatorInfo,
65        network_stats: &NetworkStats,
66    ) -> Result<u8, ProgramError> {
67        let mut score = 100u8;
68        
69        // Check commission stability
70        let commission_changes = validator.recent_commission_changes();
71        score = score.saturating_sub(commission_changes * 10);
72        
73        // Check operational history
74        let delinquent_epochs = validator.delinquent_epochs();
75        score = score.saturating_sub(delinquent_epochs * 15);
76        
77        // Check network participation
78        let participation_rate = validator.participation_rate()?;
79        if participation_rate < network_stats.avg_participation_rate {
80            score = score.saturating_sub(20);
81        }
82        
83        Ok(score)
84    }
85    
86    fn calculate_concentration_risk(
87        &self,
88        validator: &ValidatorInfo,
89        network_stats: &NetworkStats,
90    ) -> Result<u8, ProgramError> {
91        let stake_concentration = validator.total_stake as f64
92            / network_stats.total_stake as f64;
93            
94        // Higher concentration = higher risk
95        let risk_score = (stake_concentration * 100.0) as u8;
96        
97        Ok(risk_score.min(100))
98    }
99    
100    fn check_critical_risks(
101        &self,
102        validator: &ValidatorInfo,
103        risk_score: &mut RiskScore,
104    ) -> ProgramResult {
105        // Check for critical security issues
106        if validator.has_critical_security_issues() {
107            risk_score.critical_flags.push(RiskFlag::SecurityIssue);
108        }
109        
110        // Check for excessive downtime
111        if validator.has_excessive_downtime() {
112            risk_score.critical_flags.push(RiskFlag::ExcessiveDowntime);
113        }
114        
115        // Check for suspicious behavior
116        if validator.has_suspicious_activity() {
117            risk_score.critical_flags.push(RiskFlag::SuspiciousActivity);
118        }
119        
120        Ok(())
121    }
122}

1pub struct ScoringSystem {
2    /// Performance weight (0-100)
3    pub performance_weight: u8,
4    
5    /// Security weight (0-100)
6    pub security_weight: u8,
7    
8    /// Stability weight (0-100)
9    pub stability_weight: u8,
10    
11    /// Network weight (0-100)
12    pub network_weight: u8,
13}
14
15impl ScoringSystem {
16    pub fn calculate_validator_score(
17        &self,
18        metrics: &ValidatorMetrics,
19        risk_assessment: &RiskAssessment,
20        network_stats: &NetworkStats,
21    ) -> Result<ValidatorScore, ProgramError> {
22        // Calculate performance score
23        let performance_score = self.calculate_performance_score(metrics)?;
24        
25        // Calculate security score
26        let security_score = self.calculate_security_score(risk_assessment)?;
27        
28        // Calculate stability score
29        let stability_score = self.calculate_stability_score(
30            metrics,
31            risk_assessment,
32        )?;
33        
34        // Calculate network score
35        let network_score = self.calculate_network_score(
36            metrics,
37            network_stats,
38        )?;
39        
40        // Calculate weighted total
41        let total_score = self.calculate_weighted_score(
42            performance_score,
43            security_score,
44            stability_score,
45            network_score,
46        )?;
47        
48        Ok(ValidatorScore {
49            total_score,
50            performance_score,
51            security_score,
52            stability_score,
53            network_score,
54            timestamp: Clock::get()?.unix_timestamp,
55        })
56    }
57    
58    fn calculate_weighted_score(
59        &self,
60        performance_score: u8,
61        security_score: u8,
62        stability_score: u8,
63        network_score: u8,
64    ) -> Result<u8, ProgramError> {
65        let weighted_sum = (performance_score as u32)
66            .checked_mul(self.performance_weight as u32)?
67            .checked_add(
68                (security_score as u32)
69                    .checked_mul(self.security_weight as u32)?,
70            )?
71            .checked_add(
72                (stability_score as u32)
73                    .checked_mul(self.stability_weight as u32)?,
74            )?
75            .checked_add(
76                (network_score as u32)
77                    .checked_mul(self.network_weight as u32)?,
78            )?;
79            
80        let total_weight = self.performance_weight as u32
81            + self.security_weight as u32
82            + self.stability_weight as u32
83            + self.network_weight as u32;
84            
85        Ok((weighted_sum / total_weight) as u8)
86    }
87}

1pub struct MonitoringSystem {
2    /// Alert thresholds
3    pub thresholds: MonitoringThresholds,
4    
5    /// Alert system
6    pub alert_system: Arc<AlertSystem>,
7    
8    /// Metrics storage
9    pub metrics_store: Arc<MetricsStore>,
10}
11
12impl MonitoringSystem {
13    pub async fn monitor_validators(
14        &self,
15        validators: &[ValidatorInfo],
16    ) -> ProgramResult {
17        for validator in validators {
18            // Check performance metrics
19            let metrics = self.collect_metrics(validator).await?;
20            
21            // Check for threshold violations
22            if let Some(violations) = self.check_thresholds(&metrics)? {
23                // Send alerts
24                self.alert_system
25                    .send_alerts(validator, &violations)
26                    .await?;
27                    
28                // Log violations
29                self.metrics_store
30                    .log_violations(validator, &violations)
31                    .await?;
32            }
33            
34            // Store metrics
35            self.metrics_store
36                .store_metrics(validator, &metrics)
37                .await?;
38        }
39        
40        Ok(())
41    }
42    
43    fn check_thresholds(
44        &self,
45        metrics: &ValidatorMetrics,
46    ) -> Result<Option<Vec<Violation>>, ProgramError> {
47        let mut violations = Vec::new();
48        
49        // Check uptime
50        if metrics.uptime < self.thresholds.min_uptime {
51            violations.push(Violation::LowUptime {
52                current: metrics.uptime,
53                threshold: self.thresholds.min_uptime,
54            });
55        }
56        
57        // Check skip rate
58        if metrics.skip_rate > self.thresholds.max_skip_rate {
59            violations.push(Violation::HighSkipRate {
60                current: metrics.skip_rate,
61                threshold: self.thresholds.max_skip_rate,
62            });
63        }
64        
65        // Check commission changes
66        if metrics.commission_changes > self.thresholds.max_commission_changes {
67            violations.push(Violation::ExcessiveCommissionChanges {
68                current: metrics.commission_changes,
69                threshold: self.thresholds.max_commission_changes,
70            });
71        }
72        
73        Ok(if violations.is_empty() {
74            None
75        } else {
76            Some(violations)
77        })
78    }
79}