Add test for stake weights

Author: ales-otf

node/src/chain_spec/localnet.rs

@@ -35,7 +35,7 @@ pub fn localnet_config() -> Result<ChainSpec, String> {
         vec![
             // Keys for debug
             authority_keys_from_seed("Alice"),
-            authority_keys_from_seed("Bob"),
+            // authority_keys_from_seed("Bob"),
         ],
         // Pre-funded accounts
         true,

pallets/subtensor/src/epoch/run_epoch.rs

@@ -669,6 +669,7 @@ impl<T: Config> Pallet<T> {
         // ===================
         // == Value storage ==
         // ===================
+		log::warn!("netuid = {}, &stake = {:?}", netuid, &stake);
         let cloned_stake_weight: Vec<u16> = stake
             .iter()
             .map(|xi| fixed_proportion_to_u16(*xi))

pallets/subtensor/src/staking/alpha.rs

@@ -84,6 +84,7 @@ impl<T: Config> Pallet<T> {
     pub fn get_stake_weights_for_network(netuid: u16) -> (Vec<I32F32>, Vec<u64>, Vec<u64>) {
         // Step 1: Get the subnet size (number of neurons).
         let n: u16 = Self::get_subnetwork_n(netuid);
+		log::warn!("netuid = {:?}", netuid);
 
         // Step 2: Retrieve all hotkeys (neuron keys) on this subnet.
         let hotkeys: Vec<(u16, T::AccountId)> =
@@ -96,6 +97,7 @@ impl<T: Config> Pallet<T> {
         let mut raw_alpha_stake: Vec<u64> = vec![0; n as usize];
         for (uid_i, hotkey) in &hotkeys {
             let alpha: u64 = Self::get_inherited_alpha_for_hotkey_on_subnet(hotkey, netuid);
+			log::warn!("uid = {:?}, alpha = {:?}", uid_i, alpha);
             alpha_stake[*uid_i as usize] = I64F64::from_num(alpha);
             raw_alpha_stake[*uid_i as usize] = alpha;
         }

pallets/subtensor/src/staking/stake_ops.rs

@@ -126,8 +126,12 @@ impl<T: Config> Pallet<T> {
             let subnet_tao: I96F32 = I96F32::from_num(SubnetTAO::<T>::get(netuid));
             let subnet_alpha: I96F32 = I96F32::from_num(SubnetAlphaIn::<T>::get(netuid));
 
-            log::warn!("subnet_tao = {:?}", subnet_tao);
-            log::warn!("subnet_alpha = {:?}", subnet_alpha);
+            log::warn!(
+                "hotkey = {:?}, subnet_tao = {:?}, subnet_alpha = {:?}",
+                &hotkey,
+                subnet_tao,
+                subnet_alpha
+            );
 
             // Step 3b: Compute constant product k = alpha * tao
             // This is the key to the dynamic mechanism: k remains constant

pallets/subtensor/tests/staking.rs

@@ -2490,3 +2490,73 @@ fn test_anneal_global_weight() {
         );
     });
 }
+
+// https://github.com/opentensor/subtensor/issues/925
+// RUST_LOG=warn cargo test -p pallet-subtensor --test staking -- test_stake_weight_should_not_be_affected_by_zero_stakes --exact --nocapture
+#[test]
+fn test_stake_weight_should_not_be_affected_by_zero_stakes() {
+    new_test_ext(1).execute_with(|| {
+        let registrar = AccountId::from(42);
+        Balances::force_set_balance(RuntimeOrigin::root(), registrar, 10_000_000_000_000).unwrap();
+
+        // the root subnet
+        SubtensorModule::register_network_with_identity(
+            RuntimeOrigin::signed(registrar),
+            registrar,
+            1,
+            None,
+        )
+        .unwrap();
+
+        // our test subnet with id 1
+        SubtensorModule::register_network_with_identity(
+            RuntimeOrigin::signed(registrar),
+            registrar,
+            1,
+            None,
+        )
+        .unwrap();
+
+
+        // SubtensorModule::add_stake(
+        //     RuntimeOrigin::signed(registrar),
+        //     registrar,
+        //     1,
+        //     1000_000_000_000,
+        // )
+        // .unwrap();
+
+        // step_epochs(1, 1);
+
+
+        let neuron_1 = AccountId::from(123);
+        Balances::force_set_balance(RuntimeOrigin::root(), neuron_1, 10_000_000_000_000).unwrap();
+
+        SubtensorModule::burned_register(RuntimeOrigin::signed(neuron_1), 1, neuron_1).unwrap();
+        SubtensorModule::add_stake(
+            RuntimeOrigin::signed(neuron_1),
+            neuron_1,
+            1,
+            1000_000_000_000,
+        )
+        .unwrap();
+
+        // step_epochs(1, 1);
+
+        let neuron_2 = AccountId::from(321);
+        Balances::force_set_balance(RuntimeOrigin::root(), neuron_2, 10_000_000_000_000).unwrap();
+
+        SubtensorModule::burned_register(RuntimeOrigin::signed(neuron_2), 1, neuron_2).unwrap();
+        SubtensorModule::add_stake(
+            RuntimeOrigin::signed(neuron_2),
+            neuron_2,
+            1,
+            1000_000_000_000,
+        )
+        .unwrap();
+		SubtensorModule::epoch(1, 10_000_000_000_000);
+        // step_epochs(1, 1);
+
+        dbg!(SubtensorModule::get_neurons(1));
+    });
+}

runtime/src/lib.rs

@@ -2069,6 +2069,7 @@ impl_runtime_apis! {
     impl subtensor_custom_rpc_runtime_api::NeuronInfoRuntimeApi<Block> for Runtime {
         fn get_neurons_lite(netuid: u16) -> Vec<u8> {
             let result = SubtensorModule::get_neurons_lite(netuid);
+			log::warn!("{:?}", result);
             result.encode()
         }
 
@@ -2089,6 +2090,7 @@ impl_runtime_apis! {
 
         fn get_neuron(netuid: u16, uid: u16) -> Vec<u8> {
             let _result = SubtensorModule::get_neuron(netuid, uid);
+			log::warn!("{:?}", _result);
             if _result.is_some() {
                 let result = _result.expect("Could not get NeuronInfo");
                 result.encode()

scripts/localnet.sh

@@ -80,6 +80,7 @@ alice_start=(
   --validator
   --rpc-cors=all
   --allow-private-ipv4
+  --log warn
   --discover-local
   --unsafe-force-node-key-generation
 )
@@ -95,6 +96,7 @@ bob_start=(
   --rpc-cors=all
   --allow-private-ipv4
   --discover-local
+  --log warn
   --unsafe-force-node-key-generation
 )