Fix tests

Author: gztensor

pallets/subtensor/src/epoch/run_epoch.rs

@@ -390,7 +390,7 @@ impl<T: Config> Pallet<T> {
             .iter()
             .map(|updated| updated.saturating_add(activity_cutoff) < current_block)
             .collect();
-        log::trace!("Inactive: {:?}", inactive.clone());
+        log::debug!("Inactive: {:?}", inactive.clone());
 
         // Logical negation of inactive.
         let active: Vec<bool> = inactive.iter().map(|&b| !b).collect();
@@ -406,14 +406,14 @@ impl<T: Config> Pallet<T> {
         let hotkeys: Vec<(u16, T::AccountId)> =
             <Keys<T> as IterableStorageDoubleMap<u16, u16, T::AccountId>>::iter_prefix(netuid)
                 .collect();
-        log::trace!("hotkeys: {:?}", &hotkeys);
+        log::debug!("hotkeys: {:?}", &hotkeys);
 
         // Access network stake as normalized vector.
         let (mut total_stake, _alpha_stake, _tao_stake): (Vec<I64F64>, Vec<I64F64>, Vec<I64F64>) =
             Self::get_stake_weights_for_network(netuid);
         inplace_normalize_64(&mut total_stake);
         let stake: Vec<I32F32> = vec_fixed64_to_fixed32(total_stake);
-        log::trace!("Normalised Stake: {:?}", &stake);
+        log::debug!("Normalised Stake: {:?}", &stake);
 
         // =======================
         // == Validator permits ==
@@ -448,7 +448,7 @@ impl<T: Config> Pallet<T> {
 
         // Normalize active stake.
         inplace_normalize(&mut active_stake);
-        log::trace!("Active Stake:\n{:?}\n", &active_stake);
+        log::debug!("Active Stake:\n{:?}\n", &active_stake);
 
         // =============
         // == Weights ==

pallets/subtensor/src/staking/helpers.rs

@@ -63,10 +63,12 @@ impl<T: Config> Pallet<T> {
             .iter()
             .map(|hotkey| {
                 let mut total_stake: u64 = 0;
-                for (netuid, alpha) in Alpha::<T>::iter_prefix((hotkey, coldkey)) {
+                for (netuid, _) in Alpha::<T>::iter_prefix((hotkey, coldkey)) {
+                    let alpha_stake =
+                        Self::get_stake_for_hotkey_and_coldkey_on_subnet(hotkey, coldkey, netuid);
                     let tao_price: I96F32 = Self::get_alpha_price(netuid);
                     total_stake = total_stake.saturating_add(
-                        I96F32::saturating_from_num(alpha)
+                        I96F32::saturating_from_num(alpha_stake)
                             .saturating_mul(tao_price)
                             .saturating_to_num::<u64>(),
                     );

pallets/subtensor/src/staking/stake_utils.rs

@@ -167,7 +167,7 @@ impl<T: Config> Pallet<T> {
                 }
             })
             .collect();
-        log::trace!("alpha_stake: {:?}", alpha_stake);
+        log::debug!("alpha_stake: {:?}", alpha_stake);
 
         // Step 3: Calculate the global tao stake vector.
         // Initialize a vector to store global tao stakes for each neuron.
@@ -322,7 +322,7 @@ impl<T: Config> Pallet<T> {
         // Step 1: Retrieve the initial total stake (alpha) for the hotkey on the specified subnet.
         let initial_alpha: I96F32 =
             I96F32::saturating_from_num(Self::get_stake_for_hotkey_on_subnet(hotkey, netuid));
-        log::trace!(
+        log::debug!(
             "Initial alpha for hotkey {:?} on subnet {}: {:?}",
             hotkey,
             netuid,
@@ -339,13 +339,13 @@ impl<T: Config> Pallet<T> {
         // Step 2: Retrieve the lists of parents and children for the hotkey on the subnet.
         let parents: Vec<(u64, T::AccountId)> = Self::get_parents(hotkey, netuid);
         let children: Vec<(u64, T::AccountId)> = Self::get_children(hotkey, netuid);
-        log::trace!(
+        log::debug!(
             "Parents for hotkey {:?} on subnet {}: {:?}",
             hotkey,
             netuid,
             parents
         );
-        log::trace!(
+        log::debug!(
             "Children for hotkey {:?} on subnet {}: {:?}",
             hotkey,
             netuid,
@@ -370,7 +370,7 @@ impl<T: Config> Pallet<T> {
             // Add this child's allocation to the total alpha allocated to children.
             alpha_to_children = alpha_to_children.saturating_add(alpha_proportion_to_child);
         }
-        log::trace!("Total alpha allocated to children: {:?}", alpha_to_children);
+        log::debug!("Total alpha allocated to children: {:?}", alpha_to_children);
 
         // Step 4: Calculate the total alpha inherited from parents.
         for (proportion, parent) in parents {
@@ -403,7 +403,7 @@ impl<T: Config> Pallet<T> {
             // Add this parent's contribution to the total alpha inherited from parents.
             alpha_from_parents = alpha_from_parents.saturating_add(alpha_proportion_from_parent);
         }
-        log::trace!(
+        log::debug!(
             "Total alpha inherited from parents: {:?}",
             alpha_from_parents
         );