ic-query 0.90.0

Internet Computer query library for CloudEngine, NNS, SNS, ICRC, system canisters, and public network metadata
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

use serde::{Deserialize, Serialize};

///
/// NnsTopologyAssessmentStatus
///
/// Overall result of a binary NNS topology report or consistency check.
///

#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum NnsTopologyAssessmentStatus {
    /// Every assessed invariant passed.
    Ok,
    /// At least one assessed invariant needs attention.
    Attention,
}

impl NnsTopologyAssessmentStatus {
    #[cfg(feature = "nns-host")]
    pub(crate) const fn from_ok(is_ok: bool) -> Self {
        if is_ok { Self::Ok } else { Self::Attention }
    }

    /// Return the stable serialized and text label.
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Ok => "ok",
            Self::Attention => "attention",
        }
    }
}

///
/// NnsTopologyCapacityStatus
///
/// Assignment state for one NNS node operator's Registry allowance.
///

#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum NnsTopologyCapacityStatus {
    /// Assigned node count exceeds the operator allowance.
    Over,
    /// Assigned node count is unavailable.
    Unknown,
    /// Assigned node count exactly consumes the operator allowance.
    Full,
    /// At least one node slot remains available.
    Available,
}

impl NnsTopologyCapacityStatus {
    /// Return the stable serialized and text label.
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Over => "over",
            Self::Unknown => "unknown",
            Self::Full => "full",
            Self::Available => "available",
        }
    }

    #[cfg(feature = "nns-host")]
    pub(crate) const fn sort_rank(self) -> u8 {
        match self {
            Self::Over => 0,
            Self::Unknown => 1,
            Self::Full => 2,
            Self::Available => 3,
        }
    }
}

///
/// NnsTopologyProviderStatus
///
/// Registry registration and capacity state for one NNS node provider.
///

#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum NnsTopologyProviderStatus {
    /// The provider is referenced by topology records but absent from Governance.
    UnknownProvider,
    /// At least one provider node operator exceeds its Registry allowance.
    Over,
    /// The registered provider has no nodes or node operators.
    Unused,
    /// The registered provider has topology activity without over-assignment.
    Ok,
}

impl NnsTopologyProviderStatus {
    /// Return the stable serialized and text label.
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::UnknownProvider => "unknown_provider",
            Self::Over => "over",
            Self::Unused => "unused",
            Self::Ok => "ok",
        }
    }

    #[cfg(feature = "nns-host")]
    pub(crate) const fn sort_rank(self) -> u8 {
        match self {
            Self::UnknownProvider => 0,
            Self::Over => 1,
            Self::Unused => 2,
            Self::Ok => 3,
        }
    }
}

#[cfg(test)]
mod tests;