feat: remove schedule coldkey swap

Author: Samuel Dare

pallets/subtensor/src/benchmarks.rs

@@ -429,30 +429,4 @@ reveal_weights {
 
   }: reveal_weights(RawOrigin::Signed(hotkey.clone()), netuid, uids, weight_values, salt, version_key)
 
-  schedule_coldkey_swap {
-    let seed: u32 = 1;
-    let old_coldkey: T::AccountId = account("OldColdkey", 0, seed);
-    let new_coldkey: T::AccountId = account("NewColdkey", 0, seed + 1);
-    let hotkey: T::AccountId = account("Hotkey", 0, seed);
-
-    let netuid = 1u16;
-    let tempo = 1u16;
-    let block_number: u64 = Subtensor::<T>::get_current_block_as_u64();
-    let nonce = 0;
-
-    // Initialize the network
-    Subtensor::<T>::init_new_network(netuid, tempo);
-    Subtensor::<T>::set_network_registration_allowed(netuid, true);
-
-    // Add balance to the old coldkey account
-    let amount_to_be_staked: u64 = 1000000u32.into();
-    Subtensor::<T>::add_balance_to_coldkey_account(&old_coldkey.clone(), amount_to_be_staked+1000000000);
-       // Burned register the hotkey with the old coldkey
-       assert_ok!(Subtensor::<T>::burned_register(
-        RawOrigin::Signed(old_coldkey.clone()).into(),
-        netuid,
-        hotkey.clone()
-    ));
-
-  }: schedule_coldkey_swap(RawOrigin::Signed(old_coldkey.clone()), new_coldkey.clone(), vec![], block_number, nonce)
 }

pallets/subtensor/src/lib.rs

@@ -2089,7 +2089,6 @@ pub mod pallet {
         ) -> DispatchResultWithPostInfo {
             Self::do_swap_coldkey(origin, &new_coldkey)
         }
-
         /// Unstakes all tokens associated with a hotkey and transfers them to a new coldkey.
         ///
         /// # Arguments
@@ -2105,6 +2104,7 @@ pub mod pallet {
         /// # Weight
         ///
         /// Weight is calculated based on the number of database reads and writes.
+        #[cfg(test)]
         #[pallet::call_index(72)]
         #[pallet::weight((Weight::from_parts(21_000_000, 0)
 		.saturating_add(T::DbWeight::get().reads(3))

pallets/subtensor/src/swap.rs

@@ -31,10 +31,6 @@ impl<T: Config> Pallet<T> {
         new_hotkey: &T::AccountId,
     ) -> DispatchResultWithPostInfo {
         let coldkey = ensure_signed(origin)?;
-        ensure!(
-            !Self::coldkey_in_arbitration(&coldkey),
-            Error::<T>::ColdkeyIsInArbitration
-        );
 
         let mut weight = T::DbWeight::get().reads(2);
 
@@ -60,6 +56,16 @@ impl<T: Config> Pallet<T> {
             T::DbWeight::get().reads((TotalNetworks::<T>::get().saturating_add(1u16)) as u64),
         );
 
+        let swap_cost = Self::get_hotkey_swap_cost();
+        log::debug!("Swap cost: {:?}", swap_cost);
+
+        ensure!(
+            Self::can_remove_balance_from_coldkey_account(&coldkey, swap_cost),
+            Error::<T>::NotEnoughBalanceToPaySwapHotKey
+        );
+        let actual_burn_amount = Self::remove_balance_from_coldkey_account(&coldkey, swap_cost)?;
+        Self::burn_tokens(actual_burn_amount);
+
         Self::swap_owner(old_hotkey, new_hotkey, &coldkey, &mut weight);
         Self::swap_total_hotkey_stake(old_hotkey, new_hotkey, &mut weight);
         Self::swap_delegates(old_hotkey, new_hotkey, &mut weight);
@@ -189,15 +195,15 @@ impl<T: Config> Pallet<T> {
     ///
     /// This function calculates the remaining arbitration period by subtracting the current block number
     /// from the arbitration block number of the coldkey.
-    // pub fn get_remaining_arbitration_period(coldkey: &T::AccountId) -> u64 {
-    //     let current_block: u64 = Self::get_current_block_as_u64();
-    //     let arbitration_block: u64 = ColdkeyArbitrationBlock::<T>::get(coldkey);
-    //     if arbitration_block > current_block {
-    //         arbitration_block.saturating_sub(current_block)
-    //     } else {
-    //         0
-    //     }
-    // }
+    pub fn get_remaining_arbitration_period(coldkey: &T::AccountId) -> u64 {
+        let current_block: u64 = Self::get_current_block_as_u64();
+        let arbitration_block: u64 = ColdkeyArbitrationBlock::<T>::get(coldkey);
+        if arbitration_block > current_block {
+            arbitration_block.saturating_sub(current_block)
+        } else {
+            0
+        }
+    }
 
     pub fn meets_min_allowed_coldkey_balance(coldkey: &T::AccountId) -> bool {
         let all_staked_keys: Vec<T::AccountId> = StakingHotkeys::<T>::get(coldkey);

runtime/src/lib.rs

@@ -312,8 +312,7 @@ impl Contains<RuntimeCall> for SafeModeWhitelistedCalls {
                 | RuntimeCall::SafeMode(_)
                 | RuntimeCall::Timestamp(_)
                 | RuntimeCall::SubtensorModule(
-                    pallet_subtensor::Call::schedule_coldkey_swap { .. }
-                        | pallet_subtensor::Call::set_weights { .. }
+                    pallet_subtensor::Call::set_weights { .. }
                         | pallet_subtensor::Call::set_root_weights { .. }
                         | pallet_subtensor::Call::serve_axon { .. }
                 )