ic-query 0.103.1

Internet Computer query library for CloudEngine, NNS, SNS, ICRC, system canisters, and public network metadata
Documentation
//! Module: ic::live::node_provider_reward
//!
//! Responsibility: live Dashboard node-provider reward URL and wire handling.
//! Does not own: report validation, CLI parsing, provenance projection, or rendering.
//! Boundary: performs one page, one exact record, or one bounded history request.

use super::{LiveIcSource, dashboard_resource_url};
use crate::ic::{
    IcHostError, IcNodeProviderRewardHistoryObservation, IcNodeProviderRewardHistoryQuery,
    IcNodeProviderRewardHistorySourceData, IcNodeProviderRewardInfoSourceData,
    IcNodeProviderRewardListQuery, IcNodeProviderRewardListSourceData, IcNodeProviderRewardRow,
    IcNodeProviderRewardSource, IcSourceRequest, model::decoding::number_to_u64, source,
};
use serde::Deserialize as SerdeDeserialize;
use serde_json::Number;
use url::Url;

impl IcNodeProviderRewardSource for LiveIcSource {
    fn fetch_node_provider_reward_list<'a>(
        &'a self,
        request: &'a IcSourceRequest,
        query: &'a IcNodeProviderRewardListQuery,
    ) -> crate::report::SourceFuture<'a, Result<IcNodeProviderRewardListSourceData, IcHostError>>
    {
        Box::pin(async move {
            source::validate_node_provider_reward_list_query(query)?;
            let url = node_provider_reward_list_url(&request.endpoint, query)?;
            let wire: DashboardNodeProviderRewardList = self.fetch_live(url).await?;
            Ok(wire.into_source_data(request, query))
        })
    }

    fn fetch_node_provider_reward_info<'a>(
        &'a self,
        request: &'a IcSourceRequest,
        reward_id: u64,
    ) -> crate::report::SourceFuture<'a, Result<IcNodeProviderRewardInfoSourceData, IcHostError>>
    {
        Box::pin(async move {
            let url = node_provider_reward_info_url(&request.endpoint, reward_id)?;
            let wire: IcNodeProviderRewardRow = self.fetch_live(url).await?;
            Ok(IcNodeProviderRewardInfoSourceData {
                source: request.clone(),
                reward: wire,
            })
        })
    }

    fn fetch_node_provider_reward_history<'a>(
        &'a self,
        request: &'a IcSourceRequest,
        query: &'a IcNodeProviderRewardHistoryQuery,
    ) -> crate::report::SourceFuture<'a, Result<IcNodeProviderRewardHistorySourceData, IcHostError>>
    {
        Box::pin(async move {
            source::validate_node_provider_reward_history_query(query)?;
            let url = node_provider_reward_history_url(&request.endpoint, query)?;
            let wire: DashboardNodeProviderRewardHistory = self.fetch_live(url).await?;
            Ok(IcNodeProviderRewardHistorySourceData {
                source: request.clone(),
                query: query.clone(),
                observations: wire
                    .reward_node_providers
                    .into_iter()
                    .map(|[amount, timestamp]| {
                        Ok(IcNodeProviderRewardHistoryObservation {
                            timestamp_unix_secs: number_to_u64(
                                "reward history timestamp",
                                timestamp,
                            )
                            .map_err(|reason| IcHostError::InvalidSourceData { reason })?,
                            amount_e8s: number_to_u64("reward history amount_e8s", amount)
                                .map_err(|reason| IcHostError::InvalidSourceData { reason })?,
                        })
                    })
                    .collect::<Result<_, IcHostError>>()?,
            })
        })
    }
}

fn node_provider_reward_list_url(
    endpoint: &str,
    query: &IcNodeProviderRewardListQuery,
) -> Result<Url, IcHostError> {
    let mut url = dashboard_resource_url(endpoint, &["reward-node-providers"])?;
    {
        let mut pairs = url.query_pairs_mut();
        pairs.append_pair("format", "json");
        pairs.append_pair("limit", &query.limit.to_string());
        pairs.append_pair("offset", &query.offset.to_string());
        if let Some(max_reward_index) = query.max_reward_index {
            pairs.append_pair(
                "max_reward_node_provider_index",
                &max_reward_index.to_string(),
            );
        }
    }
    Ok(url)
}

fn node_provider_reward_info_url(endpoint: &str, reward_id: u64) -> Result<Url, IcHostError> {
    dashboard_resource_url(endpoint, &["reward-node-providers", &reward_id.to_string()])
}

fn node_provider_reward_history_url(
    endpoint: &str,
    query: &IcNodeProviderRewardHistoryQuery,
) -> Result<Url, IcHostError> {
    let mut url = dashboard_resource_url(endpoint, &["timeseries", "reward-node-providers"])?;
    {
        let mut pairs = url.query_pairs_mut();
        pairs.append_pair("format", "json");
        super::append_time_series(
            &mut pairs,
            query.start_unix_secs,
            query.end_unix_secs,
            query.step_secs,
        );
    }
    Ok(url)
}

#[derive(SerdeDeserialize)]
struct DashboardNodeProviderRewardList {
    data: Vec<IcNodeProviderRewardRow>,
    max_reward_node_provider_index: u64,
    total_reward_node_providers: u64,
}

impl DashboardNodeProviderRewardList {
    fn into_source_data(
        self,
        request: &IcSourceRequest,
        query: &IcNodeProviderRewardListQuery,
    ) -> IcNodeProviderRewardListSourceData {
        IcNodeProviderRewardListSourceData {
            source: request.clone(),
            query: query.clone(),
            resolved_max_reward_index: self.max_reward_node_provider_index,
            total_reward_records: self.total_reward_node_providers,
            rows: self.data,
        }
    }
}

#[derive(SerdeDeserialize)]
struct DashboardNodeProviderRewardHistory {
    reward_node_providers: Vec<[Number; 2]>,
}

#[cfg(test)]
mod tests;