Taoflow2

pallets/admin-utils/src/lib.rs

@@ -2279,6 +2279,66 @@ pub mod pallet {
             log::trace!("ColdkeySwapReannouncementDelaySet( duration: {duration:?} )");
             Ok(())
         }
+
+        /// Sets EffectiveRootProp emission scaling on/off
+        #[pallet::call_index(91)]
+        #[pallet::weight((
+            Weight::from_parts(7_343_000, 0)
+                .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(0))
+                .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1)),
+            DispatchClass::Operational,
+            Pays::Yes
+        ))]
+        pub fn sudo_set_effective_root_prop_emission_scaling(
+            origin: OriginFor<T>,
+            enabled: bool,
+        ) -> DispatchResult {
+            ensure_root(origin)?;
+            pallet_subtensor::Pallet::<T>::set_effective_root_prop_emission_scaling(enabled);
+            Ok(())
+        }
+
+        /// Sets the proportion of top subnets that receive emission
+        #[pallet::call_index(89)]
+        #[pallet::weight((
+            Weight::from_parts(7_343_000, 0)
+                .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(0))
+                .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1)),
+            DispatchClass::Operational,
+            Pays::Yes
+        ))]
+        pub fn sudo_set_emission_top_subnet_proportion(
+            origin: OriginFor<T>,
+            proportion: u16,
+        ) -> DispatchResult {
+            ensure_root(origin)?;
+            ensure!(
+                proportion > 0 && proportion <= 100,
+                Error::<T>::InvalidValue
+            );
+            let prop = U64F64::saturating_from_num(proportion)
+                .saturating_div(U64F64::saturating_from_num(100));
+            pallet_subtensor::Pallet::<T>::set_emission_top_subnet_proportion(prop);
+            Ok(())
+        }
+
+        /// Sets the absolute limit on number of subnets receiving emission (None = no limit)
+        #[pallet::call_index(90)]
+        #[pallet::weight((
+            Weight::from_parts(7_343_000, 0)
+                .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(0))
+                .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1)),
+            DispatchClass::Operational,
+            Pays::Yes
+        ))]
+        pub fn sudo_set_emission_top_subnet_absolute_limit(
+            origin: OriginFor<T>,
+            limit: Option<u16>,
+        ) -> DispatchResult {
+            ensure_root(origin)?;
+            pallet_subtensor::Pallet::<T>::set_emission_top_subnet_absolute_limit(limit);
+            Ok(())
+        }
     }
 }
 

pallets/subtensor/src/coinbase/run_coinbase.rs

@@ -638,6 +638,184 @@ impl<T: Config> Pallet<T> {
         }
     }
 
