error cases tests + clean up

Author: l0r1s

pallets/subtensor/src/macros/dispatches.rs

@@ -2350,7 +2350,7 @@ mod dispatches {
                 let when = existing.0;
                 ensure!(
                     now > when + delay,
-                    Error::<T>::ColdkeySwapReannouncedTooEarly
+                    Error::<T>::ColdKeySwapReannouncedTooEarly
                 );
             }
 
@@ -2371,11 +2371,11 @@ mod dispatches {
             let who = ensure_signed(origin)?;
 
             let (when, new_coldkey) = ColdkeySwapAnnouncements::<T>::take(who.clone())
-                .ok_or(Error::<T>::ColdkeySwapAnnouncementNotFound)?;
+                .ok_or(Error::<T>::ColdKeySwapAnnouncementNotFound)?;
 
             let now = <frame_system::Pallet<T>>::block_number();
             let delay = ColdkeySwapScheduleDuration::<T>::get();
-            ensure!(now > when + delay, Error::<T>::ColdkeySwapTooEarly);
+            ensure!(now > when + delay, Error::<T>::ColdKeySwapTooEarly);
 
             Self::do_swap_coldkey(&who, &new_coldkey)?;
 

pallets/subtensor/src/macros/errors.rs

@@ -138,8 +138,6 @@ mod errors {
         ColdKeyAlreadyAssociated,
         /// The coldkey balance is not enough to pay for the swap
         NotEnoughBalanceToPaySwapColdKey,
-        /// The coldkey is in arbitration
-        ColdkeyIsInArbitration,
         /// Attempting to set an invalid child for a hotkey on a network.
         InvalidChild,
         /// Duplicate child when setting children.
@@ -151,11 +149,11 @@ mod errors {
         /// Default transaction rate limit exceeded.
         TxRateLimitExceeded,
         /// Coldkey swap announcement not found
-        ColdkeySwapAnnouncementNotFound,
+        ColdKeySwapAnnouncementNotFound,
         /// Coldkey swap too early.
-        ColdkeySwapTooEarly,
+        ColdKeySwapTooEarly,
         /// Coldkey swap reannounced too early.
-        ColdkeySwapReannouncedTooEarly,
+        ColdKeySwapReannouncedTooEarly,
         /// New coldkey is hotkey
         NewColdKeyIsHotkey,
         /// Childkey take is invalid.

pallets/subtensor/src/tests/swap_coldkey.rs

@@ -29,7 +29,7 @@ use crate::*;
 use crate::{Call, ColdkeySwapScheduleDuration, Error};
 
 #[test]
-fn test_announce_coldkey_swap_with_no_announcement_works() {
+fn test_announce_coldkey_swap_works() {
     new_test_ext(1).execute_with(|| {
         let who = U256::from(1);
         let new_coldkey = U256::from(2);
@@ -121,7 +121,7 @@ fn test_announce_coldkey_swap_with_existing_announcement_not_past_delay_fails()
                 RuntimeOrigin::signed(who.clone()),
                 new_coldkey_2,
             ),
-            Error::<Test>::ColdkeySwapReannouncedTooEarly
+            Error::<Test>::ColdKeySwapReannouncedTooEarly
         );
     });
 }
@@ -143,6 +143,103 @@ fn test_announce_coldkey_swap_with_bad_origin_fails() {
     });
 }
 
