Rework coldkey swap

chain-extensions/src/mock.rs

@@ -325,9 +325,8 @@ parameter_types! {
     pub const InitialAlphaLow: u16 = 45875; // Represents 0.7 as per the production default
     pub const InitialLiquidAlphaOn: bool = false; // Default value for LiquidAlphaOn
     pub const InitialYuma3On: bool = false; // Default value for Yuma3On
-    // pub const InitialNetworkMaxStake: u64 = u64::MAX; // (DEPRECATED)
-    pub const InitialColdkeySwapScheduleDuration: u64 =  5 * 24 * 60 * 60 / 12; // Default as 5 days
-    pub const InitialColdkeySwapRescheduleDuration: u64 = 24 * 60 * 60 / 12; // Default as 1 day
+    pub const InitialColdkeySwapAnnouncementDelay: u64 =  5 * 24 * 60 * 60 / 12; // Default as 5 days
+    pub const InitialColdkeySwapReannouncementDelay: u64 =  24 * 60 * 60 / 12; // Default as 1 day
     pub const InitialDissolveNetworkScheduleDuration: u64 =  5 * 24 * 60 * 60 / 12; // Default as 5 days
     pub const InitialTaoWeight: u64 = 0; // 100% global weight.
     pub const InitialEmaPriceHalvingPeriod: u64 = 201_600_u64; // 4 weeks
@@ -397,8 +396,8 @@ impl pallet_subtensor::Config for Test {
     type LiquidAlphaOn = InitialLiquidAlphaOn;
     type Yuma3On = InitialYuma3On;
     type Preimages = Preimage;
-    type InitialColdkeySwapScheduleDuration = InitialColdkeySwapScheduleDuration;
-    type InitialColdkeySwapRescheduleDuration = InitialColdkeySwapRescheduleDuration;
+    type InitialColdkeySwapAnnouncementDelay = InitialColdkeySwapAnnouncementDelay;
+    type InitialColdkeySwapReannouncementDelay = InitialColdkeySwapReannouncementDelay;
     type InitialDissolveNetworkScheduleDuration = InitialDissolveNetworkScheduleDuration;
     type InitialTaoWeight = InitialTaoWeight;
     type InitialEmaPriceHalvingPeriod = InitialEmaPriceHalvingPeriod;

pallets/admin-utils/src/benchmarking.rs

@@ -480,7 +480,7 @@ mod benchmarks {
     }
 
     #[benchmark]
-    fn sudo_set_coldkey_swap_schedule_duration() {
+    fn sudo_set_coldkey_swap_announcement_delay() {
         #[extrinsic_call]
         _(RawOrigin::Root, 100u32.into());
     }

pallets/admin-utils/src/lib.rs

@@ -1354,44 +1354,6 @@ pub mod pallet {
             res
         }
 
-        /// Sets the duration of the coldkey swap schedule.
-        ///
-        /// This extrinsic allows the root account to set the duration for the coldkey swap schedule.
-        /// The coldkey swap schedule determines how long it takes for a coldkey swap operation to complete.
-        ///
-        /// # Arguments
-        /// * `origin` - The origin of the call, which must be the root account.
-        /// * `duration` - The new duration for the coldkey swap schedule, in number of blocks.
-        ///
-        /// # Errors
-        /// * `BadOrigin` - If the caller is not the root account.
-        ///
-        /// # Weight
-        /// Weight is handled by the `#[pallet::weight]` attribute.
-        #[pallet::call_index(54)]
-        #[pallet::weight((
-            Weight::from_parts(5_000_000, 0)
-                .saturating_add(T::DbWeight::get().reads(0_u64))
-			    .saturating_add(T::DbWeight::get().writes(1_u64)),
-            DispatchClass::Operational,
-            Pays::Yes
-        ))]
-        pub fn sudo_set_coldkey_swap_schedule_duration(
-            origin: OriginFor<T>,
-            duration: BlockNumberFor<T>,
-        ) -> DispatchResult {
-            // Ensure the call is made by the root account
-            ensure_root(origin)?;
-
-            // Set the new duration of schedule coldkey swap
-            pallet_subtensor::Pallet::<T>::set_coldkey_swap_schedule_duration(duration);
-
-            // Log the change
-            log::trace!("ColdkeySwapScheduleDurationSet( duration: {duration:?} )");
-
-            Ok(())
-        }
-
         /// Sets the duration of the dissolve network schedule.
         ///
         /// This extrinsic allows the root account to set the duration for the dissolve network schedule.
