Validator cut [WIP]

pallets/admin-utils/src/lib.rs

@@ -1898,6 +1898,32 @@ pub mod pallet {
             );
             Ok(())
         }
+
+        /// Sets the validator cut for a subnet.
+        /// Only callable by subnet owner or root.
+        #[pallet::call_index(78)]
+        #[pallet::weight(Weight::from_parts(15_000_000, 0)
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(1_u64))
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)))]
+        pub fn sudo_set_validator_cut(
+            origin: OriginFor<T>,
+            netuid: NetUid,
+            cut: u16,
+        ) -> DispatchResult {
+            let maybe_owner = pallet_subtensor::Pallet::<T>::ensure_sn_owner_or_root_with_limits(
+                origin,
+                netuid,
+                &[TransactionType::OwnerHyperparamUpdate],
+            )?;
+            pallet_subtensor::Pallet::<T>::set_validator_cut(netuid, cut);
+            log::debug!("ValidatorCutSet( netuid: {netuid:?}, cut: {cut:?} ) ");
+            pallet_subtensor::Pallet::<T>::record_owner_rl(
+                maybe_owner,
+                netuid,
+                &[TransactionType::OwnerHyperparamUpdate],
+            );
+            Ok(())
+        }
     }
 }
 

pallets/admin-utils/src/tests/mod.rs

@@ -2269,3 +2269,121 @@ fn test_sudo_set_subsubnet_count() {
         ));
     });
 }
+
+#[test]
+fn test_get_validator_cut() {
+    new_test_ext().execute_with(|| {
+        let netuid = NetUid::from(1);
+        let expected_cut: u16 = 5000; // 50% cut
+
+        // Set up a network
+        add_network(netuid, 10);
+
+        // Set a validator cut value
+        SubtensorModule::set_validator_cut(netuid, expected_cut);
+
+        // Test that we can retrieve the value
+        let retrieved_cut = SubtensorModule::get_validator_cut(netuid);
+        assert_eq!(retrieved_cut, expected_cut);
+    });
+}
+
+#[test]
+fn test_set_validator_cut() {
+    new_test_ext().execute_with(|| {
+        let netuid = NetUid::from(2);
+        let initial_cut: u16 = pallet_subtensor::DefaultValidatorCut::<Test>::get();
+        let new_cut: u16 = 7500; // 75% cut
+
+        // Set up a network
+        add_network(netuid, 10);
+
+        // Verify initial value
+        assert_eq!(SubtensorModule::get_validator_cut(netuid), initial_cut);
+
+        // Set new validator cut
+        SubtensorModule::set_validator_cut(netuid, new_cut);
+
+        // Verify the value was set correctly
+        assert_eq!(SubtensorModule::get_validator_cut(netuid), new_cut);
+    });
+}
+
+#[test]
+fn test_sudo_set_validator_cut() {
+    new_test_ext().execute_with(|| {
+        let netuid = NetUid::from(3);
+        let to_be_set: u16 = 4200; // 42% cut
+
+        // Set up a network
+        add_network(netuid, 10);
+
+        let sn_owner = U256::from(1324);
+        // Set the Subnet Owner
+        SubnetOwner::<Test>::insert(netuid, sn_owner);
+
+        let init_value = SubtensorModule::get_validator_cut(netuid);
+
+        // Test that non-authorized origin fails (using a regular signed origin)
+        assert_eq!(
+            AdminUtils::sudo_set_validator_cut(
+                <<Test as Config>::RuntimeOrigin>::signed(U256::from(1)),
+                netuid,
+                to_be_set
+            ),
+            Err(DispatchError::BadOrigin)
+        );
+        // Value should remain unchangeds
+        assert_eq!(SubtensorModule::get_validator_cut(netuid), init_value);
+
+        assert_ok!(AdminUtils::sudo_set_validator_cut(
+            <<Test as Config>::RuntimeOrigin>::signed(sn_owner),
+            netuid,
+            to_be_set
+        ));
+
+        // Verify the value was set correctly
+        assert_eq!(SubtensorModule::get_validator_cut(netuid), to_be_set);
+    });
+}
+
+#[test]
+fn test_sudo_set_validator_cut_root() {
+    new_test_ext().execute_with(|| {
+        let netuid = NetUid::from(4);
+        let to_be_set: u16 = 10000; // 100% cut
+
+        // Set up a network
+        add_network(netuid, 10);
+
+        // Test that root can set the validator cut successfully
+        assert_ok!(AdminUtils::sudo_set_validator_cut(
+            <<Test as Config>::RuntimeOrigin>::root(),
+            netuid,
+            to_be_set
+        ));
+
+        // Verify the value was set correctly
+        assert_eq!(SubtensorModule::get_validator_cut(netuid), to_be_set);
+    });
+}
+
+#[test]
+fn test_validator_cut_bounds() {
+    new_test_ext().execute_with(|| {
+        let netuid = NetUid::from(5);
+        let min_cut: u16 = 0; // 0% cut
+        let max_cut: u16 = u16::MAX; // 100% cut
+
+        // Set up a network
+        add_network(netuid, 10);
+
+        // Test minimum value
+        SubtensorModule::set_validator_cut(netuid, min_cut);
+        assert_eq!(SubtensorModule::get_validator_cut(netuid), min_cut);
+
+        // Test maximum value
+        SubtensorModule::set_validator_cut(netuid, max_cut);
+        assert_eq!(SubtensorModule::get_validator_cut(netuid), max_cut);
+    });
+}

