Merge branch 'feat/rao-2025-01' of github.com:opentensor/subtensor into feat/rao-2025-01

Author: unconst

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

@@ -1,7 +1,6 @@
 use frame_support::sp_runtime::DispatchError;
 use frame_support::{
-    assert_err, 
-    assert_noop, assert_ok,
+    assert_err, assert_noop, assert_ok,
     dispatch::{DispatchClass, GetDispatchInfo, Pays},
     traits::Hooks,
 };
@@ -936,7 +935,6 @@ mod sudo_set_nominator_min_required_stake {
     #[test]
     fn clears_staker_nominations_below_min() {
         new_test_ext().execute_with(|| {
-
             System::set_block_number(1);
 
             // Create accounts.
@@ -1175,7 +1173,6 @@ fn test_set_alpha_values_dispatch_info_ok() {
 #[test]
 fn test_sudo_get_set_alpha() {
     new_test_ext().execute_with(|| {
-
         let netuid: u16 = 1;
         let alpha_low: u16 = 12_u16;
         let alpha_high: u16 = u16::MAX - 10;
@@ -1186,7 +1183,9 @@ fn test_sudo_get_set_alpha() {
 
         // Enable Liquid Alpha and setup
         SubtensorModule::set_liquid_alpha_enabled(netuid, true);
-        pallet_subtensor::migrations::migrate_create_root_network::migrate_create_root_network::<Test>();
+        pallet_subtensor::migrations::migrate_create_root_network::migrate_create_root_network::<
+            Test,
+        >();
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, 1_000_000_000_000_000);
         assert_ok!(SubtensorModule::root_register(signer.clone(), hotkey,));
 

pallets/subtensor/Cargo.toml

@@ -104,7 +104,8 @@ std = [
 	"ark-serialize/std",
 	"w3f-bls/std",
 	"rand_chacha/std",
-	"sha2/std"
+	"sha2/std",
+	"share-pool/std"
 ]
 runtime-benchmarks = [
 	"frame-benchmarking/runtime-benchmarks",

pallets/subtensor/rpc/src/lib.rs

@@ -218,22 +218,33 @@ where
     fn get_all_dynamic_info(&self, at: Option<<Block as BlockT>::Hash>) -> RpcResult<Vec<u8>> {
         let api = self.client.runtime_api();
         let at = at.unwrap_or_else(|| self.client.info().best_hash);
-        api.get_all_dynamic_info(at)
-            .map_err(|e| Error::RuntimeError(format!("Unable to get dynamic subnets info: {:?}", e)).into())
+        api.get_all_dynamic_info(at).map_err(|e| {
+            Error::RuntimeError(format!("Unable to get dynamic subnets info: {:?}", e)).into()
+        })
     }
 
-    fn get_dynamic_info(&self, netuid: u16, at: Option<<Block as BlockT>::Hash>) -> RpcResult<Vec<u8>> {
+    fn get_dynamic_info(
+        &self,
+        netuid: u16,
+        at: Option<<Block as BlockT>::Hash>,
+    ) -> RpcResult<Vec<u8>> {
         let api = self.client.runtime_api();
         let at = at.unwrap_or_else(|| self.client.info().best_hash);
-        api.get_dynamic_info(at, netuid)
-            .map_err(|e| Error::RuntimeError(format!("Unable to get dynamic subnets info: {:?}", e)).into())
+        api.get_dynamic_info(at, netuid).map_err(|e| {
+            Error::RuntimeError(format!("Unable to get dynamic subnets info: {:?}", e)).into()
+        })
     }
 
-    fn get_subnet_state(&self, netuid: u16, at: Option<<Block as BlockT>::Hash>) -> RpcResult<Vec<u8>> {
+    fn get_subnet_state(
+        &self,
+        netuid: u16,
+        at: Option<<Block as BlockT>::Hash>,
+    ) -> RpcResult<Vec<u8>> {
         let api = self.client.runtime_api();
         let at = at.unwrap_or_else(|| self.client.info().best_hash);
-        api.get_subnet_state(at, netuid)
-            .map_err(|e| Error::RuntimeError(format!("Unable to get subnet state info: {:?}", e)).into())
+        api.get_subnet_state(at, netuid).map_err(|e| {
+            Error::RuntimeError(format!("Unable to get subnet state info: {:?}", e)).into()
+        })
     }
 
     fn get_subnets_info(&self, at: Option<<Block as BlockT>::Hash>) -> RpcResult<Vec<u8>> {

pallets/subtensor/src/coinbase/block_emission.rs

@@ -1,17 +1,13 @@
 use super::*;
 use frame_support::traits::Get;
-use substrate_fixed::{
-    transcendental::log2,
-    types::I96F32,
-};
+use substrate_fixed::{transcendental::log2, types::I96F32};
 
 impl<T: Config> Pallet<T> {
-
     /// Calculates the dynamic TAO emission for a given subnet.
     ///
     /// This function determines the three terms tao_in, alpha_in, alpha_out
-    /// which are consequetively, 1) the amount of tao injected into the pool
-    /// 2) the amount of alpha injected into the pool and 3) the amount of alpha
+    /// which are consecutively, 1) the amount of tao injected into the pool
+    /// 2) the amount of alpha injected into the pool, and 3) the amount of alpha
     /// left to be distributed towards miners/validators/owners per block.
     ///
     /// # Arguments
@@ -21,14 +17,18 @@ impl<T: Config> Pallet<T> {
     ///
     /// # Returns
     /// * `(u64, u64, u64)` - A tuple containing:
-    ///   - `tao_in_emission`: The adjusted TAO emission always lower or equalt to tao_emission
+    ///   - `tao_in_emission`: The adjusted TAO emission always lower or equal to tao_emission
     ///   - `alpha_in_emission`: The adjusted alpha emission amount to be added into the pool.
-    ///   - `alpha_out_emission`: The remaining alpha emission after adjustments to be distributed to miners/validatods.
+    ///   - `alpha_out_emission`: The remaining alpha emission after adjustments to be distributed to miners/validators.
     ///
     /// The algorithm ensures that the pool injection of tao_in_emission, alpha_in_emission does not effect the pool price
     /// It also ensures that the total amount of alpha_in_emission + alpha_out_emission sum to 2 * alpha_block_emission
-    /// It also ensure that 1 < alpha_out_emission < 2 * alpha_block_emission and 0 < alpha_in_emission < alpha_block_emission.
-    pub fn get_dynamic_tao_emission(netuid: u16, tao_emission: u64, alpha_block_emission: u64) -> (u64, u64, u64) {
+    /// It also ensures that 1 < alpha_out_emission < 2 * alpha_block_emission and 0 < alpha_in_emission < alpha_block_emission.
+    pub fn get_dynamic_tao_emission(
+        netuid: u16,
+        tao_emission: u64,
+        alpha_block_emission: u64,
+    ) -> (u64, u64, u64) {
         // Init terms.
         let mut tao_in_emission: I96F32 = I96F32::from_num(tao_emission);
         let float_alpha_block_emission: I96F32 = I96F32::from_num(alpha_block_emission);
@@ -38,11 +38,18 @@ impl<T: Config> Pallet<T> {
         log::debug!("{:?} - alpha_price: {:?}", netuid, alpha_price);
 
         // Get initial alpha_in
-        let mut alpha_in_emission: I96F32 = I96F32::from_num(tao_emission).checked_div(alpha_price).unwrap_or(float_alpha_block_emission);
+        let mut alpha_in_emission: I96F32 = I96F32::from_num(tao_emission)
+            .checked_div(alpha_price)
+            .unwrap_or(float_alpha_block_emission);
 
         // Check if we are emitting too much alpha_in
         if alpha_in_emission >= float_alpha_block_emission {
-            log::debug!("{:?} - alpha_in_emission: {:?} > alpha_block_emission: {:?}", netuid, alpha_in_emission, float_alpha_block_emission);
+            log::debug!(
+                "{:?} - alpha_in_emission: {:?} > alpha_block_emission: {:?}",
+                netuid,
+                alpha_in_emission,
+                float_alpha_block_emission
+            );
 
             // Scale down tao_in
             tao_in_emission = alpha_price.saturating_mul(float_alpha_block_emission);
@@ -58,15 +65,25 @@ impl<T: Config> Pallet<T> {
         }
 
         // Set Alpha in emission.
-        let alpha_out_emission = I96F32::from_num(2).saturating_mul(float_alpha_block_emission).saturating_sub(alpha_in_emission);
+        let alpha_out_emission = I96F32::from_num(2)
+            .saturating_mul(float_alpha_block_emission)
+            .saturating_sub(alpha_in_emission);
 
         // Log results.
         log::debug!("{:?} - tao_in_emission: {:?}", netuid, tao_in_emission);
         log::debug!("{:?} - alpha_in_emission: {:?}", netuid, alpha_in_emission);
-        log::debug!("{:?} - alpha_out_emission: {:?}", netuid, alpha_out_emission);
+        log::debug!(
+            "{:?} - alpha_out_emission: {:?}",
+            netuid,
+            alpha_out_emission
+        );
 
         // Return result.
-        (tao_in_emission.to_num::<u64>(), alpha_in_emission.to_num::<u64>(), alpha_out_emission.to_num::<u64>())
+        (
+            tao_in_emission.to_num::<u64>(),
+            alpha_in_emission.to_num::<u64>(),
+            alpha_out_emission.to_num::<u64>(),
+        )
     }
 
     /// Calculates the block emission based on the total issuance.
@@ -133,5 +150,4 @@ impl<T: Config> Pallet<T> {
         }
         Ok(block_emission_u64)
     }
-
-}
+}

pallets/subtensor/src/coinbase/mod.rs

@@ -1,5 +1,5 @@
 use super::*;
+pub mod block_emission;
 pub mod block_step;
 pub mod root;
 pub mod run_coinbase;
-pub mod block_emission;

pallets/subtensor/src/coinbase/root.rs

@@ -24,8 +24,6 @@ use sp_std::vec;
 use substrate_fixed::types::I64F64;
 
 impl<T: Config> Pallet<T> {
-
-
     /// Fetches the total count of root network validators
     ///
     /// This function retrieves the total number of root network validators.
@@ -47,7 +45,7 @@ impl<T: Config> Pallet<T> {
     pub fn get_max_root_validators() -> u16 {
         Self::get_max_allowed_uids(Self::get_root_netuid())
     }
-  
+
     /// Checks for any UIDs in the given list that are either equal to the root netuid or exceed the total number of subnets.
     ///
     /// It's important to check for invalid UIDs to ensure data integrity and avoid referencing nonexistent subnets.
@@ -146,8 +144,6 @@ impl<T: Config> Pallet<T> {
         weights
     }
 
-
-
     /// Registers a user's hotkey to the root network.
     ///
     /// This function is responsible for registering the hotkey of a user.
@@ -392,7 +388,8 @@ impl<T: Config> Pallet<T> {
             });
 
             if let Some(last) = sorted_members.last() {
-                let last_stake = Self::get_stake_for_hotkey_on_subnet(last, Self::get_root_netuid());
+                let last_stake =
+                    Self::get_stake_for_hotkey_on_subnet(last, Self::get_root_netuid());
 
                 if last_stake < current_stake {
                     // Swap the member with the lowest stake.
@@ -408,8 +405,6 @@ impl<T: Config> Pallet<T> {
         Ok(last)
     }
 
-
-
     pub fn do_vote_root(
         origin: T::RuntimeOrigin,
         hotkey: &T::AccountId,
@@ -456,8 +451,6 @@ impl<T: Config> Pallet<T> {
             .into())
     }
 
-
-
     /// Facilitates the removal of a user's subnetwork.
     ///
     /// # Args:
@@ -500,7 +493,6 @@ impl<T: Config> Pallet<T> {
         Ok(())
     }
 
-
     /// Removes a network (identified by netuid) and all associated parameters.
     ///
     /// This function is responsible for cleaning up all the data associated with a network.