use new pending em storages

Author: camfairchild

pallets/subtensor/src/coinbase/root.rs

@@ -315,6 +315,8 @@ impl<T: Config> Pallet<T> {
         // --- 15. Mechanism step / emissions bookkeeping.
         FirstEmissionBlockNumber::<T>::remove(netuid);
         PendingEmission::<T>::remove(netuid);
+        PendingValidatorEmission::<T>::remove(netuid);
+        PendingServerEmission::<T>::remove(netuid);
         PendingRootAlphaDivs::<T>::remove(netuid);
         PendingOwnerCut::<T>::remove(netuid);
         BlocksSinceLastStep::<T>::remove(netuid);

pallets/subtensor/src/rpc_info/dynamic_info.rs

@@ -62,7 +62,9 @@ impl<T: Config> Pallet<T> {
             alpha_out_emission: SubnetAlphaOutEmission::<T>::get(netuid).into(),
             alpha_in_emission: SubnetAlphaInEmission::<T>::get(netuid).into(),
             tao_in_emission: SubnetTaoInEmission::<T>::get(netuid).into(),
-            pending_alpha_emission: PendingEmission::<T>::get(netuid).into(),
+            pending_alpha_emission: PendingValidatorEmission::<T>::get(netuid)
+                .saturating_add(PendingServerEmission::<T>::get(netuid))
+                .into(),
             pending_root_emission: TaoCurrency::from(0u64).into(),
             subnet_volume: SubnetVolume::<T>::get(netuid).into(),
             network_registered_at: NetworkRegisteredAt::<T>::get(netuid).into(),

pallets/subtensor/src/rpc_info/metagraph.rs

@@ -694,7 +694,9 @@ impl<T: Config> Pallet<T> {
             alpha_out_emission: SubnetAlphaOutEmission::<T>::get(netuid).into(), // amount injected in alpha reserves per block
             alpha_in_emission: SubnetAlphaInEmission::<T>::get(netuid).into(), // amount injected outstanding per block
             tao_in_emission: SubnetTaoInEmission::<T>::get(netuid).into(), // amount of tao injected per block
-            pending_alpha_emission: PendingEmission::<T>::get(netuid).into(), // pending alpha to be distributed
+            pending_alpha_emission: PendingValidatorEmission::<T>::get(netuid)
+                .saturating_add(PendingServerEmission::<T>::get(netuid))
+                .into(), // pending alpha to be distributed
             pending_root_emission: TaoCurrency::from(0u64).into(), // panding tao for root divs to be distributed
             subnet_volume: subnet_volume.into(),
             moving_price: SubnetMovingPrice::<T>::get(netuid),
@@ -1000,7 +1002,11 @@ impl<T: Config> Pallet<T> {
             },
             Some(SelectiveMetagraphIndex::PendingAlphaEmission) => SelectiveMetagraph {
                 netuid: netuid.into(),
-                pending_alpha_emission: Some(PendingEmission::<T>::get(netuid).into()),
+                pending_alpha_emission: Some(
+                    PendingValidatorEmission::<T>::get(netuid)
+                        .saturating_add(PendingServerEmission::<T>::get(netuid))
+                        .into(),
+                ),
                 ..Default::default()
             },
             Some(SelectiveMetagraphIndex::PendingRootEmission) => SelectiveMetagraph {

pallets/subtensor/src/tests/children.rs

@@ -3095,7 +3095,8 @@ fn test_parent_child_chain_emission() {
         );
 
         // Set pending emission to 0
-        PendingEmission::<Test>::insert(netuid, AlphaCurrency::ZERO);
+        PendingValidatorEmission::<Test>::insert(netuid, AlphaCurrency::ZERO);
+        PendingServerEmission::<Test>::insert(netuid, AlphaCurrency::ZERO);
 
         // Run epoch with emission value
         SubtensorModule::run_coinbase(emission);

pallets/subtensor/src/tests/coinbase.rs

@@ -686,16 +686,22 @@ fn test_pending_emission() {
         // 1 TAO / ( 1 + 3 ) = 0.25 * 1 / 2 = 125000000
 
         assert_abs_diff_eq!(
-            u64::from(PendingEmission::<Test>::get(netuid)),
-            1_000_000_000 - 125000000,
+            u64::from(PendingServerEmission::<Test>::get(netuid)),
+            500_000_000,
             epsilon = 1
-        ); // 1 - swapped.
+        ); // 1 / 2.
+
+        assert_abs_diff_eq!(
+            u64::from(PendingValidatorEmission::<Test>::get(netuid)),
+            500_000_000 - 125000000,
+            epsilon = 1
+        ); // 1 / 2 - swapped.
 
         assert_abs_diff_eq!(
             u64::from(PendingRootAlphaDivs::<Test>::get(netuid)),
             125000000,
             epsilon = 1
-        ); // 1 / 2 = 125000000
+        ); // 1 / 2 * 0.25 --> (from root_prop)
     });
 }
 