@@ -1618,7 +1580,7 @@ pub mod pallet {
         /// Weight is handled by the `#[pallet::weight]` attribute.
         #[pallet::call_index(62)]
         #[pallet::weight((
-            Weight::from_parts(5_744_000, 3507)
+            Weight::from_parts(5_698_000, 0)
 			    .saturating_add(T::DbWeight::get().reads(1_u64))
                 .saturating_add(T::DbWeight::get().writes(0_u64)),
             DispatchClass::Operational,
@@ -2240,6 +2202,44 @@ pub mod pallet {
             pallet_subtensor::Pallet::<T>::set_min_non_immune_uids(netuid, min);
             Ok(())
         }
+
+        /// Sets the announcement delay for coldkey swap.
+        #[pallet::call_index(85)]
+        #[pallet::weight((
+            Weight::from_parts(5_000_000, 0)
+                .saturating_add(T::DbWeight::get().reads(0_u64))
+			    .saturating_add(T::DbWeight::get().writes(1_u64)),
+            DispatchClass::Operational,
+            Pays::Yes
+        ))]
+        pub fn sudo_set_coldkey_swap_announcement_delay(
+            origin: OriginFor<T>,
+            duration: BlockNumberFor<T>,
+        ) -> DispatchResult {
+            ensure_root(origin)?;
+            pallet_subtensor::Pallet::<T>::set_coldkey_swap_announcement_delay(duration);
+            log::trace!("ColdkeySwapAnnouncementDelaySet( duration: {duration:?} )");
+            Ok(())
+        }
+
+        /// Sets the reannouncement delay for coldkey swap.
+        #[pallet::call_index(86)]
+        #[pallet::weight((
+            Weight::from_parts(5_000_000, 0)
+                .saturating_add(T::DbWeight::get().reads(0_u64))
+			    .saturating_add(T::DbWeight::get().writes(1_u64)),
+            DispatchClass::Operational,
+            Pays::Yes
+        ))]
+        pub fn sudo_set_coldkey_swap_reannouncement_delay(
+            origin: OriginFor<T>,
+            duration: BlockNumberFor<T>,
+        ) -> DispatchResult {
+            ensure_root(origin)?;
+            pallet_subtensor::Pallet::<T>::set_coldkey_swap_reannouncement_delay(duration);
+            log::trace!("ColdkeySwapReannouncementDelaySet( duration: {duration:?} )");
+            Ok(())
+        }
     }
 }
 

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

