Merge branch 'develop' into feature/vesting-full

validator-api/src/nymd_client.rs

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::config::Config;
-use crate::rewarded_set_updater::{error::RewardingError, MixnodeToReward};
+use crate::rewarded_set_updater::error::RewardingError;
 use config::defaults::{DEFAULT_NETWORK, DEFAULT_VALIDATOR_API_PORT};
 use mixnet_contract_common::Interval;
 use mixnet_contract_common::{
@@ -332,13 +332,12 @@ impl<C> Client<C> {
     where
         C: SigningCosmWasmClient + Sync,
     {
-        let mut msgs = vec![(ExecuteMsg::AdvanceCurrentEpoch {}, vec![])];
-
-        msgs.extend(reward_msgs);
+        let mut msgs = reward_msgs;
 
         let epoch_msgs = vec![
             (ExecuteMsg::ReconcileDelegations {}, vec![]),
             (ExecuteMsg::CheckpointMixnodes {}, vec![]),
+            (ExecuteMsg::AdvanceCurrentEpoch {}, vec![]),
             (
                 ExecuteMsg::WriteRewardedSet {
                     rewarded_set,
@@ -357,28 +356,6 @@ impl<C> Client<C> {
         Ok(())
     }
 
-    pub(crate) async fn reward_mixnodes(
-        &self,
-        nodes: &[MixnodeToReward],
-        interval_id: u32,
-    ) -> Result<Vec<(ExecuteMsg, Vec<CosmosCoin>)>, RewardingError>
-    where
-        C: SigningCosmWasmClient + Sync,
-    {
-        let msgs: Vec<(ExecuteMsg, _)> = nodes
-            .iter()
-            .map(|node| node.to_reward_execute_msg(interval_id))
-            .zip(std::iter::repeat(Vec::new()))
-            .collect();
-
-        // let memo = format!("rewarding {} mixnodes", msgs.len());
-
-        // self.execute_multiple_with_retry(msgs, Default::default(), memo)
-        //     .await
-
-        Ok(msgs)
-    }
-
     async fn execute_multiple_with_retry<M>(
         &self,
         msgs: Vec<(M, Vec<CosmosCoin>)>,

validator-api/src/rewarded_set_updater/mod.rs

@@ -43,15 +43,16 @@ pub(crate) struct MixnodeToReward {
 }
 
 impl MixnodeToReward {
+    #[allow(dead_code)]
     fn params(&self) -> NodeRewardParams {
         self.params
     }
 
-    pub(crate) fn to_reward_execute_msg(&self, interval_id: u32) -> ExecuteMsg {
+    #[allow(dead_code)]
+    pub(crate) fn to_reward_execute_msg(&self) -> ExecuteMsg {
         ExecuteMsg::RewardMixnode {
             identity: self.identity.clone(),
             params: self.params(),
-            interval_id,
         }
     }
 }
@@ -138,20 +139,25 @@ impl RewardedSetUpdater {
             .insert_rewarding_report(rewarding_report)
             .await?;
 
-        Ok(self.distribute_rewards(&to_reward).await?)
+        Ok(self.generate_reward_messages(&to_reward).await?)
     }
 
-    async fn distribute_rewards(
+    #[allow(unused_variables)]
+    async fn generate_reward_messages(
         &self,
         eligible_mixnodes: &[MixnodeToReward],
     ) -> Result<Vec<(ExecuteMsg, Vec<CosmosCoin>)>, RewardingError> {
-        let epoch = self.epoch().await?;
-
-        let reward_msgs = self
-            .nymd_client
-            .reward_mixnodes(eligible_mixnodes, epoch.id())
-            .await?;
-        Ok(reward_msgs)
+        cfg_if::cfg_if! {
+            if #[cfg(feature = "no-reward")] {
+                Ok(vec![])
+            } else {
+                Ok(eligible_mixnodes
+                    .iter()
+                    .map(|node| node.to_reward_execute_msg())
+                    .zip(std::iter::repeat(Vec::new()))
+                    .collect())
+            }
+        }
     }
 
     async fn nodes_to_reward(&self) -> Result<Vec<MixnodeToReward>, RewardingError> {