@@ -3081,9 +3087,10 @@ fn test_mining_emission_distribution_with_no_root_sell() {
         // Run again but with some root stake
         step_block(subnet_tempo - 2);
         assert_abs_diff_eq!(
-            PendingEmission::<Test>::get(netuid).to_u64(),
+            PendingServerEmission::<Test>::get(netuid).to_u64(),
             U96F32::saturating_from_num(per_block_emission)
                 .saturating_mul(U96F32::saturating_from_num(subnet_tempo as u64))
+                .saturating_mul(U96F32::saturating_from_num(0.5)) // miner cut
                 .saturating_mul(U96F32::saturating_from_num(0.90))
                 .saturating_to_num::<u64>(),
             epsilon = 100_000_u64.into()

pallets/subtensor/src/tests/networks.rs

@@ -374,7 +374,8 @@ fn dissolve_clears_all_per_subnet_storages() {
         SubnetMechanism::<Test>::insert(net, 1u16);
         NetworkRegistrationAllowed::<Test>::insert(net, true);
         NetworkPowRegistrationAllowed::<Test>::insert(net, true);
-        PendingEmission::<Test>::insert(net, AlphaCurrency::from(1));
+        PendingServerEmission::<Test>::insert(net, AlphaCurrency::from(1));
+        PendingValidatorEmission::<Test>::insert(net, AlphaCurrency::from(1));
         PendingRootAlphaDivs::<Test>::insert(net, AlphaCurrency::from(1));
         PendingOwnerCut::<Test>::insert(net, AlphaCurrency::from(1));
         BlocksSinceLastStep::<Test>::insert(net, 1u64);
@@ -529,7 +530,8 @@ fn dissolve_clears_all_per_subnet_storages() {
         assert!(!SubnetMechanism::<Test>::contains_key(net));
         assert!(!NetworkRegistrationAllowed::<Test>::contains_key(net));
         assert!(!NetworkPowRegistrationAllowed::<Test>::contains_key(net));
-        assert!(!PendingEmission::<Test>::contains_key(net));
+        assert!(!PendingServerEmission::<Test>::contains_key(net));
+        assert!(!PendingValidatorEmission::<Test>::contains_key(net));
         assert!(!PendingRootAlphaDivs::<Test>::contains_key(net));
         assert!(!PendingOwnerCut::<Test>::contains_key(net));
         assert!(!BlocksSinceLastStep::<Test>::contains_key(net));

pallets/subtensor/src/utils/misc.rs

@@ -334,9 +334,6 @@ impl<T: Config> Pallet<T> {
     pub fn get_tempo(netuid: NetUid) -> u16 {
         Tempo::<T>::get(netuid)
     }
-    pub fn get_pending_emission(netuid: NetUid) -> AlphaCurrency {
-        PendingEmission::<T>::get(netuid)
-    }
     pub fn get_last_adjustment_block(netuid: NetUid) -> u64 {
         LastAdjustmentBlock::<T>::get(netuid)
     }