@@ -131,17 +131,14 @@ parameter_types! {
     pub const InitialNetworkMinLockCost: u64 = 100_000_000_000;
     pub const InitialSubnetOwnerCut: u16 = 0; // 0%. 100% of rewards go to validators + miners.
     pub const InitialNetworkLockReductionInterval: u64 = 2; // 2 blocks.
-    // pub const InitialSubnetLimit: u16 = 10; // (DEPRECATED)
     pub const InitialNetworkRateLimit: u64 = 0;
     pub const InitialKeySwapCost: u64 = 1_000_000_000;
     pub const InitialAlphaHigh: u16 = 58982; // Represents 0.9 as per the production default
     pub const InitialAlphaLow: u16 = 45875; // Represents 0.7 as per the production default
     pub const InitialLiquidAlphaOn: bool = false; // Default value for LiquidAlphaOn
     pub const InitialYuma3On: bool = false; // Default value for Yuma3On
-    // pub const InitialHotkeyEmissionTempo: u64 = 1; // (DEPRECATED)
-    // pub const InitialNetworkMaxStake: u64 = u64::MAX; // (DEPRECATED)
-    pub const InitialColdkeySwapScheduleDuration: u64 = 5 * 24 * 60 * 60 / 12; // 5 days
-    pub const InitialColdkeySwapRescheduleDuration: u64 = 24 * 60 * 60 / 12; // 1 day
+    pub const InitialColdkeySwapAnnouncementDelay: u64 = 5 * 24 * 60 * 60 / 12; // 5 days
+    pub const InitialColdkeySwapReannouncementDelay: u64 = 24 * 60 * 60 / 12; // 1 day
     pub const InitialDissolveNetworkScheduleDuration: u64 = 5 * 24 * 60 * 60 / 12; // 5 days
     pub const InitialTaoWeight: u64 = u64::MAX/10; // 10% global weight.
     pub const InitialEmaPriceHalvingPeriod: u64 = 201_600_u64; // 4 weeks
@@ -210,8 +207,8 @@ impl pallet_subtensor::Config for Test {
     type LiquidAlphaOn = InitialLiquidAlphaOn;
     type Yuma3On = InitialYuma3On;
     type Preimages = ();
-    type InitialColdkeySwapScheduleDuration = InitialColdkeySwapScheduleDuration;
-    type InitialColdkeySwapRescheduleDuration = InitialColdkeySwapRescheduleDuration;
+    type InitialColdkeySwapAnnouncementDelay = InitialColdkeySwapAnnouncementDelay;
+    type InitialColdkeySwapReannouncementDelay = InitialColdkeySwapReannouncementDelay;
     type InitialDissolveNetworkScheduleDuration = InitialDissolveNetworkScheduleDuration;
     type InitialTaoWeight = InitialTaoWeight;
     type InitialEmaPriceHalvingPeriod = InitialEmaPriceHalvingPeriod;

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

@@ -1382,39 +1382,74 @@ fn test_sudo_get_set_alpha() {
 }
 
 #[test]
-fn test_sudo_set_coldkey_swap_schedule_duration() {
+fn test_sudo_set_coldkey_swap_announcement_delay() {
     new_test_ext().execute_with(|| {
         // Arrange
         let root = RuntimeOrigin::root();
         let non_root = RuntimeOrigin::signed(U256::from(1));
-        let new_duration = 100u32.into();
+        let new_delay = 100u32.into();
 
         // Act & Assert: Non-root account should fail
         assert_noop!(
-            AdminUtils::sudo_set_coldkey_swap_schedule_duration(non_root, new_duration),
+            AdminUtils::sudo_set_coldkey_swap_announcement_delay(non_root, new_delay),
             DispatchError::BadOrigin
         );
 
         // Act: Root account should succeed
-        assert_ok!(AdminUtils::sudo_set_coldkey_swap_schedule_duration(
+        assert_ok!(AdminUtils::sudo_set_coldkey_swap_announcement_delay(
             root.clone(),
-            new_duration
+            new_delay
         ));
 
-        // Assert: Check if the duration was actually set
+        // Assert: Check if the delay was actually set
         assert_eq!(
-            pallet_subtensor::ColdkeySwapScheduleDuration::<Test>::get(),
-            new_duration
+            pallet_subtensor::ColdkeySwapAnnouncementDelay::<Test>::get(),
+            new_delay
         );
 
         // Act & Assert: Setting the same value again should succeed (idempotent operation)
-        assert_ok!(AdminUtils::sudo_set_coldkey_swap_schedule_duration(
-            root,
-            new_duration
+        assert_ok!(AdminUtils::sudo_set_coldkey_swap_announcement_delay(
+            root, new_delay
+        ));
+
+        // You might want to check for events here if your pallet emits them
+        System::assert_last_event(Event::ColdkeySwapAnnouncementDelaySet(new_delay).into());
+    });
+}
+
+#[test]
+fn test_sudo_set_coldkey_swap_reannouncement_delay() {
+    new_test_ext().execute_with(|| {
+        // Arrange
+        let root = RuntimeOrigin::root();
+        let non_root = RuntimeOrigin::signed(U256::from(1));
+        let new_delay = 100u32.into();
+
+        // Act & Assert: Non-root account should fail
+        assert_noop!(
+            AdminUtils::sudo_set_coldkey_swap_reannouncement_delay(non_root, new_delay),
+            DispatchError::BadOrigin
+        );
+
+        // Act: Root account should succeed
+        assert_ok!(AdminUtils::sudo_set_coldkey_swap_reannouncement_delay(
+            root.clone(),
+            new_delay
+        ));
+
+        // Assert: Check if the delay was actually set
+        assert_eq!(
+            pallet_subtensor::ColdkeySwapReannouncementDelay::<Test>::get(),
+            new_delay
+        );
+
+        // Act & Assert: Setting the same value again should succeed (idempotent operation)
+        assert_ok!(AdminUtils::sudo_set_coldkey_swap_reannouncement_delay(
+            root, new_delay
         ));
 
         // You might want to check for events here if your pallet emits them
-        System::assert_last_event(Event::ColdkeySwapScheduleDurationSet(new_duration).into());
+        System::assert_last_event(Event::ColdkeySwapReannouncementDelaySet(new_delay).into());
     });
 }
 

pallets/subtensor/src/benchmarks.rs

@@ -369,17 +369,6 @@ mod pallet_benchmarks {
         );
     }
 
-    #[benchmark]
-    fn schedule_swap_coldkey() {
-        let old_coldkey: T::AccountId = account("old_cold", 0, 1);
-        let new_coldkey: T::AccountId = account("new_cold", 1, 2);
-        let amount: u64 = 100_000_000_000_000;
-        Subtensor::<T>::add_balance_to_coldkey_account(&old_coldkey, amount);
-
-        #[extrinsic_call]
-        _(RawOrigin::Signed(old_coldkey.clone()), new_coldkey.clone());
-    }
-
     #[benchmark]
     fn sudo_set_tx_childkey_take_rate_limit() {
         let new_rate_limit: u64 = 100;
@@ -419,14 +408,62 @@ mod pallet_benchmarks {
     }
 
     #[benchmark]
-    fn swap_coldkey() {
+    fn announce_coldkey_swap() {
+        let coldkey: T::AccountId = account("old_coldkey", 0, 0);
+        let new_coldkey: T::AccountId = account("new_coldkey", 0, 0);
+        let new_coldkey_hash: T::Hash = <T as frame_system::Config>::Hashing::hash_of(&new_coldkey);
+
+        let swap_cost = Subtensor::<T>::get_key_swap_cost();
+        Subtensor::<T>::add_balance_to_coldkey_account(&coldkey, swap_cost.into());
+
+        #[extrinsic_call]
+        _(RawOrigin::Signed(coldkey), new_coldkey_hash);
+    }
+
+    #[benchmark]
+    fn swap_coldkey_announced() {
         let old_coldkey: T::AccountId = account("old_coldkey", 0, 0);
         let new_coldkey: T::AccountId = account("new_coldkey", 0, 0);
+        let new_coldkey_hash: T::Hash = <T as frame_system::Config>::Hashing::hash_of(&new_coldkey);
         let hotkey1: T::AccountId = account("hotkey1", 0, 0);
+
+        let now = frame_system::Pallet::<T>::block_number();
+        let delay = ColdkeySwapAnnouncementDelay::<T>::get();
+        ColdkeySwapAnnouncements::<T>::insert(&old_coldkey, (now, new_coldkey_hash));
+        frame_system::Pallet::<T>::set_block_number(now + delay + 1u32.into());
+
         let netuid = NetUid::from(1);
+        Subtensor::<T>::init_new_network(netuid, 1);
+        Subtensor::<T>::set_network_registration_allowed(netuid, true);
+        Subtensor::<T>::set_network_pow_registration_allowed(netuid, true);
+
+        let block_number = Subtensor::<T>::get_current_block_as_u64();
+        let (nonce, work) =
+            Subtensor::<T>::create_work_for_block_number(netuid, block_number, 3, &hotkey1);
+        let _ = Subtensor::<T>::register(
+            RawOrigin::Signed(old_coldkey.clone()).into(),
+            netuid,
+            block_number,
+            nonce,
+            work.clone(),
+            hotkey1.clone(),
+            old_coldkey.clone(),
+        );
+
+        #[extrinsic_call]
+        _(RawOrigin::Signed(old_coldkey), new_coldkey);
+    }
+
+    #[benchmark]
+    fn swap_coldkey() {
+        let old_coldkey: T::AccountId = account("old_coldkey", 0, 0);
+        let new_coldkey: T::AccountId = account("new_coldkey", 0, 0);
+        let hotkey1: T::AccountId = account("hotkey1", 0, 0);
+
         let swap_cost = Subtensor::<T>::get_key_swap_cost();
-        let free_balance_old = swap_cost + 12345.into();
+        Subtensor::<T>::add_balance_to_coldkey_account(&old_coldkey, swap_cost.into());
 
+        let netuid = NetUid::from(1);
         Subtensor::<T>::init_new_network(netuid, 1);
         Subtensor::<T>::set_network_registration_allowed(netuid, true);
         Subtensor::<T>::set_network_pow_registration_allowed(netuid, true);
@@ -444,19 +481,6 @@ mod pallet_benchmarks {
             old_coldkey.clone(),
         );
 
-        Subtensor::<T>::add_balance_to_coldkey_account(&old_coldkey, free_balance_old.into());
-        let name: Vec<u8> = b"The fourth Coolest Identity".to_vec();
-        let identity = ChainIdentityV2 {
-            name,
-            url: vec![],
-            github_repo: vec![],
-            image: vec![],
-            discord: vec![],
-            description: vec![],
-            additional: vec![],
-        };
-        IdentitiesV2::<T>::insert(&old_coldkey, identity);
-
         #[extrinsic_call]
         _(
             RawOrigin::Root,
@@ -466,6 +490,18 @@ mod pallet_benchmarks {
         );
     }
 
+    #[benchmark]
+    fn remove_coldkey_swap_announcement() {
+        let coldkey: T::AccountId = account("old_coldkey", 0, 0);
+        let coldkey_hash: T::Hash = <T as frame_system::Config>::Hashing::hash_of(&coldkey);
+        let now = frame_system::Pallet::<T>::block_number();
+
+        ColdkeySwapAnnouncements::<T>::insert(&coldkey, (now, coldkey_hash));
+
+        #[extrinsic_call]
+        _(RawOrigin::Root, coldkey);
+    }
+
     #[benchmark]
     fn batch_reveal_weights() {
         let tempo: u16 = 0;