skimmed batch endpoint implemented

Author: jmwample

common/client-core/src/client/topology_control/smart_api_provider.rs

@@ -1,7 +1,7 @@
 // Copyright 2024 - Nym Technologies SA <[email protected]>
 // SPDX-License-Identifier: GPL-3.0-only
 
-//!
+//! Caching, piecewise API Topology Provider
 //!
 
 #![warn(missing_docs)]
@@ -16,8 +16,6 @@ use nym_validator_client::UserAgent;
 use rand::{prelude::SliceRandom, thread_rng};
 use url::Url;
 
-use std::collections::HashMap;
-
 /// Topology Provider build around a cached piecewise provider that uses the Nym API to
 /// fetch changes and node details.
 #[derive(Clone)]
@@ -113,8 +111,28 @@ impl PiecewiseTopologyProvider for NymApiPiecewiseProvider {
         Some(topology)
     }
 
-    async fn get_descriptor_batch(&mut self, ids: &[u32]) -> Option<HashMap<u32, RoutingNode>> {
-        todo!("blocking on node batch endpoint")
+    async fn get_descriptor_batch(&mut self, ids: &[u32]) -> Option<Vec<RoutingNode>> {
+        // Does this need to return a hashmap of RoutingNodes? that is moderately inconvenient
+        // especially when the nodes themselves contain their node_id unless we expect to directly
+        // use the result of this fn for lookups where we would otherwise for example, have to
+        // iterate over a whole vec to find a specific node_id.
+        let descriptor_vec = self
+            .validator_client
+            .retrieve_basic_nodes_batch(ids)
+            .await
+            .inspect_err(|err| {
+                self.use_next_nym_api();
+                error!("failed to get current rewarded set: {err}");
+            })
+            .ok()?;
+
+        let mut out = Vec::new();
+        for node in descriptor_vec {
+            if let Ok(routing_node) = RoutingNode::try_from(&node) {
+                let _ = out.push(routing_node);
+            }
+        }
+        Some(out)
     }
 
     async fn get_layer_assignments(&mut self) -> Option<EpochRewardedSet> {

common/client-libs/validator-client/src/client.rs

@@ -498,9 +498,19 @@ impl NymApiClient {
         Ok(nodes)
     }
 
-    /// retrieve basic information for all bonded nodes on the network
-    pub async fn retrieve_basic_nodes_batch(&self, node_ids: Vec<u32>) -> Result<Vec<SkimmedNode>, ValidatorClientError> {
-        Ok(self.nym_api.retrieve_basic_nodes_batch(&node_ids).await?.nodes)
+    /// Batch request for node descriptors in the current topology.
+    ///
+    /// Given the set of node IDs included in the request body, provide the descriptor for each
+    /// associated node in if it is available in the current topology.
+    pub async fn retrieve_basic_nodes_batch(
+        &self,
+        node_ids: &[u32],
+    ) -> Result<Vec<SkimmedNode>, ValidatorClientError> {
+        Ok(self
+            .nym_api
+            .retrieve_basic_nodes_batch(node_ids)
+            .await?
+            .nodes)
     }
 
     pub async fn health(&self) -> Result<ApiHealthResponse, ValidatorClientError> {

common/topology/src/providers/piecewise.rs

@@ -12,12 +12,7 @@ use time::OffsetDateTime;
 use tokio::sync::Mutex;
 use tracing::{debug, warn};
 
-use std::{
-    cmp::min,
-    collections::{HashMap, HashSet},
-    sync::Arc,
-    time::Duration,
-};
+use std::{cmp::min, collections::HashSet, sync::Arc, time::Duration};
 
 /// Topology filtering and caching configuration
 #[derive(Debug)]
@@ -198,7 +193,7 @@ impl<M: PiecewiseTopologyProvider> NymTopologyProviderInner<M> {
 
             // Add the new nodes to our cached topology
             if let Some(new_descriptors) = response {
-                cached_topology.add_routing_nodes(new_descriptors.values());
+                cached_topology.add_routing_nodes(new_descriptors);
             }
 
             // double check that we have the expected nodes
@@ -264,7 +259,7 @@ pub trait PiecewiseTopologyProvider: Send {
     async fn get_full_topology(&mut self) -> Option<NymTopology>;
 
     /// Fetch a node descriptors for the set of provided IDs if available.
-    async fn get_descriptor_batch(&mut self, ids: &[u32]) -> Option<HashMap<u32, RoutingNode>>;
+    async fn get_descriptor_batch(&mut self, ids: &[u32]) -> Option<Vec<RoutingNode>>;
 
     /// Fetch the latest mapping of node IDs to Nym Network layer.
     async fn get_layer_assignments(&mut self) -> Option<EpochRewardedSet>;
@@ -289,11 +284,11 @@ mod test {
             Some(self.topo.clone())
         }
 
-        async fn get_descriptor_batch(&mut self, ids: &[u32]) -> Option<HashMap<u32, RoutingNode>> {
-            let mut nodes = HashMap::new();
+        async fn get_descriptor_batch(&mut self, ids: &[u32]) -> Option<Vec<RoutingNode>> {
+            let mut nodes = Vec::new();
             ids.iter().for_each(|id| {
                 if let Some(node) = self.topo.node_details.get(id) {
-                    nodes.insert(*id, node.clone());
+                    nodes.push(node.clone());
                 }
             });
 

nym-api/src/network_monitor/monitor/preparer.rs

@@ -10,7 +10,7 @@ use crate::support::caching::cache::SharedCache;
 use crate::support::legacy_helpers::legacy_host_to_ips_and_hostname;
 use nym_api_requests::legacy::{LegacyGatewayBondWithId, LegacyMixNodeBondWithLayer};
 use nym_api_requests::models::{NodeAnnotation, NymNodeDescription};
-use nym_contracts_common::NaiveFloat;
+use nym_contracts_common::{NaiveFloat, Percent};
 use nym_crypto::asymmetric::{encryption, identity};
 use nym_mixnet_contract_common::{LegacyMixLayer, NodeId};
 use nym_node_tester_utils::node::{NodeType, TestableNode};
@@ -231,6 +231,8 @@ impl PacketPreparer {
                     mixnet_entry: false,
                     mixnet_exit: false,
                 },
+                // We have no information about performance in legacy node formats
+                performance: Percent::hundred(),
             })
         }
 
@@ -263,6 +265,8 @@ impl PacketPreparer {
                     mixnet_entry: true,
                     mixnet_exit: false,
                 },
+                // We have no information about performance in legacy node formats
+                performance: Percent::hundred(),
             })
         }
 

nym-api/src/nym_nodes/handlers/unstable/mod.rs

@@ -26,7 +26,7 @@ use crate::nym_nodes::handlers::unstable::semi_skimmed::nodes_expanded;
 use crate::nym_nodes::handlers::unstable::skimmed::{
     entry_gateways_basic_active, entry_gateways_basic_all, exit_gateways_basic_active,
     exit_gateways_basic_all, mixnodes_basic_active, mixnodes_basic_all, nodes_basic_active,
-    nodes_basic_all,
+    nodes_basic_all, nodes_basic_batch,
 };
 use crate::support::http::helpers::PaginationRequest;
 use crate::support::http::state::AppState;
@@ -52,6 +52,7 @@ pub(crate) fn nym_node_routes_unstable() -> Router<AppState> {
             "/skimmed",
             Router::new()
                 .route("/", get(nodes_basic_all))
+                .route("/batch", post(nodes_basic_batch))
                 .route("/active", get(nodes_basic_active))
                 .nest(
                     "/mixnodes",

nym-api/src/nym_nodes/handlers/unstable/skimmed.rs

@@ -240,7 +240,7 @@ async fn nodes_basic(
     state: State<AppState>,
     Query(_query_params): Query<NodesParams>,
     active_only: bool,
-) -> SkimmedNodes {
+) -> AxumResult<CachedNodesResponse<SkimmedNode>> {
     // unfortunately we have to build the response semi-manually here as we need to add two sources of legacy nodes
 
     // 1. grab all relevant described nym-nodes
@@ -282,10 +282,10 @@ async fn nodes_basic(
         legacy_gateways.timestamp(),
     ]);
 
-    Ok(Json(CachedNodesResponse {
+    Ok(CachedNodesResponse {
         refreshed_at,
         nodes,
-    }))
+    })
 }
 
 #[allow(dead_code)] // not dead, used in OpenAPI docs
@@ -327,7 +327,12 @@ pub(super) async fn nodes_basic_all(
         };
     }
 
-    nodes_basic(state, Query(query_params.into()), false).await
+    let nodes = nodes_basic(state, Query(query_params.into()), false).await?;
+    // We are never using pagination (always one page) anyways so just build it here.
+    Ok(Json(PaginatedCachedNodesResponse::new_full(
+        nodes.refreshed_at,
+        nodes.nodes,
+    )))
 }
 
 /// Post request handler taking a json array of NodeId (u32) values and returning descriptors for
@@ -351,8 +356,18 @@ pub(super) async fn nodes_basic_all(
 pub(super) async fn nodes_basic_batch(
     state: State<AppState>,
     Query(query_params): Query<NodesParamsWithRole>,
+    Json(ids): Json<Vec<u32>>,
 ) -> SkimmedNodes {
-    nodes_basic(state, Query(query_params.into()), false).await
+    let nodes = nodes_basic(state, Query(query_params.into()), false).await?;
+    let requested_nodes = nodes
+        .nodes
+        .into_iter()
+        .filter(|node| ids.contains(&node.node_id))
+        .collect();
+    Ok(Json(CachedNodesResponse {
+        nodes: requested_nodes,
+        refreshed_at: nodes.refreshed_at,
+    }))
 }
 
 /// Return Nym Nodes and optionally legacy mixnodes/gateways (if `no-legacy` flag is not used)
@@ -385,7 +400,12 @@ pub(super) async fn nodes_basic_active(
         };
     }
 
-    nodes_basic(state, Query(query_params.into()), true).await
+    let nodes = nodes_basic(state, Query(query_params.into()), true).await?;
+    // We are never using pagination (always one page) anyways so just build it here.
+    Ok(Json(PaginatedCachedNodesResponse::new_full(
+        nodes.refreshed_at,
+        nodes.nodes,
+    )))
 }
 
 async fn mixnodes_basic(

nym-node/Cargo.toml

@@ -71,6 +71,7 @@ nym-verloc = { path = "../common/verloc" }
 nym-metrics = { path = "../common/nym-metrics" }
 nym-gateway-stats-storage = { path = "../common/gateway-stats-storage" }
 nym-topology = { path = "../common/topology" }
+nym-contracts-common = { path = "../common/cosmwasm-smart-contracts/contracts-common", features = ["naive_float", "utoipa"] }
 
 
 # http server

nym-node/src/node/mod.rs

@@ -32,6 +32,7 @@ use crate::node::shared_network::{
     CachedNetwork, CachedTopologyProvider, NetworkRefresher, RoutingFilter,
 };
 use nym_bin_common::bin_info;
+use nym_contracts_common::Percent;
 use nym_crypto::asymmetric::{ed25519, x25519};
 use nym_gateway::node::{ActiveClientsStore, GatewayTasksBuilder};
 use nym_mixnet_client::client::ActiveConnections;
@@ -579,6 +580,8 @@ impl NymNode {
                 mixnet_entry: true,
                 mixnet_exit: true,
             },
+            // Perf metrics are not meaningful in this context.
+            performance: Percent::hundred(),
         })
     }
 

sdk/rust/nym-sdk/src/mixnet.rs

@@ -83,7 +83,7 @@ pub use nym_statistics_common::clients::{
     connection::ConnectionStatsEvent, ClientStatsEvents, ClientStatsSender,
 };
 pub use nym_task::connections::TransmissionLane;
-pub use nym_topology::{provider_trait::TopologyProvider, NymTopology};
+pub use nym_topology::{providers::TopologyProvider, NymTopology};
 pub use paths::StoragePaths;
 pub use socks5_client::Socks5MixnetClient;
 pub use traits::MixnetMessageSender;

sdk/rust/nym-sdk/src/mixnet/client.rs

@@ -32,7 +32,7 @@ use nym_credentials_interface::TicketType;
 use nym_crypto::hkdf::DerivationMaterial;
 use nym_socks5_client_core::config::Socks5;
 use nym_task::{TaskClient, TaskHandle, TaskStatus};
-use nym_topology::provider_trait::TopologyProvider;
+use nym_topology::providers::TopologyProvider;
 use nym_validator_client::{nyxd, QueryHttpRpcNyxdClient, UserAgent};
 use rand::rngs::OsRng;
 use std::path::Path;