Add pallet-rate-limiting#2150
Conversation
ales-otf
added
the
skip-cargo-audit
| for entry in pre { | ||
| pallet_rate_limiting::RateLimitTransactionExtension::<Runtime>::post_dispatch( | ||
| entry, info, post_info, len, result, | ||
| )?; | ||
| } |
There was a problem hiding this comment.
If there are some storage writes, we need to account for them in the extension weight fn
| /// Scope identifier used to namespace stored rate limits. | ||
| type LimitScope: Parameter + Clone + PartialEq + Eq + Ord + MaybeSerializeDeserialize; | ||
|
|
There was a problem hiding this comment.
This is kind of hardcoded even though it is behind a config type, no? Right now, it is defined as NetUid, but what will happen if we decide to have some calls scoped to NetUid and some other calls scoped to NetUid + MechId?
There was a problem hiding this comment.
This is the same as with the usage key. It's now NetUid only, because we didn't have other use cases for that. if you want to introduce something like NetUid + MechId, you'd introduce an enum, something like:
enum Scope {
NetUid(NetUid),
NetUidMechId(NetUid, MechId),
}
|
just a few merge conflicts now |
yeah, i have them after almost every push to |
# Conflicts: # Cargo.lock # chain-extensions/src/tests.rs # contract-tests/src/subtensor.ts # contract-tests/test/subnet.precompile.hyperparameter.test.ts # contract-tests/test/wasm.contract.test.ts # pallets/admin-utils/Cargo.toml # pallets/admin-utils/src/lib.rs # pallets/subtensor/src/macros/config.rs # pallets/subtensor/src/migrations/mod.rs # pallets/subtensor/src/staking/add_stake.rs # pallets/subtensor/src/subnets/subnet.rs # pallets/subtensor/src/swap/swap_hotkey.rs # pallets/subtensor/src/tests/mechanism.rs # pallets/subtensor/src/tests/migration.rs # pallets/subtensor/src/tests/mock.rs # pallets/subtensor/src/tests/move_stake.rs # pallets/subtensor/src/tests/staking.rs # pallets/subtensor/src/tests/swap_hotkey.rs # pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs # pallets/subtensor/src/tests/weights.rs # pallets/subtensor/src/utils/misc.rs # pallets/transaction-fee/src/tests/mod.rs # precompiles/Cargo.toml # precompiles/src/lib.rs # runtime/src/lib.rs
# Conflicts: # pallets/subtensor/src/utils/misc.rs
# Conflicts: # pallets/subtensor/src/subnets/serving.rs
- merge devnet
6 participants
Description
This PR introduces
pallet-rate-limitingas a uniform rate-limiting solution and migrates a part of legacy rate limiting to this pallet.Rate limits are set with
pallet_rate_limiting::set_rate_limit(target, scope, limit).targetis either one call or a group of calls.scopeis optional context used to select the configured span (for example,netuid). If a call/group does not need context, it can be configured directly at runtime withtarget + limitand no resolver data.There are standalone calls and groups of calls. Groups are defined at runtime, and each call can be either standalone or within a group, but not both. Groups allow multiple calls to share rate-limiting behavior. Depending on mode (
ConfigOnly,UsageOnly,ConfigAndUsage), calls share config, usage tracking, or both.For calls that need additional context, resolvers provide it. Limits can be configured either globally per target, or scoped per target+scope. The role of
ScopeResolveris to provide that scope context (for example,netuid) so the extension can select the correct scoped limit entry.ScopeResolvercan also adjust span (for example, tempo scaling) and define bypass behavior.UsageResolverresolves usage key(s) soLastSeenis tracked with additional context (for example, per account/per subnet/per mechanism), not only by target.Enforcement happens via
UnwrappedRateLimitTransactionExtension. It first unwraps nested calls (sudo,proxy,utility,multisig), then delegates each inner call toRateLimitTransactionExtension. The extension checks the resolved target/scope and compares current block vsLastSeen. If within span, validation fails withInvalidTransaction::Custom(1). On successful dispatch, the extension writesLastSeenfor resolved usage key(s). This is what enforces rate limiting for subsequent calls.Other pallets should use
rate-limiting-interface(RateLimitingInterface) to read limits and last-seen state without depending on pallet internals. Writes through this interface should be avoided as much as possible because they introduce side-effects. The expected write path is the transaction extension itself. Manualset_last_seenwrites are only for cases where usage must be updated outside the normal rate-limited call path.pallet-rate-limitingis instanceable and is intended to be used as one instance per pallet, with local scope/usage types and resolvers. This runtime currently uses one centralized instance forpallet-subtensor+pallet-admin-utilsas a transitional setup. Migration and resolvers already exist for grouped and standalone legacy limits, but this PR migrates only grouped legacy limits (GroupedRateLimitingMigration). Standalone migration/cleanup is deferred to a follow-up PR.How to review:
I tried to organize this PR so that each major change is represented by a single commit, while avoiding meaningless commits as much as possible. You can refer to the commit history and review changes related to specific limits.
runtime/src/migrations/rate_limiting::commits_grouped. This is where you'll find everything considered "legacy" rate-limiting. You can then review each migration from the list separately.runtime/src/rate_limiting. There you'll find the resolver implementations and can review how different calls are bypassed, adjusted to tempo, and scoped (for limits: only byNetUid; for last-seen timestamp: various cases).runtime/tests/rate_limiting. These are integration tests at the extrinsic level, where transaction extensions are involved. You can verify whether rate-limiting behavior is consistent with legacy behavior and whether all cases are covered.Type of Change
Deprecated extrinsics with their equivalents in
pallet-rate-limitingpallet-admin-utils)pallet-rate-limiting::set_rate_limitparamssudo_set_tx_rate_limit(tx_rate_limit)target = Group(GROUP_SWAP_KEYS), scope = None, limit = Exact(tx_rate_limit)sudo_set_serving_rate_limit(netuid, serving_rate_limit)target = Group(GROUP_SERVE), scope = Some(netuid), limit = Exact(serving_rate_limit)sudo_set_weights_set_rate_limit(netuid, weights_set_rate_limit)target = Group(GROUP_WEIGHTS_SET), scope = Some(netuid), limit = Exact(weights_set_rate_limit)sudo_set_network_rate_limit(limit)target = Group(GROUP_REGISTER_NETWORK), scope = None, limit = Exact(limit)sudo_set_tx_delegate_take_rate_limit(tx_rate_limit)target = Group(GROUP_DELEGATE_TAKE), scope = None, limit = Exact(tx_rate_limit)sudo_set_owner_hparam_rate_limit(epochs)target = Group(GROUP_OWNER_HPARAMS), scope = Some(netuid), limit = Exact(epochs)You can find the values of
GROUP_*constants incommon/src/rate_limiting.rs.From the client's perspective, you can query
pallet-rate-limiting::Groupsstorage to list all groups with their IDs and configuration, orpallet-rate-limiting::GroupNameIndexto get the ID of a particular group by name.Removed storages from
pallet-subtensorOn the client side, use
pallet-rate-limiting::Limitsstorage to fetch limits, orpallet-rate-limiting::LastSeento fetch last-seen timestamps.NetworkRateLimit->Limits({ Group: GROUP_REGISTER_NETWORK })OwnerHyperparamRateLimit->Limits({ Group: GROUP_OWNER_HPARAMS })ServingRateLimit->Limits({ Group: GROUP_SERVE })then scoped value fornetuidStakingOperationRateLimiter->LastSeen({ Group: GROUP_STAKING_OPS }, { ColdkeyHotkeySubnet: { coldkey, hotkey, netuid } })TxDelegateTakeRateLimit->Limits({ Group: GROUP_DELEGATE_TAKE })TxRateLimit->Limits({ Group: GROUP_SWAP_KEYS })WeightsSetRateLimit->Limits({ Group: GROUP_WEIGHTS_SET })then scoped value fornetuidpallet-subtensor::Configchangestype RateLimiting: RateLimitingInterfaceInitialServingRateLimitInitialTxRateLimitInitialTxDelegateTakeRateLimitInitialNetworkRateLimitRemoved events
They moved to
pallet-rate-limiting::RateLimitSetevent like this:NetworkRateLimitSet->{ target: Group(GROUP_REGISTER_NETWORK), scope: None, limit: Exact(span) }OwnerHyperparamRateLimitSet->{ target: Group(GROUP_OWNER_HPARAMS), scope: None, limit: Exact(epochs) }ServingRateLimitSet->{ target: Group(GROUP_SERVE), scope: Some(netuid), limit: Exact(span) }TxDelegateTakeRateLimitSet->{ target: Group(GROUP_DELEGATE_TAKE), scope: None, limit: Exact(span) }TxRateLimitSet->{ target: Group(GROUP_SWAP_KEYS), scope: None, limit: Exact(span) }WeightsSetRateLimitSet->{ target: Group(GROUP_WEIGHTS_SET), scope: Some(netuid), limit: Exact(span) }Additional changes
get_network_lock_cost()now usesT::RateLimiting::last_seen(GROUP_REGISTER_NETWORK, None)instead of legacyRateLimitKey::NetworkLastRegistered.pallet_admin_utils::sudo_set_tx_rate_limit->pallet_rate_limiting::set_rate_limit(... GROUP_SWAP_KEYS)is now limit + 1:pallet_admin_utils::sudo_set_tx_rate_limit(N)) - delta <= limit: a swap was still blocked when exactlyNblocks had passed, and it became allowed only afterN + 1blocks (delta > limit);pallet_rate_limiting::set_rate_limit(... GROUP_SWAP_KEYS, Exact(S))) - delta < span: a swap is blocked while fewer thanSblocks have passed, and it is allowed at exactlySblocks (delta >= span).So to keep the same real wait time as old
N, you must setS = N + 1(N = 0stays0).The reason for this change is that
pallet-rate-limitinguses one unified comparison rule (delta < span) for all limits. We keep that consistent and compensate for this specific legacy boundary in migration (+1).Checklist
cargo fmtandcargo clippyto ensure my code is formatted and linted correctly