Implement rate-limiting resolvers for pallet-subtensor

Author: ales-otf

Cargo.lock

@@ -15,8 +15,10 @@ use sp_runtime::{
 use subtensor_macros::freeze_struct;
 
 pub use currency::*;
+pub use rate_limiting::{RateLimitScope, RateLimitUsageKey};
 
 mod currency;
+mod rate_limiting;
 
 /// Balance of an account.
 pub type Balance = u64;

common/src/lib.rs

@@ -0,0 +1,66 @@
+use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen};
+use frame_support::pallet_prelude::Parameter;
+use scale_info::TypeInfo;
+use serde::{Deserialize, Serialize};
+
+use crate::{MechId, NetUid};
+
+#[derive(
+    Serialize,
+    Deserialize,
+    Encode,
+    Decode,
+    DecodeWithMemTracking,
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Debug,
+    TypeInfo,
+    MaxEncodedLen,
+)]
+pub enum RateLimitScope {
+    Subnet(NetUid),
+    SubnetMechanism { netuid: NetUid, mecid: MechId },
+}
+
+#[derive(
+    Serialize,
+    Deserialize,
+    Encode,
+    Decode,
+    DecodeWithMemTracking,
+    Clone,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Debug,
+    TypeInfo,
+    MaxEncodedLen,
+)]
+#[scale_info(skip_type_params(AccountId))]
+pub enum RateLimitUsageKey<AccountId: Parameter> {
+    Account(AccountId),
+    Subnet(NetUid),
+    AccountSubnet {
+        account: AccountId,
+        netuid: NetUid,
+    },
+    ColdkeyHotkeySubnet {
+        coldkey: AccountId,
+        hotkey: AccountId,
+        netuid: NetUid,
+    },
+    SubnetNeuron {
+        netuid: NetUid,
+        uid: u16,
+    },
+    SubnetMechanismNeuron {
+        netuid: NetUid,
+        mecid: MechId,
+        uid: u16,
+    },
+}

common/src/rate_limiting.rs

@@ -15,7 +15,7 @@ frame-benchmarking = { workspace = true, optional = true }
 frame-support.workspace = true
 frame-system.workspace = true
 scale-info = { workspace = true, features = ["derive"] }
-serde = { workspace = true, features = ["derive"], optional = true }
+serde = { workspace = true, features = ["derive"] }
 sp-std.workspace = true
 sp-runtime.workspace = true
 subtensor-runtime-common.workspace = true
@@ -33,7 +33,7 @@ std = [
 	"frame-support/std",
 	"frame-system/std",
 	"scale-info/std",
-	"serde",
+	"serde/std",
 	"sp-std/std",
 	"sp-runtime/std",
 	"subtensor-runtime-common/std",

pallets/rate-limiting/Cargo.toml

@@ -145,7 +145,7 @@ pub mod pallet {
     };
     use frame_system::pallet_prelude::*;
     use sp_runtime::traits::{DispatchOriginOf, Dispatchable, Saturating, Zero};
-    use sp_std::{convert::TryFrom, marker::PhantomData, vec::Vec};
+    use sp_std::{boxed::Box, convert::TryFrom, marker::PhantomData, vec::Vec};
 
     #[cfg(feature = "runtime-benchmarks")]
     use crate::benchmarking::BenchmarkHelper as BenchmarkHelperTrait;

pallets/rate-limiting/src/lib.rs

@@ -1,6 +1,7 @@
 use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen};
 use frame_support::{pallet_prelude::DispatchError, traits::GetCallMetadata};
 use scale_info::TypeInfo;
+use serde::{Deserialize, Serialize};
 use sp_std::collections::btree_map::BTreeMap;
 
 /// Resolves the optional identifier within which a rate limit applies and can optionally adjust
@@ -31,8 +32,9 @@ pub trait RateLimitUsageResolver<Origin, Call, Usage> {
 }
 
 /// Identifies a runtime call by pallet and extrinsic indices.
-#[cfg_attr(feature = "std", derive(serde::Deserialize, serde::Serialize))]
 #[derive(
