code/runtime/src/proxy_filters/call_groups.rs
//! Runtime call inventory for proxy filters.
//!
//! Keep this file boring: one generated group per call-bearing runtime pallet.
//! Proxy-specific policy belongs in `mod.rs`.
// The Owner proxy keeps deprecated Subtensor tempo calls for encoded-call compatibility.
#![allow(deprecated)]
use frame_system::Call as SystemCall;
use pallet_admin_utils::Call as AdminUtilsCall;
use pallet_balances::Call as BalancesCall;
use pallet_base_fee::Call as BaseFeeCall;
use pallet_commitments::Call as CommitmentsCall;
use pallet_contracts::Call as ContractsCall;
use pallet_crowdloan::Call as CrowdloanCall;
use pallet_drand::Call as DrandCall;
use pallet_ethereum::Call as EthereumCall;
use pallet_evm::Call as EvmCall;
use pallet_grandpa::Call as GrandpaCall;
use pallet_limit_orders::Call as LimitOrdersCall;
use pallet_multisig::Call as MultisigCall;
use pallet_preimage::Call as PreimageCall;
use pallet_safe_mode::Call as SafeModeCall;
use pallet_scheduler::Call as SchedulerCall;
use pallet_shield::Call as MevShieldCall;
use pallet_subtensor::Call as SubtensorCall;
use pallet_subtensor_proxy::Call as ProxyCall;
use pallet_subtensor_swap::Call as SwapCall;
use pallet_subtensor_utility::Call as UtilityCall;
use pallet_sudo::Call as SudoCall;
use pallet_timestamp::Call as TimestampCall;
use subtensor_macros::call_filter_group;
use subtensor_runtime_common::{SMALL_ALPHA_TRANSFER_LIMIT, SMALL_TRANSFER_LIMIT};
call_filter_group!(
SystemCalls,
[
RuntimeCall::System(SystemCall::remark),
RuntimeCall::System(SystemCall::remark_with_event),
RuntimeCall::System(SystemCall::set_heap_pages),
RuntimeCall::System(SystemCall::set_code),
RuntimeCall::System(SystemCall::set_code_without_checks),
RuntimeCall::System(SystemCall::set_storage),
RuntimeCall::System(SystemCall::kill_storage),
RuntimeCall::System(SystemCall::kill_prefix),
RuntimeCall::System(SystemCall::authorize_upgrade),
RuntimeCall::System(SystemCall::authorize_upgrade_without_checks),
RuntimeCall::System(SystemCall::apply_authorized_upgrade),
]
);
call_filter_group!(
TimestampCalls,
[RuntimeCall::Timestamp(TimestampCall::set),]
);
call_filter_group!(
GrandpaCalls,
[
RuntimeCall::Grandpa(GrandpaCall::report_equivocation),
RuntimeCall::Grandpa(GrandpaCall::report_equivocation_unsigned),
RuntimeCall::Grandpa(GrandpaCall::note_stalled),
]
);
call_filter_group!(
SafeModeCalls,
[
RuntimeCall::SafeMode(SafeModeCall::enter),
RuntimeCall::SafeMode(SafeModeCall::force_enter),
RuntimeCall::SafeMode(SafeModeCall::extend),
RuntimeCall::SafeMode(SafeModeCall::force_extend),
RuntimeCall::SafeMode(SafeModeCall::force_exit),
RuntimeCall::SafeMode(SafeModeCall::force_slash_deposit),
RuntimeCall::SafeMode(SafeModeCall::release_deposit),
RuntimeCall::SafeMode(SafeModeCall::force_release_deposit),
]
);
call_filter_group!(
EthereumCalls,
[RuntimeCall::Ethereum(EthereumCall::transact),]
);
call_filter_group!(
EvmCalls,
[
RuntimeCall::EVM(EvmCall::withdraw),
RuntimeCall::EVM(EvmCall::call),
RuntimeCall::EVM(EvmCall::create),
RuntimeCall::EVM(EvmCall::create2),
RuntimeCall::EVM(EvmCall::set_whitelist),
RuntimeCall::EVM(EvmCall::disable_whitelist),
]
);
call_filter_group!(
BaseFeeCalls,
[
RuntimeCall::BaseFee(BaseFeeCall::set_base_fee_per_gas),
RuntimeCall::BaseFee(BaseFeeCall::set_elasticity),
]
);
call_filter_group!(
DrandCalls,
[
RuntimeCall::Drand(DrandCall::write_pulse),
RuntimeCall::Drand(DrandCall::set_beacon_config),
RuntimeCall::Drand(DrandCall::set_oldest_stored_round),
]
);
call_filter_group!(
CrowdloanCalls,
[
RuntimeCall::Crowdloan(CrowdloanCall::create),
RuntimeCall::Crowdloan(CrowdloanCall::contribute),
RuntimeCall::Crowdloan(CrowdloanCall::withdraw),
RuntimeCall::Crowdloan(CrowdloanCall::finalize),
RuntimeCall::Crowdloan(CrowdloanCall::refund),
RuntimeCall::Crowdloan(CrowdloanCall::dissolve),
RuntimeCall::Crowdloan(CrowdloanCall::update_min_contribution),
RuntimeCall::Crowdloan(CrowdloanCall::update_end),
RuntimeCall::Crowdloan(CrowdloanCall::update_cap),
RuntimeCall::Crowdloan(CrowdloanCall::set_max_contribution),
]
);
call_filter_group!(
SwapCalls,
[
RuntimeCall::Swap(SwapCall::toggle_user_liquidity),
RuntimeCall::Swap(SwapCall::add_liquidity),
RuntimeCall::Swap(SwapCall::remove_liquidity),
RuntimeCall::Swap(SwapCall::modify_position),
RuntimeCall::Swap(SwapCall::disable_lp),
RuntimeCall::Swap(SwapCall::set_fee_rate),
]
);
call_filter_group!(
ContractsCalls,
[
RuntimeCall::Contracts(ContractsCall::call_old_weight),
RuntimeCall::Contracts(ContractsCall::instantiate_with_code_old_weight),
RuntimeCall::Contracts(ContractsCall::instantiate_old_weight),
RuntimeCall::Contracts(ContractsCall::upload_code),
RuntimeCall::Contracts(ContractsCall::remove_code),
RuntimeCall::Contracts(ContractsCall::set_code),
RuntimeCall::Contracts(ContractsCall::call),
RuntimeCall::Contracts(ContractsCall::instantiate_with_code),
RuntimeCall::Contracts(ContractsCall::instantiate),
RuntimeCall::Contracts(ContractsCall::migrate),
]
);
call_filter_group!(
MevShieldCalls,
[
RuntimeCall::MevShield(MevShieldCall::announce_next_key),
RuntimeCall::MevShield(MevShieldCall::submit_encrypted),
RuntimeCall::MevShield(MevShieldCall::store_encrypted),
RuntimeCall::MevShield(MevShieldCall::set_max_pending_extrinsics_number),
RuntimeCall::MevShield(MevShieldCall::set_on_initialize_weight),
RuntimeCall::MevShield(MevShieldCall::set_stored_extrinsic_lifetime),
RuntimeCall::MevShield(MevShieldCall::set_max_extrinsic_weight),
]
);
call_filter_group!(
LimitOrdersCalls,
[
RuntimeCall::LimitOrders(LimitOrdersCall::execute_orders),
RuntimeCall::LimitOrders(LimitOrdersCall::execute_batched_orders),
RuntimeCall::LimitOrders(LimitOrdersCall::cancel_order),
RuntimeCall::LimitOrders(LimitOrdersCall::set_pallet_status),
]
);
call_filter_group!(
UtilityCalls,
[
RuntimeCall::Utility(UtilityCall::batch),
RuntimeCall::Utility(UtilityCall::as_derivative),
RuntimeCall::Utility(UtilityCall::batch_all),
RuntimeCall::Utility(UtilityCall::dispatch_as),
RuntimeCall::Utility(UtilityCall::force_batch),
RuntimeCall::Utility(UtilityCall::with_weight),
RuntimeCall::Utility(UtilityCall::if_else),
RuntimeCall::Utility(UtilityCall::dispatch_as_fallible),
]
);
call_filter_group!(
SudoCalls,
[
RuntimeCall::Sudo(SudoCall::sudo),
RuntimeCall::Sudo(SudoCall::sudo_unchecked_weight),
RuntimeCall::Sudo(SudoCall::set_key),
RuntimeCall::Sudo(SudoCall::sudo_as),
RuntimeCall::Sudo(SudoCall::remove_key),
]
);
call_filter_group!(
MultisigCalls,
[
RuntimeCall::Multisig(MultisigCall::as_multi_threshold_1),
RuntimeCall::Multisig(MultisigCall::as_multi),
RuntimeCall::Multisig(MultisigCall::approve_as_multi),
RuntimeCall::Multisig(MultisigCall::cancel_as_multi),
RuntimeCall::Multisig(MultisigCall::poke_deposit),
]
);
call_filter_group!(
PreimageCalls,
[
RuntimeCall::Preimage(PreimageCall::note_preimage),
RuntimeCall::Preimage(PreimageCall::unnote_preimage),
RuntimeCall::Preimage(PreimageCall::request_preimage),
RuntimeCall::Preimage(PreimageCall::unrequest_preimage),
RuntimeCall::Preimage(PreimageCall::ensure_updated),
]
);
call_filter_group!(
SchedulerCalls,
[
RuntimeCall::Scheduler(SchedulerCall::schedule),
RuntimeCall::Scheduler(SchedulerCall::cancel),
RuntimeCall::Scheduler(SchedulerCall::schedule_named),
RuntimeCall::Scheduler(SchedulerCall::cancel_named),
RuntimeCall::Scheduler(SchedulerCall::schedule_after),
RuntimeCall::Scheduler(SchedulerCall::schedule_named_after),
RuntimeCall::Scheduler(SchedulerCall::set_retry),
RuntimeCall::Scheduler(SchedulerCall::set_retry_named),
RuntimeCall::Scheduler(SchedulerCall::cancel_retry),
RuntimeCall::Scheduler(SchedulerCall::cancel_retry_named),
]
);
call_filter_group!(
ProxyCalls,
[
RuntimeCall::Proxy(ProxyCall::proxy),
RuntimeCall::Proxy(ProxyCall::add_proxy),
RuntimeCall::Proxy(ProxyCall::remove_proxy),
RuntimeCall::Proxy(ProxyCall::remove_proxies),
RuntimeCall::Proxy(ProxyCall::create_pure),
RuntimeCall::Proxy(ProxyCall::kill_pure),
RuntimeCall::Proxy(ProxyCall::announce),
RuntimeCall::Proxy(ProxyCall::remove_announcement),
RuntimeCall::Proxy(ProxyCall::reject_announcement),
RuntimeCall::Proxy(ProxyCall::proxy_announced),
RuntimeCall::Proxy(ProxyCall::poke_deposit),
RuntimeCall::Proxy(ProxyCall::set_real_pays_fee),
]
);
call_filter_group!(
CommitmentsCalls,
[
RuntimeCall::Commitments(CommitmentsCall::set_commitment),
RuntimeCall::Commitments(CommitmentsCall::set_max_space),
]
);
// Ordinary balance transfers — moving your own free balance.
call_filter_group!(
BalanceTransferCalls,
[
RuntimeCall::Balances(BalancesCall::transfer_keep_alive),
RuntimeCall::Balances(BalancesCall::transfer_allow_death),
RuntimeCall::Balances(BalancesCall::transfer_all),
]
);
// Privileged, root-only balance operations (force transfer/unreserve, burn,
// issuance adjustment).
call_filter_group!(
BalanceMaintenanceCalls,
[
RuntimeCall::Balances(BalancesCall::force_transfer),
RuntimeCall::Balances(BalancesCall::force_unreserve),
RuntimeCall::Balances(BalancesCall::upgrade_accounts),
RuntimeCall::Balances(BalancesCall::force_set_balance),
RuntimeCall::Balances(BalancesCall::force_adjust_total_issuance),
RuntimeCall::Balances(BalancesCall::burn),
]
);
// Managing your own stake: add, remove, and move between hotkeys/subnets.
call_filter_group!(
StakeManagementCalls,
[
RuntimeCall::SubtensorModule(SubtensorCall::add_stake),
RuntimeCall::SubtensorModule(SubtensorCall::add_stake_limit),
RuntimeCall::SubtensorModule(SubtensorCall::remove_stake),
RuntimeCall::SubtensorModule(SubtensorCall::remove_stake_limit),
RuntimeCall::SubtensorModule(SubtensorCall::remove_stake_full_limit),
RuntimeCall::SubtensorModule(SubtensorCall::unstake_all),
RuntimeCall::SubtensorModule(SubtensorCall::unstake_all_alpha),
RuntimeCall::SubtensorModule(SubtensorCall::move_stake),
RuntimeCall::SubtensorModule(SubtensorCall::swap_stake),
RuntimeCall::SubtensorModule(SubtensorCall::swap_stake_limit),
]
);
// Moving staked value to another coldkey — the stake analogue of a transfer.
call_filter_group!(
StakeTransferCalls,
[RuntimeCall::SubtensorModule(SubtensorCall::transfer_stake),]
);
// Permissionless proof-of-work registration (costs no TAO).
call_filter_group!(
PowRegistrationCalls,
[
RuntimeCall::SubtensorModule(SubtensorCall::register),
RuntimeCall::SubtensorModule(SubtensorCall::register_limit),
]
);
// Registration paid by burning TAO (spends value, unlike POW registration).
call_filter_group!(
BurnedRegistrationCalls,
[RuntimeCall::SubtensorModule(SubtensorCall::burned_register),]
);
// Registration into the root subnet.
call_filter_group!(
RootRegistrationCalls,
[RuntimeCall::SubtensorModule(SubtensorCall::root_register),]
);
// Development/testnet faucet. This call only exists when the runtime is built
// with `pow-faucet`, so the group is empty in production-feature builds.
#[cfg(feature = "pow-faucet")]
call_filter_group!(
FaucetCalls,
[RuntimeCall::SubtensorModule(SubtensorCall::faucet),]
);
#[cfg(not(feature = "pow-faucet"))]
pub(super) struct FaucetCalls;
#[cfg(not(feature = "pow-faucet"))]
impl frame_support::traits::Contains<crate::RuntimeCall> for FaucetCalls {
fn contains(_call: &crate::RuntimeCall) -> bool {
false
}
}
#[cfg(not(feature = "pow-faucet"))]
impl subtensor_runtime_common::CallFilterMetadata for FaucetCalls {
fn call_infos() -> ::alloc::vec::Vec<subtensor_runtime_common::CallInfo> {
::alloc::vec::Vec::new()
}
}
// Rotating a neuron's hotkey.
call_filter_group!(
HotkeySwapCalls,
[
RuntimeCall::SubtensorModule(SubtensorCall::swap_hotkey),
RuntimeCall::SubtensorModule(SubtensorCall::swap_hotkey_v2),
]
);
// Rotating a coldkey — the full account-takeover surface.
call_filter_group!(
ColdkeySwapCalls,
[
RuntimeCall::SubtensorModule(SubtensorCall::schedule_swap_coldkey),
RuntimeCall::SubtensorModule(SubtensorCall::swap_coldkey),
RuntimeCall::SubtensorModule(SubtensorCall::announce_coldkey_swap),
RuntimeCall::SubtensorModule(SubtensorCall::swap_coldkey_announced),
RuntimeCall::SubtensorModule(SubtensorCall::clear_coldkey_swap_announcement),
RuntimeCall::SubtensorModule(SubtensorCall::dispute_coldkey_swap),
RuntimeCall::SubtensorModule(SubtensorCall::reset_coldkey_swap),
]
);
// Dissolving a subnet — irreversible network destruction.
call_filter_group!(
CriticalNetworkCalls,
[
RuntimeCall::SubtensorModule(SubtensorCall::dissolve_network),
RuntimeCall::SubtensorModule(SubtensorCall::root_dissolve_network),
]
);
// Delegating a hotkey's work to child keys.
call_filter_group!(
ChildKeyCalls,
[
RuntimeCall::SubtensorModule(SubtensorCall::set_children),
RuntimeCall::SubtensorModule(SubtensorCall::set_childkey_take),
]
);
// Claiming accumulated root dividends.
call_filter_group!(
RootClaimCalls,
[RuntimeCall::SubtensorModule(SubtensorCall::claim_root),]
);
// Selecting how root dividends are claimed (a staking-side setting).
call_filter_group!(
RootClaimTypeCalls,
[RuntimeCall::SubtensorModule(
SubtensorCall::set_root_claim_type
),]
);
// A subnet's public identity and token symbol.
call_filter_group!(
SubnetIdentityCalls,
[
RuntimeCall::SubtensorModule(SubtensorCall::set_subnet_identity),
RuntimeCall::SubtensorModule(SubtensorCall::update_symbol),
]
);
// Starting a subnet's emission schedule (start_call).
call_filter_group!(
SubnetActivationCalls,
[RuntimeCall::SubtensorModule(SubtensorCall::start_call),]
);
// Residual pallet-subtensor calls that no proxy needs to grant on their own:
// weights, serving, delegate-take, alpha lock/burn/preferences, network
// registration, childkey admin, account association, tempo control, voting
// power, root-claim admin, and lease teardown.
call_filter_group!(
SubtensorCommonCalls,
[
RuntimeCall::SubtensorModule(SubtensorCall::set_weights),
RuntimeCall::SubtensorModule(SubtensorCall::set_mechanism_weights),
RuntimeCall::SubtensorModule(SubtensorCall::batch_set_weights),
RuntimeCall::SubtensorModule(SubtensorCall::commit_weights),
RuntimeCall::SubtensorModule(SubtensorCall::commit_mechanism_weights),
RuntimeCall::SubtensorModule(SubtensorCall::batch_commit_weights),
RuntimeCall::SubtensorModule(SubtensorCall::commit_crv3_mechanism_weights),
RuntimeCall::SubtensorModule(SubtensorCall::commit_timelocked_weights),
RuntimeCall::SubtensorModule(SubtensorCall::commit_timelocked_mechanism_weights),
RuntimeCall::SubtensorModule(SubtensorCall::reveal_weights),
RuntimeCall::SubtensorModule(SubtensorCall::reveal_mechanism_weights),
RuntimeCall::SubtensorModule(SubtensorCall::batch_reveal_weights),
RuntimeCall::SubtensorModule(SubtensorCall::add_stake_burn),
RuntimeCall::SubtensorModule(SubtensorCall::lock_stake),
RuntimeCall::SubtensorModule(SubtensorCall::move_lock),
RuntimeCall::SubtensorModule(SubtensorCall::set_perpetual_lock),
RuntimeCall::SubtensorModule(SubtensorCall::set_reject_locked_alpha),
RuntimeCall::SubtensorModule(SubtensorCall::recycle_alpha),
RuntimeCall::SubtensorModule(SubtensorCall::burn_alpha),
RuntimeCall::SubtensorModule(SubtensorCall::register_network),
RuntimeCall::SubtensorModule(SubtensorCall::register_network_with_identity),
RuntimeCall::SubtensorModule(SubtensorCall::register_leased_network),
RuntimeCall::SubtensorModule(SubtensorCall::decrease_take),
RuntimeCall::SubtensorModule(SubtensorCall::increase_take),
RuntimeCall::SubtensorModule(SubtensorCall::serve_axon),
RuntimeCall::SubtensorModule(SubtensorCall::serve_axon_tls),
RuntimeCall::SubtensorModule(SubtensorCall::serve_prometheus),
RuntimeCall::SubtensorModule(SubtensorCall::set_identity),
RuntimeCall::SubtensorModule(SubtensorCall::try_associate_hotkey),
RuntimeCall::SubtensorModule(SubtensorCall::associate_evm_key),
RuntimeCall::SubtensorModule(SubtensorCall::set_coldkey_auto_stake_hotkey),
RuntimeCall::SubtensorModule(SubtensorCall::set_pending_childkey_cooldown),
RuntimeCall::SubtensorModule(SubtensorCall::set_auto_parent_delegation_enabled),
RuntimeCall::SubtensorModule(SubtensorCall::sudo_set_tx_childkey_take_rate_limit),
RuntimeCall::SubtensorModule(SubtensorCall::sudo_set_min_childkey_take),
RuntimeCall::SubtensorModule(SubtensorCall::sudo_set_max_childkey_take),
RuntimeCall::SubtensorModule(SubtensorCall::terminate_lease),
RuntimeCall::SubtensorModule(SubtensorCall::trigger_epoch),
RuntimeCall::SubtensorModule(SubtensorCall::sudo_set_num_root_claims),
RuntimeCall::SubtensorModule(SubtensorCall::sudo_set_root_claim_threshold),
RuntimeCall::SubtensorModule(SubtensorCall::enable_voting_power_tracking),
RuntimeCall::SubtensorModule(SubtensorCall::disable_voting_power_tracking),
RuntimeCall::SubtensorModule(SubtensorCall::sudo_set_voting_power_ema_alpha),
]
);
// Subnet parameters a subnet owner may set directly. This includes deprecated
// Subtensor compatibility calls plus AdminUtils calls guarded by
// `ensure_sn_owner_or_root`, as opposed to the root-only `RootConfigCalls`.
call_filter_group!(
SubnetManagementCalls,
[
RuntimeCall::SubtensorModule(SubtensorCall::set_tempo),
RuntimeCall::SubtensorModule(SubtensorCall::set_activity_cutoff_factor),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_serving_rate_limit),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_max_difficulty),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_weights_version_key),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_adjustment_alpha),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_immunity_period),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_min_allowed_weights),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_rho),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_activity_cutoff),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_activity_cutoff_factor),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_tempo),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_min_burn),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_max_burn),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_bonds_moving_average),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_bonds_penalty),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_min_childkey_take_per_subnet),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_commit_reveal_weights_enabled),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_liquid_alpha_enabled),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_alpha_values),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_commit_reveal_weights_interval),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_toggle_transfer),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_recycle_or_burn),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_alpha_sigmoid_steepness),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_yuma3_enabled),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_bonds_reset_enabled),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_owner_immune_neuron_limit),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_mechanism_count),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_mechanism_emission_split),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_trim_to_max_allowed_uids),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_max_allowed_uids),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_burn_half_life),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_burn_increase_mult),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_owner_cut_enabled),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_owner_cut_auto_lock_enabled),
]
);
// Admin parameters that require root (set via sudo / governance). A subnet
// owner cannot call these; they reach the broad proxies only as inert grants
// (the dispatch's `ensure_root` rejects a proxy's signed origin). Includes the
// two deprecated extrinsics that always error.
call_filter_group!(
RootConfigCalls,
[
RuntimeCall::AdminUtils(AdminUtilsCall::swap_authorities),
RuntimeCall::AdminUtils(AdminUtilsCall::schedule_grandpa_change),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_default_take),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_tx_rate_limit),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_min_difficulty),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_weights_set_rate_limit),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_adjustment_interval),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_kappa),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_network_registration_allowed),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_network_pow_registration_allowed),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_target_registrations_per_interval),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_difficulty),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_max_allowed_validators),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_max_registrations_per_block),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_subnet_owner_cut),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_network_rate_limit),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_total_issuance),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_network_immunity_period),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_network_min_lock_cost),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_subnet_limit),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_lock_reduction_interval),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_rao_recycled),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_stake_threshold),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_nominator_min_required_stake),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_tx_delegate_take_rate_limit),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_min_delegate_take),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_dissolve_network_schedule_duration),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_evm_chain_id),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_toggle_evm_precompile),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_subnet_moving_alpha),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_ema_price_halving_period),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_subtoken_enabled),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_commit_reveal_version),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_ck_burn),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_admin_freeze_window),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_owner_hparam_rate_limit),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_min_allowed_uids),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_min_non_immune_uids),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_tao_flow_cutoff),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_tao_flow_normalization_exponent),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_tao_flow_smoothing_factor),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_net_tao_flow_enabled),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_max_mechanism_count),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_start_call_delay),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_coldkey_swap_announcement_delay),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_coldkey_swap_reannouncement_delay),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_subnet_emission_enabled),
RuntimeCall::AdminUtils(AdminUtilsCall::sudo_set_max_epochs_per_block),
]
);
// Rotating a subnet's owner key — an ownership-takeover vector, deliberately
// kept out of the Owner proxy.
call_filter_group!(
OwnerKeyCalls,
[RuntimeCall::AdminUtils(
AdminUtilsCall::sudo_set_sn_owner_hotkey
),]
);
// ============================================================================
// Conditional, proxy-specific groups
//
// These carry amount / nested-call constraints, so they overlap the inventory
// groups above (e.g. `transfer_keep_alive` is also in `BalanceTransferCalls`).
// They are deliberately excluded from `AllCalls` to keep that a non-overlapping
// partition. Generating them with the same macro keeps the executable filter
// and the client-facing metadata in lockstep.
// ============================================================================
// `SmallTransfer`: amount-bounded balance and stake transfers.
call_filter_group!(SmallTransferCalls, [
RuntimeCall::Balances(BalancesCall::transfer_keep_alive)
where value < SMALL_TRANSFER_LIMIT,
RuntimeCall::Balances(BalancesCall::transfer_allow_death)
where value < SMALL_TRANSFER_LIMIT,
RuntimeCall::SubtensorModule(SubtensorCall::transfer_stake)
where alpha_amount < SMALL_ALPHA_TRANSFER_LIMIT,
]);
// `SudoUncheckedSetCode`: a single sudo call, only when it wraps
// `System::set_code`.
call_filter_group!(SudoSetCodeCalls, [
RuntimeCall::Sudo(SudoCall::sudo_unchecked_weight)
where nested(call) == RuntimeCall::System(SystemCall::set_code),
]);
// Full inventory of every runtime call, used only by the coverage test that
// checks it against `RuntimeCall` metadata. Nested in three blocks so the
// flattened tuple stays within the `CallFilterMetadata` tuple-impl arity;
// `call_infos()` recurses regardless.
// Infrastructure pallets granted wholesale to the broad proxies, excluding
// `SudoCalls` (which `NonCritical` denies). Shared by the proxy policy in
// `mod.rs` and by the `WholesalePalletCalls` inventory below so the list lives
// in one place.
pub(super) type InfraCommonCalls = (
SystemCalls,
TimestampCalls,
GrandpaCalls,
UtilityCalls,
MultisigCalls,
PreimageCalls,
SchedulerCalls,
ProxyCalls,
CommitmentsCalls,
SafeModeCalls,
EthereumCalls,
EvmCalls,
BaseFeeCalls,
DrandCalls,
CrowdloanCalls,
SwapCalls,
ContractsCalls,
MevShieldCalls,
LimitOrdersCalls,
);
#[cfg(test)]
pub(super) type AllCalls = (
WholesalePalletCalls,
SubtensorSplitCalls,
AdminUtilsSplitCalls,
);
// Pallets every granting proxy grants in full.
#[cfg(test)]
type WholesalePalletCalls = (InfraCommonCalls, SudoCalls);
// Balances + pallet-subtensor, split by proxy membership.
#[cfg(test)]
type SubtensorSplitCalls = (
BalanceTransferCalls,
BalanceMaintenanceCalls,
StakeManagementCalls,
StakeTransferCalls,
PowRegistrationCalls,
BurnedRegistrationCalls,
RootRegistrationCalls,
FaucetCalls,
HotkeySwapCalls,
ColdkeySwapCalls,
CriticalNetworkCalls,
ChildKeyCalls,
RootClaimCalls,
RootClaimTypeCalls,
SubnetIdentityCalls,
SubnetActivationCalls,
SubtensorCommonCalls,
);
// AdminUtils calls and deprecated owner-call shims, split for owner proxies.
#[cfg(test)]
type AdminUtilsSplitCalls = (SubnetManagementCalls, RootConfigCalls, OwnerKeyCalls);
#[cfg(test)]
mod tests {
use super::*;
use crate::RuntimeCall;
use alloc::{collections::BTreeSet, format, string::String, vec::Vec};
use frame_support::traits::GetCallMetadata;
use subtensor_runtime_common::{CallFilterMetadata, CallInfo};
#[test]
fn all_call_groups_cover_runtime_call_metadata() {
let groups_call_infos = AllCalls::call_infos();
let groups_call_names = call_names_from_group_infos(&groups_call_infos);
let runtime_call_names = call_names_from_runtime_metadata();
let duplicate_group_calls = duplicate_call_names(&groups_call_infos);
let missing_from_groups = runtime_call_names
.difference(&groups_call_names)
.cloned()
.collect::<Vec<_>>();
let extra_in_groups = groups_call_names
.difference(&runtime_call_names)
.cloned()
.collect::<Vec<_>>();
assert!(
missing_from_groups.is_empty()
&& extra_in_groups.is_empty()
&& duplicate_group_calls.is_empty(),
"AllCalls inventory does not match RuntimeCall metadata.\n\
call_infos: {}\n\
runtime calls: {}\n\
missing from AllCalls ({}):\n{}\n\
extra in AllCalls ({}):\n{}\n\
duplicates in AllCalls ({}):\n{}",
groups_call_names.len(),
runtime_call_names.len(),
missing_from_groups.len(),
format_call_list(&missing_from_groups),
extra_in_groups.len(),
format_call_list(&extra_in_groups),
duplicate_group_calls.len(),
format_call_list(&duplicate_group_calls),
);
}
fn call_names_from_group_infos(call_infos: &[CallInfo]) -> BTreeSet<String> {
call_infos.iter().map(format_call_info).collect()
}
fn call_names_from_runtime_metadata() -> BTreeSet<String> {
RuntimeCall::get_module_names()
.iter()
.flat_map(|module| {
RuntimeCall::get_call_names(module)
.iter()
.map(move |call| format!("{}::{}", module, call))
})
.collect()
}
fn duplicate_call_names(call_infos: &[CallInfo]) -> Vec<String> {
let mut seen = BTreeSet::new();
let mut duplicates = Vec::new();
for call_info in call_infos {
let call_name = format_call_info(call_info);
if !seen.insert(call_name.clone()) {
duplicates.push(call_name);
}
}
duplicates
}
fn format_call_info(call_info: &CallInfo) -> String {
format!(
"{}::{}",
String::from_utf8_lossy(&call_info.pallet_name),
String::from_utf8_lossy(&call_info.call_name)
)
}
fn format_call_list(calls: &[String]) -> String {
if calls.is_empty() {
return " <none>".into();
}
calls
.iter()
.map(|call| format!(" {}", call))
.collect::<Vec<_>>()
.join("\n")
}
}