add more tests for root pending etc

Author: unconst

pallets/subtensor/src/coinbase/run_coinbase.rs

@@ -138,8 +138,10 @@ impl<T: Config> Pallet<T> {
         for netuid_i in subnets.iter() {
             // Get alpha out.
             let alpha_out_i: I96F32 = *alpha_out.get(netuid_i).unwrap_or(&asfloat!(0));
+            log::debug!("alpha_out_i: {:?}", alpha_out_i);
             // Calculate the owner cut.
             let owner_cut_i: I96F32 = alpha_out_i.saturating_mul(cut_percent);
+            log::debug!("owner_cut_i: {:?}", owner_cut_i);
             // Save owner cut.
             *owner_cuts.entry(*netuid_i).or_insert(asfloat!(0)) = owner_cut_i;
             // Save new alpha_out.
@@ -155,24 +157,33 @@ impl<T: Config> Pallet<T> {
         for netuid_i in subnets.iter() {
             // Get remaining alpha out.
             let alpha_out_i: I96F32 = *alpha_out.get(netuid_i).unwrap_or(&asfloat!(0.0));
+            log::debug!("alpha_out_i: {:?}", alpha_out_i);
             // Get total TAO on root.
             let root_tao: I96F32 = asfloat!(SubnetTAO::<T>::get(0));
+            log::debug!("root_tao: {:?}", root_tao);
             // Get total ALPHA on subnet.
             let alpha_issuance: I96F32 = asfloat!(Self::get_alpha_issuance(*netuid_i));
+            log::debug!("alpha_issuance: {:?}", alpha_issuance);
             // Get tao_weight
             let tao_weight: I96F32 = root_tao.saturating_mul(Self::get_tao_weight());
+            log::debug!("tao_weight: {:?}", tao_weight);
             // Get root proportional dividends.
             let root_proportion: I96F32 = tao_weight
                 .checked_div(tao_weight.saturating_add(alpha_issuance))
                 .unwrap_or(asfloat!(0.0));
+            log::debug!("root_proportion: {:?}", root_proportion);
             // Get root proportion of alpha_out dividends.
             let root_alpha: I96F32 = root_proportion
                 .saturating_mul(alpha_out_i) // Total alpha emission per block remaining.
                 .saturating_mul(asfloat!(0.5)); // 50% to validators.
                                                 // Remove root alpha from alpha_out.
+            log::debug!("root_alpha: {:?}", root_alpha);
+            // Get pending alpha as original alpha_out - root_alpha.
             let pending_alpha: I96F32 = alpha_out_i.saturating_sub(root_alpha);
+            log::debug!("pending_alpha: {:?}", pending_alpha);
             // Sell root emission through the pool.
             let root_tao: u64 = Self::swap_alpha_for_tao(*netuid_i, tou64!(root_alpha));
+            log::debug!("root_tao: {:?}", root_tao);
             // Accumulate alpha emission in pending.
             PendingAlphaSwapped::<T>::mutate(*netuid_i, |total| {
                 *total = total.saturating_add(tou64!(root_alpha));

pallets/subtensor/src/tests/coinbase.rs

@@ -360,3 +360,41 @@ fn test_coinbase_alpha_issuance_with_cap_trigger_and_block_emission() {
         // No emission.
     });
 }
+
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor --lib -- tests::coinbase::test_owner_cut_base --exact --show-output --nocapture
+#[test]
+fn test_owner_cut_base() {
+    new_test_ext(1).execute_with(|| {
+        let netuid: u16 = 1;
+        add_network(netuid, 1, 0);
+        SubtensorModule::set_tempo(netuid, 10000);// Large number (dont drain)
+        SubtensorModule::set_subnet_owner_cut( 0 );
+        SubtensorModule::run_coinbase(I96F32::from_num(0));
+        assert_eq!( PendingOwnerCut::<Test>::get(netuid), 0 ); // No cut 
+        SubtensorModule::set_subnet_owner_cut( u16::MAX );
+        SubtensorModule::run_coinbase(I96F32::from_num(0));
+        assert_eq!( PendingOwnerCut::<Test>::get(netuid), 1_000_000_000 ); // Full cut.
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor --lib -- tests::coinbase::test_pending_swapped --exact --show-output --nocapture
+#[test]
+fn test_pending_swapped() {
+    new_test_ext(1).execute_with(|| {
+        let netuid: u16 = 1;
+        let emission: u64 = 1_000_000;
+        add_network(netuid, 1, 0);
+        SubtensorModule::run_coinbase(I96F32::from_num(0));
+        assert_eq!( PendingAlphaSwapped::<Test>::get(netuid), 0 ); // Zero tao weight and no root.
+        SubnetTAO::<Test>::insert( 0, 1_000_000_000); // Add root weight.
+        SubtensorModule::run_coinbase(I96F32::from_num(0));
+        assert_eq!( PendingAlphaSwapped::<Test>::get(netuid), 0 ); // Zero tao weight with 1 root.
+        SubtensorModule::set_tempo(netuid, 10000);// Large number (dont drain)
+        SubtensorModule::set_tao_weight( u64::MAX ); // Set TAO weight to 1.0
+        SubtensorModule::run_coinbase(I96F32::from_num(0));
+        assert_eq!( PendingAlphaSwapped::<Test>::get(netuid), 125000000 ); // 1 TAO / ( 1 + 3 ) = 0.25 * 1 / 2 = 125000000
+        assert_eq!( PendingEmission::<Test>::get(netuid), 1_000_000_000 - 125000000 ); // 1 - swapped.
+        assert_eq!( PendingRootDivs::<Test>::get(netuid), 125000000 ); // swapped * (price = 1)
+    });
+}