Merge remote-tracking branch 'origin/devnet-ready' into forbid-saturating-math-lint

Author: keithtensor

docs/rust-setup.md

@@ -24,7 +24,7 @@ Use a terminal shell to execute the following commands:
 ```bash
 sudo apt update
 # May prompt for location information
-sudo apt install -y git clang curl libssl-dev llvm libudev-dev
+sudo apt install -y git clang curl libssl-dev llvm libudev-dev make pkg-config protobuf-compiler
 ```
 
 ### Arch Linux

pallets/admin-utils/src/lib.rs

@@ -29,6 +29,7 @@ pub mod pallet {
     use frame_system::pallet_prelude::*;
     use pallet_evm_chain_id::{self, ChainId};
     use sp_runtime::BoundedVec;
+    use substrate_fixed::types::I96F32;
 
     /// The main data structure of the module.
     #[pallet::pallet]
@@ -1377,6 +1378,27 @@ pub mod pallet {
             }
             Ok(())
         }
+
+        ///
+        ///
+        /// # Arguments
+        /// * `origin` - The origin of the call, which must be the root account.
+        /// * `alpha` - The new moving alpha value for the SubnetMovingAlpha.
+        ///
+        /// # Errors
+        /// * `BadOrigin` - If the caller is not the root account.
+        ///
+        /// # Weight
+        /// Weight is handled by the `#[pallet::weight]` attribute.
+        #[pallet::call_index(63)]
+        #[pallet::weight((0, DispatchClass::Operational, Pays::No))]
+        pub fn sudo_set_subnet_moving_alpha(origin: OriginFor<T>, alpha: I96F32) -> DispatchResult {
+            ensure_root(origin)?;
+            pallet_subtensor::SubnetMovingAlpha::<T>::set(alpha);
+
+            log::debug!("SubnetMovingAlphaSet( alpha: {:?} )", alpha);
+            Ok(())
+        }
     }
 }
 

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

@@ -10,6 +10,7 @@ use pallet_subtensor::Error as SubtensorError;
 use pallet_subtensor::Event;
 use sp_consensus_grandpa::AuthorityId as GrandpaId;
 use sp_core::{Pair, U256, ed25519};
+use substrate_fixed::types::I96F32;
 
 use crate::Error;
 use crate::pallet::PrecompileEnable;
@@ -1449,3 +1450,19 @@ fn test_sudo_toggle_evm_precompile() {
         assert!(final_enabled);
     });
 }
+
+#[test]
+fn test_sudo_root_sets_subnet_moving_alpha() {
+    new_test_ext().execute_with(|| {
+        let alpha: I96F32 = I96F32::saturating_from_num(0.5);
+        let initial = pallet_subtensor::SubnetMovingAlpha::<Test>::get();
+        assert!(initial != alpha);
+
+        assert_ok!(AdminUtils::sudo_set_subnet_moving_alpha(
+            <<Test as Config>::RuntimeOrigin>::root(),
+            alpha
+        ));
+
+        assert_eq!(pallet_subtensor::SubnetMovingAlpha::<Test>::get(), alpha);
+    });
+}

pallets/subtensor/src/epoch/run_epoch.rs

