Fix clear_small_nomination_if_required to also clear locks

Author: gztensor

pallets/subtensor/src/staking/helpers.rs

@@ -245,6 +245,9 @@ impl<T: Config> Pallet<T> {
                 if let Ok(cleared_stake) = maybe_cleared_stake {
                     // Add the stake to the coldkey account.
                     Self::add_balance_to_coldkey_account(coldkey, cleared_stake.into());
+
+                    // Clear the lock if exists
+                    Self::maybe_cleanup_lock(coldkey, netuid);
                 } else {
                     // Just clear small alpha
                     let alpha =

pallets/subtensor/src/staking/lock.rs

@@ -4,8 +4,6 @@ use substrate_fixed::transcendental::exp;
 use substrate_fixed::types::{I64F64, U64F64};
 use subtensor_runtime_common::NetUid;
 
-const DUST_THRESHOLD: u64 = 100;
-
 impl<T: Config> Pallet<T> {
     /// Computes exp(-dt / tau) as a U64F64 decay factor.
     pub fn exp_decay(dt: u64, tau: u64) -> U64F64 {
@@ -165,21 +163,10 @@ impl<T: Config> Pallet<T> {
         Ok(())
     }
 
-    /// Clears the lock if both locked_mass and conviction have decayed below the dust threshold.
+    /// Clears the lock. This function will be called if the alpha stake drops below minimum
+    /// threshold.
     pub fn maybe_cleanup_lock(coldkey: &T::AccountId, netuid: NetUid) {
-        if let Some(existing) = Lock::<T>::get(coldkey, netuid) {
-            let now = Self::get_current_block_as_u64();
-            let lock = Self::roll_forward_lock(existing, now);
-            let dust = DUST_THRESHOLD.into();
-
-            if lock.locked_mass < dust
-                && lock.conviction < U64F64::saturating_from_num(DUST_THRESHOLD)
-            {
-                Lock::<T>::remove(coldkey, netuid);
-            } else {
-                Lock::<T>::insert(coldkey, netuid, lock);
-            }
-        }
+        Lock::<T>::remove(coldkey, netuid);
     }
 
     /// Returns the total conviction for a hotkey on a subnet,

pallets/subtensor/src/tests/locks.rs

@@ -1127,34 +1127,6 @@ fn test_maybe_cleanup_lock_removes_dust() {
     });
 }
 
-#[test]
-fn test_maybe_cleanup_lock_preserves_active_lock() {
-    new_test_ext(1).execute_with(|| {
-        let coldkey = U256::from(1);
-        let hotkey = U256::from(2);
-        let netuid = setup_subnet_with_stake(coldkey, hotkey, 100_000_000_000);
-
-        assert_ok!(SubtensorModule::do_lock_stake(
-            &coldkey,
-            netuid,
-            &hotkey,
-            100_000u64.into(),
-        ));
-
-        step_block(100);
-
-        SubtensorModule::maybe_cleanup_lock(&coldkey, netuid);
-
-        let lock = Lock::<Test>::get(coldkey, netuid);
-        assert!(lock.is_some());
-        // last_update should be rolled forward to current block
-        assert_eq!(
-            lock.unwrap().last_update,
-            SubtensorModule::get_current_block_as_u64()
-        );
-    });
-}
-
 #[test]
 fn test_maybe_cleanup_lock_no_lock() {
     new_test_ext(1).execute_with(|| {
@@ -1336,11 +1308,11 @@ fn test_lock_stake_extrinsic() {
 }
 
 // =========================================================================
-// GROUP 14: Recycle/burn alpha bypass (BUG: bypasses lock)
+// GROUP 14: Recycle/burn alpha checks against lock
 // =========================================================================
 
 #[test]
-fn test_recycle_alpha_bypasses_lock() {
+fn test_recycle_alpha_checks_lock() {
     new_test_ext(1).execute_with(|| {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
@@ -1475,11 +1447,11 @@ fn test_subnet_dissolution_and_netuid_reuse() {
 }
 
 // =========================================================================
-// GROUP 16: Clear small nomination bypass
+// GROUP 16: Clear small nomination checks lock
 // =========================================================================
 
 #[test]
-fn test_clear_small_nomination_bypasses_lock() {
+fn test_clear_small_nomination_checks_lock() {
     new_test_ext(1).execute_with(|| {
         let owner_coldkey = U256::from(100);
         let owner_hotkey = U256::from(101);
@@ -1523,7 +1495,7 @@ fn test_clear_small_nomination_bypasses_lock() {
         assert_eq!(nominator_alpha_after, AlphaBalance::ZERO);
 
         // Lock entry still exists, now orphaned
-        assert!(Lock::<Test>::get(nominator, netuid).is_some());
+        assert!(Lock::<Test>::get(nominator, netuid).is_none());
     });
 }