From 2ecebb1945863a6677df925d9dfc899a44a0034c Mon Sep 17 00:00:00 2001 From: Keith Date: Tue, 13 May 2025 18:27:13 +0800 Subject: [PATCH 1/3] Ensure stake threshold is respected when handing out vpermits --- pallets/subtensor/src/epoch/math.rs | 16 ++++++++ pallets/subtensor/src/epoch/run_epoch.rs | 50 ++++++++++++++++++++---- pallets/subtensor/src/tests/epoch.rs | 8 ++-- 3 files changed, 63 insertions(+), 11 deletions(-) diff --git a/pallets/subtensor/src/epoch/math.rs b/pallets/subtensor/src/epoch/math.rs index 6a53cb135b..11930bf26e 100644 --- a/pallets/subtensor/src/epoch/math.rs +++ b/pallets/subtensor/src/epoch/math.rs @@ -246,6 +246,22 @@ pub fn is_topk(vector: &[I32F32], k: usize) -> Vec { result } +// Returns a bool vector where an item is true if the vector item is in topk values and is non-zero. +#[allow(dead_code, clippy::indexing_slicing)] +pub fn is_topk_nonzero(vector: &[I32F32], k: usize) -> Vec { + let n: usize = vector.len(); + let mut result: Vec = vector.iter().map(|&elem| elem != I32F32::from(0)).collect(); + if n < k { + return result; + } + let mut idxs: Vec = (0..n).collect(); + idxs.sort_by_key(|&idx| &vector[idx]); // ascending stable sort + for &idx in idxs.iter().take(n.saturating_sub(k)) { + result[idx] = false; + } + result +} + // Returns a normalized (sum to 1 except 0) copy of the input vector. #[allow(dead_code)] pub fn normalize(x: &[I32F32]) -> Vec { diff --git a/pallets/subtensor/src/epoch/run_epoch.rs b/pallets/subtensor/src/epoch/run_epoch.rs index 1b87388b85..c550135123 100644 --- a/pallets/subtensor/src/epoch/run_epoch.rs +++ b/pallets/subtensor/src/epoch/run_epoch.rs @@ -80,10 +80,26 @@ impl Pallet { log::trace!("hotkeys: {:?}", &hotkeys); // Access network stake as normalized vector. - let (mut total_stake, _alpha_stake, _tao_stake): (Vec, Vec, Vec) = + let (total_stake, _alpha_stake, _tao_stake): (Vec, Vec, Vec) = Self::get_stake_weights_for_network(netuid); - inplace_normalize_64(&mut total_stake); - let stake: Vec = vec_fixed64_to_fixed32(total_stake); + + // Get the minimum stake required. + let min_stake = Self::get_stake_threshold(); + + // Set stake of validators that doesn't meet the staking threshold to 0 as filter. + let mut filtered_stake: Vec = total_stake + .iter() + .map(|&s| { + if fixed64_to_u64(s) < min_stake { + return I64F64::from(0); + } + s + }) + .collect(); + log::debug!("Filtered stake: {:?}", &filtered_stake); + + inplace_normalize_64(&mut filtered_stake); + let stake: Vec = vec_fixed64_to_fixed32(filtered_stake); log::trace!("S: {:?}", &stake); // ======================= @@ -102,7 +118,8 @@ impl Pallet { log::trace!("max_allowed_validators: {:?}", max_allowed_validators); // Get new validator permits. - let new_validator_permits: Vec = is_topk(&stake, max_allowed_validators as usize); + let new_validator_permits: Vec = + is_topk_nonzero(&stake, max_allowed_validators as usize); log::trace!("new_validator_permits: {:?}", new_validator_permits); // ================== @@ -470,10 +487,26 @@ impl Pallet { log::debug!("hotkeys: {:?}", &hotkeys); // Access network stake as normalized vector. - let (mut total_stake, _alpha_stake, _tao_stake): (Vec, Vec, Vec) = + let (total_stake, _alpha_stake, _tao_stake): (Vec, Vec, Vec) = Self::get_stake_weights_for_network(netuid); - inplace_normalize_64(&mut total_stake); - let stake: Vec = vec_fixed64_to_fixed32(total_stake); + + // Get the minimum stake required. + let min_stake = Self::get_stake_threshold(); + + // Set stake of validators that doesn't meet the staking threshold to 0 as filter. + let mut filtered_stake: Vec = total_stake + .iter() + .map(|&s| { + if fixed64_to_u64(s) < min_stake { + return I64F64::from(0); + } + s + }) + .collect(); + log::debug!("Filtered stake: {:?}", &filtered_stake); + + inplace_normalize_64(&mut filtered_stake); + let stake: Vec = vec_fixed64_to_fixed32(filtered_stake); log::debug!("Normalised Stake: {:?}", &stake); // ======================= @@ -492,7 +525,8 @@ impl Pallet { log::trace!("max_allowed_validators: {:?}", max_allowed_validators); // Get new validator permits. - let new_validator_permits: Vec = is_topk(&stake, max_allowed_validators as usize); + let new_validator_permits: Vec = + is_topk_nonzero(&stake, max_allowed_validators as usize); log::trace!("new_validator_permits: {:?}", new_validator_permits); // ================== diff --git a/pallets/subtensor/src/tests/epoch.rs b/pallets/subtensor/src/tests/epoch.rs index a6e688625d..2557709912 100644 --- a/pallets/subtensor/src/tests/epoch.rs +++ b/pallets/subtensor/src/tests/epoch.rs @@ -2095,13 +2095,14 @@ fn test_deregistered_miner_bonds() { }); } -// Test that epoch assigns validator permits to highest stake uids, varies uid interleaving and stake values. +// Test that epoch assigns validator permits to highest stake uids that are over the stake threshold, varies uid interleaving and stake values. #[test] fn test_validator_permits() { let netuid: u16 = 1; let tempo: u16 = u16::MAX - 1; // high tempo to skip automatic epochs in on_initialize, use manual epochs instead for interleave in 0..3 { for (network_n, validators_n) in [(2, 1), (4, 2), (8, 4)] { + let min_stake = validators_n as u64; for assignment in 0..=1 { let (validators, servers) = distribute_nodes(validators_n as usize, network_n, interleave as usize); @@ -2132,6 +2133,7 @@ fn test_validator_permits() { netuid, network_n as u16, ); + SubtensorModule::set_stake_threshold(min_stake); // === Register [validator1, validator2, server1, server2] for key in 0..network_n as u64 { @@ -2173,7 +2175,7 @@ fn test_validator_permits() { SubtensorModule::epoch(netuid, 1_000_000_000); // run first epoch to set allowed validators for validator in &validators { assert_eq!( - correct, + stake[*validator as usize] >= min_stake, SubtensorModule::get_validator_permit_for_uid(netuid, *validator) ); } @@ -2211,7 +2213,7 @@ fn test_validator_permits() { } for server in &servers { assert_eq!( - correct, + (stake[*server as usize] + (2 * network_n as u64)) >= min_stake, SubtensorModule::get_validator_permit_for_uid(netuid, *server) ); } From 4e3f374b3f6297c6fe30ae9b7478d57fe6f00817 Mon Sep 17 00:00:00 2001 From: Keith Date: Tue, 13 May 2025 18:51:36 +0800 Subject: [PATCH 2/3] Set stake threshold to 0 in commit reveal test --- pallets/subtensor/src/tests/weights.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/pallets/subtensor/src/tests/weights.rs b/pallets/subtensor/src/tests/weights.rs index 14b80a0310..9c5bb3072b 100644 --- a/pallets/subtensor/src/tests/weights.rs +++ b/pallets/subtensor/src/tests/weights.rs @@ -2077,6 +2077,7 @@ fn test_commit_reveal_multiple_commits() { SubtensorModule::set_validator_permit_for_uid(netuid, 0, true); SubtensorModule::set_validator_permit_for_uid(netuid, 1, true); SubtensorModule::set_commit_reveal_weights_enabled(netuid, true); + SubtensorModule::set_stake_threshold(0); // 1. Commit 10 times successfully let mut commit_info = Vec::new(); From 17a81adf47189ab050ec80abf36596c17b40e6e2 Mon Sep 17 00:00:00 2001 From: Keith Date: Tue, 13 May 2025 22:12:03 +0800 Subject: [PATCH 3/3] Set validator stake to 1 during testing --- pallets/subtensor/src/tests/weights.rs | 294 ++++++++++++++++++++++++- 1 file changed, 293 insertions(+), 1 deletion(-) diff --git a/pallets/subtensor/src/tests/weights.rs b/pallets/subtensor/src/tests/weights.rs index 9c5bb3072b..3d240750cf 100644 --- a/pallets/subtensor/src/tests/weights.rs +++ b/pallets/subtensor/src/tests/weights.rs @@ -677,6 +677,13 @@ fn test_weights_err_setting_weights_too_fast() { SubtensorModule::get_uid_for_net_and_hotkey(netuid, &hotkey_account_id) .expect("Not registered."); SubtensorModule::set_validator_permit_for_uid(netuid, neuron_uid, true); + SubtensorModule::add_balance_to_coldkey_account(&U256::from(66), 1); + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &hotkey_account_id, + &(U256::from(66)), + netuid, + 1, + ); SubtensorModule::set_weights_set_rate_limit(netuid, 10); assert_eq!(SubtensorModule::get_weights_set_rate_limit(netuid), 10); @@ -753,6 +760,7 @@ fn test_weights_err_has_duplicate_ids() { let salt: Vec = vec![1, 2, 3, 4, 5, 6, 7, 8]; add_network(netuid, tempo, 0); + SubtensorModule::set_stake_threshold(0); SubtensorModule::set_max_allowed_uids(netuid, 100); // Allow many registrations per block. SubtensorModule::set_max_registrations_per_block(netuid, 100); // Allow many registrations per block. SubtensorModule::set_target_registrations_per_interval(netuid, 100); // Allow many registrations per block. @@ -762,6 +770,13 @@ fn test_weights_err_has_duplicate_ids() { SubtensorModule::get_uid_for_net_and_hotkey(netuid, &hotkey_account_id) .expect("Not registered."); SubtensorModule::set_validator_permit_for_uid(netuid, neuron_uid, true); + SubtensorModule::add_balance_to_coldkey_account(&U256::from(77), 1); + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &hotkey_account_id, + &(U256::from(77)), + netuid, + 1, + ); // uid 1 register_ok_neuron(netuid, U256::from(1), U256::from(1), 100_000); @@ -933,7 +948,15 @@ fn test_set_weights_err_invalid_uid() { let neuron_uid: u16 = SubtensorModule::get_uid_for_net_and_hotkey(netuid, &hotkey_account_id) .expect("Not registered."); + SubtensorModule::set_stake_threshold(0); SubtensorModule::set_validator_permit_for_uid(netuid, neuron_uid, true); + SubtensorModule::add_balance_to_coldkey_account(&U256::from(66), 1); + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &hotkey_account_id, + &(U256::from(66)), + netuid, + 1, + ); let weight_keys: Vec = vec![9999]; // Does not exist let weight_values: Vec = vec![88]; // random value let result = @@ -958,6 +981,13 @@ fn test_set_weight_not_enough_values() { .expect("Not registered."); SubtensorModule::set_validator_permit_for_uid(netuid, neuron_uid, true); SubtensorModule::set_max_weight_limit(netuid, u16::MAX); + SubtensorModule::add_balance_to_coldkey_account(&U256::from(2), 1); + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &account_id, + &(U256::from(2)), + netuid, + 1, + ); register_ok_neuron(1, U256::from(3), U256::from(4), 300000); SubtensorModule::set_min_allowed_weights(netuid, 2); @@ -1059,8 +1089,16 @@ fn test_set_weights_sum_larger_than_u16_max() { register_ok_neuron(1, U256::from(1), U256::from(2), 100_000); let neuron_uid: u16 = SubtensorModule::get_uid_for_net_and_hotkey(netuid, &U256::from(1)) .expect("Not registered."); + SubtensorModule::set_stake_threshold(0); SubtensorModule::set_validator_permit_for_uid(netuid, neuron_uid, true); SubtensorModule::set_max_weight_limit(netuid, u16::MAX); + SubtensorModule::add_balance_to_coldkey_account(&U256::from(2), 1); + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &(U256::from(1)), + &(U256::from(2)), + netuid, + 1, + ); register_ok_neuron(1, U256::from(3), U256::from(4), 300_000); SubtensorModule::set_min_allowed_weights(1, 2); @@ -1548,10 +1586,25 @@ fn test_commit_reveal_weights_ok() { // Register neurons and set up configurations register_ok_neuron(netuid, U256::from(3), U256::from(4), 300_000); register_ok_neuron(netuid, U256::from(1), U256::from(2), 100_000); + SubtensorModule::set_stake_threshold(0); SubtensorModule::set_weights_set_rate_limit(netuid, 5); SubtensorModule::set_validator_permit_for_uid(netuid, 0, true); SubtensorModule::set_validator_permit_for_uid(netuid, 1, true); SubtensorModule::set_commit_reveal_weights_enabled(netuid, true); + SubtensorModule::add_balance_to_coldkey_account(&U256::from(0), 1); + SubtensorModule::add_balance_to_coldkey_account(&U256::from(1), 1); + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &(U256::from(0)), + &(U256::from(0)), + netuid, + 1, + ); + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &(U256::from(1)), + &(U256::from(1)), + netuid, + 1, + ); // Commit at block 0 assert_ok!(SubtensorModule::commit_weights( @@ -1601,10 +1654,25 @@ fn test_commit_reveal_tempo_interval() { register_ok_neuron(netuid, U256::from(3), U256::from(4), 300_000); register_ok_neuron(netuid, U256::from(1), U256::from(2), 100_000); + SubtensorModule::set_stake_threshold(0); SubtensorModule::set_weights_set_rate_limit(netuid, 5); SubtensorModule::set_validator_permit_for_uid(netuid, 0, true); SubtensorModule::set_validator_permit_for_uid(netuid, 1, true); SubtensorModule::set_commit_reveal_weights_enabled(netuid, true); + SubtensorModule::add_balance_to_coldkey_account(&U256::from(0), 1); + SubtensorModule::add_balance_to_coldkey_account(&U256::from(1), 1); + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &(U256::from(0)), + &(U256::from(0)), + netuid, + 1, + ); + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &(U256::from(1)), + &(U256::from(1)), + netuid, + 1, + ); // Commit at block 0 assert_ok!(SubtensorModule::commit_weights( @@ -1722,9 +1790,24 @@ fn test_commit_reveal_hash() { register_ok_neuron(netuid, U256::from(3), U256::from(4), 300_000); register_ok_neuron(netuid, U256::from(1), U256::from(2), 100_000); + SubtensorModule::set_stake_threshold(0); SubtensorModule::set_weights_set_rate_limit(netuid, 5); SubtensorModule::set_validator_permit_for_uid(netuid, 0, true); SubtensorModule::set_validator_permit_for_uid(netuid, 1, true); + SubtensorModule::add_balance_to_coldkey_account(&U256::from(0), 1); + SubtensorModule::add_balance_to_coldkey_account(&U256::from(1), 1); + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &(U256::from(0)), + &(U256::from(0)), + netuid, + 1, + ); + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &(U256::from(1)), + &(U256::from(1)), + netuid, + 1, + ); SubtensorModule::set_commit_reveal_weights_enabled(netuid, true); @@ -1807,9 +1890,24 @@ fn test_commit_reveal_disabled_or_enabled() { register_ok_neuron(netuid, U256::from(3), U256::from(4), 300_000); register_ok_neuron(netuid, U256::from(1), U256::from(2), 100_000); + SubtensorModule::set_stake_threshold(0); SubtensorModule::set_weights_set_rate_limit(netuid, 5); SubtensorModule::set_validator_permit_for_uid(netuid, 0, true); SubtensorModule::set_validator_permit_for_uid(netuid, 1, true); + SubtensorModule::add_balance_to_coldkey_account(&U256::from(0), 1); + SubtensorModule::add_balance_to_coldkey_account(&U256::from(1), 1); + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &(U256::from(0)), + &(U256::from(0)), + netuid, + 1, + ); + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &(U256::from(1)), + &(U256::from(1)), + netuid, + 1, + ); // Disable commit/reveal SubtensorModule::set_commit_reveal_weights_enabled(netuid, false); @@ -1869,9 +1967,24 @@ fn test_toggle_commit_reveal_weights_and_set_weights() { register_ok_neuron(netuid, U256::from(3), U256::from(4), 300_000); register_ok_neuron(netuid, U256::from(1), U256::from(2), 100_000); + SubtensorModule::set_stake_threshold(0); SubtensorModule::set_validator_permit_for_uid(netuid, 0, true); SubtensorModule::set_validator_permit_for_uid(netuid, 1, true); SubtensorModule::set_weights_set_rate_limit(netuid, 5); + SubtensorModule::add_balance_to_coldkey_account(&U256::from(0), 1); + SubtensorModule::add_balance_to_coldkey_account(&U256::from(1), 1); + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &(U256::from(0)), + &(U256::from(0)), + netuid, + 1, + ); + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &(U256::from(1)), + &(U256::from(1)), + netuid, + 1, + ); // Enable commit/reveal SubtensorModule::set_commit_reveal_weights_enabled(netuid, true); @@ -1939,10 +2052,25 @@ fn test_tempo_change_during_commit_reveal_process() { register_ok_neuron(netuid, U256::from(3), U256::from(4), 300_000); register_ok_neuron(netuid, U256::from(1), U256::from(2), 100_000); + SubtensorModule::set_stake_threshold(0); SubtensorModule::set_weights_set_rate_limit(netuid, 5); SubtensorModule::set_validator_permit_for_uid(netuid, 0, true); SubtensorModule::set_validator_permit_for_uid(netuid, 1, true); SubtensorModule::set_commit_reveal_weights_enabled(netuid, true); + SubtensorModule::add_balance_to_coldkey_account(&U256::from(0), 1); + SubtensorModule::add_balance_to_coldkey_account(&U256::from(1), 1); + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &(U256::from(0)), + &(U256::from(0)), + netuid, + 1, + ); + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &(U256::from(1)), + &(U256::from(1)), + netuid, + 1, + ); assert_ok!(SubtensorModule::commit_weights( RuntimeOrigin::signed(hotkey), @@ -2073,11 +2201,25 @@ fn test_commit_reveal_multiple_commits() { // Setup the network and neurons register_ok_neuron(netuid, U256::from(3), U256::from(4), 300_000); register_ok_neuron(netuid, U256::from(1), U256::from(2), 100_000); + SubtensorModule::set_stake_threshold(0); SubtensorModule::set_weights_set_rate_limit(netuid, 0); SubtensorModule::set_validator_permit_for_uid(netuid, 0, true); SubtensorModule::set_validator_permit_for_uid(netuid, 1, true); SubtensorModule::set_commit_reveal_weights_enabled(netuid, true); - SubtensorModule::set_stake_threshold(0); + SubtensorModule::add_balance_to_coldkey_account(&U256::from(0), 1); + SubtensorModule::add_balance_to_coldkey_account(&U256::from(1), 1); + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &(U256::from(0)), + &(U256::from(0)), + netuid, + 1, + ); + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &(U256::from(1)), + &(U256::from(1)), + netuid, + 1, + ); // 1. Commit 10 times successfully let mut commit_info = Vec::new(); @@ -2464,8 +2606,23 @@ fn test_expired_commits_handling_in_commit_and_reveal() { // Register neurons register_ok_neuron(netuid, U256::from(3), U256::from(4), 300_000); register_ok_neuron(netuid, U256::from(1), U256::from(2), 100_000); + SubtensorModule::set_stake_threshold(0); SubtensorModule::set_validator_permit_for_uid(netuid, 0, true); SubtensorModule::set_validator_permit_for_uid(netuid, 1, true); + SubtensorModule::add_balance_to_coldkey_account(&U256::from(0), 1); + SubtensorModule::add_balance_to_coldkey_account(&U256::from(1), 1); + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &(U256::from(0)), + &(U256::from(0)), + netuid, + 1, + ); + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &(U256::from(1)), + &(U256::from(1)), + netuid, + 1, + ); // 1. Commit 5 times in epoch 0 let mut commit_info = Vec::new(); @@ -2647,8 +2804,23 @@ fn test_reveal_at_exact_epoch() { register_ok_neuron(netuid, U256::from(3), U256::from(4), 300_000); register_ok_neuron(netuid, U256::from(1), U256::from(2), 100_000); + SubtensorModule::set_stake_threshold(0); SubtensorModule::set_validator_permit_for_uid(netuid, 0, true); SubtensorModule::set_validator_permit_for_uid(netuid, 1, true); + SubtensorModule::add_balance_to_coldkey_account(&U256::from(0), 1); + SubtensorModule::add_balance_to_coldkey_account(&U256::from(1), 1); + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &(U256::from(0)), + &(U256::from(0)), + netuid, + 1, + ); + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &(U256::from(1)), + &(U256::from(1)), + netuid, + 1, + ); let reveal_periods: Vec = vec![0, 1, 2, 7, 40, 86, 100]; @@ -2796,8 +2968,23 @@ fn test_tempo_and_reveal_period_change_during_commit_reveal_process() { register_ok_neuron(netuid, U256::from(3), U256::from(4), 300_000); register_ok_neuron(netuid, U256::from(1), U256::from(2), 100_000); + SubtensorModule::set_stake_threshold(0); SubtensorModule::set_validator_permit_for_uid(netuid, 0, true); SubtensorModule::set_validator_permit_for_uid(netuid, 1, true); + SubtensorModule::add_balance_to_coldkey_account(&U256::from(0), 1); + SubtensorModule::add_balance_to_coldkey_account(&U256::from(1), 1); + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &(U256::from(0)), + &(U256::from(0)), + netuid, + 1, + ); + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &(U256::from(1)), + &(U256::from(1)), + netuid, + 1, + ); // Step 1: Commit weights assert_ok!(SubtensorModule::commit_weights( @@ -2971,8 +3158,23 @@ fn test_commit_reveal_order_enforcement() { register_ok_neuron(netuid, U256::from(3), U256::from(4), 300_000); register_ok_neuron(netuid, U256::from(1), U256::from(2), 100_000); + SubtensorModule::set_stake_threshold(0); SubtensorModule::set_validator_permit_for_uid(netuid, 0, true); SubtensorModule::set_validator_permit_for_uid(netuid, 1, true); + SubtensorModule::add_balance_to_coldkey_account(&U256::from(0), 1); + SubtensorModule::add_balance_to_coldkey_account(&U256::from(1), 1); + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &(U256::from(0)), + &(U256::from(0)), + netuid, + 1, + ); + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &(U256::from(1)), + &(U256::from(1)), + netuid, + 1, + ); // Commit three times: A, B, C let mut commit_info = Vec::new(); @@ -3228,8 +3430,23 @@ fn test_successful_batch_reveal() { register_ok_neuron(netuid, U256::from(3), U256::from(4), 300_000); register_ok_neuron(netuid, hotkey, U256::from(2), 100_000); + SubtensorModule::set_stake_threshold(0); SubtensorModule::set_validator_permit_for_uid(netuid, 0, true); SubtensorModule::set_validator_permit_for_uid(netuid, 1, true); + SubtensorModule::add_balance_to_coldkey_account(&U256::from(0), 1); + SubtensorModule::add_balance_to_coldkey_account(&U256::from(1), 1); + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &(U256::from(0)), + &(U256::from(0)), + netuid, + 1, + ); + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &(U256::from(1)), + &(U256::from(1)), + netuid, + 1, + ); // 1. Commit multiple times let mut commit_info = Vec::new(); @@ -3291,8 +3508,23 @@ fn test_batch_reveal_with_expired_commits() { register_ok_neuron(netuid, U256::from(3), U256::from(4), 300_000); register_ok_neuron(netuid, hotkey, U256::from(2), 100_000); + SubtensorModule::set_stake_threshold(0); SubtensorModule::set_validator_permit_for_uid(netuid, 0, true); SubtensorModule::set_validator_permit_for_uid(netuid, 1, true); + SubtensorModule::add_balance_to_coldkey_account(&U256::from(0), 1); + SubtensorModule::add_balance_to_coldkey_account(&U256::from(1), 1); + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &(U256::from(0)), + &(U256::from(0)), + netuid, + 1, + ); + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &(U256::from(1)), + &(U256::from(1)), + netuid, + 1, + ); let mut commit_info = Vec::new(); @@ -3693,8 +3925,23 @@ fn test_batch_reveal_with_out_of_order_commits() { register_ok_neuron(netuid, U256::from(3), U256::from(4), 300_000); register_ok_neuron(netuid, hotkey, U256::from(2), 100_000); + SubtensorModule::set_stake_threshold(0); SubtensorModule::set_validator_permit_for_uid(netuid, 0, true); SubtensorModule::set_validator_permit_for_uid(netuid, 1, true); + SubtensorModule::add_balance_to_coldkey_account(&U256::from(0), 1); + SubtensorModule::add_balance_to_coldkey_account(&U256::from(1), 1); + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &(U256::from(0)), + &(U256::from(0)), + netuid, + 1, + ); + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &(U256::from(1)), + &(U256::from(1)), + netuid, + 1, + ); // 1. Commit multiple times (A, B, C) let mut commit_info = Vec::new(); @@ -4081,10 +4328,25 @@ fn test_get_reveal_blocks() { // **5. Register Neurons and Configure the Network** register_ok_neuron(netuid, U256::from(3), U256::from(4), 300_000); register_ok_neuron(netuid, U256::from(1), U256::from(2), 100_000); + SubtensorModule::set_stake_threshold(0); SubtensorModule::set_weights_set_rate_limit(netuid, 5); SubtensorModule::set_validator_permit_for_uid(netuid, 0, true); SubtensorModule::set_validator_permit_for_uid(netuid, 1, true); SubtensorModule::set_commit_reveal_weights_enabled(netuid, true); + SubtensorModule::add_balance_to_coldkey_account(&U256::from(0), 1); + SubtensorModule::add_balance_to_coldkey_account(&U256::from(1), 1); + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &(U256::from(0)), + &(U256::from(0)), + netuid, + 1, + ); + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &(U256::from(1)), + &(U256::from(1)), + netuid, + 1, + ); // **6. Commit Weights at Block 0** assert_ok!(SubtensorModule::commit_weights( @@ -4200,10 +4462,25 @@ fn test_commit_weights_rate_limit() { register_ok_neuron(netuid, U256::from(3), U256::from(4), 300_000); register_ok_neuron(netuid, U256::from(1), U256::from(2), 100_000); + SubtensorModule::set_stake_threshold(0); SubtensorModule::set_weights_set_rate_limit(netuid, 10); // Rate limit is 10 blocks SubtensorModule::set_validator_permit_for_uid(netuid, 0, true); SubtensorModule::set_validator_permit_for_uid(netuid, 1, true); SubtensorModule::set_commit_reveal_weights_enabled(netuid, true); + SubtensorModule::add_balance_to_coldkey_account(&U256::from(0), 1); + SubtensorModule::add_balance_to_coldkey_account(&U256::from(1), 1); + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &(U256::from(0)), + &(U256::from(0)), + netuid, + 1, + ); + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &(U256::from(1)), + &(U256::from(1)), + netuid, + 1, + ); let neuron_uid = SubtensorModule::get_uid_for_net_and_hotkey(netuid, &hotkey).expect("expected uid"); @@ -4368,6 +4645,7 @@ fn test_reveal_crv3_commits_success() { add_network(netuid, 5, 0); register_ok_neuron(netuid, hotkey1, U256::from(3), 100_000); register_ok_neuron(netuid, hotkey2, U256::from(4), 100_000); + SubtensorModule::set_stake_threshold(0); SubtensorModule::set_weights_set_rate_limit(netuid, 0); SubtensorModule::set_commit_reveal_weights_enabled(netuid, true); SubtensorModule::set_reveal_period(netuid, 3); @@ -4379,6 +4657,20 @@ fn test_reveal_crv3_commits_success() { SubtensorModule::set_validator_permit_for_uid(netuid, neuron_uid1, true); SubtensorModule::set_validator_permit_for_uid(netuid, neuron_uid2, true); + SubtensorModule::add_balance_to_coldkey_account(&U256::from(3), 1); + SubtensorModule::add_balance_to_coldkey_account(&U256::from(4), 1); + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &hotkey1, + &(U256::from(3)), + netuid, + 1, + ); + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &hotkey2, + &(U256::from(4)), + netuid, + 1, + ); let version_key = SubtensorModule::get_weights_version_key(netuid);