+#[test]
+fn test_swap_coldkey_announced_too_early_fails() {
+    new_test_ext(1).execute_with(|| {
+        let who = U256::from(1);
+        let new_coldkey = U256::from(2);
+
+        assert_ok!(SubtensorModule::announce_coldkey_swap(
+            RuntimeOrigin::signed(who.clone()),
+            new_coldkey,
+        ));
+
+        assert_noop!(
+            SubtensorModule::swap_coldkey_announced(
+                <Test as frame_system::Config>::RuntimeOrigin::signed(who)
+            ),
+            Error::<Test>::ColdKeySwapTooEarly
+        );
+    })
+}
+
+#[test]
+fn test_swap_coldkey_announced_with_already_associated_coldkey_fails() {
+    new_test_ext(1).execute_with(|| {
+        let who = U256::from(1);
+        let new_coldkey = U256::from(2);
+        let hotkey = U256::from(3);
+
+        assert_ok!(SubtensorModule::announce_coldkey_swap(
+            RuntimeOrigin::signed(who.clone()),
+            new_coldkey,
+        ));
+
+        let now = System::block_number();
+        let delay = ColdkeySwapScheduleDuration::<Test>::get() + 1;
+        System::run_to_block::<AllPalletsWithSystem>(now + delay);
+
+        let swap_cost = SubtensorModule::get_key_swap_cost();
+        SubtensorModule::add_balance_to_coldkey_account(&who, swap_cost.to_u64());
+
+        SubtensorModule::create_account_if_non_existent(&new_coldkey, &hotkey);
+
+        assert_noop!(
+            SubtensorModule::swap_coldkey_announced(
+                <Test as frame_system::Config>::RuntimeOrigin::signed(who)
+            ),
+            Error::<Test>::ColdKeyAlreadyAssociated
+        );
+    })
+}
+
+#[test]
+fn test_swap_coldkey_announced_using_registered_hotkey_fails() {
+    new_test_ext(1).execute_with(|| {
+        let who = U256::from(1);
+        let new_coldkey = U256::from(2);
+        let hotkey = U256::from(3);
+
+        assert_ok!(SubtensorModule::announce_coldkey_swap(
+            RuntimeOrigin::signed(who.clone()),
+            hotkey.clone(),
+        ));
+
+        let now = System::block_number();
+        let delay = ColdkeySwapScheduleDuration::<Test>::get() + 1;
+        System::run_to_block::<AllPalletsWithSystem>(now + delay);
+
+        let swap_cost = SubtensorModule::get_key_swap_cost();
+        SubtensorModule::add_balance_to_coldkey_account(&who, swap_cost.to_u64());
+
+        SubtensorModule::create_account_if_non_existent(&new_coldkey, &hotkey);
+
+        assert_noop!(
+            SubtensorModule::swap_coldkey_announced(
+                <Test as frame_system::Config>::RuntimeOrigin::signed(who)
+            ),
+            Error::<Test>::NewColdKeyIsHotkey
+        );
+    })
+}
+
+#[test]
+fn test_swap_coldkey_with_not_enough_balance_to_pay_swap_cost_fails() {
+    new_test_ext(1).execute_with(|| {
+        let who = U256::from(1);
+        let new_coldkey = U256::from(2);
+        
+        let now = System::block_number();
+        let delay = ColdkeySwapScheduleDuration::<Test>::get() + 1;
+        System::run_to_block::<AllPalletsWithSystem>(now + delay);
+
+        assert_noop!(
+            SubtensorModule::do_swap_coldkey(&who, &new_coldkey),
+            Error::<Test>::NotEnoughBalanceToPaySwapColdKey
+        );
+    });
+}
+
 #[test]
 fn test_swap_subnet_owner() {
     new_test_ext(1).execute_with(|| {
@@ -662,28 +759,6 @@ fn test_swap_concurrent_modifications() {
     });
 }
 
-#[test]
-fn test_swap_with_invalid_subnet_ownership() {
-    new_test_ext(1).execute_with(|| {
-        let old_coldkey = U256::from(1);
-        let new_coldkey = U256::from(2);
-        let netuid = NetUid::from(1u16);
-
-        SubnetOwner::<Test>::insert(netuid, old_coldkey);
-
-        // Simulate an invalid state where the subnet owner doesn't match the old_coldkey
-        SubnetOwner::<Test>::insert(netuid, U256::from(3));
-
-        let swap_cost = SubtensorModule::get_key_swap_cost();
-        SubtensorModule::add_balance_to_coldkey_account(&old_coldkey, swap_cost.to_u64());
-
-        assert_ok!(SubtensorModule::do_swap_coldkey(&old_coldkey, &new_coldkey,));
-
-        // The swap should not affect the mismatched subnet ownership
-        assert_eq!(SubnetOwner::<Test>::get(netuid), U256::from(3));
-    });
-}
-
 #[test]
 fn test_do_swap_coldkey_success() {
     new_test_ext(1).execute_with(|| {
@@ -1917,20 +1992,6 @@ fn test_coldkey_swap_no_identity_no_changes_newcoldkey_exists() {
     });
 }
 
-#[test]
-fn test_cant_schedule_swap_without_enough_to_burn() {
-    new_test_ext(1).execute_with(|| {
-        let old_coldkey = U256::from(3);
-        let new_coldkey = U256::from(4);
-        let hotkey = U256::from(5);
-
-        assert_noop!(
-            SubtensorModule::do_swap_coldkey(&old_coldkey, &new_coldkey),
-            Error::<Test>::NotEnoughBalanceToPaySwapColdKey
-        );
-    });
-}
-
 #[test]
 fn test_coldkey_in_swap_schedule_prevents_funds_usage() {
     // Testing the signed extension validate function