Merge branch 'devnet-ready' into feat/untrim-uids

Author: l0r1s

Cargo.lock

@@ -2502,6 +2502,28 @@ fn test_trim_to_max_allowed_uids() {
         Keys::<Test>::insert(netuid, 14, sn_owner_hotkey2);
         Uids::<Test>::insert(netuid, sn_owner_hotkey2, 14);
 
+        // Set some evm addresses
+        AssociatedEvmAddress::<Test>::insert(
+            netuid,
+            6,
+            (sp_core::H160::from_slice(b"12345678901234567891"), now),
+        );
+        AssociatedEvmAddress::<Test>::insert(
+            netuid,
+            10,
+            (sp_core::H160::from_slice(b"12345678901234567892"), now),
+        );
+        AssociatedEvmAddress::<Test>::insert(
+            netuid,
+            12,
+            (sp_core::H160::from_slice(b"12345678901234567893"), now),
+        );
+        AssociatedEvmAddress::<Test>::insert(
+            netuid,
+            14,
+            (sp_core::H160::from_slice(b"12345678901234567894"), now),
+        );
+
         // Populate Weights and Bonds storage items to test trimming
         // Create weights and bonds that span across the range that will be trimmed
         for uid in 0..max_n {
@@ -2578,6 +2600,7 @@ fn test_trim_to_max_allowed_uids() {
         for uid in new_max_n..max_n {
             assert!(!Keys::<Test>::contains_key(netuid, uid));
             assert!(!BlockAtRegistration::<Test>::contains_key(netuid, uid));
+            assert!(!AssociatedEvmAddress::<Test>::contains_key(netuid, uid));
             for mecid in 0..mechanism_count.into() {
                 let netuid_index =
                     SubtensorModule::get_mechanism_storage_index(netuid, MechId::from(mecid));
@@ -2635,6 +2658,23 @@ fn test_trim_to_max_allowed_uids() {
         // Actual number of neurons on the network updated after trimming
         assert_eq!(SubnetworkN::<Test>::get(netuid), new_max_n);
 
+        // Uids match enumeration order
+        for i in 0..new_max_n.into() {
+            let hotkey = Keys::<Test>::get(netuid, i);
+            let uid = Uids::<Test>::get(netuid, hotkey);
+            assert_eq!(uid, Some(i));
+        }
+
+        // EVM association have been remapped correctly (uids: 7 -> 2, 14 -> 7)
+        assert_eq!(
+            AssociatedEvmAddress::<Test>::get(netuid, 2),
+            Some((sp_core::H160::from_slice(b"12345678901234567891"), now))
+        );
+        assert_eq!(
+            AssociatedEvmAddress::<Test>::get(netuid, 7),
+            Some((sp_core::H160::from_slice(b"12345678901234567894"), now))
+        );
+
         // Non existent subnet
         assert_err!(
             AdminUtils::sudo_trim_to_max_allowed_uids(
@@ -2677,7 +2717,7 @@ fn test_trim_to_max_allowed_uids_too_many_immune() {
         MaxRegistrationsPerBlock::<Test>::insert(netuid, 256);
         TargetRegistrationsPerInterval::<Test>::insert(netuid, 256);
         ImmuneOwnerUidsLimit::<Test>::insert(netuid, 2);
-        MinAllowedUids::<Test>::set(netuid, 4);
+        MinAllowedUids::<Test>::set(netuid, 2);
 
         // Add 5 neurons
         let max_n = 5;
@@ -2715,7 +2755,7 @@ fn test_trim_to_max_allowed_uids_too_many_immune() {
                 netuid,
                 4
             ),
-            pallet_subtensor::Error::<Test>::InvalidValue
+            pallet_subtensor::Error::<Test>::TrimmingWouldExceedMaxImmunePercentage
         );
 
         // Try to trim to 3 UIDs - this should also fail because 4/3 > 80% immune (>= 80%)
@@ -2725,7 +2765,7 @@ fn test_trim_to_max_allowed_uids_too_many_immune() {
                 netuid,
                 3
             ),
-            pallet_subtensor::Error::<Test>::InvalidValue
+            pallet_subtensor::Error::<Test>::TrimmingWouldExceedMaxImmunePercentage
         );
 
         // Now test a scenario where trimming should succeed
@@ -2737,10 +2777,6 @@ fn test_trim_to_max_allowed_uids_too_many_immune() {
         Uids::<Test>::remove(netuid, hotkey_to_remove);
         BlockAtRegistration::<Test>::remove(netuid, uid_to_remove);
 
-        // Now we have 3 immune out of 4 total UIDs
-        // Try to trim to 3 UIDs - this should succeed because 3/3 = 100% immune, but that's exactly 80%
-        // Wait, 100% is > 80%, so this should fail. Let me test with a scenario where we have fewer immune UIDs
-
         // Remove another immune UID to make it 2 immune out of 3 total
         let uid_to_remove2 = 2;
         let hotkey_to_remove2 = U256::from(uid_to_remove2 * 1000 + 1000);

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

@@ -135,6 +135,7 @@ impl<T: Config> Pallet<T> {
         let pruning_score = extract_from_sorted_terms!(terms_sorted, pruning_score);
         let validator_trust = extract_from_sorted_terms!(terms_sorted, validator_trust);
         let new_validator_permit = extract_from_sorted_terms!(terms_sorted, new_validator_permit);
+        let stake_weight = extract_from_sorted_terms!(terms_sorted, stake_weight);
 
         Active::<T>::insert(netuid, active.clone());
         Emission::<T>::insert(netuid, emission);
@@ -145,6 +146,7 @@ impl<T: Config> Pallet<T> {
         PruningScores::<T>::insert(netuid, pruning_score);
         ValidatorTrust::<T>::insert(netuid, validator_trust);
         ValidatorPermit::<T>::insert(netuid, new_validator_permit);
+        StakeWeight::<T>::insert(netuid, stake_weight);
     }
 
     /// Calculates reward consensus and returns the emissions for uids/hotkeys in a given `netuid`.

pallets/subtensor/src/epoch/run_epoch.rs

@@ -256,5 +256,9 @@ mod errors {
         CannotAffordLockCost,
         /// exceeded the rate limit for associating an EVM key.
         EvmKeyAssociateRateLimitExceeded,
+        /// The UID map for the subnet could not be cleared
+        UidMapCouldNotBeCleared,
+        /// Trimming would exceed the max immune neurons percentage
+        TrimmingWouldExceedMaxImmunePercentage,
     }
 }

pallets/subtensor/src/macros/errors.rs

@@ -46,6 +46,7 @@ impl<T: Config> Pallet<T> {
             }
         }
         Dividends::<T>::mutate(netuid, |v| Self::set_element_at(v, neuron_index, 0));
+        StakeWeight::<T>::mutate(netuid, |v| Self::set_element_at(v, neuron_index, 0));
     }
 
     /// Replace the neuron under this uid.
@@ -162,7 +163,7 @@ impl<T: Config> Pallet<T> {
             let immune_percentage = Percent::from_rational(immune_count, max_n);
             ensure!(
                 immune_percentage < T::MaxImmuneUidsPercentage::get(),
-                Error::<T>::InvalidValue
+                Error::<T>::TrimmingWouldExceedMaxImmunePercentage
             );
 
             // Get all emissions with their UIDs and sort by emission (descending)
@@ -209,6 +210,7 @@ impl<T: Config> Pallet<T> {
                     #[allow(unknown_lints)]
                     Keys::<T>::remove(netuid, neuron_uid);
                     BlockAtRegistration::<T>::remove(netuid, neuron_uid);
+                    AssociatedEvmAddress::<T>::remove(netuid, neuron_uid);
                     for mecid in 0..mechanisms_count {
                         let netuid_index = Self::get_mechanism_storage_index(netuid, mecid.into());
                         Weights::<T>::remove(netuid_index, neuron_uid);
@@ -315,6 +317,7 @@ impl<T: Config> Pallet<T> {
 
                 // Swap uid specific storage items to new compressed positions
                 Keys::<T>::swap(netuid, old_neuron_uid, netuid, new_neuron_uid);
+                AssociatedEvmAddress::<T>::swap(netuid, old_neuron_uid, netuid, new_neuron_uid);
                 BlockAtRegistration::<T>::swap(netuid, old_neuron_uid, netuid, new_neuron_uid);
 
                 for mecid in 0..mechanisms_count {
@@ -352,6 +355,21 @@ impl<T: Config> Pallet<T> {
                 }
             }
 
+            // Clear the UID map for the subnet
+            let clear_result = Uids::<T>::clear_prefix(netuid, u32::MAX, None);
+            // Shouldn't happen, but possible.
+            ensure!(
+                clear_result.maybe_cursor.is_none(),
+                Error::<T>::UidMapCouldNotBeCleared
+            );
+
+            // Insert the new UIDs
+            for new_uid in old_to_new_uid.values() {
+                // Get the hotkey using Keys map and new UID.
+                let hotkey = Keys::<T>::get(netuid, *new_uid as u16);
+                Uids::<T>::insert(netuid, hotkey, *new_uid as u16);
+            }
+
             // Update the subnet's uid count to reflect the new maximum
             SubnetworkN::<T>::insert(netuid, max_n);
         }