Fix scoping for weights rate-limited group

Author: ales-otf

runtime/src/rate_limiting/migration.rs

@@ -10,10 +10,10 @@ use pallet_rate_limiting::{
 };
 use pallet_subtensor::{
     self, AssociatedEvmAddress, Axons, Config as SubtensorConfig, HasMigrationRun,
-    LastRateLimitedBlock, LastUpdate, MaxUidsTrimmingRateLimit, MechanismCountCurrent,
-    MechanismCountSetRateLimit, MechanismEmissionRateLimit, NetworkRateLimit,
-    OwnerHyperparamRateLimit, Pallet, Prometheus, RateLimitKey, TransactionKeyLastBlock,
-    TxChildkeyTakeRateLimit, TxDelegateTakeRateLimit, TxRateLimit, WeightsVersionKeyRateLimit,
+    LastRateLimitedBlock, LastUpdate, MaxUidsTrimmingRateLimit, MechanismCountSetRateLimit,
+    MechanismEmissionRateLimit, NetworkRateLimit, OwnerHyperparamRateLimit, Pallet, Prometheus,
+    RateLimitKey, TransactionKeyLastBlock, TxChildkeyTakeRateLimit, TxDelegateTakeRateLimit,
+    TxRateLimit, WeightsVersionKeyRateLimit,
     utils::rate_limiting::{Hyperparameter, TransactionType},
 };
 use sp_runtime::traits::SaturatedConversion;
@@ -22,7 +22,7 @@ use sp_std::{
     vec,
     vec::Vec,
 };
-use subtensor_runtime_common::{MechId, NetUid};
+use subtensor_runtime_common::NetUid;
 
 use super::{RateLimitScope, RateLimitUsageKey};
 
@@ -240,13 +240,6 @@ fn weight_calls_subnet(grouping: &Grouping) -> Vec<TransactionIdentifier> {
         .unwrap_or_default()
 }
 
-fn weight_calls_mechanism(grouping: &Grouping) -> Vec<TransactionIdentifier> {
-    grouping
-        .members(GROUP_WEIGHTS_MECHANISM)
-        .map(|m| m.iter().copied().collect())
-        .unwrap_or_default()
-}
-
 fn build_grouping() -> Grouping {
     let mut grouping = Grouping::default();
 
@@ -469,13 +462,10 @@ fn gather_weight_limits<T: SubtensorConfig>(
     let mut reads: u64 = 0;
     let netuids = Pallet::<T>::get_all_subnet_netuids();
 
-    let mut subnet_limits = BTreeMap::<NetUid, BlockNumberFor<T>>::new();
     let subnet_calls = weight_calls_subnet(grouping);
-    let mechanism_calls = weight_calls_mechanism(grouping);
     for netuid in &netuids {
         reads += 1;
         if let Some(span) = block_number::<T>(Pallet::<T>::get_weights_set_rate_limit(*netuid)) {
-            subnet_limits.insert(*netuid, span);
             for call in &subnet_calls {
                 set_scoped_limit::<T>(
                     limits,
@@ -487,26 +477,6 @@ fn gather_weight_limits<T: SubtensorConfig>(
         }
     }
 
-    for netuid in &netuids {
-        reads += 1;
-        let mech_count: u8 = MechanismCountCurrent::<T>::get(*netuid).into();
-        if mech_count <= 1 {
-            continue;
-        }
-        let Some(span) = subnet_limits.get(netuid).copied() else {
-            continue;
-        };
-        for mecid in 1..mech_count {
-            let scope = RateLimitScope::SubnetMechanism {
-                netuid: *netuid,
-                mecid: MechId::from(mecid),
-            };
-            for call in &mechanism_calls {
-                set_scoped_limit::<T>(limits, grouping.config_target(*call), scope.clone(), span);
-            }
-        }
-    }
-
     reads
 }
 
@@ -621,18 +591,9 @@ fn import_last_update_entries<T: SubtensorConfig>(
 ) -> u64 {
     let mut reads: u64 = 0;
     let subnet_calls = weight_calls_subnet(grouping);
-    let mechanism_calls = weight_calls_mechanism(grouping);
     for (index, blocks) in LastUpdate::<T>::iter() {
         reads += 1;
         let netuid = Pallet::<T>::get_netuid(index);
-        let sub_id = u16::from(index)
-            .checked_div(pallet_subtensor::subnets::mechanism::GLOBAL_MAX_SUBNET_COUNT)
-            .unwrap_or_default();
-        let is_mechanism = sub_id != 0;
-        let Ok(sub_id) = u8::try_from(sub_id) else {
-            continue;
-        };
-        let mecid = MechId::from(sub_id);
 
         for (uid, last_block) in blocks.into_iter().enumerate() {
             if last_block == 0 {
@@ -641,26 +602,12 @@ fn import_last_update_entries<T: SubtensorConfig>(
             let Ok(uid_u16) = u16::try_from(uid) else {
                 continue;
             };
-            let usage = if is_mechanism {
-                RateLimitUsageKey::SubnetMechanismNeuron {
-                    netuid,
-                    mecid,
-                    uid: uid_u16,
-                }
-            } else {
-                RateLimitUsageKey::SubnetNeuron {
-                    netuid,
-                    uid: uid_u16,
-                }
-            };
-
-            let call_set: &[TransactionIdentifier] = if is_mechanism {
-                mechanism_calls.as_slice()
-            } else {
-                subnet_calls.as_slice()
+            let usage = RateLimitUsageKey::SubnetNeuron {
+                netuid,
+                uid: uid_u16,
             };
 
-            for call in call_set {
+            for call in &subnet_calls {
                 record_last_seen_entry::<T>(
                     entries,
                     grouping.usage_target(*call),

runtime/src/rate_limiting/mod.rs

@@ -280,19 +280,14 @@ impl RateLimitScopeResolver<RuntimeOrigin, RuntimeCall, RateLimitScope, BlockNum
                 | SubtensorCall::commit_weights { netuid, .. }
                 | SubtensorCall::reveal_weights { netuid, .. }
                 | SubtensorCall::batch_reveal_weights { netuid, .. }
-                | SubtensorCall::commit_timelocked_weights { netuid, .. } => {
+                | SubtensorCall::commit_timelocked_weights { netuid, .. }
+                | SubtensorCall::set_mechanism_weights { netuid, .. }
+                | SubtensorCall::commit_mechanism_weights { netuid, .. }
+                | SubtensorCall::reveal_mechanism_weights { netuid, .. }
+                | SubtensorCall::commit_crv3_mechanism_weights { netuid, .. }
+                | SubtensorCall::commit_timelocked_mechanism_weights { netuid, .. } => {
                     Some(RateLimitScope::Subnet(*netuid))
                 }
-                SubtensorCall::set_mechanism_weights { netuid, mecid, .. }
-                | SubtensorCall::commit_mechanism_weights { netuid, mecid, .. }
-                | SubtensorCall::reveal_mechanism_weights { netuid, mecid, .. }
-                | SubtensorCall::commit_crv3_mechanism_weights { netuid, mecid, .. }
-                | SubtensorCall::commit_timelocked_mechanism_weights { netuid, mecid, .. } => {
-                    Some(RateLimitScope::SubnetMechanism {
-                        netuid: *netuid,
-                        mecid: *mecid,
-                    })
-                }
                 _ => None,
             },
             RuntimeCall::AdminUtils(inner) => {