feat: fix child take tests

Author: Samuel Dare

pallets/subtensor/src/lib.rs

@@ -1137,7 +1137,11 @@ pub mod pallet {
     pub type LastTxBlock<T: Config> =
         StorageMap<_, Identity, T::AccountId, u64, ValueQuery, DefaultLastTxBlock<T>>;
     #[pallet::storage]
-    /// --- MAP ( key ) --> last_block
+    /// --- MAP ( key ) --> last_tx_block_childkey_take
+    pub type LastTxBlockChildKeyTake<T: Config> =
+        StorageMap<_, Identity, T::AccountId, u64, ValueQuery, DefaultLastTxBlock<T>>;
+    #[pallet::storage]
+    /// --- MAP ( key ) --> last_tx_block_delegate_take
     pub type LastTxBlockDelegateTake<T: Config> =
         StorageMap<_, Identity, T::AccountId, u64, ValueQuery, DefaultLastTxBlock<T>>;
     #[pallet::storage]

pallets/subtensor/src/macros/dispatches.rs

@@ -737,7 +737,7 @@ mod dispatches {
         /// * `TxChildkeyTakeRateLimitExceeded`:
         ///     - The rate limit for changing childkey take has been exceeded.
         ///
-        #[pallet::call_index(68)]
+        #[pallet::call_index(75)]
         #[pallet::weight((
             Weight::from_parts(34_000, 0)
             .saturating_add(T::DbWeight::get().reads(4))

pallets/subtensor/src/staking/set_children.rs

@@ -236,26 +236,28 @@ impl<T: Config> Pallet<T> {
             Error::<T>::InvalidChildkeyTake
         );
 
-        // Ensure the hotkey passes the rate limit
-        ensure!(
-            Self::passes_rate_limit_on_subnet(&TransactionType::SetChildkeyTake, &hotkey, netuid),
-            Error::<T>::TxChildkeyTakeRateLimitExceeded
+        // Check if the rate limit has been exceeded
+        let current_block = Self::get_current_block_as_u64();
+        let last_tx_block =
+            Self::get_last_transaction_block(&hotkey, netuid, &TransactionType::SetChildkeyTake);
+        let rate_limit = TxChildkeyTakeRateLimit::<T>::get();
+        let passes =
+            Self::passes_rate_limit_on_subnet(&TransactionType::SetChildkeyTake, &hotkey, netuid);
+
+        log::info!(
+            "Rate limit check: current_block: {}, last_tx_block: {}, rate_limit: {}, passes: {}",
+            current_block,
+            last_tx_block,
+            rate_limit,
+            passes
         );
 
+        ensure!(passes, Error::<T>::TxChildkeyTakeRateLimitExceeded);
+
         // Set the new childkey take value for the given hotkey and network
         ChildkeyTake::<T>::insert(hotkey.clone(), netuid, take);
 
-        // TODO: Consider adding a check to ensure the hotkey is registered on the specified network (netuid)
-        // before setting the childkey take. This could prevent setting takes for non-existent or
-        // unregistered hotkeys.
-
-        // NOTE: The childkey take is now associated with both the hotkey and the network ID.
-        // This allows for different take values across different networks for the same hotkey.
-
         // Update the last transaction block
-        let current_block: u64 = <frame_system::Pallet<T>>::block_number()
-            .try_into()
-            .unwrap_or(0);
         Self::set_last_transaction_block(
             &hotkey,
             netuid,

pallets/subtensor/src/utils/misc.rs

@@ -8,33 +8,6 @@ use sp_core::U256;
 use sp_runtime::Saturating;
 use substrate_fixed::types::I32F32;
 
-/// Enum representing different types of transactions
-#[derive(Copy, Clone)]
-pub enum TransactionType {
-    SetChildren,
-    Unknown,
-}
-
-/// Implement conversion from TransactionType to u16
-impl From<TransactionType> for u16 {
-    fn from(tx_type: TransactionType) -> Self {
-        match tx_type {
-            TransactionType::SetChildren => 0,
-            TransactionType::Unknown => 1,
-        }
-    }
-}
-
-/// Implement conversion from u16 to TransactionType
-impl From<u16> for TransactionType {
-    fn from(value: u16) -> Self {
-        match value {
-            0 => TransactionType::SetChildren,
-            _ => TransactionType::Unknown,
-        }
-    }
-}
-
 impl<T: Config> Pallet<T> {
     pub fn ensure_subnet_owner_or_root(
         o: T::RuntimeOrigin,
@@ -312,17 +285,7 @@ impl<T: Config> Pallet<T> {
     pub fn coinbase(amount: u64) {
         TotalIssuance::<T>::put(TotalIssuance::<T>::get().saturating_add(amount));
     }
-    pub fn get_default_take() -> u16 {
-        // Default to maximum
-        MaxTake::<T>::get()
-    }
-    pub fn set_max_take(default_take: u16) {
-        MaxTake::<T>::put(default_take);
-        Self::deposit_event(Event::DefaultTakeSet(default_take));
-    }
-    pub fn get_min_take() -> u16 {
-        MinTake::<T>::get()
-    }
+
     pub fn set_subnet_locked_balance(netuid: u16, amount: u64) {
         SubnetLocked::<T>::insert(netuid, amount);
     }
@@ -357,18 +320,49 @@ impl<T: Config> Pallet<T> {
         Self::deposit_event(Event::TxDelegateTakeRateLimitSet(tx_rate_limit));
     }
     pub fn set_min_delegate_take(take: u16) {
-        MinTake::<T>::put(take);
+        MinDelegateTake::<T>::put(take);
         Self::deposit_event(Event::MinDelegateTakeSet(take));
     }
     pub fn set_max_delegate_take(take: u16) {
-        MaxTake::<T>::put(take);
+        MaxDelegateTake::<T>::put(take);
         Self::deposit_event(Event::MaxDelegateTakeSet(take));
     }
     pub fn get_min_delegate_take() -> u16 {
-        MinTake::<T>::get()
+        MinDelegateTake::<T>::get()
     }
     pub fn get_max_delegate_take() -> u16 {
-        MaxTake::<T>::get()
+        MaxDelegateTake::<T>::get()
+    }
+    pub fn get_default_delegate_take() -> u16 {
+        // Default to maximum
+        MaxDelegateTake::<T>::get()
+    }
+    // get_default_childkey_take
+    pub fn get_default_childkey_take() -> u16 {
+        // Default to maximum
+        MinChildkeyTake::<T>::get()
+    }
+    pub fn get_tx_childkey_take_rate_limit() -> u64 {
+        TxChildkeyTakeRateLimit::<T>::get()
+    }
+    pub fn set_tx_childkey_take_rate_limit(tx_rate_limit: u64) {
+        TxChildkeyTakeRateLimit::<T>::put(tx_rate_limit);
+        Self::deposit_event(Event::TxChildKeyTakeRateLimitSet(tx_rate_limit));
+    }
+    pub fn set_min_childkey_take(take: u16) {
+        MinChildkeyTake::<T>::put(take);
+        Self::deposit_event(Event::MinChildKeyTakeSet(take));
+    }
+    pub fn set_max_childkey_take(take: u16) {
+        MaxChildkeyTake::<T>::put(take);
+        Self::deposit_event(Event::MaxChildKeyTakeSet(take));
+    }
+    pub fn get_min_childkey_take() -> u16 {
+        MinChildkeyTake::<T>::get()
+    }
+
+    pub fn get_max_childkey_take() -> u16 {
+        MaxChildkeyTake::<T>::get()
     }
 
     pub fn get_serving_rate_limit(netuid: u16) -> u64 {

pallets/subtensor/src/utils/rate_limiting.rs

@@ -5,6 +5,7 @@ use sp_core::Get;
 #[derive(Copy, Clone)]
 pub enum TransactionType {
     SetChildren,
+    SetChildkeyTake,
     Unknown,
 }
 
@@ -13,7 +14,8 @@ impl From<TransactionType> for u16 {
     fn from(tx_type: TransactionType) -> Self {
         match tx_type {
             TransactionType::SetChildren => 0,
-            TransactionType::Unknown => 1,
+            TransactionType::SetChildkeyTake => 1,
+            TransactionType::Unknown => 2,
         }
     }
 }
@@ -23,6 +25,7 @@ impl From<u16> for TransactionType {
     fn from(value: u16) -> Self {
         match value {
             0 => TransactionType::SetChildren,
+            1 => TransactionType::SetChildkeyTake,
             _ => TransactionType::Unknown,
         }
     }
@@ -35,6 +38,7 @@ impl<T: Config> Pallet<T> {
     pub fn get_rate_limit(tx_type: &TransactionType) -> u64 {
         match tx_type {
             TransactionType::SetChildren => (DefaultTempo::<T>::get().saturating_mul(2)).into(), // Cannot set children twice within the default tempo period.
+            TransactionType::SetChildkeyTake => TxChildkeyTakeRateLimit::<T>::get(),
             TransactionType::Unknown => 0, // Default to no limit for unknown types (no limit)
         }
     }
@@ -48,7 +52,9 @@ impl<T: Config> Pallet<T> {
         let block: u64 = Self::get_current_block_as_u64();
         let limit: u64 = Self::get_rate_limit(tx_type);
         let last_block: u64 = Self::get_last_transaction_block(hotkey, netuid, tx_type);
-        block.saturating_sub(last_block) < limit
+
+        // Allow the first transaction (when last_block is 0) or if the rate limit has passed
+        last_block == 0 || block.saturating_sub(last_block) >= limit
     }
 
     /// Check if a transaction should be rate limited globally
@@ -93,6 +99,13 @@ impl<T: Config> Pallet<T> {
     pub fn get_last_tx_block_delegate_take(key: &T::AccountId) -> u64 {
         LastTxBlockDelegateTake::<T>::get(key)
     }
+
+    pub fn set_last_tx_block_childkey_take(key: &T::AccountId, block: u64) {
+        LastTxBlockChildKeyTake::<T>::insert(key, block)
+    }
+    pub fn get_last_tx_block_childkey_take(key: &T::AccountId) -> u64 {
+        LastTxBlockChildKeyTake::<T>::get(key)
+    }
     pub fn exceeds_tx_rate_limit(prev_tx_block: u64, current_block: u64) -> bool {
         let rate_limit: u64 = Self::get_tx_rate_limit();
         if rate_limit == 0 || prev_tx_block == 0 {