freenet 0.2.48

Freenet core software
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

//! Verification report and summary display.

use super::types::ContractStateHistory;
use super::types::StateAnomaly;

/// Full verification report.
#[derive(Debug, Clone)]
pub struct VerificationReport {
    /// Per-contract state history.
    pub contract_histories: Vec<ContractStateHistory>,
    /// All detected anomalies.
    pub anomalies: Vec<StateAnomaly>,
    /// Total events analyzed.
    pub total_events: usize,
    /// Total state-mutating events.
    pub state_events: usize,
    /// Number of contracts analyzed.
    pub contracts_analyzed: usize,
}

impl VerificationReport {
    /// Returns true if no anomalies were detected.
    pub fn is_clean(&self) -> bool {
        self.anomalies.is_empty()
    }

    /// Returns only divergence anomalies.
    pub fn divergences(&self) -> Vec<&StateAnomaly> {
        self.anomalies
            .iter()
            .filter(|a| matches!(a, StateAnomaly::FinalDivergence { .. }))
            .collect()
    }

    /// Returns only missing broadcast anomalies.
    pub fn missing_broadcasts(&self) -> Vec<&StateAnomaly> {
        self.anomalies
            .iter()
            .filter(|a| matches!(a, StateAnomaly::MissingBroadcast { .. }))
            .collect()
    }

    /// Returns only unapplied broadcast anomalies.
    pub fn unapplied_broadcasts(&self) -> Vec<&StateAnomaly> {
        self.anomalies
            .iter()
            .filter(|a| matches!(a, StateAnomaly::BroadcastNotApplied { .. }))
            .collect()
    }

    pub fn suspected_partitions(&self) -> Vec<&StateAnomaly> {
        self.anomalies
            .iter()
            .filter(|a| matches!(a, StateAnomaly::SuspectedPartition { .. }))
            .collect()
    }

    pub fn stale_peers(&self) -> Vec<&StateAnomaly> {
        self.anomalies
            .iter()
            .filter(|a| matches!(a, StateAnomaly::StalePeer { .. }))
            .collect()
    }

    pub fn state_oscillations(&self) -> Vec<&StateAnomaly> {
        self.anomalies
            .iter()
            .filter(|a| matches!(a, StateAnomaly::StateOscillation { .. }))
            .collect()
    }

    pub fn zombie_transactions(&self) -> Vec<&StateAnomaly> {
        self.anomalies
            .iter()
            .filter(|a| matches!(a, StateAnomaly::ZombieTransaction { .. }))
            .collect()
    }

    pub fn broadcast_storms(&self) -> Vec<&StateAnomaly> {
        self.anomalies
            .iter()
            .filter(|a| matches!(a, StateAnomaly::BroadcastStorm { .. }))
            .collect()
    }

    pub fn delta_sync_cascades(&self) -> Vec<&StateAnomaly> {
        self.anomalies
            .iter()
            .filter(|a| matches!(a, StateAnomaly::DeltaSyncFailureCascade { .. }))
            .collect()
    }

    /// Produce a human-readable summary.
    pub fn display(&self) -> String {
        let mut out = String::new();
        out.push_str(&format!(
            "=== State Verification Report ===\n\
             Events analyzed: {} ({} state-mutating)\n\
             Contracts: {}\n\
             Anomalies: {}\n",
            self.total_events,
            self.state_events,
            self.contracts_analyzed,
            self.anomalies.len(),
        ));

        if self.anomalies.is_empty() {
            out.push_str("  No anomalies detected. All contracts converged.\n");
        } else {
            let missing = self.missing_broadcasts().len();
            let unapplied = self.unapplied_broadcasts().len();
            let divergences = self.divergences().len();
            let unexpected = self
                .anomalies
                .iter()
                .filter(|a| matches!(a, StateAnomaly::UnexpectedStateChange { .. }))
                .count();

            out.push_str(&format!(
                "  Missing broadcasts: {}\n\
                 Unapplied broadcasts: {}\n\
                 Unexpected state changes: {}\n\
                 Final divergences: {}\n",
                missing, unapplied, unexpected, divergences
            ));
        }

        for history in &self.contract_histories {
            out.push_str(&format!(
                "\n--- Contract: {} ---\n\
                 Transitions: {}, Broadcasts emitted: {}\n\
                 Final states: {}\n",
                history.contract_key,
                history.transitions.len(),
                history.emitted_broadcasts.len(),
                history
                    .final_peer_states
                    .iter()
                    .map(|(addr, hash)| format!("  {}={}", addr, hash))
                    .collect::<Vec<_>>()
                    .join("\n"),
            ));
        }

        if !self.anomalies.is_empty() {
            out.push_str("\n--- Anomalies ---\n");
            for (i, anomaly) in self.anomalies.iter().enumerate() {
                out.push_str(&format!("  [{}] {}\n", i + 1, anomaly));
            }
        }

        out
    }
}