Fix tests after raising min stake to 2_000_000 rao

Author: gztensor

pallets/subtensor/src/lib.rs

@@ -703,8 +703,9 @@ pub mod pallet {
 
     #[pallet::type_value]
     /// Default minimum stake.
+    /// 2M rao matches $1 at $500/TAO
     pub fn DefaultMinStake<T: Config>() -> u64 {
-        1_000
+        2_000_000
     }
 
     #[pallet::type_value]

pallets/subtensor/src/tests/children.rs

@@ -3058,28 +3058,36 @@ fn test_childkey_multiple_parents_emission() {
 
         // Register neurons and add initial stakes
         let initial_stakes: Vec<(bool, U256, U256, u64)> = vec![
-            (false, coldkey_parent1, parent1, 200_000),
-            (true, coldkey_parent2, parent2, 150_000),
-            (true, coldkey_child, child, 20_000),
-            (true, coldkey_weight_setter, weight_setter, 100_000),
+            (false, coldkey_parent1, parent1, 200_000_000),
+            (true, coldkey_parent2, parent2, 150_000_000),
+            (true, coldkey_child, child, 20_000_000),
+            (true, coldkey_weight_setter, weight_setter, 100_000_000),
         ];
 
-        for (register, coldkey, hotkey, stake) in initial_stakes.iter() {
-            SubtensorModule::add_balance_to_coldkey_account(coldkey, *stake);
-            if *register {
-                // Register a neuron
-                register_ok_neuron(netuid, *hotkey, *coldkey, 0);
-            } else {
-                // Just create hotkey account
-                SubtensorModule::create_account_if_non_existent(coldkey, hotkey);
-            }
-            assert_ok!(SubtensorModule::add_stake(
-                RuntimeOrigin::signed(*coldkey),
-                *hotkey,
-                netuid,
-                *stake
-            ));
-        }
+        let initial_actual_stakes: Vec<u64> = initial_stakes
+            .iter()
+            .map(|(register, coldkey, hotkey, stake)| {
+                SubtensorModule::add_balance_to_coldkey_account(coldkey, *stake);
+                if *register {
+                    // Register a neuron
+                    register_ok_neuron(netuid, *hotkey, *coldkey, 0);
+                } else {
+                    // Just create hotkey account
+                    SubtensorModule::create_account_if_non_existent(coldkey, hotkey);
+                }
+                assert_ok!(SubtensorModule::add_stake(
+                    RuntimeOrigin::signed(*coldkey),
+                    *hotkey,
+                    netuid,
+                    *stake
+                ));
+
+                // Return actual stake
+                SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+                    &hotkey, &coldkey, netuid,
+                )
+            })
+            .collect();
 
         SubtensorModule::set_weights_set_rate_limit(netuid, 0);
         step_block(2);
@@ -3152,23 +3160,26 @@ fn test_childkey_multiple_parents_emission() {
         );
 
         assert!(
-            parent1_stake > 200_000,
+            parent1_stake > initial_actual_stakes[0],
             "Parent1 should have received emission"
         );
         assert!(
-            parent2_stake > 150_000,
+            parent2_stake > initial_actual_stakes[1],
             "Parent2 should have received emission"
         );
-        assert!(child_stake > 20_000, "Child should have received emission");
         assert!(
-            weight_setter_stake > 100_000,
+            child_stake > initial_actual_stakes[2],
+            "Child should have received emission"
+        );
+        assert!(
+            weight_setter_stake > initial_actual_stakes[3],
             "Weight setter should have received emission"
         );
 
         // Check individual stake increases
-        let parent1_stake_increase = parent1_stake - 200_000;
-        let parent2_stake_increase = parent2_stake - 150_000;
-        let child_stake_increase = child_stake - 20_000;
+        let parent1_stake_increase = parent1_stake - initial_actual_stakes[0];
+        let parent2_stake_increase = parent2_stake - initial_actual_stakes[1];
+        let child_stake_increase = child_stake - initial_actual_stakes[2];
 
         log::debug!(
             "Stake increases - Parent1: {}, Parent2: {}, Child: {}",
@@ -3192,12 +3203,13 @@ fn test_childkey_multiple_parents_emission() {
         );
 
         // Check that the total stake has increased by the emission amount
+        // Allow 1% slippage
         let total_stake = parent1_stake + parent2_stake + child_stake + weight_setter_stake;
-        let initial_total_stake: u64 = initial_stakes.iter().map(|(_, _, _, stake)| stake).sum();
+        let initial_total_stake: u64 = initial_actual_stakes.iter().sum::<u64>();
         assert_abs_diff_eq!(
             total_stake,
-            initial_total_stake + total_emission - 2,
-            epsilon = total_emission / 10_000
+            initial_total_stake + total_emission,
+            epsilon = total_emission / 100
         );
     });
 }

