sigil-node · health

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum HealthStatus {
    /// Node is healthy, synced, and participating normally.
    Healthy,
    /// Node is syncing and not yet caught up to the network tip.
    Syncing,
    /// Node is degraded — operational but experiencing issues.
    Degraded,
    /// Node is not operational.
    Unhealthy,
}

pub fn is_serving(&self) -> bool;

pub fn is_healthy(&self) -> bool;

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct SyncState {
/// Whether the node has completed initial sync.

pub synced: bool,
/// Current block height on this node.

pub current_height: u64,
/// Highest block height known from peers.

pub highest_known_height: u64,
/// Number of blocks remaining to sync.

pub blocks_behind: u64,
/// Current epoch number.

pub current_epoch: u64
}

pub fn progress(&self) -> f64;

#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct NodeMetrics {
/// Total blocks processed (produced + validated + synced).

pub blocks_processed: u64,
/// Total transactions processed across all blocks.

pub transactions_processed: u64,
/// Number of blocks this node proposed (validator/producer modes only).

pub blocks_proposed: u64,
/// Number of consensus votes cast (validator/producer modes only).

pub votes_cast: u64,
/// Number of peers currently connected.

pub peer_count: u32,
/// Number of transactions in the mempool.

pub mempool_size: u32,
/// Total bytes received from the P2P network.

pub bytes_received: u64,
/// Total bytes sent on the P2P network.

pub bytes_sent: u64
}

pub fn new() -> Self;

pub fn record_block(&mut self, tx_count: u64);

pub fn record_proposal(&mut self);

pub fn record_vote(&mut self);

#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct TowerMetrics {
/// Current Tower slot number.

pub current_slot: u64,
/// Current Tower epoch.

pub current_epoch: u64,
/// Latest finalized epoch via Casper FFG.

pub finalized_epoch: u64,
/// Total finality votes this node has cast.

pub finality_votes_cast: u64,
/// Total committee attestations this node has produced.

pub attestations_produced: u64
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct HealthCheck {
/// Overall health status.

pub status: HealthStatus,
/// Software version.

pub version: String,
/// Chain ID.

pub chain_id: String,
/// Node operating mode.

pub node_mode: String,
/// Sync state relative to the network.

pub sync: SyncState,
/// Activity counters.

pub metrics: NodeMetrics,
/// Tower chain metrics (present only for Tower-aware modes).

#[serde(default, skip_serializing_if = "Option::is_none")]
pub tower: Option<TowerMetrics>,
/// Unix timestamp of this health check.

pub timestamp: u64,
/// Node uptime in seconds.

pub uptime_secs: u64
}

pub fn compute_status(synced: bool, peer_count: u32) -> HealthStatus;