fix + tests

Author: l0r1s

pallets/admin-utils/src/lib.rs

@@ -538,7 +538,7 @@ pub mod pallet {
             );
             // Prevent chain bloat: Require max UIDs to be limited
             let mechanism_count = pallet_subtensor::MechanismCountCurrent::<T>::get(netuid);
-            pallet_subtensor::Pallet::<T>::check_max_uids_vs_mechanism_count(
+            pallet_subtensor::Pallet::<T>::ensure_max_uids_over_all_mechanisms(
                 max_allowed_uids,
                 mechanism_count.into(),
             )?;

pallets/admin-utils/src/tests/mod.rs

@@ -10,7 +10,10 @@ use pallet_subtensor::{
     TargetRegistrationsPerInterval, Tempo, WeightsVersionKeyRateLimit, *,
 };
 // use pallet_subtensor::{migrations, Event};
-use pallet_subtensor::{Event, utils::rate_limiting::TransactionType};
+use pallet_subtensor::{
+    Event, subnets::mechanism::MAX_MECHANISM_COUNT_PER_SUBNET,
+    utils::rate_limiting::TransactionType,
+};
 use sp_consensus_grandpa::AuthorityId as GrandpaId;
 use sp_core::{Get, Pair, U256, ed25519};
 use substrate_fixed::types::I96F32;
@@ -540,10 +543,10 @@ fn test_sudo_set_max_allowed_uids() {
             Error::<Test>::MaxAllowedUidsGreaterThanDefaultMaxAllowedUids
         );
 
-        // Chain bloat check against mechanism count
-        // Set MechanismCountCurrent to exceed 256 / DefaultMaxAllowedUids (16)
+        // Trying to set max allowed uids that would cause max_allowed_uids * mechanism_count > 256
+        MaxAllowedUids::<Test>::insert(netuid, 8);
         MechanismCountCurrent::<Test>::insert(netuid, MechId::from(32));
-        let large_max_uids = 16_u16;
+        let large_max_uids = 16;
         assert_noop!(
             AdminUtils::sudo_set_max_allowed_uids(
                 <<Test as Config>::RuntimeOrigin>::root(),
@@ -2888,3 +2891,32 @@ fn test_sudo_set_min_allowed_uids() {
         );
     });
 }
+
+#[test]
+fn test_sudo_set_max_mechanism_count() {
+    new_test_ext().execute_with(|| {
+        // Normal case
+        assert_ok!(AdminUtils::sudo_set_max_mechanism_count(
+            <<Test as Config>::RuntimeOrigin>::root(),
+            MechId::from(10)
+        ));
+
+        // Zero fails
+        assert_noop!(
+            AdminUtils::sudo_set_max_mechanism_count(
+                <<Test as Config>::RuntimeOrigin>::root(),
+                MechId::from(0)
+            ),
+            pallet_subtensor::Error::<Test>::InvalidValue
+        );
+
+        // Over max bound fails
+        assert_noop!(
+            AdminUtils::sudo_set_max_mechanism_count(
+                <<Test as Config>::RuntimeOrigin>::root(),
+                MechId::from(MAX_MECHANISM_COUNT_PER_SUBNET + 1)
+            ),
+            pallet_subtensor::Error::<Test>::InvalidValue
+        );
+    });
+}

pallets/subtensor/src/lib.rs

@@ -2310,15 +2310,17 @@ pub mod pallet {
         MechId::from(1)
     }
 
+    /// -- ITEM (Maximum number of mechanisms)
     #[pallet::type_value]
-    /// -- ITEM (Maximum number of sub-subnets)
     pub fn DefaultMaxMechanismCount<T: Config>() -> MechId {
         MechId::from(2)
     }
-    #[pallet::storage]
+
     /// ITEM( max_mechanism_count )
+    #[pallet::storage]
     pub type MaxMechanismCount<T> =
         StorageValue<_, MechId, ValueQuery, DefaultMaxMechanismCount<T>>;
+
     /// -- ITEM (Rate limit for mechanism count updates)
     #[pallet::type_value]
     pub fn MechanismCountSetRateLimit<T: Config>() -> u64 {

pallets/subtensor/src/subnets/mechanism.rs

@@ -95,21 +95,18 @@ impl<T: Config> Pallet<T> {
         Ok(())
     }
 
-    pub fn check_max_uids_vs_mechanism_count(
+    pub fn ensure_max_uids_over_all_mechanisms(
         max_uids: u16,
         mechanism_count: MechId,
     ) -> DispatchResult {
-        let max_uids_for_one_mechanism = 256_u16;
-        let max_uids_for_mechanism_count =
-            max_uids_for_one_mechanism.safe_div(u8::from(mechanism_count) as u16);
         ensure!(
-            max_uids_for_mechanism_count >= max_uids,
+            max_uids * u8::from(mechanism_count) as u16 <= 256,
             Error::<T>::TooManyUIDsPerMechanism
         );
         Ok(())
     }
 
-    /// Set the desired value of sub-subnet count for a subnet identified
+    /// Set the desired value of mechanism count for a subnet identified
     /// by netuid
     pub fn do_set_mechanism_count(netuid: NetUid, mechanism_count: MechId) -> DispatchResult {
         // Make sure the subnet exists
@@ -129,7 +126,7 @@ impl<T: Config> Pallet<T> {
 
         // Prevent chain bloat: Require max UIDs to be limited
         let max_uids = MaxAllowedUids::<T>::get(netuid);
-        Self::check_max_uids_vs_mechanism_count(max_uids, mechanism_count)?;
+        Self::ensure_max_uids_over_all_mechanisms(max_uids, mechanism_count)?;
 
         // Make sure we are not allowing numbers that will break the math
         ensure!(