fix announcement

Author: l0r1s

pallets/subtensor/src/macros/dispatches.rs

@@ -2345,6 +2345,15 @@ mod dispatches {
             let who = ensure_signed(origin)?;
             let now = <frame_system::Pallet<T>>::block_number();
 
+            if let Some(existing) = ColdkeySwapAnnouncements::<T>::get(who.clone()) {
+                let delay = ColdkeySwapScheduleDuration::<T>::get();
+                let when = existing.0;
+                ensure!(
+                    now > when + delay,
+                    Error::<T>::ColdkeySwapReannouncedTooEarly
+                );
+            }
+
             ColdkeySwapAnnouncements::<T>::insert(who.clone(), (now, new_coldkey.clone()));
 
             Self::deposit_event(Event::ColdkeySwapAnnounced {
@@ -2355,25 +2364,8 @@ mod dispatches {
             Ok(())
         }
 
-        /// Removes a coldkey swap announcement.
-        #[pallet::call_index(126)]
-        #[pallet::weight(Weight::zero())]
-        pub fn remove_coldkey_swap_announcement(origin: OriginFor<T>) -> DispatchResult {
-            let who = ensure_signed(origin)?;
-
-            ensure!(
-                ColdkeySwapAnnouncements::<T>::contains_key(who.clone()),
-                Error::<T>::ColdkeySwapAnnouncementNotFound
-            );
-
-            ColdkeySwapAnnouncements::<T>::remove(who.clone());
-
-            Self::deposit_event(Event::ColdkeySwapAnnouncementRemoved { who: who.clone() });
-            Ok(())
-        }
-
         /// Performs a coldkey swap iff an announcement has been made.
-        #[pallet::call_index(127)]
+        #[pallet::call_index(126)]
         #[pallet::weight(Weight::zero())]
         pub fn swap_coldkey_announced(origin: OriginFor<T>) -> DispatchResult {
             let who = ensure_signed(origin)?;
@@ -2382,8 +2374,8 @@ mod dispatches {
                 .ok_or(Error::<T>::ColdkeySwapAnnouncementNotFound)?;
 
             let now = <frame_system::Pallet<T>>::block_number();
-            let delay = when + ColdkeySwapScheduleDuration::<T>::get();
-            ensure!(now >= delay, Error::<T>::ColdkeySwapTooEarly);
+            let delay = ColdkeySwapScheduleDuration::<T>::get();
+            ensure!(now > when + delay, Error::<T>::ColdkeySwapTooEarly);
 
             Self::do_swap_coldkey(&who, &new_coldkey)?;
 

pallets/subtensor/src/macros/errors.rs

@@ -154,6 +154,8 @@ mod errors {
         ColdkeySwapAnnouncementNotFound,
         /// Coldkey swap too early.
         ColdkeySwapTooEarly,
+        /// Coldkey swap reannounced too early.
+        ColdkeySwapReannouncedTooEarly,
         /// New coldkey is hotkey
         NewColdKeyIsHotkey,
         /// Childkey take is invalid.

pallets/subtensor/src/tests/swap_coldkey.rs

@@ -29,10 +29,10 @@ use crate::*;
 use crate::{Call, ColdkeySwapScheduleDuration, Error};
 
 #[test]
-fn test_announce_coldkey_swap_works() {
+fn test_announce_coldkey_swap_with_no_announcement_works() {
     new_test_ext(1).execute_with(|| {
         let who = U256::from(1);
-        let new_coldkey = U256::from(1);
+        let new_coldkey = U256::from(2);
 
         assert_eq!(ColdkeySwapAnnouncements::<Test>::iter().count(), 0);
 
@@ -58,65 +58,86 @@ fn test_announce_coldkey_swap_works() {
 }
 
 #[test]
-fn test_announce_coldkey_swap_bad_origin_fails() {
+fn test_announce_coldkey_swap_with_existing_announcement_past_delay_works() {
     new_test_ext(1).execute_with(|| {
-        let new_coldkey = U256::from(1);
+        let who = U256::from(1);
+        let new_coldkey = U256::from(2);
+        let new_coldkey_2 = U256::from(3);
 
-        assert_noop!(
-            SubtensorModule::announce_coldkey_swap(RuntimeOrigin::none(), new_coldkey),
-            BadOrigin
+        assert_eq!(ColdkeySwapAnnouncements::<Test>::iter().count(), 0);
+
+        assert_ok!(SubtensorModule::announce_coldkey_swap(
+            RuntimeOrigin::signed(who.clone()),
+            new_coldkey,
+        ));
+
+        let now = System::block_number();
+        assert_eq!(
+            ColdkeySwapAnnouncements::<Test>::iter().collect::<Vec<_>>(),
+            vec![(who.clone(), (now, new_coldkey))]
         );
 
-        assert_noop!(
-            SubtensorModule::announce_coldkey_swap(RuntimeOrigin::root(), new_coldkey),
-            BadOrigin
+        let delay = ColdkeySwapScheduleDuration::<Test>::get() + 1;
+        System::run_to_block::<AllPalletsWithSystem>(now + delay);
+
+        assert_ok!(SubtensorModule::announce_coldkey_swap(
+            RuntimeOrigin::signed(who.clone()),
+            new_coldkey_2,
+        ));
+
+        let now = System::block_number();
+        assert_eq!(
+            ColdkeySwapAnnouncements::<Test>::iter().collect::<Vec<_>>(),
+            vec![(who.clone(), (now, new_coldkey_2))]
         );
     });
 }
 
 #[test]
-fn test_remove_coldkey_swap_announcement_works() {
+fn test_announce_coldkey_swap_with_existing_announcement_not_past_delay_fails() {
     new_test_ext(1).execute_with(|| {
         let who = U256::from(1);
         let new_coldkey = U256::from(2);
-        let now = System::block_number();
-        ColdkeySwapAnnouncements::<Test>::insert(who.clone(), (now, new_coldkey));
+        let new_coldkey_2 = U256::from(3);
+
+        assert_eq!(ColdkeySwapAnnouncements::<Test>::iter().count(), 0);
 
-        assert_ok!(SubtensorModule::remove_coldkey_swap_announcement(
+        assert_ok!(SubtensorModule::announce_coldkey_swap(
             RuntimeOrigin::signed(who.clone()),
+            new_coldkey,
         ));
 
-        assert_eq!(ColdkeySwapAnnouncements::<Test>::iter().count(), 0);
+        let now = System::block_number();
         assert_eq!(
-            last_event(),
-            RuntimeEvent::SubtensorModule(Event::ColdkeySwapAnnouncementRemoved { who })
+            ColdkeySwapAnnouncements::<Test>::iter().collect::<Vec<_>>(),
+            vec![(who.clone(), (now, new_coldkey))]
         );
-    });
-}
 
-#[test]
-fn test_remove_coldkey_swap_announcement_fails_if_no_announcement_exists() {
-    new_test_ext(1).execute_with(|| {
-        let who = U256::from(1);
-        let new_coldkey = U256::from(2);
+        let unmet_delay = ColdkeySwapScheduleDuration::<Test>::get();
+        System::run_to_block::<AllPalletsWithSystem>(now + unmet_delay);
 
         assert_noop!(
-            SubtensorModule::remove_coldkey_swap_announcement(RuntimeOrigin::signed(who.clone())),
-            Error::<Test>::ColdkeySwapAnnouncementNotFound
+            SubtensorModule::announce_coldkey_swap(
+                RuntimeOrigin::signed(who.clone()),
+                new_coldkey_2,
+            ),
+            Error::<Test>::ColdkeySwapReannouncedTooEarly
         );
     });
 }
 
 #[test]
-fn test_remove_coldkey_swap_announcement_bad_origin_fails() {
+fn test_announce_coldkey_swap_with_bad_origin_fails() {
     new_test_ext(1).execute_with(|| {
+        let new_coldkey = U256::from(1);
+
         assert_noop!(
-            SubtensorModule::remove_coldkey_swap_announcement(RuntimeOrigin::none()),
+            SubtensorModule::announce_coldkey_swap(RuntimeOrigin::none(), new_coldkey),
             BadOrigin
         );
 
         assert_noop!(
-            SubtensorModule::remove_coldkey_swap_announcement(RuntimeOrigin::root()),
+            SubtensorModule::announce_coldkey_swap(RuntimeOrigin::root(), new_coldkey),
             BadOrigin
         );
     });