Merge branch 'main' of github.com:input-output-hk/acropolis into shd/abstain-votes-conway

Author: shd

.github/workflows/run-tests-on-push-to-main.yml

@@ -38,7 +38,11 @@ jobs:
             --package acropolis_module_drep_state \
             --package acropolis_module_epochs_state \
             --package acropolis_module_genesis_bootstrapper \
+            --package acropolis_module_governance_state \
+            --package acropolis_module_historical_accounts_state \
             --package acropolis_module_mithril_snapshot_fetcher \
+            --package acropolis_module_parameters_state \
+            --package acropolis_module_rest_blockfrost \
             --package acropolis_module_snapshot_bootstrapper \
             --package acropolis_module_spdd_state \
             --package acropolis_module_spo_state \

common/src/queries/accounts.rs

@@ -18,7 +18,7 @@ pub enum AccountsStateQuery {
     GetAccountRegistrationHistory { account: StakeAddress },
     GetAccountDelegationHistory { account: StakeAddress },
     GetAccountMIRHistory { account: StakeAddress },
-    GetAccountWithdrawalHistory { stake_key: Vec<u8> },
+    GetAccountWithdrawalHistory { account: StakeAddress },
     GetAccountAssociatedAddresses { stake_key: Vec<u8> },
     GetAccountAssets { stake_key: Vec<u8> },
     GetAccountAssetsTotals { stake_key: Vec<u8> },
@@ -52,7 +52,7 @@ pub enum AccountsStateQueryResponse {
     AccountRegistrationHistory(Vec<RegistrationUpdate>),
     AccountDelegationHistory(Vec<DelegationUpdate>),
     AccountMIRHistory(Vec<AccountWithdrawal>),
-    AccountWithdrawalHistory(AccountWithdrawalHistory),
+    AccountWithdrawalHistory(Vec<AccountWithdrawal>),
     AccountAssociatedAddresses(AccountAssociatedAddresses),
     AccountAssets(AccountAssets),
     AccountAssetsTotals(AccountAssetsTotals),

common/src/stake_addresses.rs

@@ -867,6 +867,8 @@ mod tests {
     }
 
     mod withdrawal_tests {
+        use crate::TxIdentifier;
+
         use super::*;
 
         #[test]
@@ -880,6 +882,7 @@ mod tests {
             let withdrawal = Withdrawal {
                 address: stake_address.clone(),
                 value: 40,
+                tx_identifier: TxIdentifier::default(),
             };
             stake_addresses.process_withdrawal(&withdrawal);
 
@@ -898,6 +901,7 @@ mod tests {
             let withdrawal = Withdrawal {
                 address: stake_address.clone(),
                 value: 24,
+                tx_identifier: TxIdentifier::default(),
             };
             stake_addresses.process_withdrawal(&withdrawal);
             assert_eq!(stake_addresses.get(&stake_address).unwrap().rewards, 12);
@@ -906,6 +910,7 @@ mod tests {
             let withdrawal = Withdrawal {
                 address: stake_address.clone(),
                 value: 2,
+                tx_identifier: TxIdentifier::default(),
             };
             stake_addresses.process_withdrawal(&withdrawal);
             assert_eq!(stake_addresses.get(&stake_address).unwrap().rewards, 10);
@@ -922,6 +927,7 @@ mod tests {
             let withdrawal = Withdrawal {
                 address: stake_address.clone(),
                 value: 0,
+                tx_identifier: TxIdentifier::default(),
             };
 
             stake_addresses.process_withdrawal(&withdrawal);
@@ -936,6 +942,7 @@ mod tests {
             let withdrawal = Withdrawal {
                 address: stake_address.clone(),
                 value: 10,
+                tx_identifier: TxIdentifier::default(),
             };
 
             // Should log error but not panic

common/src/types.rs

@@ -610,6 +610,9 @@ pub struct Withdrawal {
 
     /// Value to withdraw
     pub value: Lovelace,
+
+    // Identifier of withdrawal tx
+    pub tx_identifier: TxIdentifier,
 }
 
 /// Treasury pot account

modules/accounts_state/src/rewards.rs

@@ -14,7 +14,7 @@ use std::sync::Arc;
 use tracing::{debug, info, warn};
 
 /// Type of reward being given
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum RewardType {
     Leader,
     Member,
@@ -34,7 +34,7 @@ pub struct RewardDetail {
 }
 
 /// Result of a rewards calculation
-#[derive(Debug, Default)]
+#[derive(Debug, Default, Clone)]
 pub struct RewardsResult {
     /// Epoch these rewards were earned in (when blocks produced)
     pub epoch: u64,

modules/accounts_state/src/state.rs

@@ -1,6 +1,6 @@
 //! Acropolis AccountsState: State storage
 use crate::monetary::calculate_monetary_change;
-use crate::rewards::{calculate_rewards, RewardsResult};
+use crate::rewards::{calculate_rewards, RewardType, RewardsResult};
 use crate::snapshot::Snapshot;
 use crate::verifier::Verifier;
 use acropolis_common::queries::accounts::OptimalPoolSizing;
@@ -116,9 +116,6 @@ pub struct State {
     /// Pool refunds to apply next epoch (list of reward accounts to refund to)
     pool_refunds: Vec<StakeAddress>,
 
-    /// Stake address refunds to apply next epoch
-    stake_refunds: Vec<(StakeAddress, Lovelace)>,
-
     /// MIRs to pay next epoch
     mirs: Vec<MoveInstantaneousReward>,
 
@@ -324,7 +321,6 @@ impl State {
 
         // Pay the refunds after snapshot, so they don't appear in active_stake
         reward_deltas.extend(self.pay_pool_refunds());
-        reward_deltas.extend(self.pay_stake_refunds());
 
         // Verify pots state
         verifier.verify_pots(epoch, &self.pots);
@@ -496,33 +492,6 @@ impl State {
         reward_deltas
     }
 
-    /// Pay stake address refunds
-    fn pay_stake_refunds(&mut self) -> Vec<StakeRewardDelta> {
-        let mut reward_deltas = Vec::<StakeRewardDelta>::new();
-
-        let refunds = take(&mut self.stake_refunds);
-        if !refunds.is_empty() {
-            info!(
-                "{} deregistered stake addresses, total refunds {}",
-                refunds.len(),
-                refunds.iter().map(|(_, n)| n).sum::<Lovelace>()
-            );
-        }
-
-        // Send them their deposits back
-        for (stake_address, deposit) in refunds {
-            let mut stake_addresses = self.stake_addresses.lock().unwrap();
-            reward_deltas.push(StakeRewardDelta {
-                stake_address: stake_address.clone(), // Extract hash for delta
-                delta: deposit as i64,
-            });
-            stake_addresses.add_to_reward(&stake_address, deposit);
-            self.pots.deposits -= deposit;
-        }
-
-        reward_deltas
-    }
-
     /// Pay MIRs
     fn pay_mirs(&mut self) -> Vec<StakeRewardDelta> {
         let mut reward_deltas = Vec::<StakeRewardDelta>::new();
@@ -657,36 +626,52 @@ impl State {
 
         // If rewards have been calculated, save the results
         if let Some(task) = task.take() {
-            if let Ok(Ok(reward_result)) = task.await {
-                // Collect rewards to stake addresses reward deltas
-                for rewards in reward_result.rewards.values() {
-                    reward_deltas.extend(
-                        rewards
-                            .iter()
-                            .map(|reward| StakeRewardDelta {
-                                stake_address: reward.account.clone(),
-                                delta: reward.amount as i64,
-                            })
-                            .collect::<Vec<_>>(),
-                    );
-                }
-
-                // Verify them
-                verifier.verify_rewards(reward_result.epoch, &reward_result);
-
+            if let Ok(Ok(rewards_result)) = task.await {
                 // Pay the rewards
                 let mut stake_addresses = self.stake_addresses.lock().unwrap();
-                for (_, rewards) in reward_result.rewards {
+                let mut filtered_rewards_result = rewards_result.clone();
+                for (spo, rewards) in rewards_result.rewards {
                     for reward in rewards {
-                        stake_addresses.add_to_reward(&reward.account, reward.amount);
+                        if stake_addresses.is_registered(&reward.account) {
+                            stake_addresses.add_to_reward(&reward.account, reward.amount);
+                            reward_deltas.push(StakeRewardDelta {
+                                stake_address: reward.account.clone(),
+                                delta: reward.amount as i64,
+                            });
+                        } else {
+                            warn!(
+                                "Reward account {} deregistered - paying reward {} to treasury",
+                                reward.account, reward.amount
+                            );
+                            self.pots.treasury += reward.amount;
+
+                            // Remove from filtered version for comparison and result
+                            if let Some(rewards) = filtered_rewards_result.rewards.get_mut(&spo) {
+                                rewards.retain(|r| r.account != reward.account);
+                            }
+
+                            if let Some((_, spor)) = filtered_rewards_result
+                                .spo_rewards
+                                .iter_mut()
+                                .find(|(fspo, _)| *fspo == spo)
+                            {
+                                spor.total_rewards -= reward.amount;
+                                if reward.rtype == RewardType::Leader {
+                                    spor.operator_rewards -= reward.amount;
+                                }
+                            }
+                        }
                     }
                 }
 
+                // Verify them
+                verifier.verify_rewards(&filtered_rewards_result);
+
                 // save SPO rewards
-                spo_rewards = reward_result.spo_rewards.into_iter().collect();
+                spo_rewards = filtered_rewards_result.spo_rewards.clone();
 
                 // Adjust the reserves for next time with amount actually paid
-                self.pots.reserves -= reward_result.total_paid;
+                self.pots.reserves -= rewards_result.total_paid;
             }
         };
 
@@ -841,8 +826,7 @@ impl State {
                 }
             };
 
-            // Schedule refund
-            self.stake_refunds.push((stake_address.clone(), deposit));
+            self.pots.deposits -= deposit;
 
             // Add to registration changes
             self.current_epoch_registration_changes.lock().unwrap().push(RegistrationChange {
@@ -1314,6 +1298,7 @@ mod tests {
             withdrawals: vec![Withdrawal {
                 address: stake_address.clone(),
                 value: 39,
+                tx_identifier: TxIdentifier::default(),
             }],
         };
 

modules/accounts_state/src/verifier.rs

@@ -119,7 +119,8 @@ impl Verifier {
     }
 
     /// Verify rewards, logging any errors
-    pub fn verify_rewards(&self, epoch: u64, rewards: &RewardsResult) {
+    pub fn verify_rewards(&self, rewards: &RewardsResult) {
+        let epoch = rewards.epoch;
         if let Some(template) = &self.rewards_file_template {
             let path = template.replace("{}", &epoch.to_string());
 

modules/governance_state/src/alonzo_babbage_voting.rs

@@ -5,12 +5,15 @@ use acropolis_common::{
 use anyhow::{bail, Result};
 use std::collections::{HashMap, HashSet};
 
+// (vote epoch, vote slot, proposal)
+type VoteData = (u64, u64, Box<ProtocolParamUpdate>);
+
 #[derive(Default)]
 pub struct AlonzoBabbageVoting {
     /// map "enact epoch" (proposal enacts at this epoch end) to voting
-    /// "voting": map voter (genesis key) => (vote epoch, vote slot, proposal)
+    /// "voting": map voter (genesis key) => votedata
     /// "vote epoch/slot" --- moment, when the vote was cast for the proposal
-    proposals: HashMap<u64, HashMap<GenesisKeyhash, (u64, u64, Box<ProtocolParamUpdate>)>>,
+    proposals: HashMap<u64, HashMap<GenesisKeyhash, VoteData>>,
     slots_per_epoch: u32,
     update_quorum: u32,
 }
@@ -31,7 +34,7 @@ impl AlonzoBabbageVoting {
     pub fn process_update_proposals(
         &mut self,
         block_info: &BlockInfo,
-        updates: &Vec<AlonzoBabbageUpdateProposal>,
+        updates: &[AlonzoBabbageUpdateProposal],
     ) -> Result<()> {
         if updates.is_empty() {
             return Ok(());
@@ -46,7 +49,7 @@ impl AlonzoBabbageVoting {
         }
 
         for pp in updates.iter() {
-            let entry = self.proposals.entry(pp.enactment_epoch + 1).or_insert(HashMap::new());
+            let entry = self.proposals.entry(pp.enactment_epoch + 1).or_default();
             for (k, p) in &pp.proposals {
                 // A new proposal for key k always replaces the old one
                 entry.insert(k.clone(), (block_info.epoch, block_info.slot, p.clone()));
@@ -81,7 +84,8 @@ impl AlonzoBabbageVoting {
 
                 let votes: Vec<_> = proposals
                     .iter()
-                    .filter_map(|(k, v)| (v == parameter_update).then(|| k.clone()))
+                    .filter(|&(_, v)| v == parameter_update)
+                    .map(|(k, _)| k.clone())
                     .collect();
 
                 for v in &votes {
@@ -220,7 +224,7 @@ mod tests {
     fn extract_mainnet_parameter<T: Clone>(
         f: impl Fn(&ProtocolParamUpdate) -> Option<T>,
     ) -> Result<Vec<(u64, T)>> {
-        extract_parameter(5, 432_000, &MAINNET_PROPOSALS_JSON, f)
+        extract_parameter(5, 432_000, MAINNET_PROPOSALS_JSON, f)
     }
 
     const DECENTRALISATION: [(u64, f32); 39] = [
@@ -282,9 +286,9 @@ mod tests {
         let dcu = extract_mainnet_parameter(|p| p.decentralisation_constant)?;
 
         assert_eq!(DECENTRALISATION.len(), dcu.len());
-        for i in 0..dcu.len() {
-            let rat = rational_number_from_f32(DECENTRALISATION[i].1)?;
-            assert_eq!((DECENTRALISATION[i].0, rat), *dcu.get(i).unwrap());
+        for (decent, param) in DECENTRALISATION.iter().zip(dcu) {
+            let rat = rational_number_from_f32(decent.1)?;
+            assert_eq!((decent.0, rat), param);
         }
 
         Ok(())
@@ -319,7 +323,7 @@ mod tests {
     fn extract_sanchonet_parameter<T: Clone>(
         f: impl Fn(&ProtocolParamUpdate) -> Option<T>,
     ) -> Result<Vec<(u64, T)>> {
-        extract_parameter(3, 86_400, &SANCHONET_PROPOSALS_JSON, f)
+        extract_parameter(3, 86_400, SANCHONET_PROPOSALS_JSON, f)
     }
 
     const SANCHONET_PROTOCOL_VERSION: [(u64, (u64, u64)); 3] =