Configure pallet-rate-limiting for the runtime

Author: ales-otf

Cargo.lock

@@ -440,7 +440,6 @@ pub mod pallet {
         pub groups: Vec<(<T as Config<I>>::GroupId, Vec<u8>, GroupSharing)>,
     }
 
-    #[cfg(feature = "std")]
     impl<T: Config<I>, I: 'static> Default for GenesisConfig<T, I> {
         fn default() -> Self {
             Self {

pallets/rate-limiting/src/lib.rs

@@ -35,6 +35,16 @@ where
     T: Config<I> + Send + Sync + TypeInfo,
     I: 'static + TypeInfo;
 
+impl<T, I> RateLimitTransactionExtension<T, I>
+where
+    T: Config<I> + Send + Sync + TypeInfo,
+    I: 'static + TypeInfo,
+{
+    pub fn new() -> Self {
+        Self(PhantomData)
+    }
+}
+
 impl<T, I> Clone for RateLimitTransactionExtension<T, I>
 where
     T: Config<I> + Send + Sync + TypeInfo,

pallets/rate-limiting/src/tx_extension.rs

@@ -39,6 +39,7 @@ frame-try-runtime = { workspace = true, optional = true }
 pallet-timestamp.workspace = true
 pallet-transaction-payment.workspace = true
 pallet-rate-limiting.workspace = true
+pallet-rate-limiting-runtime-api.workspace = true
 pallet-subtensor-utility.workspace = true
 frame-executive.workspace = true
 frame-metadata-hash-extension.workspace = true
@@ -189,6 +190,7 @@ std = [
 	"pallet-transaction-payment-rpc-runtime-api/std",
 	"pallet-transaction-payment/std",
 	"pallet-rate-limiting/std",
+	"pallet-rate-limiting-runtime-api/std",
 	"pallet-subtensor-utility/std",
 	"pallet-sudo/std",
 	"pallet-multisig/std",

runtime/Cargo.toml

@@ -24,7 +24,9 @@ use frame_support::{
     dispatch::DispatchResult,
     genesis_builder_helper::{build_state, get_preset},
     pallet_prelude::Get,
-    traits::{Contains, InsideBoth, LinearStoragePrice, fungible::HoldConsideration},
+    traits::{
+        Contains, GetCallMetadata, InsideBoth, LinearStoragePrice, fungible::HoldConsideration,
+    },
 };
 use frame_system::{EnsureRoot, EnsureRootWithSuccess, EnsureSigned};
 use pallet_commitments::{CanCommit, OnMetadataCommitment};
@@ -74,6 +76,8 @@ use subtensor_swap_interface::{Order, SwapHandler};
 pub use rate_limiting::{
     ScopeResolver as RuntimeScopeResolver, UsageResolver as RuntimeUsageResolver,
 };
+pub type RateLimitingInstance = ();
+pub type RateLimitGroupId = u32;
 
 // A few exports that help ease life for downstream crates.
 pub use frame_support::{
@@ -158,6 +162,7 @@ impl frame_system::offchain::CreateSignedTransaction<pallet_drand::Call<Runtime>
             frame_system::CheckEra::<Runtime>::from(Era::Immortal),
             check_nonce::CheckNonce::<Runtime>::from(nonce).into(),
             frame_system::CheckWeight::<Runtime>::new(),
+            pallet_rate_limiting::RateLimitTransactionExtension::<Runtime>::new(),
             ChargeTransactionPaymentWrapper::new(
                 pallet_transaction_payment::ChargeTransactionPayment::<Runtime>::from(0),
             ),
@@ -225,10 +230,10 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
     //   `spec_version`, and `authoring_version` are the same between Wasm and native.
     // This value is set to 100 to notify Polkadot-JS App (https://polkadot.js.org/apps) to use
     //   the compatible custom types.
-    spec_version: 347,
+    spec_version: 348,
     impl_version: 1,
     apis: RUNTIME_API_VERSIONS,
-    transaction_version: 1,
+    transaction_version: 2,
     system_version: 1,
 };
 
@@ -1121,6 +1126,25 @@ impl pallet_subtensor::Config for Runtime {
     type EvmKeyAssociateRateLimit = EvmKeyAssociateRateLimit;
 }
 
+parameter_types! {
+    pub const RateLimitingMaxGroupMembers: u32 = 64;
+    pub const RateLimitingMaxGroupNameLength: u32 = 64;
+}
+
+impl pallet_rate_limiting::Config for Runtime {
+    type RuntimeCall = RuntimeCall;
+    type AdminOrigin = EnsureRoot<AccountId>;
+    type LimitScope = RateLimitScope;
+    type LimitScopeResolver = RuntimeScopeResolver;
+    type UsageKey = RateLimitUsageKey<AccountId>;
+    type UsageResolver = RuntimeUsageResolver;
+    type GroupId = u32;
+    type MaxGroupMembers = RateLimitingMaxGroupMembers;
+    type MaxGroupNameLength = RateLimitingMaxGroupNameLength;
+    #[cfg(feature = "runtime-benchmarks")]
+    type BenchmarkHelper = ();
+}
+
 parameter_types! {
     pub const SwapProtocolId: PalletId = PalletId(*b"ten/swap");
     pub const SwapMaxFeeRate: u16 = 10000; // 15.26%
@@ -1574,6 +1598,7 @@ construct_runtime!(
         Crowdloan: pallet_crowdloan = 27,
         Swap: pallet_subtensor_swap = 28,
         Contracts: pallet_contracts = 29,
+        RateLimiting: pallet_rate_limiting = 30,
     }
 );
 
@@ -1592,6 +1617,7 @@ pub type TransactionExtensions = (
     frame_system::CheckEra<Runtime>,
     check_nonce::CheckNonce<Runtime>,
     frame_system::CheckWeight<Runtime>,
+    pallet_rate_limiting::RateLimitTransactionExtension<Runtime>,
     ChargeTransactionPaymentWrapper<Runtime>,
     pallet_subtensor::transaction_extension::SubtensorTransactionExtension<Runtime>,
     pallet_drand::drand_priority::DrandPriority<Runtime>,
@@ -1610,6 +1636,7 @@ type Migrations = (
     pallet_subtensor::migrations::migrate_init_total_issuance::initialise_total_issuance::Migration<
         Runtime,
     >,
+    rate_limiting::migration::Migration<Runtime>,
     // Remove storage from removed governance pallets
     frame_support::migrations::RemovePallet<TriumviratePalletStr, RocksDbWeight>,
     frame_support::migrations::RemovePallet<TriumvirateMembersPalletStr, RocksDbWeight>,
@@ -2162,6 +2189,80 @@ impl_runtime_apis! {
         }
     }
 
+    impl pallet_rate_limiting_runtime_api::RateLimitingRuntimeApi<Block> for Runtime {
+        fn get_rate_limit(
+            pallet: Vec<u8>,
+            extrinsic: Vec<u8>,
+        ) -> Option<pallet_rate_limiting_runtime_api::RateLimitRpcResponse> {
+            use pallet_rate_limiting::{
+                RateLimit, RateLimitKind, RateLimitTarget, TransactionIdentifier,
+            };
+            use pallet_rate_limiting_runtime_api::RateLimitRpcResponse;
+
+            let pallet_name = sp_std::str::from_utf8(&pallet).ok()?;
+            let extrinsic_name = sp_std::str::from_utf8(&extrinsic).ok()?;
+
+            let pallet_index = u8::try_from(
+                RuntimeCall::get_module_names()
+                    .iter()
+                    .position(|name| *name == pallet_name)?,
+            )
+            .ok()?;
+            let extrinsic_index = u8::try_from(
+                RuntimeCall::get_call_names(pallet_name)
+                    .iter()
+                    .position(|name| *name == extrinsic_name)?,
+            )
+            .ok()?;
+
+            let identifier = TransactionIdentifier::new(pallet_index, extrinsic_index);
+            let target = if let Some(group_id) =
+                pallet_rate_limiting::CallGroups::<Runtime>::get(identifier)
+            {
+                let uses_group = pallet_rate_limiting::Groups::<Runtime>::get(
+                    group_id,
+                )
+                .map(|details| details.sharing.config_uses_group())
+                .unwrap_or(false);
+
+                if uses_group {
+                    RateLimitTarget::Group(group_id)
+                } else {
+                    RateLimitTarget::Transaction(identifier)
+                }
+            } else {
+                RateLimitTarget::Transaction(identifier)
+            };
+
+            let limits =
+                pallet_rate_limiting::Limits::<Runtime>::get(target)?;
+            let default_limit =
+                pallet_rate_limiting::DefaultLimit::<Runtime>::get();
+            let resolved = limits.kind_for(None).map(|kind| match *kind {
+                RateLimitKind::Default => default_limit,
+                RateLimitKind::Exact(span) => span,
+            });
+
+            let (global, contextual) = match limits {
+                RateLimit::Global(kind) => (Some(kind), sp_std::vec::Vec::new()),
+                RateLimit::Scoped(entries) => (
+                    None,
+                    entries
+                        .into_iter()
+                        .map(|(scope, kind)| (scope.encode(), kind))
+                        .collect(),
+                ),
+            };
+
+            Some(RateLimitRpcResponse {
+                global,
+                contextual,
+                default_limit,
+                resolved,
+            })
+        }
+    }
+
     impl pallet_contracts::ContractsApi<Block, AccountId, Balance, BlockNumber, Hash, EventRecord>
         for Runtime
     {