+    Serialize,
+    Deserialize,
     Clone,
     Copy,
     PartialEq,
@@ -101,8 +103,9 @@ impl TransactionIdentifier {
 }
 
 /// Policy describing the block span enforced by a rate limit.
-#[cfg_attr(feature = "std", derive(serde::Deserialize, serde::Serialize))]
 #[derive(
+    Serialize,
+    Deserialize,
     Clone,
     Copy,
     PartialEq,
@@ -125,14 +128,21 @@ pub enum RateLimitKind<BlockNumber> {
 ///
 /// The configuration is mutually exclusive: either the call is globally limited or it stores a set
 /// of per-scope spans.
-#[cfg_attr(feature = "std", derive(serde::Deserialize, serde::Serialize))]
-#[cfg_attr(
-    feature = "std",
-    serde(
-        bound = "Scope: Ord + serde::Serialize + serde::de::DeserializeOwned, BlockNumber: serde::Serialize + serde::de::DeserializeOwned"
-    )
+#[derive(
+    Serialize,
+    Deserialize,
+    Clone,
+    PartialEq,
+    Eq,
+    Encode,
+    Decode,
+    DecodeWithMemTracking,
+    TypeInfo,
+    Debug,
+)]
+#[serde(
+    bound = "Scope: Ord + serde::Serialize + serde::de::DeserializeOwned, BlockNumber: serde::Serialize + serde::de::DeserializeOwned"
 )]
-#[derive(Clone, PartialEq, Eq, Encode, Decode, DecodeWithMemTracking, TypeInfo, Debug)]
 pub enum RateLimit<Scope, BlockNumber> {
     /// Global span applied to every invocation.
     Global(RateLimitKind<BlockNumber>),

pallets/rate-limiting/src/types.rs

@@ -1,3 +1,5 @@
+use codec::{Decode, Encode};
+use scale_info::TypeInfo;
 use subtensor_runtime_common::NetUid;
 
 use super::*;

pallets/subtensor/src/utils/rate_limiting.rs

@@ -38,6 +38,7 @@ frame-system = { workspace = true }
 frame-try-runtime = { workspace = true, optional = true }
 pallet-timestamp.workspace = true
 pallet-transaction-payment.workspace = true
+pallet-rate-limiting.workspace = true
 pallet-subtensor-utility.workspace = true
 frame-executive.workspace = true
 frame-metadata-hash-extension.workspace = true
@@ -187,6 +188,7 @@ std = [
 	"pallet-timestamp/std",
 	"pallet-transaction-payment-rpc-runtime-api/std",
 	"pallet-transaction-payment/std",
+	"pallet-rate-limiting/std",
 	"pallet-subtensor-utility/std",
 	"pallet-sudo/std",
 	"pallet-multisig/std",
@@ -328,6 +330,7 @@ try-runtime = [
 	"pallet-insecure-randomness-collective-flip/try-runtime",
 	"pallet-timestamp/try-runtime",
 	"pallet-transaction-payment/try-runtime",
+	"pallet-rate-limiting/try-runtime",
 	"pallet-subtensor-utility/try-runtime",
 	"pallet-safe-mode/try-runtime",
 	"pallet-subtensor/try-runtime",

runtime/Cargo.toml

@@ -12,6 +12,7 @@ use core::num::NonZeroU64;
 
 pub mod check_nonce;
 mod migrations;
+mod rate_limiting;
 pub mod transaction_payment_wrapper;
 
 extern crate alloc;
@@ -70,6 +71,10 @@ use subtensor_precompiles::Precompiles;
 use subtensor_runtime_common::{AlphaCurrency, TaoCurrency, time::*, *};
 use subtensor_swap_interface::{Order, SwapHandler};
 
+pub use rate_limiting::{
+    ScopeResolver as RuntimeScopeResolver, UsageResolver as RuntimeUsageResolver,
+};
+
 // A few exports that help ease life for downstream crates.
 pub use frame_support::{
     StorageValue, construct_runtime, parameter_types,