Replace RewardAccount with StakeAddress for consistency and simplify related logic

- Update `RewardDetail` and reward handling logic to use `StakeAddress` directly.
- Replace `reward_account` field with `.get_hash()` where necessary.

Author: lowhung

modules/accounts_state/src/rewards.rs

@@ -3,7 +3,7 @@
 use crate::snapshot::{Snapshot, SnapshotSPO};
 use acropolis_common::{
     protocol_params::ShelleyParams, rational_number::RationalNumber, KeyHash, Lovelace,
-    RewardAccount, SPORewards,
+    RewardAccount, SPORewards, StakeAddress,
 };
 use anyhow::{bail, Result};
 use bigdecimal::{BigDecimal, One, ToPrimitive, Zero};
@@ -24,7 +24,7 @@ pub enum RewardType {
 #[derive(Debug, Clone)]
 pub struct RewardDetail {
     /// Account reward paid to
-    pub account: RewardAccount,
+    pub account: StakeAddress,
 
     /// Type of reward
     pub rtype: RewardType,
@@ -134,7 +134,8 @@ pub fn calculate_rewards(
             );
 
             // Note we use the staking reward account - it could have changed
-            pay_to_pool_reward_account = registrations.contains(staking_spo.reward_account.get_hash())
+            pay_to_pool_reward_account =
+                registrations.contains(staking_spo.reward_account.get_hash())
         }
 
         // There was a bug in the original node from Shelley until Allegra where if multiple SPOs
@@ -376,7 +377,7 @@ fn calculate_spo_rewards(
 
                 // Transfer from reserves to this account
                 rewards.push(RewardDetail {
-                    account: hash.clone(),
+                    account: spo.reward_account.clone(),
                     rtype: RewardType::Member,
                     amount: to_pay,
                 });
@@ -393,16 +394,15 @@ fn calculate_spo_rewards(
 
     if pay_to_pool_reward_account {
         rewards.push(RewardDetail {
-            // TODO Hack to remove e1 header - needs resolving properly with StakeAddress
-            account: RewardAccount::from(spo.reward_account.get_hash()),
+            account: spo.reward_account.clone(),
             rtype: RewardType::Leader,
             amount: spo_benefit,
         });
     } else {
         info!(
             "SPO {}'s reward account {} not paid {}",
             hex::encode(&operator_id),
-            hex::encode(&spo.reward_account.get_hash()),
+            hex::encode(spo.reward_account.get_hash()),
             spo_benefit,
         );
     }

modules/accounts_state/src/state.rs

@@ -663,7 +663,7 @@ impl State {
                             rewards
                                 .iter()
                                 .map(|reward| StakeRewardDelta {
-                                    hash: reward.account.clone(),
+                                    hash: reward.account.get_hash().to_vec(),
                                     delta: reward.amount as i64,
                                 })
                                 .collect::<Vec<_>>(),
@@ -677,7 +677,7 @@ impl State {
                     let mut stake_addresses = self.stake_addresses.lock().unwrap();
                     for (_, rewards) in reward_result.rewards {
                         for reward in rewards {
-                            stake_addresses.add_to_reward(&reward.account, reward.amount);
+                            stake_addresses.add_to_reward(&reward.account.get_hash().to_vec(), reward.amount);
                         }
                     }
 
@@ -784,14 +784,14 @@ impl State {
 
             // Schedule to retire - we need them to still be in place when we count
             // blocks for the previous epoch
-            self.retiring_spos.push(id.clone());
+            self.retiring_spos.push(id.to_vec());
         }
 
         self.spos = new_spos;
         Ok(())
     }
 
-    /// Register a stake address, with specified deposit if known
+    /// Register a stake address, with a specified deposit if known
     fn register_stake_address(&mut self, credential: &StakeCredential, deposit: Option<Lovelace>) {
         // Stake addresses can be registered after being used in UTXOs
         let mut stake_addresses = self.stake_addresses.lock().unwrap();

modules/accounts_state/src/verifier.rs

@@ -1,7 +1,7 @@
 //! Verification of calculated values against captured CSV from Haskell node / DBSync
 use crate::rewards::{RewardDetail, RewardType, RewardsResult};
 use crate::state::Pots;
-use acropolis_common::{KeyHash, RewardAccount};
+use acropolis_common::{KeyHash, RewardAccount, StakeAddress};
 use hex::FromHex;
 use itertools::EitherOrBoth::{Both, Left, Right};
 use itertools::Itertools;
@@ -114,7 +114,7 @@ impl Verifier {
         match (&left.rtype, &right.rtype) {
             (RewardType::Leader, RewardType::Member) => Ordering::Less,
             (RewardType::Member, RewardType::Leader) => Ordering::Greater,
-            _ => left.account.cmp(&right.account),
+            _ => left.account.get_hash().cmp(&right.account.get_hash()),
         }
     }
 
@@ -161,12 +161,13 @@ impl Verifier {
                     _ => continue,
                 };
 
-                // Convert account with e1 header to just hash
-                // TODO: use StakeAddress, skipping first byte (e1) for now
-                let account = RewardAccount::from(&account[1..]);
+                let Ok(stake_address) = StakeAddress::from_binary(&account[1..]) else {
+                    error!("Bad stake address in {path} for address: {address} - skipping");
+                    continue;
+                };
 
                 expected_rewards.entry(spo).or_default().push(RewardDetail {
-                    account,
+                    account: stake_address,
                     rtype,
                     amount,
                 });
@@ -217,7 +218,7 @@ impl Verifier {
                                     error!(
                                         "Missing reward: SPO {} account {} {:?} {}",
                                         hex::encode(&expected_spo.0),
-                                        hex::encode(&expected.account),
+                                        hex::encode(&expected.account.get_hash()),
                                         expected.rtype,
                                         expected.amount
                                     );
@@ -227,7 +228,7 @@ impl Verifier {
                                     error!(
                                         "Extra reward: SPO {} account {} {:?} {}",
                                         hex::encode(&actual_spo.0),
-                                        hex::encode(&actual.account),
+                                        hex::encode(&actual.account.get_hash()),
                                         actual.rtype,
                                         actual.amount
                                     );
@@ -237,7 +238,7 @@ impl Verifier {
                                     if expected.amount != actual.amount {
                                         error!("Different reward: SPO {} account {} {:?} expected {}, actual {} ({})",
                                                hex::encode(&expected_spo.0),
-                                               hex::encode(&expected.account),
+                                               hex::encode(&expected.account.get_hash()),
                                                expected.rtype,
                                                expected.amount,
                                                actual.amount,
@@ -247,7 +248,7 @@ impl Verifier {
                                         debug!(
                                             "Reward match: SPO {} account {} {:?} {}",
                                             hex::encode(&expected_spo.0),
-                                            hex::encode(&expected.account),
+                                            hex::encode(&expected.account.get_hash()),
                                             expected.rtype,
                                             expected.amount
                                         );