docs: update CHANGELOG with new readiness checks and methods in Rust client

feat(health): add `readyz()` and `is_ready()` methods to Rust `HealthClient`
feat(health): introduce `ReadinessStatus` enum for Rust client
refactor: update Rust client example to demonstrate liveness and readiness checks

Author: randygrok

CHANGELOG.md

@@ -16,13 +16,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Added aggregator block production rate check to `/health/ready` endpoint to ensure aggregators are producing blocks within expected timeframe (5x block time) ([#2800](https://github.com/evstack/ev-node/pull/2800))
 - Added `GetReadiness()` method to Go RPC client for checking `/health/ready` endpoint ([#2800](https://github.com/evstack/ev-node/pull/2800))
 - Added `ReadinessStatus` type to Go RPC client with READY/UNREADY/UNKNOWN states ([#2800](https://github.com/evstack/ev-node/pull/2800))
+- Added `readyz()` and `is_ready()` methods to Rust `HealthClient` for checking `/health/ready` endpoint ([#2800](https://github.com/evstack/ev-node/pull/2800))
+- Added `ReadinessStatus` enum to Rust client with Ready/Unready/Unknown states ([#2800](https://github.com/evstack/ev-node/pull/2800))
 
 ### Changed
 
 - Use cache instead of in memory store for reaper. Persist cache on reload. Autoclean after 24 hours. ([#2811](https://github.com/evstack/ev-node/pull/2811))
 - Simplified `/health/live` endpoint to only check store accessibility (liveness) instead of business logic, following Kubernetes best practices ([#2800](https://github.com/evstack/ev-node/pull/2800))
 - Updated `/health/ready` endpoint to use `GetState()` instead of `Height()` to access block production timing information ([#2800](https://github.com/evstack/ev-node/pull/2800))
 - Renamed integration test from `TestHealthEndpointWhenBlockProductionStops` to `TestReadinessEndpointWhenBlockProductionStops` to correctly test readiness endpoint ([#2800](https://github.com/evstack/ev-node/pull/2800))
+- Updated Rust client example (`client/crates/client/examples/basic.rs`) to demonstrate both liveness and readiness checks ([#2800](https://github.com/evstack/ev-node/pull/2800))
 
 ### Removed
 

client/crates/client/examples/basic.rs

@@ -1,4 +1,4 @@
-use ev_client::{Client, HealthClient, P2PClient, StoreClient};
+use ev_client::{health::HealthClient, Client, P2PClient, StoreClient};
 use std::error::Error;
 
 #[tokio::main]
@@ -14,15 +14,26 @@ async fn main() -> Result<(), Box<dyn Error>> {
     let client = Client::connect(&endpoint).await?;
     println!("Successfully connected to evolve node");
 
-    // Check health status
+    // Check health status (HTTP endpoints)
     println!("\n=== Health Check ===");
-    let health = HealthClient::new(&client);
-    match health.get_health().await {
-        Ok(health_response) => {
-            println!("Health status: {:?}", health_response.status());
-            println!("Node is healthy: {}", health.is_healthy().await?);
+    let health = HealthClient::with_base_url(endpoint.clone());
+
+    // Liveness check - is the process alive?
+    match health.livez().await {
+        Ok(status) => {
+            println!("Liveness status: {:?}", status);
+            println!("Node is alive: {}", health.is_healthy().await?);
+        }
+        Err(e) => println!("Failed to get liveness status: {e}"),
+    }
+
+    // Readiness check - can it serve correct data?
+    match health.readyz().await {
+        Ok(status) => {
+            println!("Readiness status: {:?}", status);
+            println!("Node is ready: {}", health.is_ready().await?);
         }
-        Err(e) => println!("Failed to get health status: {e}"),
+        Err(e) => println!("Failed to get readiness status: {e}"),
     }
 
     // Get P2P information

client/crates/client/src/health.rs

@@ -1,6 +1,6 @@
 use crate::{client::Client, error::Result};
 
-/// Health status of the node
+/// Health status of the node (liveness check)
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum HealthStatus {
     /// Node is operating normally
@@ -13,6 +13,17 @@ pub enum HealthStatus {
     Unknown,
 }
 
+/// Readiness status of the node (can serve correct data)
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ReadinessStatus {
+    /// Node is ready to serve traffic
+    Ready,
+    /// Node is not ready to serve traffic
+    Unready,
+    /// Unknown readiness status
+    Unknown,
+}
+
 pub struct HealthClient {
     base_url: String,
     http_client: reqwest::Client,
@@ -37,7 +48,10 @@ impl HealthClient {
         }
     }
 
-    /// Check if the node is alive and get its health status
+    /// Check if the node is alive and get its health status (liveness check)
+    ///
+    /// This endpoint checks if the process is alive and responsive.
+    /// A failing liveness check should result in killing/restarting the process.
     pub async fn livez(&self) -> Result<HealthStatus> {
         let url = format!("{}/health/live", self.base_url);
         let response = self.http_client.get(&url).send().await?;
@@ -52,9 +66,35 @@ impl HealthClient {
         }
     }
 
-    /// Check if the node is healthy (status is PASS)
+    /// Check if the node is ready to serve correct data (readiness check)
+    ///
+    /// This endpoint checks if the node can serve correct data to clients.
+    /// A failing readiness check should remove the node from load balancer
+    /// but NOT kill the process.
+    pub async fn readyz(&self) -> Result<ReadinessStatus> {
+        let url = format!("{}/health/ready", self.base_url);
+        let response = self.http_client.get(&url).send().await?;
+
+        let status_text = response.text().await?.trim().to_string();
+
+        if status_text.starts_with("READY") {
+            Ok(ReadinessStatus::Ready)
+        } else if status_text.starts_with("UNREADY") {
+            Ok(ReadinessStatus::Unready)
+        } else {
+            Ok(ReadinessStatus::Unknown)
+        }
+    }
+
+    /// Check if the node is healthy (liveness status is PASS)
     pub async fn is_healthy(&self) -> Result<bool> {
         let status = self.livez().await?;
         Ok(status == HealthStatus::Pass)
     }
+
+    /// Check if the node is ready (readiness status is READY)
+    pub async fn is_ready(&self) -> Result<bool> {
+        let status = self.readyz().await?;
+        Ok(status == ReadinessStatus::Ready)
+    }
 }

client/crates/client/src/lib.rs

@@ -88,7 +88,7 @@ pub mod store;
 pub use client::{Client, ClientBuilder};
 pub use config::ConfigClient;
 pub use error::{ClientError, Result};
-pub use health::HealthClient;
+pub use health::{HealthClient, HealthStatus, ReadinessStatus};
 pub use p2p::P2PClient;
 pub use signer::SignerClient;
 pub use store::StoreClient;

client/crates/types/tests/feature_test.rs

@@ -10,13 +10,11 @@ fn test_message_types_available() {
 #[test]
 fn test_grpc_types_available() {
     // These should only be available with the grpc feature
-    use ev_types::v1::health_service_client::HealthServiceClient;
     use ev_types::v1::p2p_service_client::P2pServiceClient;
     use ev_types::v1::signer_service_client::SignerServiceClient;
     use ev_types::v1::store_service_client::StoreServiceClient;
 
     // Just verify the types exist
-    let _ = std::any::type_name::<HealthServiceClient<tonic::transport::Channel>>();
     let _ = std::any::type_name::<P2pServiceClient<tonic::transport::Channel>>();
     let _ = std::any::type_name::<SignerServiceClient<tonic::transport::Channel>>();
     let _ = std::any::type_name::<StoreServiceClient<tonic::transport::Channel>>();

pkg/rpc/client/client_test.go

@@ -26,7 +26,7 @@ import (
 
 // setupTestServerOptions holds optional parameters for setupTestServer
 type setupTestServerOptions struct {
-	config                   *config.Config
+	config                  *config.Config
 	bestKnownHeightProvider server.BestKnownHeightProvider
 }