Lines
37.25 %
Functions
20 %
Branches
100 %
// Copyright 2022 Parity Technologies (UK) Ltd.
// This file is part of Polkadot.
// Polkadot is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// Polkadot is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with Polkadot. If not, see <http://www.gnu.org/licenses/>.
//! Track configurations for governance.
use super::*;
use crate::currency::{GLMR, KILOGLMR, SUPPLY_FACTOR};
use core::str::from_utf8;
use sp_std::str::FromStr;
const fn percent(x: i32) -> sp_runtime::FixedI64 {
sp_runtime::FixedI64::from_rational(x as u128, 100)
}
const fn permill(x: i32) -> sp_runtime::FixedI64 {
sp_runtime::FixedI64::from_rational(x as u128, 1000)
use pallet_referenda::{Curve, Track};
use sp_runtime::str_array as s;
const TRACKS_DATA: [Track<u16, Balance, BlockNumber>; 6] = [
Track {
id: 0,
info: pallet_referenda::TrackInfo {
// Name of this track.
name: s("root"),
// A limit for the number of referenda on this track that can be being decided at once.
// For Root origin this should generally be just one.
max_deciding: 5,
// Amount that must be placed on deposit before a decision can be made.
decision_deposit: 20 * KILOGLMR * SUPPLY_FACTOR,
// Amount of time this must be submitted for before a decision can be made.
prepare_period: 1 * DAYS,
// Amount of time that a decision may take to be approved prior to cancellation.
decision_period: 14 * DAYS,
// Amount of time that the approval criteria must hold before it can be approved.
confirm_period: 1 * DAYS,
// Minimum amount of time that an approved proposal must be in the dispatch queue.
min_enactment_period: 1 * DAYS,
// Minimum aye votes as percentage of overall conviction-weighted votes needed for
// approval as a function of time into decision period.
min_approval: Curve::make_reciprocal(4, 14, percent(80), percent(50), percent(100)),
// Minimum pre-conviction aye-votes ("support") as percentage of overall population that
// is needed for approval as a function of time into decision period.
min_support: Curve::make_linear(14, 14, permill(5), percent(25)),
},
id: 1,
name: s("whitelisted_caller"),
max_deciding: 100,
decision_deposit: 2 * KILOGLMR * SUPPLY_FACTOR,
prepare_period: 10 * MINUTES,
confirm_period: 10 * MINUTES,
min_enactment_period: 30 * MINUTES,
min_approval: Curve::make_reciprocal(1, 14, percent(96), percent(50), percent(100)),
min_support: Curve::make_reciprocal(1, 14 * 24, percent(1), percent(0), percent(2)),
id: 2,
name: s("general_admin"),
max_deciding: 10,
decision_deposit: 100 * GLMR * SUPPLY_FACTOR,
prepare_period: 1 * HOURS,
min_support: Curve::make_reciprocal(7, 14, percent(10), percent(0), percent(50)),
id: 3,
name: s("referendum_canceller"),
max_deciding: 20,
confirm_period: 3 * HOURS,
min_enactment_period: 10 * MINUTES,
min_support: Curve::make_reciprocal(1, 14, percent(1), percent(0), percent(10)),
id: 4,
name: s("referendum_killer"),
decision_deposit: 4 * KILOGLMR * SUPPLY_FACTOR,
id: 5,
name: s("fast_general_admin"),
min_support: Curve::make_reciprocal(5, 14, percent(1), percent(0), percent(50)),
];
pub struct TracksInfo;
impl pallet_referenda::TracksInfo<Balance, BlockNumber> for TracksInfo {
type Id = u16;
type RuntimeOrigin = <RuntimeOrigin as frame_support::traits::OriginTrait>::PalletsOrigin;
fn tracks() -> impl Iterator<Item = Cow<'static, Track<Self::Id, Balance, BlockNumber>>> {
TRACKS_DATA.iter().map(Cow::Borrowed)
fn track_for(id: &Self::RuntimeOrigin) -> Result<Self::Id, ()> {
if let Ok(system_origin) = frame_system::RawOrigin::try_from(id.clone()) {
match system_origin {
frame_system::RawOrigin::Root => {
if let Some(track) = Self::tracks()
.into_iter()
.find(|track| track.info.name == s("root"))
{
Ok(track.id)
} else {
Err(())
_ => Err(()),
} else if let Ok(custom_origin) = custom_origins::Origin::try_from(id.clone()) {
if let Some(track) = Self::tracks().into_iter().find(|track| {
let Ok(track_name) = from_utf8(&track.info.name) else {
return false;
};
let track_name = track_name.trim_end_matches('\0');
if let Ok(track_custom_origin) = custom_origins::Origin::from_str(track_name) {
track_custom_origin == custom_origin
false
}) {
#[test]
/// To ensure voters are always locked into their vote
fn vote_locking_always_longer_than_enactment_period() {
for track in TRACKS_DATA {
assert!(
<Runtime as pallet_conviction_voting::Config>::VoteLockingPeriod::get()
>= track.info.min_enactment_period,
"Track {} has enactment period {} < vote locking period {}",
from_utf8(&track.info.name).expect("Track name is valid UTF-8"),
track.info.min_enactment_period,
<Runtime as pallet_conviction_voting::Config>::VoteLockingPeriod::get(),
);
fn all_tracks_have_origins() {
// check name.into() is successful either converts into "root" or custom origin
let track_is_root = track.info.name == s("root");
let track_name = from_utf8(&track.info.name)
.expect("Track name is valid UTF-8")
.trim_end_matches('\0');
let track_has_custom_origin = custom_origins::Origin::from_str(track_name).is_ok();
println!("{:?}", from_utf8(&track.info.name).unwrap());
assert!(track_is_root || track_has_custom_origin);