print underlying error

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

@@ -19,7 +19,7 @@ use nym_api_requests::ecash::{
 };
 use nym_api_requests::models::{
     GatewayCoreStatusResponse, MixnodeCoreStatusResponse, MixnodeStatusResponse,
-    RewardEstimationResponse, StakeSaturationResponse,
+    NymNodeDescription, RewardEstimationResponse, StakeSaturationResponse,
 };
 use nym_api_requests::models::{LegacyDescribedGateway, MixNodeBondAnnotated};
 use nym_api_requests::nym_nodes::SkimmedNode;
@@ -320,7 +320,7 @@ impl NymApiClient {
         loop {
             let mut res = self
                 .nym_api
-                .get_all_basic_entry_assigned_nodes(
+                .get_basic_entry_assigned_nodes(
                     semver_compatibility.clone(),
                     false,
                     Some(page),
@@ -397,6 +397,27 @@ impl NymApiClient {
         Ok(self.nym_api.get_gateways_described().await?)
     }
 
+    pub async fn get_all_described_nodes(
+        &self,
+    ) -> Result<Vec<NymNodeDescription>, ValidatorClientError> {
+        // TODO: deal with paging in macro or some helper function or something, because it's the same pattern everywhere
+        let mut page = 0;
+        let mut descriptions = Vec::new();
+
+        loop {
+            let mut res = self.nym_api.get_nodes_described(Some(page), None).await?;
+
+            descriptions.append(&mut res.data);
+            if descriptions.len() < res.pagination.total {
+                page += 1
+            } else {
+                break;
+            }
+        }
+
+        Ok(descriptions)
+    }
+
     pub async fn get_gateway_core_status_count(
         &self,
         identity: IdentityKeyRef<'_>,

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

@@ -11,9 +11,10 @@ use nym_api_requests::ecash::models::{
 };
 use nym_api_requests::ecash::VerificationKeyResponse;
 use nym_api_requests::models::{
-    AnnotationResponse, LegacyDescribedMixNode, NodePerformanceResponse,
+    AnnotationResponse, LegacyDescribedMixNode, NodePerformanceResponse, NymNodeDescription,
 };
 use nym_api_requests::nym_nodes::PaginatedCachedNodesResponse;
+use nym_api_requests::pagination::PaginatedResponse;
 pub use nym_api_requests::{
     ecash::{
         models::{
@@ -119,6 +120,25 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
+    async fn get_nodes_described(
+        &self,
+        page: Option<u32>,
+        per_page: Option<u32>,
+    ) -> Result<PaginatedResponse<NymNodeDescription>, NymAPIError> {
+        let mut params = Vec::new();
+
+        if let Some(page) = page {
+            params.push(("page", page.to_string()))
+        }
+
+        if let Some(per_page) = per_page {
+            params.push(("per_page", per_page.to_string()))
+        }
+
+        self.get_json(&[routes::API_VERSION, "nym-nodes", "described"], &params)
+            .await
+    }
+
     async fn get_basic_mixnodes(
         &self,
         semver_compatibility: Option<String>,
@@ -167,7 +187,7 @@ pub trait NymApiClientExt: ApiClient {
 
     /// retrieve basic information for nodes are capable of operating as an entry gateway
     /// this includes legacy gateways and nym-nodes
-    async fn get_all_basic_entry_assigned_nodes(
+    async fn get_basic_entry_assigned_nodes(
         &self,
         semver_compatibility: Option<String>,
         no_legacy: bool,

common/wireguard/src/peer_controller.rs

@@ -158,10 +158,13 @@ impl<St: Storage + Clone + 'static> PeerController<St> {
             .ok_or(Error::MissingClientBandwidthEntry)?
             .client_id
         {
-            storage.create_bandwidth_entry(client_id).await?;
+            let bandwidth = storage
+                .get_available_bandwidth(client_id)
+                .await?
+                .ok_or(Error::MissingClientBandwidthEntry)?;
             Ok(Some(BandwidthStorageManager::new(
                 storage,
-                ClientBandwidth::new(Default::default()),
+                ClientBandwidth::new(bandwidth.into()),
                 client_id,
                 BandwidthFlushingBehaviourConfig::default(),
                 true,

common/wireguard/src/peer_handle.rs

@@ -84,12 +84,13 @@ impl<St: Storage + Clone + 'static> PeerHandle<St> {
                 .ok_or(Error::InconsistentConsumedBytes)?
                 .try_into()
                 .map_err(|_| Error::InconsistentConsumedBytes)?;
-            if bandwidth_manager
-                .write()
-                .await
-                .try_use_bandwidth(spent_bandwidth)
-                .await
-                .is_err()
+            if spent_bandwidth > 0
+                && bandwidth_manager
+                    .write()
+                    .await
+                    .try_use_bandwidth(spent_bandwidth)
+                    .await
+                    .is_err()
             {
                 let success = self.remove_peer().await?;
                 return Ok(!success);

nym-api/src/node_status_api/models.rs

@@ -437,7 +437,7 @@ pub enum NymApiStorageError {
     GatewayNotFound { identity: String },
 
     // I don't think we want to expose errors to the user about what really happened
-    #[error("experienced internal database error")]
+    #[error("experienced internal database error: {0}")]
     InternalDatabaseError(#[from] sqlx::Error),
 
     // the same is true here (also note that the message is subtly different so we would be able to distinguish them)

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

@@ -9,7 +9,7 @@ use axum::routing::get;
 use axum::{Json, Router};
 use nym_api_requests::models::{
     AnnotationResponse, NodeDatePerformanceResponse, NodePerformanceResponse, NoiseDetails,
-    NymNodeData, PerformanceHistoryResponse, UptimeHistoryResponse,
+    NymNodeDescription, PerformanceHistoryResponse, UptimeHistoryResponse,
 };
 use nym_api_requests::pagination::{PaginatedResponse, Pagination};
 use nym_contracts_common::NaiveFloat;
@@ -125,32 +125,27 @@ async fn get_bonded_nodes(
     path = "/described",
     context_path = "/v1/nym-nodes",
     responses(
-        (status = 200, body = PaginatedResponse<NymNodeData>)
+        (status = 200, body = PaginatedResponse<NymNodeDescription>)
     ),
     params(PaginationRequest)
 )]
 async fn get_described_nodes(
     State(state): State<AppState>,
     Query(pagination): Query<PaginationRequest>,
-) -> AxumResult<Json<PaginatedResponse<NymNodeData>>> {
+) -> AxumResult<Json<PaginatedResponse<NymNodeDescription>>> {
     // TODO: implement it
     let _ = pagination;
 
     let cache = state.described_nodes_cache.get().await?;
-    let descriptions = cache.all_nodes();
-
-    let data = descriptions
-        .map(|n| &n.description)
-        .cloned()
-        .collect::<Vec<_>>();
+    let descriptions = cache.all_nodes().cloned().collect::<Vec<_>>();
 
     Ok(Json(PaginatedResponse {
         pagination: Pagination {
-            total: data.len(),
+            total: descriptions.len(),
             page: 0,
-            size: data.len(),
+            size: descriptions.len(),
         },
-        data,
+        data: descriptions,
     }))
 }
 

service-providers/authenticator/src/mixnet_listener.rs

@@ -297,6 +297,10 @@ impl<S: Storage + Clone + 'static> MixnetListener<S> {
         credential: CredentialSpendingData,
         client_id: i64,
     ) -> Result<i64> {
+        ecash_verifier
+            .storage()
+            .create_bandwidth_entry(client_id)
+            .await?;
         let bandwidth = ecash_verifier
             .storage()
             .get_available_bandwidth(client_id)