fixes to the childkey emission

Author: unconst

pallets/subtensor/src/coinbase/run_coinbase.rs

@@ -338,14 +338,17 @@ impl<T: Config> Pallet<T> {
         }
         log::debug!("alpha_dividends: {:?}", alpha_dividends);
         log::debug!("root_dividends: {:?}", root_dividends);
+        log::debug!("total_root_divs: {:?}", total_root_divs);
 
         // Compute root divs as TAO. Here we take
         let mut tao_dividends: BTreeMap<T::AccountId, I96F32> = BTreeMap::new();
         for (hotkey, root_divs) in root_dividends {
             // Root proportion.
             let root_share: I96F32 = root_divs.checked_div(total_root_divs).unwrap_or(zero);
+            log::debug!("hotkey: {:?}, root_share: {:?}", hotkey, root_share);
             // Root proportion in TAO
             let root_tao: I96F32 = asfloat!(pending_tao).saturating_mul(root_share);
+            log::debug!("hotkey: {:?}, root_tao: {:?}", hotkey, root_tao);
             // Record root dividends as TAO.
             tao_dividends
                 .entry(hotkey)
@@ -583,10 +586,18 @@ impl<T: Config> Pallet<T> {
                 (remaining_emission.saturating_mul(emission_factor)).saturating_to_num::<u64>();
 
             // Add the parent's emission to the distribution list
-            dividend_tuples.push((parent, parent_emission));
+            dividend_tuples.push((parent.clone(), parent_emission));
 
             // Keep track of total emission distributed to parents
             to_parents = to_parents.saturating_add(parent_emission);
+            log::debug!(
+                "Parent contribution for parent {:?} with contribution: {:?}, of total: {:?} of emission: {:?} gets: {:?}",
+                parent,
+                contribution,
+                total_contribution,
+                remaining_emission,
+                parent_emission
+            );
         }
         // Calculate the final emission for the hotkey itself.
         // This includes the take left from the parents and the self contribution.

pallets/subtensor/src/staking/stake_utils.rs

@@ -128,16 +128,16 @@ impl<T: Config> Pallet<T> {
         // Step 1: Get stake of hotkey (neuron)
         let alpha_stake =
             I64F64::saturating_from_num(Self::get_inherited_for_hotkey_on_subnet(hotkey, netuid));
-        log::trace!("alpha_stake: {:?}", alpha_stake);
+        log::debug!("alpha_stake: {:?}", alpha_stake);
 
         // Step 2: Get the global tao stake for the hotkey
         let tao_stake =
-            I64F64::saturating_from_num(Self::get_inherited_for_hotkey_on_subnet(hotkey, 0));
-        log::trace!("tao_stake: {:?}", tao_stake);
+            I64F64::saturating_from_num(Self::get_tao_inherited_for_hotkey_on_subnet(hotkey, netuid));
+        log::debug!("tao_stake: {:?}", tao_stake);
 
         // Step 3: Combine alpha and tao stakes
         let total_stake = alpha_stake.saturating_add(tao_stake.saturating_mul(tao_weight));
-        log::trace!("total_stake: {:?}", total_stake);
+        log::debug!("total_stake: {:?}", total_stake);
 
         (total_stake, alpha_stake, tao_stake)
     }
@@ -173,8 +173,8 @@ impl<T: Config> Pallet<T> {
             .map(|uid| {
                 if Keys::<T>::contains_key(netuid, uid) {
                     let hotkey: T::AccountId = Keys::<T>::get(netuid, uid);
-                    I64F64::saturating_from_num(Self::get_inherited_for_hotkey_on_subnet(
-                        &hotkey, 0,
+                    I64F64::saturating_from_num(Self::get_tao_inherited_for_hotkey_on_subnet(
+                        &hotkey, netuid,
                     ))
                 } else {
                     I64F64::saturating_from_num(0)
@@ -222,6 +222,102 @@ impl<T: Config> Pallet<T> {
     ///
     /// # Note
     /// This function uses saturating arithmetic to prevent overflows.
+    pub fn get_tao_inherited_for_hotkey_on_subnet(hotkey: &T::AccountId, netuid: u16) -> u64 {
+
+        let initial_tao: I96F32 =
+        I96F32::saturating_from_num(Self::get_stake_for_hotkey_on_subnet(hotkey, Self::get_root_netuid()));
+
+         // Initialize variables to track alpha allocated to children and inherited from parents.
+         let mut tao_to_children: I96F32 = I96F32::saturating_from_num(0);
+         let mut tao_from_parents: I96F32 = I96F32::saturating_from_num(0);
+ 
+         // 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!(
+             "Parents for hotkey {:?} on subnet {}: {:?}",
+             hotkey,
+             netuid,
+             parents
+         );
+         log::trace!(
+             "Children for hotkey {:?} on subnet {}: {:?}",
+             hotkey,
+             netuid,
+             children
+         );
+ 
+         // Step 3: Calculate the total tao allocated to children.
+         for (proportion, _) in children {
+             // Convert the proportion to a normalized value between 0 and 1.
+             let normalized_proportion: I96F32 = I96F32::saturating_from_num(proportion)
+                 .safe_div(I96F32::saturating_from_num(u64::MAX));
+             log::trace!(
+                 "Normalized proportion for child: {:?}",
+                 normalized_proportion
+             );
+ 
+             // Calculate the amount of tao to be allocated to this child.
+             let tao_proportion_to_child: I96F32 =
+                 I96F32::saturating_from_num(initial_tao).saturating_mul(normalized_proportion);
+             log::trace!("Tao proportion to child: {:?}", tao_proportion_to_child);
+ 
+             // Add this child's allocation to the total tao allocated to children.
+             tao_to_children = tao_to_children.saturating_add(tao_proportion_to_child);
+         }
+         log::trace!("Total tao allocated to children: {:?}", tao_to_children);
+ 
+         // Step 4: Calculate the total tao inherited from parents.
+         for (proportion, parent) in parents {
+             // Retrieve the parent's total stake on this subnet.
+             let parent_tao: I96F32 =
+                 I96F32::saturating_from_num(Self::get_stake_for_hotkey_on_subnet(&parent, Self::get_root_netuid()));
+             log::trace!(
+                 "Parent tao for parent {:?} on subnet {}: {:?}",
+                 parent,
+                 netuid,
+                 parent_tao
+             );
+ 
+             // Convert the proportion to a normalized value between 0 and 1.
+             let normalized_proportion: I96F32 = I96F32::saturating_from_num(proportion)
+                 .safe_div(I96F32::saturating_from_num(u64::MAX));
+             log::trace!(
+                 "Normalized proportion from parent: {:?}",
+                 normalized_proportion
+             );
+ 
+             // Calculate the amount of tao to be inherited from this parent.
+             let tao_proportion_from_parent: I96F32 =
+                 I96F32::saturating_from_num(parent_tao).saturating_mul(normalized_proportion);
+             log::trace!(
+                 "Tao proportion from parent: {:?}",
+                tao_proportion_from_parent
+             );
+ 
+             // Add this parent's contribution to the total tao inherited from parents.
+             tao_from_parents = tao_from_parents.saturating_add(tao_proportion_from_parent);
+         }
+         log::trace!(
+             "Total tao inherited from parents: {:?}",
+             tao_from_parents
+         );
+ 
+         // Step 5: Calculate the final inherited tao for the hotkey.
+         let finalized_tao: I96F32 = initial_tao
+             .saturating_sub(tao_to_children) // Subtract tao allocated to children
+             .saturating_add(tao_from_parents); // Add tao inherited from parents
+         log::trace!(
+             "Finalized tao for hotkey {:?} on subnet {}: {:?}",
+             hotkey,
+             netuid,
+             finalized_tao
+         );
+ 
+         // Step 6: Return the final inherited tao value.
+         finalized_tao.saturating_to_num::<u64>()
+    }
+
     pub fn get_inherited_for_hotkey_on_subnet(hotkey: &T::AccountId, netuid: u16) -> u64 {
         // Step 1: Retrieve the initial total stake (alpha) for the hotkey on the specified subnet.
         let initial_alpha: I96F32 =