+    /// Computes and stores the EffectiveRootProp for a subnet. Returns the utilization value.
+    ///
+    /// EffectiveRootProp = raw_root_prop * utilization
+    ///
+    /// Where:
+    ///   raw_root_prop  = sum(root_alpha_dividends) / (sum(alpha_dividends) + sum(root_alpha_dividends))
+    ///   utilization    = sum(root_stake_i * efficiency_i) / total_root_stake
+    ///   efficiency_i   = min(actual_share_i / expected_share_i, 1.0)
+    ///   expected_share_i = root_stake_i / total_root_stake
+    ///   actual_share_i   = root_alpha_dividends[i] / sum(root_alpha_dividends)
+    ///
+    /// Only root stake of validators with UIDs on this subnet is counted.
+    /// TotalIssuance, unstaked TAO, and root stake on other subnets are irrelevant.
+    pub fn compute_and_store_effective_root_prop(
+        netuid: NetUid,
+        alpha_dividends: &BTreeMap<T::AccountId, U96F32>,
+        root_alpha_dividends: &BTreeMap<T::AccountId, U96F32>,
+    ) -> U96F32 {
+        let zero = U96F32::saturating_from_num(0);
+        let one = U96F32::saturating_from_num(1);
+
+        let total_alpha_divs: U96F32 = alpha_dividends
+            .values()
+            .fold(zero, |acc, v| acc.saturating_add(*v));
+
+        let total_root_divs: U96F32 = root_alpha_dividends
+            .values()
+            .fold(zero, |acc, v| acc.saturating_add(*v));
+
+        let total = total_alpha_divs.saturating_add(total_root_divs);
+
+        let raw_root_prop = if total > zero {
+            total_root_divs.checked_div(total).unwrap_or(zero)
+        } else {
+            zero
+        };
+
+        // Compute dividend-efficiency-based utilization.
+        // For each root-staked validator registered on this subnet:
+        //   expected_share = root_stake_i / total_root_stake
+        //   actual_share   = root_dividends_i / total_root_divs
+        //   efficiency     = min(actual_share / expected_share, 1.0)
+        //   utilization    = sum(root_stake_i * efficiency_i) / total_root_stake
+        let n = SubnetworkN::<T>::get(netuid);
+        let mut total_root_stake = zero;
+
+        // First pass: compute total root stake on this subnet
+        let mut hotkey_root_stakes: Vec<(T::AccountId, U96F32)> = Vec::new();
+        for uid in 0..n {
+            if let Ok(hotkey) = Keys::<T>::try_get(netuid, uid) {
+                let root_stake = Self::get_stake_for_hotkey_on_subnet(&hotkey, NetUid::ROOT);
+                let rs = U96F32::saturating_from_num(root_stake.to_u64());
+                total_root_stake = total_root_stake.saturating_add(rs);
+                if rs > zero {
+                    hotkey_root_stakes.push((hotkey, rs));
+                }
+            }
+        }
+
+        let utilization = if total_root_stake > zero && total_root_divs > zero {
+            // Second pass: compute weighted efficiency
+            let mut weighted_efficiency_sum = zero;
+            for (hotkey, rs) in &hotkey_root_stakes {
+                let expected_share = rs.checked_div(total_root_stake).unwrap_or(zero);
+                let actual_div = root_alpha_dividends.get(hotkey).copied().unwrap_or(zero);
+                let actual_share = actual_div.checked_div(total_root_divs).unwrap_or(zero);
+                let efficiency = if expected_share > zero {
+                    let raw_eff = actual_share.checked_div(expected_share).unwrap_or(zero);
+                    raw_eff.min(one)
+                } else {
+                    zero
+                };
+                weighted_efficiency_sum =
+                    weighted_efficiency_sum.saturating_add(rs.saturating_mul(efficiency));
+            }
+            weighted_efficiency_sum
+                .checked_div(total_root_stake)
+                .unwrap_or(zero)
+        } else if total_root_stake > zero {
+            // No root dividends at all → utilization = 0
+            zero
+        } else {
+            zero
+        };
+
+        let effective_root_prop = raw_root_prop.saturating_mul(utilization);
+
+        log::debug!(
+            "EffectiveRootProp for netuid {netuid:?}: {effective_root_prop:?} (raw: {raw_root_prop:?}, utilization: {utilization:?}, total_root_stake: {total_root_stake:?})"
+        );
+
+        EffectiveRootProp::<T>::insert(netuid, effective_root_prop);
+        utilization
+    }
+
+    /// Computes the fraction of a hotkey's dividends attributable to root stake.
+    ///
+    /// root_fraction = (root_stake * tao_weight) / (alpha_stake + root_stake * tao_weight)
+    ///
+    /// Returns 0 if the hotkey has no root stake or the total is zero.
+    pub fn get_root_dividend_fraction(
+        hotkey: &T::AccountId,
+        netuid: NetUid,
+        tao_weight: U96F32,
+    ) -> U96F32 {
+        let zero = U96F32::saturating_from_num(0);
+        let root_stake = Self::get_stake_for_hotkey_on_subnet(hotkey, NetUid::ROOT);
+        let root_stake_f = asfloat!(root_stake.to_u64());
+        if root_stake_f <= zero {
+            return zero;
+        }
+        let root_alpha_weighted = root_stake_f.saturating_mul(tao_weight);
+        let alpha_stake = Self::get_stake_for_hotkey_on_subnet(hotkey, netuid);
+        let alpha_stake_f = asfloat!(alpha_stake.to_u64());
+        let total_stake = alpha_stake_f.saturating_add(root_alpha_weighted);
+        if total_stake <= zero {
+            return zero;
+        }
+        root_alpha_weighted.checked_div(total_stake).unwrap_or(zero)
+    }
+
+    /// Applies utilization-based scaling or hard cap to root dividend maps.
+    ///
+    /// - utilization >= 1.0: no scaling, returns 0 recycled
+    /// - 0.5 <= utilization < 1.0: scales root dividends by utilization, recycles the rest
+    /// - utilization < 0.5 (hard cap): zeroes all root dividends, recycles everything,
+    ///   sets EffectiveRootProp to 0
+    ///
+    /// Also adjusts the root-staked portion of alpha_dividends accordingly.
+    /// Returns the total amount recycled.
+    pub fn apply_utilization_scaling(
+        netuid: NetUid,
+        utilization: U96F32,
+        alpha_dividends: &mut BTreeMap<T::AccountId, U96F32>,
+        root_alpha_dividends: &mut BTreeMap<T::AccountId, U96F32>,
+        tao_weight: U96F32,
+    ) -> U96F32 {
+        let half = U96F32::saturating_from_num(0.5);
+        let zero = U96F32::saturating_from_num(0);
+
+        let has_root_dividends =
+            !root_alpha_dividends.is_empty() && root_alpha_dividends.values().any(|v| *v > zero);
+
+        if !has_root_dividends || utilization >= half {
+            return zero;
+        }
+
+        let mut total_recycled = zero;
+
+        // Hard cap: utilization < 0.5 → recycle ALL root alpha dividends
+        let total_root: U96F32 = root_alpha_dividends
+            .values()
+            .fold(zero, |acc, v| acc.saturating_add(*v));
+        Self::recycle_subnet_alpha(netuid, AlphaCurrency::from(tou64!(total_root)));
+        total_recycled = total_recycled.saturating_add(total_root);
+        root_alpha_dividends.clear();
+
+        // Zero root-staked portion of alpha_dividends
+        for (hotkey, alpha_div) in alpha_dividends.iter_mut() {
+            let root_fraction = Self::get_root_dividend_fraction(hotkey, netuid, tao_weight);
+            if root_fraction > zero {
+                let recycle_amount = (*alpha_div).saturating_mul(root_fraction);
+                *alpha_div = (*alpha_div).saturating_sub(recycle_amount);
+                Self::recycle_subnet_alpha(netuid, AlphaCurrency::from(tou64!(recycle_amount)));
+                total_recycled = total_recycled.saturating_add(recycle_amount);
+            }
+        }
+
+        // Overwrite EffectiveRootProp to 0
+        EffectiveRootProp::<T>::insert(netuid, U96F32::saturating_from_num(0));
+
+        log::debug!(
+            "Hard cap triggered for netuid {netuid:?}: utilization {utilization:?} < 0.5, all root dividends recycled"
+        );
+
+        total_recycled
+    }
+
     pub fn get_stake_map(
         netuid: NetUid,
         hotkeys: Vec<&T::AccountId>,
@@ -724,7 +902,7 @@ impl<T: Config> Pallet<T> {
         let root_alpha = pending_root_alpha;
         let owner_cut = pending_owner_cut;
 
-        let (incentives, (alpha_dividends, root_alpha_dividends)) =
+        let (incentives, (mut alpha_dividends, mut root_alpha_dividends)) =
             Self::calculate_dividend_and_incentive_distribution(
                 netuid,
                 root_alpha,
@@ -733,6 +911,22 @@ impl<T: Config> Pallet<T> {
                 tao_weight,
             );
 
+        // Compute and store EffectiveRootProp, getting back utilization for scaling.
+        let utilization = Self::compute_and_store_effective_root_prop(
+            netuid,
+            &alpha_dividends,
+            &root_alpha_dividends,
+        );
+
+        // Apply utilization-based scaling or hard cap to root dividends.
+        Self::apply_utilization_scaling(
+            netuid,
+            utilization,
+            &mut alpha_dividends,
+            &mut root_alpha_dividends,
+            tao_weight,
+        );
+
         Self::distribute_dividends_and_incentives(
             netuid,
             owner_cut,