Add nodes/delegations endpoint (#5733)

* WIP

* Add /delegations endpoint

* Bump package version

* Remove node_id field

Author: dynco-nym

Cargo.lock

@@ -3,7 +3,7 @@
 
 [package]
 name = "nym-node-status-api"
-version = "2.2.0"
+version = "2.3.0"
 authors.workspace = true
 repository.workspace = true
 homepage.workspace = true

nym-node-status-api/nym-node-status-api/Cargo.toml

@@ -1,18 +1,26 @@
 use axum::{
-    extract::{Query, State},
+    extract::{Path, Query, State},
     Json, Router,
 };
+use nym_validator_client::client::NodeId;
+use serde::Deserialize;
 use tracing::instrument;
+use utoipa::IntoParams;
 
 use crate::http::{
     error::{HttpError, HttpResult},
-    models::ExtendedNymNode,
+    models::{ExtendedNymNode, NodeDelegation},
     state::AppState,
     PagedResult, Pagination,
 };
 
 pub(crate) fn routes() -> Router<AppState> {
-    Router::new().route("/", axum::routing::get(nym_nodes))
+    Router::new()
+        .route("/", axum::routing::get(nym_nodes))
+        .route(
+            "/:node_id/delegations",
+            axum::routing::get(node_delegations),
+        )
 }
 
 #[utoipa::path(
@@ -27,7 +35,7 @@ pub(crate) fn routes() -> Router<AppState> {
         (status = 200, body = PagedResult<ExtendedNymNode>)
     )
 )]
-#[instrument(level = tracing::Level::DEBUG, skip_all, fields(page=pagination.page, size=pagination.size))]
+#[instrument(level = tracing::Level::INFO, skip_all, fields(page=pagination.page, size=pagination.size))]
 async fn nym_nodes(
     Query(pagination): Query<Pagination>,
     State(state): State<AppState>,
@@ -46,3 +54,35 @@ async fn nym_nodes(
 
     Ok(Json(PagedResult::paginate(pagination, nodes)))
 }
+
+#[allow(dead_code)] // clippy doesn't detect usage in utoipa macros
+#[derive(Deserialize, IntoParams)]
+#[into_params(parameter_in = Path)]
+struct NodeIdParam {
+    #[param(minimum = 0)]
+    node_id: NodeId,
+}
+
+#[utoipa::path(
+    tag = "Nym Explorer",
+    get,
+    params(
+        NodeIdParam
+    ),
+    path = "/{node_id}/delegations",
+    context_path = "/explorer/v3/nym-nodes",
+    responses(
+        (status = 200, body = NodeDelegation)
+    )
+)]
+#[instrument(level = tracing::Level::INFO, skip(state))]
+async fn node_delegations(
+    Path(node_id): Path<NodeId>,
+    State(state): State<AppState>,
+) -> HttpResult<Json<Vec<NodeDelegation>>> {
+    state
+        .node_delegations(node_id)
+        .await
+        .ok_or_else(|| HttpError::no_delegations_for_node(node_id))
+        .map(Json)
+}

nym-node-status-api/nym-node-status-api/src/http/api/nym_nodes.rs

@@ -1,3 +1,4 @@
+use nym_mixnet_contract_common::NodeId;
 use std::fmt::Display;
 
 pub(crate) type HttpResult<T> = Result<T, HttpError>;
@@ -40,6 +41,14 @@ impl HttpError {
             status: axum::http::StatusCode::SERVICE_UNAVAILABLE,
         }
     }
