add test cases

Author: open-junius

pallets/admin-utils/src/lib.rs

@@ -512,7 +512,11 @@ pub mod pallet {
         .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_kappa(origin: OriginFor<T>, netuid: NetUid, kappa: u16) -> DispatchResult {
-            ensure_root(origin)?;
+            if pallet_subtensor::Pallet::<T>::get_kappa_can_set_by_owner(netuid) {
+                pallet_subtensor::Pallet::<T>::ensure_subnet_owner_or_root(origin, netuid)?;
+            } else {
+                ensure_root(origin)?;
+            }
 
             ensure!(
                 pallet_subtensor::Pallet::<T>::if_subnet_exist(netuid),
@@ -1673,6 +1677,30 @@ pub mod pallet {
             pallet_subtensor::Pallet::<T>::set_commit_reveal_weights_version(version);
             Ok(())
         }
+
+        /// The extrinsic sets the kappa for a subnet.
+        /// It is only callable by the root account or subnet owner.
+        /// The extrinsic will call the Subtensor pallet to set the kappa.
+        #[pallet::call_index(72)]
+        #[pallet::weight(Weight::from_parts(16_740_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_kappa_can_set_by_owner(
+            origin: OriginFor<T>,
+            netuid: NetUid,
+            kappa_can_set_by_owner: bool,
+        ) -> DispatchResult {
+            ensure_root(origin)?;
+
+            pallet_subtensor::Pallet::<T>::set_kappa_can_set_by_owner(
+                netuid,
+                kappa_can_set_by_owner,
+            );
+            log::debug!(
+                "KappaCanSetByOwnerSet( netuid: {netuid:?} kappaCanSet: {kappa_can_set_by_owner:?} ) "
+            );
+            Ok(())
+        }
     }
 }
 

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

