Merge branch 'nonclaim' of https://github.com/opentensor/subtensor into nonclaim

Author: unconst

pallets/subtensor/src/coinbase/run_coinbase.rs

@@ -249,6 +249,11 @@ impl<T: Config> Pallet<T> {
                 BlocksSinceLastStep::<T>::mutate(netuid, |total| *total = total.saturating_add(1));
             }
         }
+
+        // --- 8. Apply pending childkeys of this subnet for the next epoch
+        for netuid in subnets.iter() {
+            Self::do_set_pending_children(*netuid);
+        }
     }
 
     pub fn drain_pending_emission(

pallets/subtensor/src/migrations/migrate_rao.rs

@@ -77,7 +77,7 @@ pub fn migrate_rao<T: Config>() -> Weight {
         // The initial TAO is the locked amount, with a minimum of 1 RAO and a cap of 100 TAO.
         let pool_initial_tao = Pallet::<T>::get_network_min_lock();
         if lock < pool_initial_tao {
-            let difference: u64 = pool_initial_tao.saturating_sub( lock );
+            let difference: u64 = pool_initial_tao.saturating_sub(lock);
             TotalIssuance::<T>::mutate(|total| {
                 *total = total.saturating_add(difference);
             });
@@ -86,15 +86,12 @@ pub fn migrate_rao<T: Config>() -> Weight {
         let remaining_lock = lock.saturating_sub(pool_initial_tao);
         // Refund the owner for the remaining lock.
         Pallet::<T>::add_balance_to_coldkey_account(&owner, remaining_lock);
-        SubnetLocked::<T>::insert( netuid, 0 ); // Clear lock amount.
-        SubnetTAO::<T>::insert( netuid, pool_initial_tao); 
+        SubnetLocked::<T>::insert(netuid, 0); // Clear lock amount.
+        SubnetTAO::<T>::insert(netuid, pool_initial_tao);
         TotalStake::<T>::mutate(|total| {
-            *total = total.saturating_add( pool_initial_tao);
+            *total = total.saturating_add(pool_initial_tao);
         }); // Increase total stake.
-        SubnetAlphaIn::<T>::insert(
-            netuid,
-            pool_initial_tao
-        ); // Set initial alpha to pool initial tao.
+        SubnetAlphaIn::<T>::insert(netuid, pool_initial_tao); // Set initial alpha to pool initial tao.
         SubnetAlphaOut::<T>::insert(netuid, 0); // Set zero subnet alpha out.
         SubnetMechanism::<T>::insert(netuid, 1); // Convert to dynamic immediately with initialization.
         Tempo::<T>::insert(netuid, DefaultTempo::<T>::get());

pallets/subtensor/src/subnets/subnet.rs

@@ -236,9 +236,10 @@ impl<T: Config> Pallet<T> {
         // Put initial TAO from lock into subnet TAO and produce numerically equal amount of Alpha
         // The initial TAO is the locked amount, with a minimum of 1 RAO and a cap of 100 TAO.
         let pool_initial_tao = Self::get_network_min_lock();
-        let actual_tao_lock_amount_less_pool_tao = actual_tao_lock_amount.saturating_sub(pool_initial_tao);
+        let actual_tao_lock_amount_less_pool_tao =
+            actual_tao_lock_amount.saturating_sub(pool_initial_tao);
         SubnetTAO::<T>::insert(netuid_to_register, pool_initial_tao);
-        SubnetAlphaIn::<T>::insert( netuid_to_register, pool_initial_tao); 
+        SubnetAlphaIn::<T>::insert(netuid_to_register, pool_initial_tao);
         SubnetOwner::<T>::insert(netuid_to_register, coldkey.clone());
         SubnetOwnerHotkey::<T>::insert(netuid_to_register, hotkey.clone());
         TotalStakeAtDynamic::<T>::insert(netuid_to_register, TotalStake::<T>::get());

pallets/subtensor/src/tests/networks.rs

@@ -299,14 +299,8 @@ fn test_register_subnet_low_lock_cost() {
         assert!(SubtensorModule::if_subnet_exist(netuid));
 
         // Ensure that both Subnet TAO and Subnet Alpha In equal to (actual) lock_cost
-        assert_eq!(
-            SubnetTAO::<Test>::get(netuid),
-            lock_cost,
-        );
-        assert_eq!(
-            SubnetAlphaIn::<Test>::get(netuid),
-            lock_cost,
-        );
+        assert_eq!(SubnetTAO::<Test>::get(netuid), lock_cost,);
+        assert_eq!(SubnetAlphaIn::<Test>::get(netuid), lock_cost,);
     })
 }