feat: move back to on_initialise, lints

Author: Samuel Dare

pallets/subtensor/src/delegate_info.rs

@@ -142,7 +142,7 @@ impl<T: Config> Pallet<T> {
 
             for (delegator, stake) in Stake::<T>::iter_prefix(&hotkey) {
                 if delegator != owner {
-                    total_delegated += stake;
+                    total_delegated = total_delegated.saturating_add(stake);
                 }
             }
         }
@@ -162,7 +162,7 @@ impl<T: Config> Pallet<T> {
         // Iterate through all delegators for this hotkey
         for (delegator, stake) in Stake::<T>::iter_prefix(hotkey) {
             if delegator != Self::get_coldkey_for_hotkey(hotkey) {
-                total_delegated += stake;
+                total_delegated = total_delegated.saturating_add(stake);
             }
         }
 

pallets/subtensor/src/lib.rs

@@ -1343,40 +1343,48 @@ pub mod pallet {
 
     #[pallet::hooks]
     impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
-        fn on_idle(_n: BlockNumberFor<T>, remaining_weight: Weight) -> Weight {
-            // Unstake and transfer pending coldkeys up to the remaining weight
-            match Self::swap_coldkeys_this_block(&remaining_weight) {
+        fn on_idle(_n: BlockNumberFor<T>, _remaining_weight: Weight) -> Weight {
+            Weight::zero()
+        }
+
+        fn on_initialize(_block_number: BlockNumberFor<T>) -> Weight {
+            let mut total_weight = Weight::zero();
+
+            // Create a Weight::MAX value to pass to swap_coldkeys_this_block
+            let max_weight = Weight::MAX;
+
+            // Perform coldkey swapping
+            let swap_weight = match Self::swap_coldkeys_this_block(&max_weight) {
                 Ok(weight_used) => weight_used,
                 Err(e) => {
                     log::error!("Error while swapping coldkeys: {:?}", e);
-                    Weight::default()
+                    Weight::zero()
                 }
-            }
-        }
+            };
+            total_weight = total_weight.saturating_add(swap_weight);
 
-        // ---- Called on the initialization of this pallet. (the order of on_finalize calls is determined in the runtime)
-        //
-        // # Args:
-        // 	* 'n': (BlockNumberFor<T>):
-        // 		- The number of the block we are initializing.
-        fn on_initialize(_block_number: BlockNumberFor<T>) -> Weight {
+            // Perform block step
             let block_step_result = Self::block_step();
             match block_step_result {
                 Ok(_) => {
-                    // --- If the block step was successful, return the weight.
                     log::debug!("Successfully ran block step.");
-                    Weight::from_parts(110_634_229_000_u64, 0)
-                        .saturating_add(T::DbWeight::get().reads(8304_u64))
-                        .saturating_add(T::DbWeight::get().writes(110_u64))
+                    total_weight = total_weight.saturating_add(
+                        Weight::from_parts(110_634_229_000_u64, 0)
+                            .saturating_add(T::DbWeight::get().reads(8304_u64))
+                            .saturating_add(T::DbWeight::get().writes(110_u64)),
+                    );
                 }
                 Err(e) => {
-                    // --- If the block step was unsuccessful, return the weight anyway.
                     log::error!("Error while stepping block: {:?}", e);
-                    Weight::from_parts(110_634_229_000_u64, 0)
-                        .saturating_add(T::DbWeight::get().reads(8304_u64))
-                        .saturating_add(T::DbWeight::get().writes(110_u64))
+                    total_weight = total_weight.saturating_add(
+                        Weight::from_parts(110_634_229_000_u64, 0)
+                            .saturating_add(T::DbWeight::get().reads(8304_u64))
+                            .saturating_add(T::DbWeight::get().writes(110_u64)),
+                    );
                 }
             }
+
+            total_weight
         }
 
         fn on_runtime_upgrade() -> frame_support::weights::Weight {

pallets/subtensor/src/schedule_coldkey_swap_info.rs

@@ -1,6 +1,7 @@
 use super::*;
 use codec::Compact;
 use frame_support::pallet_prelude::{Decode, Encode};
+
 use sp_core::hexdisplay::AsBytesRef;
 
 #[derive(Decode, Encode, PartialEq, Eq, Clone, Debug)]
@@ -37,7 +38,10 @@ impl<T: Config> Pallet<T> {
 
         Some(ScheduledColdkeySwapInfo {
             old_coldkey: coldkey,
-            new_coldkey: destinations[0].clone(),
+            new_coldkey: destinations.first().cloned().unwrap_or_else(|| {
+                T::AccountId::decode(&mut sp_runtime::traits::TrailingZeroInput::zeroes())
+                    .expect("Infinite length input; no invalid inputs for type; qed")
+            }),
             arbitration_block: arbitration_block.into(),
         })
     }

pallets/subtensor/src/staking.rs

@@ -868,75 +868,4 @@ impl<T: Config> Pallet<T> {
             Self::add_balance_to_coldkey_account(&delegate_coldkey_i, stake_i);
         }
     }
-
-    // pub fn x( coldkey_a: &T::AccountId, coldkey_b: &T::AccountId ) -> Weight {
-    //     let mut weight = frame_support::weights::Weight::from_parts(0, 0);
-
-    //     // Get the hotkeys associated with coldkey_a.
-    //     let coldkey_a_hotkeys: Vec<T::AccountId> = StakingHotkeys::<T>::get( &coldkey_a );
-    //     weight = weight.saturating_add(T::DbWeight::get().reads_writes(1, 0));
-
-    //     // Iterate over all the hotkeys associated with this coldkey
-    //     for hotkey_i in coldkey_a_hotkeys.iter() {
-
-    //         // Get the current stake from coldkey_a to hotkey_i.
-    //         let all_current_stake_i: u64 = Self::get_stake_for_coldkey_and_hotkey( &coldkey_a, &hotkey_i );
-    //         weight = weight.saturating_add(T::DbWeight::get().reads_writes(1, 0));
-
-    //         // We remove the balance from the hotkey acount equal to all of it.
-    //         Self::decrease_stake_on_coldkey_hotkey_account( &coldkey_a, &hotkey_i, all_current_stake_i );
-    //         weight = weight.saturating_add(T::DbWeight::get().reads_writes(0, 4));
-
-    //         // We add the balance to the coldkey. If the above fails we will not credit this coldkey.
-    //         Self::add_balance_to_coldkey_account( &coldkey_a, all_current_stake_i );
-    //         weight = weight.saturating_add(T::DbWeight::get().reads_writes(2, 2));
-    //     }
-    // Unstake all delegate stake make by this coldkey to non-owned hotkeys
-    // let staking_hotkeys = StakingHotkeys::<T>::get(&current_coldkey);
-
-    // // iterate over all staking hotkeys.
-    // for hotkey in staking_hotkeys {
-    //     // Get the current stake
-    //     let current_stake: u64 =
-    //         Self::get_stake_for_coldkey_and_hotkey(&current_coldkey, &hotkey);
-
-    //     // Unstake all balance if there's any stake
-    //     if current_stake > 0 {
-    //         Self::do_remove_stake(
-    //             RawOrigin::Signed(current_coldkey.clone()).into(),
-    //             hotkey.clone(),
-    //             current_stake,
-    //         )?;
-    //     }
-    // }
-
-    // let total_balance = Self::get_coldkey_balance(&current_coldkey);
-    // log::info!("Total Bank Balance: {:?}", total_balance);
-
-    //     // Get the total balance here.
-    //     let total_balance = Self::get_coldkey_balance( &coldkey_a );
-    //     weight = weight.saturating_add(T::DbWeight::get().reads_writes(1, 0));
-
-    //     if !total_balance.is_zero() {
-    //         // Attempt to transfer the entire total balance to coldkey_b.
-    //         let _ = T::Currency::transfer(
-    //             coldkey_a,
-    //             coldkey_b,
-    //             total_balance,
-    //             Preservation::Expendable,
-    //         );
-    //         weight = weight.saturating_add(T::DbWeight::get().reads_writes(1, 1));
-    //     }
-
-    //     // Emit event
-    //     Self::deposit_event(
-    //         Event::AllBalanceUnstakedAndTransferredToNewColdkey {
-    //             current_coldkey: coldkey_a.clone(),
-    //             new_coldkey: coldkey_b.clone(),
-    //             total_balance
-    //         }
-    //     );
-
-    //     weight
-    // }
 }

pallets/subtensor/src/swap.rs

@@ -203,9 +203,11 @@ impl<T: Config> Pallet<T> {
         let all_staked_keys: Vec<T::AccountId> = StakingHotkeys::<T>::get(coldkey);
         let mut total_staking_balance: u64 = 0;
         for hotkey in all_staked_keys {
-            total_staking_balance += Self::get_stake_for_coldkey_and_hotkey(coldkey, &hotkey);
+            total_staking_balance = total_staking_balance
+                .saturating_add(Self::get_stake_for_coldkey_and_hotkey(coldkey, &hotkey));
         }
-        total_staking_balance += Self::get_coldkey_balance(coldkey);
+        total_staking_balance =
+            total_staking_balance.saturating_add(Self::get_coldkey_balance(coldkey));
         total_staking_balance >= MIN_BALANCE_TO_PERFORM_COLDKEY_SWAP
     }
 
@@ -414,15 +416,13 @@ impl<T: Config> Pallet<T> {
         // Swap the coldkey.
         let total_balance: u64 = Self::get_coldkey_balance(old_coldkey);
         if total_balance > 0 {
-            // Attempt to transfer the entire total balance to coldkeyB.
-            if let Err(e) = T::Currency::transfer(
+            // Attempt to transfer the entire total balance to new_coldkey.
+            T::Currency::transfer(
                 old_coldkey,
                 new_coldkey,
                 total_balance,
                 Preservation::Expendable,
-            ) {
-                return Err(e.into());
-            }
+            )?;
         }
 
         Ok(weight)
@@ -832,7 +832,7 @@ impl<T: Config> Pallet<T> {
                 Owner::<T>::insert(hotkey, new_coldkey);
 
                 // Update the transaction weight
-                *weight += T::DbWeight::get().reads_writes(2, 2);
+                weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 2));
             }
         }
 
