add new test

Author: unconst

pallets/subtensor/src/coinbase/run_coinbase.rs

@@ -353,6 +353,7 @@ impl<T: Config> Pallet<T> {
         if let Ok(owner_coldkey) = SubnetOwner::<T>::try_get(netuid) {
             if let Ok(owner_hotkey) = SubnetOwnerHotkey::<T>::try_get(netuid) {
                 // Increase stake for owner hotkey and coldkey.
+                log::debug!("owner_hotkey: {:?} owner_coldkey: {:?}, owner_cut: {:?}", owner_hotkey, owner_coldkey, owner_cut);
                 Self::increase_stake_for_hotkey_and_coldkey_on_subnet(
                     &owner_hotkey,
                     &owner_coldkey,
@@ -365,6 +366,7 @@ impl<T: Config> Pallet<T> {
         // Distribute mining incentives.
         for (hotkey, incentive) in incentives {
             // Increase stake for miner.
+            log::debug!("incentives: hotkey: {:?}", incentive);
             Self::increase_stake_for_hotkey_and_coldkey_on_subnet(
                 &hotkey.clone(),
                 &Owner::<T>::get(hotkey.clone()),
@@ -376,21 +378,21 @@ impl<T: Config> Pallet<T> {
         // Distribute alpha divs.
         let _ = AlphaDividendsPerSubnet::<T>::clear_prefix(netuid, u32::MAX, None);
         for (hotkey, mut alpha_divs) in alpha_dividends {
-            log::debug!("hotkey: {:?} alpha_divs: {:?}", hotkey, alpha_divs);
-
             // Get take prop
             let alpha_take: I96F32 =
                 Self::get_hotkey_take_float(&hotkey).saturating_mul(alpha_divs);
             // Remove take prop from alpha_divs
             alpha_divs = alpha_divs.saturating_sub(alpha_take);
             // Give the validator their take.
+            log::debug!("hotkey: {:?} alpha_take: {:?}", hotkey, alpha_take);
             Self::increase_stake_for_hotkey_and_coldkey_on_subnet(
                 &hotkey,
                 &Owner::<T>::get(hotkey.clone()),
                 netuid,
                 tou64!(alpha_take),
             );
             // Give all other nominators.
+            log::debug!("hotkey: {:?} alpha_divs: {:?}", hotkey, alpha_divs);
             Self::increase_stake_for_hotkey_on_subnet(&hotkey.clone(), netuid, tou64!(alpha_divs));
             // Record dividends for this hotkey.
             AlphaDividendsPerSubnet::<T>::mutate(netuid, hotkey.clone(), |divs| {
@@ -401,19 +403,20 @@ impl<T: Config> Pallet<T> {
         // Distribute root tao divs.
         let _ = TaoDividendsPerSubnet::<T>::clear_prefix(netuid, u32::MAX, None);
         for (hotkey, mut root_tao) in tao_dividends {
-            log::debug!("hotkey: {:?} root_tao: {:?}", hotkey, root_tao);
             // Get take prop
             let tao_take: I96F32 = Self::get_hotkey_take_float(&hotkey).saturating_mul(root_tao);
             // Remove take prop from root_tao
             root_tao = root_tao.saturating_sub(tao_take);
             // Give the validator their take.
+            log::debug!("hotkey: {:?} tao_take: {:?}", hotkey, tao_take);
             Self::increase_stake_for_hotkey_and_coldkey_on_subnet(
                 &hotkey,
                 &Owner::<T>::get(hotkey.clone()),
                 Self::get_root_netuid(),
                 tou64!(tao_take),
             );
             // Give rest to nominators.
+            log::debug!("hotkey: {:?} root_tao: {:?}", hotkey, root_tao);
             Self::increase_stake_for_hotkey_on_subnet(
                 &hotkey,
                 Self::get_root_netuid(),

pallets/subtensor/src/tests/coinbase.rs

@@ -724,3 +724,41 @@ fn test_drain_base_with_subnet_with_two_stakers_registered_and_root_different_am
         close(expected_root2.to_num::<u64>(), root_after2, 10);
     });
 }
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor --lib -- tests::coinbase::test_drain_alpha_childkey_parentkey --exact --show-output --nocapture
+#[test]
+fn test_drain_alpha_childkey_parentkey() {
+    new_test_ext(1).execute_with(|| {
+        let netuid: u16 = 1;
+        add_network(netuid, 1, 0);
+        let parent = U256::from(1);
+        let child = U256::from(2);
+        let coldkey = U256::from(3);
+        let stake_before: u64 = 1_000_000_000;
+        register_ok_neuron(netuid, child, coldkey, 0);
+        SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
+            &parent,
+            &coldkey,
+            netuid,
+            stake_before,
+        );
+        mock_set_children_no_epochs(netuid, &parent, &[(u64::MAX, child)]);
+
+        // Childkey take is 10%
+        ChildkeyTake::<Test>::insert(child, netuid, u16::MAX/10);
+
+        let pending_alpha: u64 = 1_000_000_000;
+        SubtensorModule::drain_pending_emission(netuid, pending_alpha, 0, 0, 0);
+        let parent_stake_after =
+            SubtensorModule::get_stake_for_hotkey_on_subnet(&parent, netuid);
+        let child_stake_after =
+            SubtensorModule::get_stake_for_hotkey_on_subnet(&child, netuid);
+
+        // Child gets 10%, parent gets 90%
+        let expected = I96F32::from_num(stake_before) + I96F32::from_num(pending_alpha) * I96F32::from_num(9.0 / 10.0);
+        log::info!("expected: {:?}, parent_stake_after: {:?}", expected.to_num::<u64>(), parent_stake_after);
+        close(expected.to_num::<u64>(), parent_stake_after, 10_000);
+        let expected = I96F32::from_num(pending_alpha) / I96F32::from_num(10);
+        close(expected.to_num::<u64>(), child_stake_after, 10_000);
+    });
+}