pallets/subtensor/src/tests/epoch.rs

@@ -12,7 +12,7 @@ use frame_support::{assert_err, assert_ok};
 
 // use frame_system::Config;
 use rand::{distributions::Uniform, rngs::StdRng, seq::SliceRandom, thread_rng, Rng, SeedableRng};
-use sp_core::U256;
+use sp_core::{Get, U256};
 // use sp_runtime::DispatchError;
 use std::time::Instant;
 use substrate_fixed::types::I32F32;
@@ -1505,7 +1505,7 @@ fn test_set_alpha_disabled() {
             signer.clone(),
             hotkey,
             netuid,
-            1000
+            DefaultMinStake::<Test>::get()
         ));
         // Only owner can set alpha values
         assert_ok!(SubtensorModule::register_network(signer.clone(), hotkey));
@@ -2600,7 +2600,7 @@ fn test_get_set_alpha() {
             signer.clone(),
             hotkey,
             netuid,
-            1000
+            DefaultMinStake::<Test>::get()
         ));
 
         assert_ok!(SubtensorModule::do_set_alpha_values(

pallets/subtensor/src/tests/move_stake.rs

@@ -2,7 +2,7 @@ use super::mock::*;
 use crate::*;
 use approx::assert_abs_diff_eq;
 use frame_support::{assert_err, assert_noop, assert_ok};
-use sp_core::U256;
+use sp_core::{Get, U256};
 
 // 1. test_do_move_success
 // Description: Test a successful move of stake between two hotkeys in the same subnet
@@ -16,7 +16,7 @@ fn test_do_move_success() {
         let coldkey = U256::from(1);
         let origin_hotkey = U256::from(2);
         let destination_hotkey = U256::from(3);
-        let stake_amount = 1_000_000;
+        let stake_amount = DefaultMinStake::<Test>::get() * 10;
 
         // Set up initial stake
         SubtensorModule::create_account_if_non_existent(&coldkey, &origin_hotkey);
@@ -54,7 +54,7 @@ fn test_do_move_success() {
                 netuid
             ),
             stake_amount,
-            epsilon = 100
+            epsilon = stake_amount / 1000
         );
     });
 }
@@ -72,7 +72,7 @@ fn test_do_move_different_subnets() {
         let coldkey = U256::from(1);
         let origin_hotkey = U256::from(2);
         let destination_hotkey = U256::from(3);
-        let stake_amount = 1_000_000;
+        let stake_amount = DefaultMinStake::<Test>::get() * 10;
 
         // Set up initial stake and subnets
         SubtensorModule::create_account_if_non_existent(&coldkey, &origin_hotkey);
@@ -110,7 +110,7 @@ fn test_do_move_different_subnets() {
                 destination_netuid
             ),
             stake_amount,
-            epsilon = 100
+            epsilon = stake_amount / 1000
         );
     });
 }
@@ -271,7 +271,7 @@ fn test_do_move_all_stake() {
         let coldkey = U256::from(1);
         let origin_hotkey = U256::from(2);
         let destination_hotkey = U256::from(3);
-        let stake_amount = 1_000_000;
+        let stake_amount = DefaultMinStake::<Test>::get() * 10;
 
         // Set up initial stake
         SubtensorModule::stake_into_subnet(&origin_hotkey, &coldkey, netuid, stake_amount);
@@ -309,7 +309,7 @@ fn test_do_move_all_stake() {
                 netuid
             ),
             stake_amount,
-            epsilon = 100
+            epsilon = stake_amount / 1000
         );
     });
 }