@@ -858,18 +858,18 @@ impl<T: Config> Pallet<T> {
             );
 
             // Update the transaction weight
-            *weight += T::DbWeight::get().reads_writes(2, 2);
+            weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 2));
         }
 
         // Update the list of owned hotkeys for both old and new coldkeys
         OwnedHotkeys::<T>::remove(old_coldkey);
         OwnedHotkeys::<T>::insert(new_coldkey, old_owned_hotkeys);
-        *weight += T::DbWeight::get().reads_writes(1, 2);
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
 
         // Update the staking hotkeys for both old and new coldkeys
         let staking_hotkeys: Vec<T::AccountId> = StakingHotkeys::<T>::take(old_coldkey);
         StakingHotkeys::<T>::insert(new_coldkey, staking_hotkeys);
-        *weight += T::DbWeight::get().reads_writes(1, 1);
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
 
         // Log the total stake of old and new coldkeys after the swap
         log::info!(

pallets/subtensor/tests/staking.rs

@@ -1,4 +1,5 @@
 #![allow(clippy::unwrap_used)]
+#![allow(clippy::arithmetic_side_effects)]
 
 use frame_support::pallet_prelude::{
     InvalidTransaction, TransactionValidity, TransactionValidityError,

runtime/src/lib.rs

@@ -139,7 +139,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
     //   `spec_version`, and `authoring_version` are the same between Wasm and native.
     // This value is set to 100 to notify Polkadot-JS App (https://polkadot.js.org/apps) to use
     //   the compatible custom types.
-    spec_version: 189,
+    spec_version: 187,
     impl_version: 1,
     apis: RUNTIME_API_VERSIONS,
     transaction_version: 1,