Add derived algorithm_version to node-rewards command

rs/cli/src/commands/node_rewards/common.rs

@@ -3,8 +3,8 @@ use csv::Writer;
 use futures_util::future::join_all;
 use ic_base_types::{PrincipalId, SubnetId};
 use ic_canisters::node_rewards::NodeRewardsCanisterWrapper;
-use ic_node_rewards_canister_api::DateUtc;
 use ic_node_rewards_canister_api::provider_rewards_calculation::{DailyNodeFailureRate, DailyNodeProviderRewards, DailyResults};
+use ic_node_rewards_canister_api::{DateUtc, RewardsCalculationAlgorithmVersion};
 use icp_ledger::AccountIdentifier;
 use itertools::Itertools;
 use log::info;
@@ -18,6 +18,7 @@ use tabled::{Table, Tabled};
 pub struct NodeRewardsCtx {
     pub start_date: NaiveDate,
     pub end_date: NaiveDate,
+    pub algorithm_version: Option<RewardsCalculationAlgorithmVersion>,
     pub csv_detailed_output_path: Option<String>,
     pub provider_id: Option<String>,
     pub compare_with_governance: bool,
@@ -59,8 +60,11 @@ pub trait NodeRewardsDataFetcher {
         println!("Fetching node rewards for all providers from NRC from {} to {}...", start_date, end_date);
 
         let days: Vec<DateUtc> = start_date.iter_days().take_while(|day| day <= &end_date).map(DateUtc::from).collect();
-        let responses: Vec<anyhow::Result<DailyResults>> =
-            join_all(days.iter().map(|day| async move { node_rewards_client.get_rewards_daily(*day).await })).await;
+        let responses: Vec<anyhow::Result<DailyResults>> = join_all(
+            days.iter()
+                .map(|day| async move { node_rewards_client.get_rewards_daily(*day, ctx.algorithm_version).await }),
+        )
+        .await;
 
         let mut providers_rewards: BTreeMap<PrincipalId, Vec<(DateUtc, DailyNodeProviderRewards)>> = BTreeMap::new();
         let mut subnets_failure_rates: BTreeMap<SubnetId, Vec<(DateUtc, f64)>> = BTreeMap::new();

rs/cli/src/commands/node_rewards/ongoing.rs

@@ -70,6 +70,7 @@ impl ExecutableCommand for Ongoing {
         let rewards_ctx = NodeRewardsCtx {
             start_date,
             end_date,
+            algorithm_version: None,
             csv_detailed_output_path: self.common.csv_detailed_output_path.clone(),
             provider_id: self.common.provider_id.clone(),
             governance_providers_rewards,

rs/cli/src/commands/node_rewards/past_rewards.rs

@@ -2,6 +2,7 @@ use chrono::{DateTime, Datelike};
 use clap::Args;
 use ic_canisters::governance::GovernanceCanisterWrapper;
 use ic_canisters::node_rewards::NodeRewardsCanisterWrapper;
+use ic_node_rewards_canister_api::RewardsCalculationAlgorithmVersion;
 use log::info;
 use std::collections::BTreeMap;
 
@@ -75,10 +76,12 @@ impl ExecutableCommand for PastRewards {
             .ok_or_else(|| anyhow::anyhow!("Cannot get previous day"))?;
 
         let node_providers = governance_client.get_node_providers().await?;
+        let algorithm_version = last.algorithm_version.map(|v| RewardsCalculationAlgorithmVersion { version: v });
 
         let rewards_ctx = NodeRewardsCtx {
             start_date,
             end_date,
+            algorithm_version,
             csv_detailed_output_path: self.common.csv_detailed_output_path.clone(),
             provider_id: self.common.provider_id.clone(),
             governance_providers_rewards,

rs/ic-canisters/src/node_rewards.rs

@@ -2,8 +2,9 @@ use std::str::FromStr;
 
 use crate::IcAgentCanisterClient;
 use candid::Principal;
-use ic_node_rewards_canister_api::provider_rewards_calculation::{
-    DailyResults, DateUtc, GetNodeProvidersRewardsCalculationRequest, GetNodeProvidersRewardsCalculationResponse,
+use ic_node_rewards_canister_api::{
+    RewardsCalculationAlgorithmVersion,
+    provider_rewards_calculation::{DailyResults, DateUtc, GetNodeProvidersRewardsCalculationRequest, GetNodeProvidersRewardsCalculationResponse},
 };
 
 const NODE_REWARDS_CANISTER: &str = "sgymv-uiaaa-aaaaa-aaaia-cai";
@@ -23,16 +24,16 @@ impl NodeRewardsCanisterWrapper {
         Self { agent }
     }
 
-    pub async fn get_rewards_daily(&self, day: DateUtc) -> anyhow::Result<DailyResults> {
+    pub async fn get_rewards_daily(
+        &self,
+        day: DateUtc,
+        algorithm_version: Option<RewardsCalculationAlgorithmVersion>,
+    ) -> anyhow::Result<DailyResults> {
         self.agent
             .query::<GetNodeProvidersRewardsCalculationResponse>(
                 &Principal::from_str(NODE_REWARDS_CANISTER).map_err(anyhow::Error::from)?,
                 "get_node_providers_rewards_calculation",
-                candid::encode_one(GetNodeProvidersRewardsCalculationRequest {
-                    day,
-                    // Use the default version
-                    algorithm_version: None,
-                })?,
+                candid::encode_one(GetNodeProvidersRewardsCalculationRequest { day, algorithm_version })?,
             )
             .await?
             .map_err(|e| anyhow::anyhow!(e))