pallets/subtensor/src/coinbase/run_coinbase.rs

@@ -663,10 +663,12 @@ impl<T: Config> Pallet<T> {
             });
         log::debug!("incentive_sum: {incentive_sum:?}");
 
+        let validator_cut = Self::get_validator_cut(netuid);
         let pending_validator_alpha = if !incentive_sum.is_zero() {
             pending_alpha
                 .saturating_add(pending_swapped)
-                .saturating_div(2.into())
+                .saturating_div(AlphaCurrency::from(u16::MAX as u64))
+                .saturating_mul(AlphaCurrency::from(validator_cut as u64))
                 .saturating_sub(pending_swapped)
         } else {
             // If the incentive is 0, then Validators get 100% of the alpha.

pallets/subtensor/src/lib.rs

@@ -1501,6 +1501,17 @@ pub mod pallet {
     pub type ImmuneOwnerUidsLimit<T> =
         StorageMap<_, Identity, NetUid, u16, ValueQuery, DefaultImmuneOwnerUidsLimit<T>>;
 
+    #[pallet::type_value]
+    /// Default validator cut 50%
+    pub fn DefaultValidatorCut<T: Config>() -> u16 {
+        u16::MAX / 2
+    }
+
+    #[pallet::storage]
+    /// --- MAP ( netuid ) --> Validator cut
+    pub type ValidatorCut<T> =
+        StorageMap<_, Identity, NetUid, u16, ValueQuery, DefaultValidatorCut<T>>;
+
     /// =======================================
     /// ==== Subnetwork Consensus Storage  ====
     /// =======================================

pallets/subtensor/src/staking/helpers.rs

@@ -327,4 +327,24 @@ impl<T: Config> Pallet<T> {
             *total = total.saturating_sub(amount);
         });
     }
+
+    /// Gets the validator cut for a given subnet.
+    ///
+    /// # Arguments
+    /// * `netuid` - The network UID.
+    ///
+    /// # Returns
+    /// The validator cut value for the subnet.
+    pub fn get_validator_cut(netuid: NetUid) -> u16 {
+        ValidatorCut::<T>::get(netuid)
+    }
+
+    /// Sets the validator cut for a given subnet.
+    ///
+    /// # Arguments
+    /// * `netuid` - The network UID.
+    /// * `cut` - The validator cut value to set.
+    pub fn set_validator_cut(netuid: NetUid, cut: u16) {
+        ValidatorCut::<T>::insert(netuid, cut);
+    }
 }