@@ -390,7 +390,7 @@ impl<T: Config> Pallet<T> {
             .iter()
             .map(|updated| updated.saturating_add(activity_cutoff) < current_block)
             .collect();
-        log::trace!("Inactive: {:?}", inactive.clone());
+        log::debug!("Inactive: {:?}", inactive.clone());
 
         // Logical negation of inactive.
         let active: Vec<bool> = inactive.iter().map(|&b| !b).collect();
@@ -406,14 +406,14 @@ impl<T: Config> Pallet<T> {
         let hotkeys: Vec<(u16, T::AccountId)> =
             <Keys<T> as IterableStorageDoubleMap<u16, u16, T::AccountId>>::iter_prefix(netuid)
                 .collect();
-        log::trace!("hotkeys: {:?}", &hotkeys);
+        log::debug!("hotkeys: {:?}", &hotkeys);
 
         // Access network stake as normalized vector.
         let (mut total_stake, _alpha_stake, _tao_stake): (Vec<I64F64>, Vec<I64F64>, Vec<I64F64>) =
             Self::get_stake_weights_for_network(netuid);
         inplace_normalize_64(&mut total_stake);
         let stake: Vec<I32F32> = vec_fixed64_to_fixed32(total_stake);
-        log::trace!("Normalised Stake: {:?}", &stake);
+        log::debug!("Normalised Stake: {:?}", &stake);
 
         // =======================
         // == Validator permits ==
@@ -448,7 +448,7 @@ impl<T: Config> Pallet<T> {
 
         // Normalize active stake.
         inplace_normalize(&mut active_stake);
-        log::trace!("Active Stake:\n{:?}\n", &active_stake);
+        log::debug!("Active Stake:\n{:?}\n", &active_stake);
 
         // =============
         // == Weights ==

pallets/subtensor/src/lib.rs

@@ -998,18 +998,6 @@ pub mod pallet {
     #[pallet::storage] // --- MAP ( cold ) --> Vec<hot> | Returns the vector of hotkeys controlled by this coldkey.
     pub type OwnedHotkeys<T: Config> =
         StorageMap<_, Blake2_128Concat, T::AccountId, Vec<T::AccountId>, ValueQuery>;
-    #[pallet::storage]
-    /// (DEPRECATED) DMAP ( hot, cold ) --> stake | Returns the stake under a coldkey prefixed by hotkey.
-    pub type Stake<T: Config> = StorageDoubleMap<
-        _,
-        Blake2_128Concat,
-        T::AccountId,
-        Identity,
-        T::AccountId,
-        u64,
-        ValueQuery,
-        DefaultZeroU64<T>,
-    >;
 
     #[pallet::storage] // --- DMAP ( cold ) --> () | Maps coldkey to if a coldkey swap is scheduled.
     pub type ColdkeySwapScheduled<T: Config> =

pallets/subtensor/src/macros/dispatches.rs

@@ -1882,5 +1882,30 @@ mod dispatches {
                 allow_partial,
             )
         }
+
+        /// Attempts to associate a hotkey with a coldkey.
+        ///
+        /// # Arguments
+        /// * `origin` - The origin of the transaction, which must be signed by the coldkey that owns the `hotkey`.
+        /// * `hotkey` - The hotkey to associate with the coldkey.
+        ///
+        /// # Note
+        /// Will charge based on the weight even if the hotkey is already associated with a coldkey.
+        #[pallet::call_index(91)]
+        #[pallet::weight((
+            Weight::from_parts(3_000_000, 0).saturating_add(T::DbWeight::get().reads_writes(3, 3)),
+            DispatchClass::Operational,
+            Pays::Yes
+        ))]
+        pub fn try_associate_hotkey(
+            origin: T::RuntimeOrigin,
+            hotkey: T::AccountId,
+        ) -> DispatchResult {
+            let coldkey = ensure_signed(origin)?;
+
+            let _ = Self::do_try_associate_hotkey(&coldkey, &hotkey);
+
+            Ok(())
+        }
     }
 }

pallets/subtensor/src/macros/hooks.rs

@@ -63,12 +63,6 @@ mod hooks {
                 // Populate OwnedHotkeys map for coldkey swap. Doesn't update storage vesion.
                 // Storage version v6 -> v7
                 .saturating_add(migrations::migrate_populate_owned_hotkeys::migrate_populate_owned::<T>())
-                // Populate StakingHotkeys map for coldkey swap. Doesn't update storage vesion.
-                // Storage version v7 -> v8
-                .saturating_add(migrations::migrate_populate_staking_hotkeys::migrate_populate_staking_hotkeys::<T>())
-                // Fix total coldkey stake.
-                // Storage version v8 -> v9
-                .saturating_add(migrations::migrate_fix_total_coldkey_stake::migrate_fix_total_coldkey_stake::<T>())
                 // Migrate Delegate Ids on chain
                 .saturating_add(migrations::migrate_chain_identity::migrate_set_hotkey_identities::<T>())
                 // Migrate Commit-Reval 2.0
@@ -83,7 +77,9 @@ mod hooks {
 				// Set the min burn across all subnets to a new minimum
 				.saturating_add(migrations::migrate_set_min_burn::migrate_set_min_burn::<T>())
 				// Set the min difficulty across all subnets to a new minimum
-				.saturating_add(migrations::migrate_set_min_difficulty::migrate_set_min_difficulty::<T>());
+				.saturating_add(migrations::migrate_set_min_difficulty::migrate_set_min_difficulty::<T>())
+                // Remove Stake map entries
+				.saturating_add(migrations::migrate_remove_stake_map::migrate_remove_stake_map::<T>());
             weight
         }