@@ -323,7 +323,7 @@ fn test_do_move_half_stake() {
         let coldkey = U256::from(1);
         let origin_hotkey = U256::from(2);
         let destination_hotkey = U256::from(3);
-        let stake_amount = 1_000_000;
+        let stake_amount = DefaultMinStake::<Test>::get() * 10;
 
         // Set up initial stake
         SubtensorModule::stake_into_subnet(&origin_hotkey, &coldkey, netuid, stake_amount);
@@ -353,7 +353,7 @@ fn test_do_move_half_stake() {
                 netuid
             ),
             stake_amount / 2,
-            epsilon = 100
+            epsilon = stake_amount / 1000
         );
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
@@ -362,7 +362,7 @@ fn test_do_move_half_stake() {
                 netuid
             ),
             stake_amount / 2,
-            epsilon = 100
+            epsilon = stake_amount / 1000
         );
     });
 }
@@ -379,7 +379,7 @@ fn test_do_move_partial_stake() {
         let coldkey = U256::from(1);
         let origin_hotkey = U256::from(2);
         let destination_hotkey = U256::from(3);
-        let total_stake = 1_000_000;
+        let total_stake = DefaultMinStake::<Test>::get() * 10;
 
         // Set up initial stake
         SubtensorModule::stake_into_subnet(&origin_hotkey, &coldkey, netuid, total_stake);
@@ -417,7 +417,7 @@ fn test_do_move_partial_stake() {
                 netuid
             ),
             total_stake,
-            epsilon = 100
+            epsilon = total_stake / 1000
         );
     });
 }
@@ -434,7 +434,7 @@ fn test_do_move_multiple_times() {
         let coldkey = U256::from(1);
         let hotkey1 = U256::from(2);
         let hotkey2 = U256::from(3);
-        let initial_stake = 1_000_000;
+        let initial_stake = DefaultMinStake::<Test>::get() * 10;
 
         // Set up initial stake
         SubtensorModule::create_account_if_non_existent(&coldkey, &hotkey1);
@@ -471,7 +471,7 @@ fn test_do_move_multiple_times() {
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey1, &coldkey, netuid),
             initial_stake,
-            epsilon = 100
+            epsilon = initial_stake / 1000
         );
         assert_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey2, &coldkey, netuid),
@@ -548,7 +548,7 @@ fn test_do_move_same_hotkey() {
         let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
-        let stake_amount = 1_000_000;
+        let stake_amount = DefaultMinStake::<Test>::get() * 10;
 
         // Set up initial stake
         SubtensorModule::create_account_if_non_existent(&coldkey, &hotkey);
@@ -587,7 +587,7 @@ fn test_do_move_event_emission() {
         let coldkey = U256::from(1);
         let origin_hotkey = U256::from(2);
         let destination_hotkey = U256::from(3);
-        let stake_amount = 10_000;
+        let stake_amount = DefaultMinStake::<Test>::get() * 10;
 
         // Set up initial stake
         SubtensorModule::create_account_if_non_existent(&coldkey, &origin_hotkey);
@@ -618,7 +618,7 @@ fn test_do_move_event_emission() {
                 netuid,
                 destination_hotkey,
                 netuid,
-                alpha,
+                19999999, // Should be TAO equivalent
             )
             .into(),
         );
@@ -638,7 +638,7 @@ fn test_do_move_storage_updates() {
         let coldkey = U256::from(1);
         let origin_hotkey = U256::from(2);
         let destination_hotkey = U256::from(3);
-        let stake_amount = 1_000_000;
+        let stake_amount = DefaultMinStake::<Test>::get() * 10;
 
         // Set up initial stake
         SubtensorModule::stake_into_subnet(&origin_hotkey, &coldkey, origin_netuid, stake_amount);
@@ -743,7 +743,7 @@ fn test_moving_too_little_fails() {
     new_test_ext(1).execute_with(|| {
         let hotkey_account_id = U256::from(533453);
         let coldkey_account_id = U256::from(55453);
-        let amount = 10_000;
+        let amount = DefaultMinStake::<Test>::get();
 
         //add network
         let netuid: u16 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);