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;