+
+    pub(crate) fn no_delegations_for_node(node_id: NodeId) -> Self {
+        Self {
+            message: serde_json::json!({"message": format!("No delegation data for node_id={}", node_id)})
+                .to_string(),
+            status: axum::http::StatusCode::NOT_FOUND,
+        }
+    }
 }
 
 impl axum::response::IntoResponse for HttpError {

nym-node-status-api/nym-node-status-api/src/http/error.rs

@@ -1,4 +1,5 @@
-use cosmwasm_std::Decimal;
+use cosmwasm_std::{Addr, Coin, Decimal};
+use nym_mixnet_contract_common::CoinSchema;
 use nym_node_requests::api::v1::node::models::NodeDescription;
 use nym_validator_client::client::NodeId;
 use serde::{Deserialize, Serialize};
@@ -120,3 +121,27 @@ pub struct SessionStats {
     pub mixnet_sessions: Option<serde_json::Value>,
     pub unknown_sessions: Option<serde_json::Value>,
 }
+
+#[derive(Debug, Clone, Deserialize, Serialize, ToSchema)]
+pub struct NodeDelegation {
+    #[schema(value_type = CoinSchema)]
+    pub amount: Coin,
+    pub cumulative_reward_ratio: String,
+    pub block_height: u64,
+    #[schema(value_type = String)]
+    pub owner: Addr,
+    #[schema(value_type = Option<String>)]
+    pub proxy: Option<Addr>,
+}
+
+impl From<nym_mixnet_contract_common::Delegation> for NodeDelegation {
+    fn from(value: nym_mixnet_contract_common::Delegation) -> Self {
+        Self {
+            amount: value.amount,
+            cumulative_reward_ratio: value.cumulative_reward_ratio.to_string(),
+            block_height: value.height,
+            owner: value.owner,
+            proxy: value.proxy,
+        }
+    }
+}

nym-node-status-api/nym-node-status-api/src/http/models.rs

@@ -1,13 +1,14 @@
 use axum::Router;
 use core::net::SocketAddr;
 use nym_crypto::asymmetric::ed25519::PublicKey;
-use tokio::{net::TcpListener, task::JoinHandle};
+use std::sync::Arc;
+use tokio::{net::TcpListener, sync::RwLock, task::JoinHandle};
 use tokio_util::sync::{CancellationToken, WaitForCancellationFutureOwned};
 
 use crate::{
     db::DbPool,
     http::{api::RouterBuilder, state::AppState},
-    monitor::NodeGeoCache,
+    monitor::{DelegationsCache, NodeGeoCache},
 };
 
 /// Return handles that allow for graceful shutdown of server + awaiting its
@@ -19,6 +20,7 @@ pub(crate) async fn start_http_api(
     agent_key_list: Vec<PublicKey>,
     agent_max_count: i64,
     node_geocache: NodeGeoCache,
+    node_delegations: Arc<RwLock<DelegationsCache>>,
 ) -> anyhow::Result<ShutdownHandles> {
     let router_builder = RouterBuilder::with_default_routes();
 
@@ -28,6 +30,7 @@ pub(crate) async fn start_http_api(
         agent_key_list,
         agent_max_count,
         node_geocache,
+        node_delegations,
     )
     .await;
     let router = router_builder.with_state(state);

nym-node-status-api/nym-node-status-api/src/http/server.rs

@@ -1,17 +1,17 @@
-use std::{collections::HashMap, sync::Arc, time::Duration};
-
 use cosmwasm_std::Decimal;
 use moka::{future::Cache, Entry};
 use nym_contracts_common::NaiveFloat;
 use nym_crypto::asymmetric::ed25519::PublicKey;
+use nym_mixnet_contract_common::NodeId;
 use nym_validator_client::nym_api::SkimmedNode;
+use std::{collections::HashMap, sync::Arc, time::Duration};
 use tokio::sync::RwLock;
 use tracing::instrument;
 
 use crate::{
     db::{queries, DbPool},
     http::models::{DailyStats, ExtendedNymNode, Gateway, Mixnode, NodeGeoData, SummaryHistory},
-    monitor::NodeGeoCache,
+    monitor::{DelegationsCache, NodeGeoCache},
 };
 
 use super::models::SessionStats;
@@ -23,6 +23,7 @@ pub(crate) struct AppState {
     agent_key_list: Vec<PublicKey>,
     agent_max_count: i64,
     node_geocache: NodeGeoCache,
+    node_delegations: Arc<RwLock<DelegationsCache>>,
 }
 
 impl AppState {
@@ -32,13 +33,15 @@ impl AppState {
         agent_key_list: Vec<PublicKey>,
         agent_max_count: i64,
         node_geocache: NodeGeoCache,
+        node_delegations: Arc<RwLock<DelegationsCache>>,
     ) -> Self {
         Self {
             db_pool,
             cache: HttpCache::new(cache_ttl).await,
             agent_key_list,
             agent_max_count,
             node_geocache,
+            node_delegations,
         }
     }
 
@@ -61,6 +64,16 @@ impl AppState {
     pub(crate) fn node_geocache(&self) -> NodeGeoCache {
         self.node_geocache.clone()
     }
+
+    pub(crate) async fn node_delegations(
+        &self,
+        node_id: NodeId,
+    ) -> Option<Vec<super::models::NodeDelegation>> {
+        self.node_delegations
+            .read()
+            .await
+            .delegations_owned(node_id)
+    }
 }
 
 static GATEWAYS_LIST_KEY: &str = "gateways";

nym-node-status-api/nym-node-status-api/src/http/state.rs

@@ -1,6 +1,9 @@
+use crate::monitor::DelegationsCache;
 use clap::Parser;
 use nym_crypto::asymmetric::ed25519::PublicKey;
 use nym_task::signal::wait_for_signal;
+use nym_validator_client::nyxd::NyxdClient;
+use std::sync::Arc;
 
 mod cli;
 mod db;
@@ -41,19 +44,27 @@ async fn main() -> anyhow::Result<()> {
     let geocache = moka::future::Cache::builder()
         .time_to_live(args.geodata_ttl)
         .build();
+    let delegations_cache = DelegationsCache::new();
 
     // Start the monitor
     let args_clone = args.clone();
     let geocache_clone = geocache.clone();
+    let delegations_cache_clone = Arc::clone(&delegations_cache);
+    let config = nym_validator_client::nyxd::Config::try_from_nym_network_details(
+        &nym_network_defaults::NymNetworkDetails::new_from_env(),
+    )?;
+    let nyxd_client = NyxdClient::connect(config, args.nyxd_addr.as_str())
+        .map_err(|err| anyhow::anyhow!("Couldn't connect: {}", err))?;
 
     tokio::spawn(async move {
         monitor::spawn_in_background(
             db_pool,
             args_clone.nym_api_client_timeout,
-            args_clone.nyxd_addr,
+            nyxd_client,
             args_clone.monitor_refresh_interval,
             args_clone.ipinfo_api_token,
             geocache_clone,
+            delegations_cache_clone,
         )
         .await;
         tracing::info!("Started monitor task");
@@ -74,6 +85,7 @@ async fn main() -> anyhow::Result<()> {
         agent_key_list.to_owned(),
         args.max_agent_count,
         geocache,
+        delegations_cache,
     )
     .await
     .expect("Failed to start server");