Validator cut [WIP]

pallets/admin-utils/src/lib.rs

@@ -2142,6 +2142,33 @@ pub mod pallet {
             );
             Ok(())
         }
+
+        /// Sets the validator cut for a subnet.
+        /// Only callable by subnet owner or root.
+        #[pallet::call_index(81)]
+        #[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: u64,
+        ) -> DispatchResult {
+            let maybe_owner = pallet_subtensor::Pallet::<T>::ensure_sn_owner_or_root_with_limits(
+                origin.clone(),
+                netuid,
+                &[TransactionType::SetValidatorCut],
+            )?;
+
+            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::SetValidatorCut],
+            );
+            Ok(())
+        }
     }
 }
 

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

@@ -2895,3 +2895,121 @@ fn test_sudo_set_min_allowed_uids() {
         );
     });
 }
+
+#[test]
+fn test_get_validator_cut() {
+    new_test_ext().execute_with(|| {
+        let netuid = NetUid::from(1);
+        let expected_cut: u64 = 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: u64 = pallet_subtensor::DefaultValidatorCut::<Test>::get();
+        let new_cut: u64 = 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: u64 = 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: u64 = 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: u64 = 0; // 0% cut
+        let max_cut: u64 = u64::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

@@ -674,11 +674,34 @@ impl<T: Config> Pallet<T> {
             });
         log::debug!("incentive_sum: {incentive_sum:?}");
 
+        let validator_cut = Self::get_validator_cut(netuid);
+        log::debug!("validator_cut: {validator_cut:?}");
+
+        let rate = U96F32::from(validator_cut).saturating_div(u64::MAX.into());
+        log::debug!("validator rate: {rate:?}");
+        let miner_rate = U96F32::from(1_u64)
+            .saturating_sub(rate)
+            .saturating_mul(U96F32::from(2_u64));
+
+        // Update incentive according to the validator cut
+        let hotkey_emission: Vec<(T::AccountId, AlphaCurrency, AlphaCurrency)> = hotkey_emission
+            .iter()
+            .map(|(hotkey, incentive, reward)| {
+                let result: AlphaCurrency = U96F32::from(incentive.to_u64())
+                    .saturating_mul(miner_rate)
+                    .saturating_to_num::<u64>()
+                    .into();
+                (hotkey.clone(), result, *reward)
+            })
+            .collect();
+
         let pending_validator_alpha = if !incentive_sum.is_zero() {
-            pending_alpha
-                .saturating_add(pending_swapped)
-                .saturating_div(2.into())
-                .saturating_sub(pending_swapped)
+            let pending_alpha_f = U96F32::from(pending_alpha.to_u64());
+            let result = pending_alpha_f
+                .saturating_add(U96F32::from(pending_swapped.to_u64()))
+                .saturating_mul(rate)
+                .saturating_sub(U96F32::from(pending_swapped.to_u64()));
+            result.saturating_to_num::<u64>().into()
         } else {
             // If the incentive is 0, then Validators get 100% of the alpha.
             pending_alpha

pallets/subtensor/src/lib.rs

@@ -1559,6 +1559,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>() -> u64 {
+        u64::MAX / 2
+    }
+
+    #[pallet::storage]
+    /// --- MAP ( netuid ) --> Validator cut
+    pub type ValidatorCut<T> =
+        StorageMap<_, Identity, NetUid, u64, ValueQuery, DefaultValidatorCut<T>>;
+
     /// =======================================
     /// ==== Subnetwork Consensus Storage  ====
     /// =======================================

pallets/subtensor/src/staking/helpers.rs

@@ -326,6 +326,26 @@ impl<T: Config> Pallet<T> {
         });
     }
 
+    /// 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) -> u64 {
+        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: u64) {
+        ValidatorCut::<T>::insert(netuid, cut);
+    }
+
     pub fn burn_subnet_alpha(_netuid: NetUid, _amount: AlphaCurrency) {
         // Do nothing; TODO: record burned alpha in a tracker
     }

pallets/subtensor/src/tests/mod.rs

@@ -28,4 +28,5 @@ mod swap_coldkey;
 mod swap_hotkey;
 mod swap_hotkey_with_subnet;
 mod uids;
+mod validator_cut;
 mod weights;