Add ValidatorTimeout hyperparameter

pallets/subtensor/src/benchmarks.rs

@@ -455,6 +455,16 @@ benchmarks! {
 
   }: sudo_set_min_allowed_weights(RawOrigin::<AccountIdOf<T>>::Root, netuid, min_allowed_weights)
 
+  benchmark_sudo_set_validator_timeout{
+    let netuid: u16 = 1;
+    let tempo: u16 = 1;
+    let modality: u16 = 0;
+    let validator_timeout: u16 = 10;
+
+    assert_ok!( Subtensor::<T>::do_add_network( RawOrigin::Root.into(), netuid.try_into().unwrap(), tempo.into(), modality.into()));
+
+  }: sudo_set_validator_timeout(RawOrigin::<AccountIdOf<T>>::Root, netuid, validator_timeout)
+
   benchmark_sudo_set_validator_batch_size{
     let netuid: u16 = 1;
     let tempo: u16 = 1;

pallets/subtensor/src/lib.rs

@@ -161,6 +161,8 @@ pub mod pallet {
 		type InitialKappa: Get<u16>;		
 		#[pallet::constant] // Max UID constant.
 		type InitialMaxAllowedUids: Get<u16>;
+		#[pallet::constant] // Default validator timeout.
+		type InitialValidatorTimeout: Get<u16>;
 		#[pallet::constant] // Default batch size.
 		type InitialValidatorBatchSize: Get<u16>;
 		#[pallet::constant] // Default Sequence length.
@@ -435,6 +437,8 @@ pub mod pallet {
 	#[pallet::type_value] 
 	pub fn DefaultValidatorPruneLen<T: Config>() -> u64 { T::InitialValidatorPruneLen::get() }
 	#[pallet::type_value] 
+	pub fn DefaultValidatorTimeout<T: Config>() -> u16 { T::InitialValidatorTimeout::get() }
+	#[pallet::type_value] 
 	pub fn DefaultValidatorBatchSize<T: Config>() -> u16 { T::InitialValidatorBatchSize::get() }
 	#[pallet::type_value] 
 	pub fn DefaultValidatorSequenceLen<T: Config>() -> u16 { T::InitialValidatorSequenceLen::get() }
@@ -484,6 +488,8 @@ pub mod pallet {
 	pub type AdjustmentInterval<T> = StorageMap<_, Identity, u16, u16, ValueQuery, DefaultAdjustmentInterval<T> >;
 	#[pallet::storage] // --- MAP ( netuid ) --> bonds_moving_average
 	pub type BondsMovingAverage<T> = StorageMap<_, Identity, u16, u64, ValueQuery, DefaultBondsMovingAverage<T> >;
+	#[pallet::storage] // --- MAP ( netuid ) --> validator_timeout
+	pub type ValidatorTimeout<T> = StorageMap<_, Identity, u16, u16, ValueQuery, DefaultValidatorTimeout<T> >;
 	#[pallet::storage] // --- MAP ( netuid ) --> validator_batch_size
 	pub type ValidatorBatchSize<T> = StorageMap<_, Identity, u16, u16, ValueQuery, DefaultValidatorBatchSize<T> >;
 	#[pallet::storage] // --- MAP ( netuid ) --> weights_set_rate_limit
@@ -583,6 +589,7 @@ pub mod pallet {
 		RhoSet( u16, u16 ), // --- Event created when Rho value is set.
 		KappaSet( u16, u16 ), // --- Event created when Kappa is set for a subnet.
 		MinAllowedWeightSet( u16, u16 ), // --- Event created when minimun allowed weight is set for a subnet.
+		ValidatorTimeoutSet( u16, u16 ), // --- Event created when validator timeout is set for a subnet.
 		ValidatorBatchSizeSet( u16, u16 ), // --- Event created when validator batch size is set for a subnet.
 		ValidatorSequenceLengthSet( u16, u16 ), // --- Event created when validator sequence length is set for a subnet.
 		ValidatorEpochPerResetSet( u16, u16 ), // --- Event created when validator epoch per reset is set for a subnet.
@@ -1718,6 +1725,14 @@ pub mod pallet {
 		pub fn sudo_remove_votes(origin: OriginFor<T>, who: T::AccountId ) -> DispatchResult {
 			Self::do_remove_votes(origin, &who)
 		}  
+
+		#[pallet::call_index(58)]
+		#[pallet::weight((Weight::from_ref_time(14_000_000)
+		.saturating_add(T::DbWeight::get().reads(1))
+		.saturating_add(T::DbWeight::get().writes(1)), DispatchClass::Operational, Pays::No))]
+		pub fn sudo_set_validator_timeout( origin:OriginFor<T>, netuid: u16, validator_timeout: u16 ) -> DispatchResult {
+			Self::do_sudo_set_validator_timeout( origin, netuid, validator_timeout )
+		}
 	}	
 
 	// ---- Subtensor helper functions.

pallets/subtensor/src/networks.rs

@@ -275,6 +275,7 @@ impl<T: Config> Pallet<T> {
         if !MaxWeightsLimit::<T>::contains_key( netuid ) { MaxWeightsLimit::<T>::insert( netuid, MaxWeightsLimit::<T>::get( netuid ));}
         if !ValidatorEpochLen::<T>::contains_key( netuid ) { ValidatorEpochLen::<T>::insert( netuid, ValidatorEpochLen::<T>::get( netuid ));}
         if !MinAllowedWeights::<T>::contains_key( netuid ) { MinAllowedWeights::<T>::insert( netuid, MinAllowedWeights::<T>::get( netuid )); }
+        if !ValidatorTimeout::<T>::contains_key( netuid ) { ValidatorTimeout::<T>::insert( netuid, ValidatorTimeout::<T>::get( netuid ));}
         if !ValidatorBatchSize::<T>::contains_key( netuid ) { ValidatorBatchSize::<T>::insert( netuid, ValidatorBatchSize::<T>::get( netuid ));}
         if !ValidatorEpochsPerReset::<T>::contains_key( netuid ) { ValidatorEpochsPerReset::<T>::insert( netuid, ValidatorEpochsPerReset::<T>::get( netuid ));}
         if !ValidatorSequenceLength::<T>::contains_key( netuid ) { ValidatorSequenceLength::<T>::insert( netuid, ValidatorSequenceLength::<T>::get( netuid ));}
@@ -316,6 +317,7 @@ impl<T: Config> Pallet<T> {
         MaxWeightsLimit::<T>::remove( netuid );
         ValidatorEpochLen::<T>::remove( netuid );
         MinAllowedWeights::<T>::remove( netuid );
+        ValidatorTimeout::<T>::remove( netuid );
         ValidatorBatchSize::<T>::remove( netuid );
         ValidatorEpochsPerReset::<T>::remove( netuid );
         ValidatorSequenceLength::<T>::remove( netuid );

pallets/subtensor/src/subnet_info.rs

@@ -13,6 +13,7 @@ pub struct SubnetInfo {
     kappa: Compact<u16>,
     difficulty: Compact<u64>,
     immunity_period: Compact<u16>,
+    validator_timeout: Compact<u16>,
     validator_batch_size: Compact<u16>,
     validator_sequence_length: Compact<u16>,
     validator_epochs_per_reset: Compact<u16>,
@@ -42,6 +43,7 @@ impl<T: Config> Pallet<T> {
         let kappa = Self::get_kappa(netuid);
         let difficulty = Self::get_difficulty_as_u64(netuid);
         let immunity_period = Self::get_immunity_period(netuid);
+        let validator_timeout = Self::get_validator_timeout(netuid);
         let validator_batch_size = Self::get_validator_batch_size(netuid);
         let validator_sequence_length = Self::get_validator_sequence_length(netuid);
         let validator_epochs_per_reset = Self::get_validator_epochs_per_reset(netuid);
@@ -72,6 +74,7 @@ impl<T: Config> Pallet<T> {
             difficulty: difficulty.into(),
             immunity_period: immunity_period.into(),
             netuid: netuid.into(),
+            validator_timeout: validator_timeout.into(),
             validator_batch_size: validator_batch_size.into(),
             validator_sequence_length: validator_sequence_length.into(),
             validator_epochs_per_reset: validator_epochs_per_reset.into(),

pallets/subtensor/src/utils.rs

@@ -318,6 +318,17 @@ impl<T: Config> Pallet<T> {
         Ok(())
     }
 
+    pub fn get_validator_timeout( netuid: u16 ) -> u16 { ValidatorTimeout::<T>::get( netuid ) }
+    pub fn set_validator_timeout( netuid: u16, validator_timeout: u16 ) { ValidatorTimeout::<T>::insert( netuid, validator_timeout ); }
+    pub fn do_sudo_set_validator_timeout( origin:T::RuntimeOrigin, netuid: u16, validator_timeout: u16 ) -> DispatchResult {
+        ensure_root( origin )?;
+        ensure!(Self::if_subnet_exist(netuid), Error::<T>::NetworkDoesNotExist);
+        Self::set_validator_timeout( netuid, validator_timeout );
+        log::info!("ValidatorTimeoutSet( netuid: {:?} validator_timeout: {:?} ) ", netuid, validator_timeout);
+        Self::deposit_event(Event::ValidatorTimeoutSet(netuid, validator_timeout));
+        Ok(())
+    }
+
     pub fn get_validator_batch_size( netuid: u16 ) -> u16 { ValidatorBatchSize::<T>::get( netuid ) }
     pub fn set_validator_batch_size( netuid: u16, validator_batch_size: u16 ) { ValidatorBatchSize::<T>::insert( netuid, validator_batch_size ); }
     pub fn do_sudo_set_validator_batch_size( origin:T::RuntimeOrigin, netuid: u16, validator_batch_size: u16 ) -> DispatchResult {

pallets/subtensor/tests/mock.rs

@@ -131,6 +131,7 @@ parameter_types! {
 	pub const InitialMinBurn: u64 = 0; 
 	pub const InitialMaxBurn: u64 = 1_000_000_000;
 
+	pub const InitialValidatorTimeout: u16 = 10;
 	pub const InitialValidatorBatchSize: u16 = 10;
 	pub const InitialValidatorSequenceLen: u16 = 10;
 	pub const InitialValidatorPruneLen: u64 = 0;
@@ -316,6 +317,7 @@ impl pallet_subtensor::Config for Test {
 	type InitialRho = InitialRho;
 	type InitialKappa = InitialKappa;
 	type InitialMaxAllowedUids = InitialMaxAllowedUids;
+	type InitialValidatorTimeout = InitialValidatorTimeout;
 	type InitialValidatorBatchSize = InitialValidatorBatchSize;
 	type InitialValidatorSequenceLen = InitialValidatorSequenceLen;
 	type InitialValidatorPruneLen = InitialValidatorPruneLen;

pallets/subtensor/tests/sudo.rs

@@ -28,6 +28,7 @@ fn test_defaults() {
         assert_eq!(SubtensorModule::get_min_allowed_weights(netuid), 0);
         assert_eq!(SubtensorModule::get_adjustment_interval(netuid), 100);
         assert_eq!(SubtensorModule::get_bonds_moving_average(netuid), 900_000);
+        assert_eq!(SubtensorModule::get_validator_timeout(netuid), 10);
         assert_eq!(SubtensorModule::get_validator_batch_size(netuid), 10);
         assert_eq!(SubtensorModule::get_last_adjustment_block(netuid), 0);
         assert_eq!(SubtensorModule::get_last_mechanism_step_block(netuid), 0);
@@ -751,6 +752,42 @@ fn test_sudo_set_validator_sequence_length() {
     });
 }
 
+#[test]
+fn test_sudo_set_validator_timeout() {
+    new_test_ext().execute_with(|| {
+        let netuid: u16 = 1;
+        let to_be_set: u16 = 10;
+        let init_value: u16 = SubtensorModule::get_validator_timeout(netuid);
+        add_network(netuid, 10, 0);
+        assert_eq!(
+            SubtensorModule::sudo_set_validator_timeout(
+                <<Test as Config>::RuntimeOrigin>::signed(U256::from(0)),
+                netuid,
+                to_be_set
+            ),
+            Err(DispatchError::BadOrigin.into())
+        );
+        assert_eq!(
+            SubtensorModule::sudo_set_validator_timeout(
+                <<Test as Config>::RuntimeOrigin>::root(),
+                netuid + 1,
+                to_be_set
+            ),
+            Err(Error::<Test>::NetworkDoesNotExist.into())
+        );
+        assert_eq!(
+            SubtensorModule::get_validator_timeout(netuid),
+            init_value
+        );
+        assert_ok!(SubtensorModule::sudo_set_validator_timeout(
+            <<Test as Config>::RuntimeOrigin>::root(),
+            netuid,
+            to_be_set
+        ));
+        assert_eq!(SubtensorModule::get_validator_timeout(netuid), to_be_set);
+    });
+}
+
 #[test]
 fn test_sudo_set_validator_batch_size() {
     new_test_ext().execute_with(|| {

runtime/src/lib.rs

@@ -500,6 +500,7 @@ parameter_types! {
     pub const SubtensorInitialMinAllowedWeights: u16 = 1024;
     pub const SubtensorInitialEmissionValue: u16 = 0;
     pub const SubtensorInitialMaxWeightsLimit: u16 = 1000; // 1000/2^16 = 0.015
+    pub const SubtensorInitialValidatorTimeout: u16 = 10;
     pub const SubtensorInitialValidatorBatchSize: u16 = 32; // 32
     pub const SubtensorInitialValidatorSequenceLen: u16 = 256; // 256
     pub const SubtensorInitialValidatorEpochLen: u16 = 100;
@@ -548,6 +549,7 @@ impl pallet_subtensor::Config for Runtime {
 	type InitialMinAllowedWeights = SubtensorInitialMinAllowedWeights;
 	type InitialEmissionValue = SubtensorInitialEmissionValue;
 	type InitialMaxWeightsLimit = SubtensorInitialMaxWeightsLimit;
+	type InitialValidatorTimeout = SubtensorInitialValidatorTimeout;
 	type InitialValidatorBatchSize = SubtensorInitialValidatorBatchSize;
 	type InitialValidatorSequenceLen = SubtensorInitialValidatorSequenceLen;
 	type InitialValidatorEpochLen = SubtensorInitialValidatorEpochLen;