@@ -585,6 +585,7 @@ fn test_sudo_set_kappa() {
         let to_be_set: u16 = 10;
         add_network(netuid, 10);
         let init_value: u16 = SubtensorModule::get_kappa(netuid);
+        let can_set_by_owner: bool = SubtensorModule::get_kappa_can_set_by_owner(netuid);
         assert_eq!(
             AdminUtils::sudo_set_kappa(
                 <<Test as Config>::RuntimeOrigin>::signed(U256::from(1)),
@@ -601,6 +602,8 @@ fn test_sudo_set_kappa() {
             ),
             Err(Error::<Test>::SubnetDoesNotExist.into())
         );
+
+        assert_eq!(can_set_by_owner, true);
         assert_eq!(SubtensorModule::get_kappa(netuid), init_value);
         assert_ok!(AdminUtils::sudo_set_kappa(
             <<Test as Config>::RuntimeOrigin>::root(),
@@ -611,6 +614,65 @@ fn test_sudo_set_kappa() {
     });
 }
 
+#[test]
+fn test_subnet_owner_set_kappa() {
+    new_test_ext().execute_with(|| {
+        let netuid = NetUid::from(1);
+        let to_be_set: u16 = 10;
+        add_network(netuid, 10);
+
+        let owner = pallet_subtensor::pallet::SubnetOwner::<Test>::get(netuid);
+        let init_value: u16 = SubtensorModule::get_kappa(netuid);
+        let can_set_by_owner: bool = SubtensorModule::get_kappa_can_set_by_owner(netuid);
+        assert_eq!(
+            AdminUtils::sudo_set_kappa(
+                <<Test as Config>::RuntimeOrigin>::signed(U256::from(1)),
+                netuid,
+                to_be_set
+            ),
+            Err(DispatchError::BadOrigin)
+        );
+        assert_eq!(
+            AdminUtils::sudo_set_kappa(
+                <<Test as Config>::RuntimeOrigin>::root(),
+                netuid.next(),
+                to_be_set
+            ),
+            Err(Error::<Test>::SubnetDoesNotExist.into())
+        );
+
+        assert_eq!(can_set_by_owner, true);
+        assert_eq!(SubtensorModule::get_kappa(netuid), init_value);
+        assert_ok!(AdminUtils::sudo_set_kappa(
+            <<Test as Config>::RuntimeOrigin>::signed(owner),
+            netuid,
+            to_be_set
+        ));
+        assert_eq!(SubtensorModule::get_kappa(netuid), to_be_set);
+
+        assert_ok!(AdminUtils::sudo_set_kappa_can_set_by_owner(
+            <<Test as Config>::RuntimeOrigin>::root(),
+            netuid,
+            false
+        ));
+        assert_eq!(SubtensorModule::get_kappa_can_set_by_owner(netuid), false);
+
+        assert_eq!(
+            AdminUtils::sudo_set_kappa(
+                <<Test as Config>::RuntimeOrigin>::signed(owner),
+                netuid,
+                to_be_set
+            ),
+            Err(DispatchError::BadOrigin)
+        );
+        assert_ok!(AdminUtils::sudo_set_kappa(
+            <<Test as Config>::RuntimeOrigin>::root(),
+            netuid,
+            to_be_set
+        ));
+    });
+}
+
 #[test]
 fn test_sudo_set_rho() {
     new_test_ext().execute_with(|| {

pallets/subtensor/src/lib.rs

@@ -1464,6 +1464,11 @@ pub mod pallet {
     pub type SubtokenEnabled<T> =
         StorageMap<_, Identity, NetUid, bool, ValueQuery, DefaultFalse<T>>;
 
+    #[pallet::storage]
+    /// --- MAP ( netuid ) --> If Kappa can be set by owner
+    pub type KappaCanSetByOwner<T> =
+        StorageMap<_, Identity, NetUid, bool, ValueQuery, DefaultTrue<T>>;
+
     /// =======================================
     /// ==== Subnetwork Consensus Storage  ====
     /// =======================================

pallets/subtensor/src/macros/config.rs

@@ -15,7 +15,7 @@ mod config {
     {
         /// call type
         type RuntimeCall: Parameter
-            + Dispatchable<RuntimeOrigin = Self::RuntimeOrigin>
+            + Dispatchable<RuntimeOrigin = <Self as frame_system::Config>::RuntimeOrigin>
             + From<Call<Self>>
             + IsType<<Self as frame_system::Config>::RuntimeCall>
             + From<frame_system::Call<Self>>;
@@ -25,11 +25,11 @@ mod config {
 
         /// A sudo-able call.
         type SudoRuntimeCall: Parameter
-            + UnfilteredDispatchable<RuntimeOrigin = Self::RuntimeOrigin>
+            + UnfilteredDispatchable<RuntimeOrigin = <Self as frame_system::Config>::RuntimeOrigin>
             + GetDispatchInfo;
 
         /// Origin checking for council majority
-        type CouncilOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+        type CouncilOrigin: EnsureOrigin<<Self as frame_system::Config>::RuntimeOrigin>;
 
         ///  Currency type that will be used to place deposits on neurons
         type Currency: fungible::Balanced<Self::AccountId, Balance = u64>

pallets/subtensor/src/utils/misc.rs

@@ -248,6 +248,10 @@ impl<T: Config> Pallet<T> {
         BlockAtRegistration::<T>::get(netuid, neuron_uid)
     }
 
+    pub fn get_kappa_can_set_by_owner(netuid: NetUid) -> bool {
+        KappaCanSetByOwner::<T>::get(netuid)
+    }
+
     // ========================
     // ===== Take checks ======
     // ========================
@@ -804,4 +808,18 @@ impl<T: Config> Pallet<T> {
             Err(_) => None,
         }
     }
+
+    /// Set if Kappa can be set by owner
+    ///
+    /// # Arguments
+    ///
+    /// * `netuid` - The unique identifier for the subnet.
+    /// * `can_set` - Whether Kappa can be set by owner.
+    ///
+    /// # Effects
+    ///
+    /// * Update the KappaCanSetByOwner storage.
+    pub fn set_kappa_can_set_by_owner(netuid: NetUid, can_set: bool) {
+        KappaCanSetByOwner::<T>::insert(netuid, can_set);
+    }
 }