Allow to decrease and increase take, add tests

pallets/admin-utils/src/lib.rs

@@ -102,6 +102,15 @@ pub mod pallet {
             Ok(())
         }
 
+        #[pallet::call_index(45)]
+        #[pallet::weight((0, DispatchClass::Operational, Pays::No))]
+        pub fn sudo_set_tx_delegate_take_rate_limit(origin: OriginFor<T>, tx_rate_limit: u64) -> DispatchResult {
+            ensure_root(origin)?;
+            T::Subtensor::set_tx_delegate_take_rate_limit(tx_rate_limit);
+            log::info!("TxRateLimitDelegateTakeSet( tx_delegate_take_rate_limit: {:?} ) ", tx_rate_limit);
+            Ok(())
+        }
+
         #[pallet::call_index(3)]
         #[pallet::weight(T::WeightInfo::sudo_set_serving_rate_limit())]
         pub fn sudo_set_serving_rate_limit(
@@ -809,6 +818,7 @@ impl<A, M> AuraInterface<A, M> for () {
 pub trait SubtensorInterface<AccountId, Balance, RuntimeOrigin> {
     fn set_default_take(default_take: u16);
     fn set_tx_rate_limit(rate_limit: u64);
+    fn set_tx_delegate_take_rate_limit(rate_limit: u64);
 
     fn set_serving_rate_limit(netuid: u16, rate_limit: u64);
 

pallets/admin-utils/tests/mock.rs

@@ -79,6 +79,7 @@ parameter_types! {
     pub const InitialWeightsVersionKey: u16 = 0;
     pub const InitialServingRateLimit: u64 = 0; // No limit.
     pub const InitialTxRateLimit: u64 = 0; // Disable rate limit for testing
+    pub const InitialTxDelegateTakeRateLimit: u64 = 0; // Disable rate limit for testing
     pub const InitialBurn: u64 = 0;
     pub const InitialMinBurn: u64 = 0;
     pub const InitialMaxBurn: u64 = 1_000_000_000;
@@ -143,6 +144,7 @@ impl pallet_subtensor::Config for Test {
     type InitialMinDifficulty = InitialMinDifficulty;
     type InitialServingRateLimit = InitialServingRateLimit;
     type InitialTxRateLimit = InitialTxRateLimit;
+    type InitialTxDelegateTakeRateLimit = InitialTxDelegateTakeRateLimit;
     type InitialBurn = InitialBurn;
     type InitialMaxBurn = InitialMaxBurn;
     type InitialMinBurn = InitialMinBurn;
@@ -211,6 +213,10 @@ impl pallet_admin_utils::SubtensorInterface<AccountId, Balance, RuntimeOrigin> f
         SubtensorModule::set_tx_rate_limit(rate_limit);
     }
 
+    fn set_tx_delegate_take_rate_limit(rate_limit: u64) {
+        SubtensorModule::set_tx_delegate_take_rate_limit(rate_limit);
+    }
+
     fn set_serving_rate_limit(netuid: u16, rate_limit: u64) {
         SubtensorModule::set_serving_rate_limit(netuid, rate_limit);
     }

pallets/admin-utils/tests/tests.rs

@@ -9,7 +9,7 @@ mod mock;
 use mock::*;
 
 #[allow(dead_code)]
-pub fn add_network(netuid: u16, tempo: u16) {
+pub fn add_network(netuid: u16, tempo: u16, _modality: u16) {
     SubtensorModule::init_new_network(netuid, tempo);
     SubtensorModule::set_network_registration_allowed(netuid, true);
     SubtensorModule::set_network_pow_registration_allowed(netuid, true);
@@ -65,7 +65,7 @@ fn test_sudo_set_min_difficulty() {
     new_test_ext().execute_with(|| {
         let netuid: u16 = 1;
         let to_be_set: u64 = 10;
-        add_network(netuid, 10);
+        add_network(netuid, 10, 0);
         let init_value: u64 = SubtensorModule::get_min_difficulty(netuid);
         assert_eq!(
             AdminUtils::sudo_set_min_difficulty(
@@ -98,7 +98,7 @@ fn test_sudo_set_max_difficulty() {
     new_test_ext().execute_with(|| {
         let netuid: u16 = 1;
         let to_be_set: u64 = 10;
-        add_network(netuid, 10);
+        add_network(netuid, 10, 0);
         let init_value: u64 = SubtensorModule::get_max_difficulty(netuid);
         assert_eq!(
             AdminUtils::sudo_set_max_difficulty(
@@ -131,7 +131,7 @@ fn test_sudo_set_weights_version_key() {
     new_test_ext().execute_with(|| {
         let netuid: u16 = 1;
         let to_be_set: u64 = 10;
-        add_network(netuid, 10);
+        add_network(netuid, 10, 0);
         let init_value: u64 = SubtensorModule::get_weights_version_key(netuid);
         assert_eq!(
             AdminUtils::sudo_set_weights_version_key(
@@ -164,7 +164,7 @@ fn test_sudo_set_weights_set_rate_limit() {
     new_test_ext().execute_with(|| {
         let netuid: u16 = 1;
         let to_be_set: u64 = 10;
-        add_network(netuid, 10);
+        add_network(netuid, 10, 0);
         let init_value: u64 = SubtensorModule::get_weights_set_rate_limit(netuid);
         assert_eq!(
             AdminUtils::sudo_set_weights_set_rate_limit(
@@ -203,7 +203,7 @@ fn test_sudo_set_adjustment_interval() {
     new_test_ext().execute_with(|| {
         let netuid: u16 = 1;
         let to_be_set: u16 = 10;
-        add_network(netuid, 10);
+        add_network(netuid, 10, 0);
         let init_value: u16 = SubtensorModule::get_adjustment_interval(netuid);
         assert_eq!(
             AdminUtils::sudo_set_adjustment_interval(
@@ -236,7 +236,7 @@ fn test_sudo_set_adjustment_alpha() {
     new_test_ext().execute_with(|| {
         let netuid: u16 = 1;
         let to_be_set: u64 = 10;
-        add_network(netuid, 10);
+        add_network(netuid, 10, 0);
         let init_value: u64 = SubtensorModule::get_adjustment_alpha(netuid);
         assert_eq!(
             AdminUtils::sudo_set_adjustment_alpha(
@@ -290,7 +290,7 @@ fn test_sudo_set_max_weight_limit() {
     new_test_ext().execute_with(|| {
         let netuid: u16 = 1;
         let to_be_set: u16 = 10;
-        add_network(netuid, 10);
+        add_network(netuid, 10, 0);
         let init_value: u16 = SubtensorModule::get_max_weight_limit(netuid);
         assert_eq!(
             AdminUtils::sudo_set_max_weight_limit(
@@ -342,7 +342,7 @@ fn test_sudo_set_immunity_period() {
     new_test_ext().execute_with(|| {
         let netuid: u16 = 1;
         let to_be_set: u16 = 10;
-        add_network(netuid, 10);
+        add_network(netuid, 10, 0);
         let init_value: u16 = SubtensorModule::get_immunity_period(netuid);
         assert_eq!(
             AdminUtils::sudo_set_immunity_period(
@@ -375,7 +375,7 @@ fn test_sudo_set_min_allowed_weights() {
     new_test_ext().execute_with(|| {
         let netuid: u16 = 1;
         let to_be_set: u16 = 10;
-        add_network(netuid, 10);
+        add_network(netuid, 10, 0);
         let init_value: u16 = SubtensorModule::get_min_allowed_weights(netuid);
         assert_eq!(
             AdminUtils::sudo_set_min_allowed_weights(
@@ -408,7 +408,7 @@ fn test_sudo_set_max_allowed_uids() {
     new_test_ext().execute_with(|| {
         let netuid: u16 = 1;
         let to_be_set: u16 = 10;
-        add_network(netuid, 10);
+        add_network(netuid, 10, 0);
         let init_value: u16 = SubtensorModule::get_max_allowed_uids(netuid);
         assert_eq!(
             AdminUtils::sudo_set_max_allowed_uids(
@@ -441,7 +441,7 @@ fn test_sudo_set_and_decrease_max_allowed_uids() {
     new_test_ext().execute_with(|| {
         let netuid: u16 = 1;
         let to_be_set: u16 = 10;
-        add_network(netuid, 10);
+        add_network(netuid, 10, 0);
         let init_value: u16 = SubtensorModule::get_max_allowed_uids(netuid);
         assert_eq!(
             AdminUtils::sudo_set_max_allowed_uids(
@@ -478,7 +478,7 @@ fn test_sudo_set_kappa() {
     new_test_ext().execute_with(|| {
         let netuid: u16 = 1;
         let to_be_set: u16 = 10;
-        add_network(netuid, 10);
+        add_network(netuid, 10, 0);
         let init_value: u16 = SubtensorModule::get_kappa(netuid);
         assert_eq!(
             AdminUtils::sudo_set_kappa(
@@ -511,7 +511,7 @@ fn test_sudo_set_rho() {
     new_test_ext().execute_with(|| {
         let netuid: u16 = 1;
         let to_be_set: u16 = 10;
-        add_network(netuid, 10);
+        add_network(netuid, 10, 0);
         let init_value: u16 = SubtensorModule::get_rho(netuid);
         assert_eq!(
             AdminUtils::sudo_set_rho(
@@ -544,7 +544,7 @@ fn test_sudo_set_activity_cutoff() {
     new_test_ext().execute_with(|| {
         let netuid: u16 = 1;
         let to_be_set: u16 = 10;
-        add_network(netuid, 10);
+        add_network(netuid, 10, 0);
         let init_value: u16 = SubtensorModule::get_activity_cutoff(netuid);
         assert_eq!(
             AdminUtils::sudo_set_activity_cutoff(
@@ -577,7 +577,7 @@ fn test_sudo_set_target_registrations_per_interval() {
     new_test_ext().execute_with(|| {
         let netuid: u16 = 1;
         let to_be_set: u16 = 10;
-        add_network(netuid, 10);
+        add_network(netuid, 10, 0);
         let init_value: u16 = SubtensorModule::get_target_registrations_per_interval(netuid);
         assert_eq!(
             AdminUtils::sudo_set_target_registrations_per_interval(
@@ -616,7 +616,7 @@ fn test_sudo_set_difficulty() {
     new_test_ext().execute_with(|| {
         let netuid: u16 = 1;
         let to_be_set: u64 = 10;
-        add_network(netuid, 10);
+        add_network(netuid, 10, 0);
         let init_value: u64 = SubtensorModule::get_difficulty_as_u64(netuid);
         assert_eq!(
             AdminUtils::sudo_set_difficulty(
@@ -649,7 +649,7 @@ fn test_sudo_set_max_allowed_validators() {
     new_test_ext().execute_with(|| {
         let netuid: u16 = 1;
         let to_be_set: u16 = 10;
-        add_network(netuid, 10);
+        add_network(netuid, 10, 0);
         let init_value: u16 = SubtensorModule::get_max_allowed_validators(netuid);
         assert_eq!(
             AdminUtils::sudo_set_max_allowed_validators(
@@ -751,7 +751,7 @@ fn test_sudo_set_bonds_moving_average() {
     new_test_ext().execute_with(|| {
         let netuid: u16 = 1;
         let to_be_set: u64 = 10;
-        add_network(netuid, 10);
+        add_network(netuid, 10, 0);
         let init_value: u64 = SubtensorModule::get_bonds_moving_average(netuid);
         assert_eq!(
             AdminUtils::sudo_set_bonds_moving_average(
@@ -787,7 +787,7 @@ fn test_sudo_set_rao_recycled() {
     new_test_ext().execute_with(|| {
         let netuid: u16 = 1;
         let to_be_set: u64 = 10;
-        add_network(netuid, 10);
+        add_network(netuid, 10, 0);
         let init_value: u64 = SubtensorModule::get_rao_recycled(netuid);
 
         // Need to run from genesis block
@@ -852,7 +852,7 @@ fn test_sudo_set_subnet_limit() {
     new_test_ext().execute_with(|| {
         let netuid: u16 = 1;
         let to_be_set: u16 = 10;
-        add_network(netuid, 10);
+        add_network(netuid, 10, 0);
 
         let init_value: u16 = SubtensorModule::get_max_subnets();
         assert_eq!(
@@ -876,7 +876,7 @@ fn test_sudo_set_network_lock_reduction_interval() {
     new_test_ext().execute_with(|| {
         let netuid: u16 = 1;
         let to_be_set: u64 = 7200;
-        add_network(netuid, 10);
+        add_network(netuid, 10, 0);
 
         let init_value: u64 = SubtensorModule::get_lock_reduction_interval();
         assert_eq!(
@@ -900,7 +900,7 @@ fn test_sudo_set_network_pow_registration_allowed() {
     new_test_ext().execute_with(|| {
         let netuid: u16 = 1;
         let to_be_set: bool = true;
-        add_network(netuid, 10);
+        add_network(netuid, 10, 0);
 
         let init_value: bool = SubtensorModule::get_network_pow_registration_allowed(netuid);
         assert_eq!(
@@ -926,3 +926,45 @@ fn test_sudo_set_network_pow_registration_allowed() {
         );
     });
 }
+
+#[test]
+fn test_sudo_set_tx_rate_limit() {
+    new_test_ext().execute_with(|| {
+        let to_be_set: u64 = 10;
+        let init_value: u64 = SubtensorModule::get_tx_rate_limit();
+        assert_eq!(
+            AdminUtils::sudo_set_tx_rate_limit(
+                <<Test as Config>::RuntimeOrigin>::signed(U256::from(1)),
+                to_be_set
+            ),
+            Err(DispatchError::BadOrigin.into())
+        );
+        assert_eq!(SubtensorModule::get_tx_rate_limit(), init_value);
+        assert_ok!(AdminUtils::sudo_set_tx_rate_limit(
+            <<Test as Config>::RuntimeOrigin>::root(),
+            to_be_set
+        ));
+        assert_eq!(SubtensorModule::get_tx_rate_limit(), to_be_set);
+    });
+}
+
+#[test]
+fn test_sudo_set_tx_delegate_take_rate_limit() {
+    new_test_ext().execute_with(|| {
+        let to_be_set: u64 = 10;
+        let init_value: u64 = SubtensorModule::get_tx_delegate_take_rate_limit();
+        assert_eq!(
+            AdminUtils::sudo_set_tx_delegate_take_rate_limit(
+                <<Test as Config>::RuntimeOrigin>::signed(U256::from(1)),
+                to_be_set
+            ),
+            Err(DispatchError::BadOrigin.into())
+        );
+        assert_eq!(SubtensorModule::get_tx_delegate_take_rate_limit(), init_value);
+        assert_ok!(AdminUtils::sudo_set_tx_delegate_take_rate_limit(
+            <<Test as Config>::RuntimeOrigin>::root(),
+            to_be_set
+        ));
+        assert_eq!(SubtensorModule::get_tx_delegate_take_rate_limit(), to_be_set);
+    });
+}

pallets/registry/src/types.rs

@@ -15,7 +15,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-// use super::*;
 use codec::{Decode, Encode, MaxEncodedLen};
 use enumflags2::{bitflags, BitFlags};
 use frame_support::{