// Copyright (C) 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 .
//! The Rococo runtime for v1 parachains.
#![cfg_attr(not(feature = "std"), no_std)]
// `construct_runtime!` does a lot of recursion and requires us to increase the limit.
#![recursion_limit = "512"]
use pallet_nis::WithMaximumOf;
use parity_scale_codec::{Decode, Encode, MaxEncodedLen};
use primitives::{
slashing,
vstaging::{ApprovalVotingParams, NodeFeatures},
AccountId, AccountIndex, Balance, BlockNumber, CandidateEvent, CandidateHash,
CommittedCandidateReceipt, CoreState, DisputeState, ExecutorParams, GroupRotationInfo, Hash,
Id as ParaId, InboundDownwardMessage, InboundHrmpMessage, Moment, Nonce,
OccupiedCoreAssumption, PersistedValidationData, ScrapedOnChainVotes, SessionInfo, Signature,
ValidationCode, ValidationCodeHash, ValidatorId, ValidatorIndex, PARACHAIN_KEY_TYPE_ID,
};
use rococo_runtime_constants::system_parachain::BROKER_ID;
use runtime_common::{
assigned_slots, auctions, claims, crowdloan, identity_migrator, impl_runtime_weights,
impls::{
LocatableAssetConverter, ToAuthor, VersionedLocatableAsset, VersionedLocationConverter,
},
paras_registrar, paras_sudo_wrapper, prod_or_fast, slots,
traits::{Leaser, OnSwap},
BlockHashCount, BlockLength, SlowAdjustingFeeUpdate,
};
use scale_info::TypeInfo;
use sp_std::{cmp::Ordering, collections::btree_map::BTreeMap, prelude::*};
use runtime_parachains::{
assigner_coretime as parachains_assigner_coretime,
assigner_on_demand as parachains_assigner_on_demand, configuration as parachains_configuration,
coretime, disputes as parachains_disputes,
disputes::slashing as parachains_slashing,
dmp as parachains_dmp, hrmp as parachains_hrmp, inclusion as parachains_inclusion,
inclusion::{AggregateMessageOrigin, UmpQueueId},
initializer as parachains_initializer, origin as parachains_origin, paras as parachains_paras,
paras_inherent as parachains_paras_inherent,
runtime_api_impl::{
v7 as parachains_runtime_api_impl, vstaging as parachains_staging_runtime_api_impl,
},
scheduler as parachains_scheduler, session_info as parachains_session_info,
shared as parachains_shared,
};
use authority_discovery_primitives::AuthorityId as AuthorityDiscoveryId;
use beefy_primitives::{
ecdsa_crypto::{AuthorityId as BeefyId, Signature as BeefySignature},
mmr::{BeefyDataProvider, MmrLeafVersion},
};
use frame_support::{
construct_runtime, derive_impl,
genesis_builder_helper::{build_config, create_default_config},
parameter_types,
traits::{
fungible::HoldConsideration, Contains, EitherOf, EitherOfDiverse, EverythingBut,
InstanceFilter, KeyOwnerProofSystem, LinearStoragePrice, PrivilegeCmp, ProcessMessage,
ProcessMessageError, StorageMapShim, WithdrawReasons,
},
weights::{ConstantMultiplier, WeightMeter, WeightToFee as _},
PalletId,
};
use frame_system::{EnsureRoot, EnsureSigned};
use pallet_grandpa::{fg_primitives, AuthorityId as GrandpaId};
use pallet_identity::legacy::IdentityInfo;
use pallet_session::historical as session_historical;
use pallet_transaction_payment::{CurrencyAdapter, FeeDetails, RuntimeDispatchInfo};
use sp_core::{ConstU128, OpaqueMetadata, H256};
use sp_runtime::{
create_runtime_str, generic, impl_opaque_keys,
traits::{
BlakeTwo256, Block as BlockT, ConstU32, ConvertInto, Extrinsic as ExtrinsicT,
IdentityLookup, Keccak256, OpaqueKeys, SaturatedConversion, Verify,
},
transaction_validity::{TransactionPriority, TransactionSource, TransactionValidity},
ApplyExtrinsicResult, BoundToRuntimeAppPublic, FixedU128, KeyTypeId, Perbill, Percent, Permill,
RuntimeAppPublic, RuntimeDebug,
};
use sp_staking::SessionIndex;
#[cfg(any(feature = "std", test))]
use sp_version::NativeVersion;
use sp_version::RuntimeVersion;
use xcm::{
latest::prelude::*, IntoVersion, VersionedAssetId, VersionedAssets, VersionedLocation,
VersionedXcm,
};
use xcm_builder::PayOverXcm;
pub use frame_system::Call as SystemCall;
pub use pallet_balances::Call as BalancesCall;
/// Constant values used within the runtime.
use rococo_runtime_constants::{currency::*, fee::*, time::*};
// Weights used in the runtime.
mod weights;
// XCM configurations.
pub mod xcm_config;
// Implemented types.
mod impls;
use impls::ToParachainIdentityReaper;
// Governance and configurations.
pub mod governance;
use governance::{
pallet_custom_origins, AuctionAdmin, Fellows, GeneralAdmin, LeaseAdmin, Treasurer,
TreasurySpender,
};
use xcm_fee_payment_runtime_api::Error as XcmPaymentApiError;
#[cfg(test)]
mod tests;
mod validator_manager;
impl_runtime_weights!(rococo_runtime_constants);
// Make the WASM binary available.
#[cfg(feature = "std")]
include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));
/// Provides the `WASM_BINARY` build with `fast-runtime` feature enabled.
///
/// This is for example useful for local test chains.
#[cfg(feature = "std")]
pub mod fast_runtime_binary {
include!(concat!(env!("OUT_DIR"), "/fast_runtime_binary.rs"));
}
/// Runtime version (Rococo).
#[sp_version::runtime_version]
pub const VERSION: RuntimeVersion = RuntimeVersion {
spec_name: create_runtime_str!("rococo"),
impl_name: create_runtime_str!("parity-rococo-v2.0"),
authoring_version: 0,
spec_version: 1_009_000,
impl_version: 0,
apis: RUNTIME_API_VERSIONS,
transaction_version: 24,
state_version: 1,
};
/// The BABE epoch configuration at genesis.
pub const BABE_GENESIS_EPOCH_CONFIG: babe_primitives::BabeEpochConfiguration =
babe_primitives::BabeEpochConfiguration {
c: PRIMARY_PROBABILITY,
allowed_slots: babe_primitives::AllowedSlots::PrimaryAndSecondaryVRFSlots,
};
/// Native version.
#[cfg(any(feature = "std", test))]
pub fn native_version() -> NativeVersion {
NativeVersion { runtime_version: VERSION, can_author_with: Default::default() }
}
/// A type to identify calls to the Identity pallet. These will be filtered to prevent invocation,
/// locking the state of the pallet and preventing further updates to identities and sub-identities.
/// The locked state will be the genesis state of a new system chain and then removed from the Relay
/// Chain.
pub struct IsIdentityCall;
impl Contains for IsIdentityCall {
fn contains(c: &RuntimeCall) -> bool {
matches!(c, RuntimeCall::Identity(_))
}
}
parameter_types! {
pub const Version: RuntimeVersion = VERSION;
pub const SS58Prefix: u8 = 42;
}
#[derive_impl(frame_system::config_preludes::RelayChainDefaultConfig)]
impl frame_system::Config for Runtime {
type BaseCallFilter = EverythingBut;
type BlockWeights = BlockWeights;
type BlockLength = BlockLength;
type DbWeight = RocksDbWeight;
type Nonce = Nonce;
type Hash = Hash;
type AccountId = AccountId;
type Block = Block;
type BlockHashCount = BlockHashCount;
type Version = Version;
type AccountData = pallet_balances::AccountData;
type SystemWeightInfo = weights::frame_system::WeightInfo;
type SS58Prefix = SS58Prefix;
type MaxConsumers = frame_support::traits::ConstU32<16>;
}
parameter_types! {
pub MaximumSchedulerWeight: Weight = Perbill::from_percent(80) *
BlockWeights::get().max_block;
pub const MaxScheduledPerBlock: u32 = 50;
pub const NoPreimagePostponement: Option = Some(10);
}
/// Used the compare the privilege of an origin inside the scheduler.
pub struct OriginPrivilegeCmp;
impl PrivilegeCmp for OriginPrivilegeCmp {
fn cmp_privilege(left: &OriginCaller, right: &OriginCaller) -> Option {
if left == right {
return Some(Ordering::Equal);
}
match (left, right) {
// Root is greater than anything.
(OriginCaller::system(frame_system::RawOrigin::Root), _) => Some(Ordering::Greater),
// For every other origin we don't care, as they are not used for `ScheduleOrigin`.
_ => None,
}
}
}
impl pallet_scheduler::Config for Runtime {
type RuntimeOrigin = RuntimeOrigin;
type RuntimeEvent = RuntimeEvent;
type PalletsOrigin = OriginCaller;
type RuntimeCall = RuntimeCall;
type MaximumWeight = MaximumSchedulerWeight;
// The goal of having ScheduleOrigin include AuctionAdmin is to allow the auctions track of
// OpenGov to schedule periodic auctions.
type ScheduleOrigin = EitherOf, AuctionAdmin>;
type MaxScheduledPerBlock = MaxScheduledPerBlock;
type WeightInfo = weights::pallet_scheduler::WeightInfo;
type OriginPrivilegeCmp = OriginPrivilegeCmp;
type Preimages = Preimage;
}
parameter_types! {
pub const PreimageBaseDeposit: Balance = deposit(2, 64);
pub const PreimageByteDeposit: Balance = deposit(0, 1);
pub const PreimageHoldReason: RuntimeHoldReason = RuntimeHoldReason::Preimage(pallet_preimage::HoldReason::Preimage);
}
impl pallet_preimage::Config for Runtime {
type WeightInfo = weights::pallet_preimage::WeightInfo;
type RuntimeEvent = RuntimeEvent;
type Currency = Balances;
type ManagerOrigin = EnsureRoot;
type Consideration = HoldConsideration<
AccountId,
Balances,
PreimageHoldReason,
LinearStoragePrice,
>;
}
parameter_types! {
pub const ExpectedBlockTime: Moment = MILLISECS_PER_BLOCK;
pub ReportLongevity: u64 = EpochDurationInBlocks::get() as u64 * 10;
}
impl pallet_babe::Config for Runtime {
type EpochDuration = EpochDurationInBlocks;
type ExpectedBlockTime = ExpectedBlockTime;
// session module is the trigger
type EpochChangeTrigger = pallet_babe::ExternalTrigger;
type DisabledValidators = Session;
type WeightInfo = ();
type MaxAuthorities = MaxAuthorities;
type MaxNominators = ConstU32<0>;
type KeyOwnerProof = sp_session::MembershipProof;
type EquivocationReportSystem =
pallet_babe::EquivocationReportSystem;
}
parameter_types! {
pub const IndexDeposit: Balance = 100 * CENTS;
}
impl pallet_indices::Config for Runtime {
type AccountIndex = AccountIndex;
type Currency = Balances;
type Deposit = IndexDeposit;
type RuntimeEvent = RuntimeEvent;
type WeightInfo = weights::pallet_indices::WeightInfo;
}
parameter_types! {
pub const ExistentialDeposit: Balance = EXISTENTIAL_DEPOSIT;
pub const MaxLocks: u32 = 50;
pub const MaxReserves: u32 = 50;
}
impl pallet_balances::Config for Runtime {
type Balance = Balance;
type DustRemoval = ();
type RuntimeEvent = RuntimeEvent;
type ExistentialDeposit = ExistentialDeposit;
type AccountStore = System;
type MaxLocks = MaxLocks;
type MaxReserves = MaxReserves;
type ReserveIdentifier = [u8; 8];
type WeightInfo = weights::pallet_balances_balances::WeightInfo;
type FreezeIdentifier = ();
type RuntimeHoldReason = RuntimeHoldReason;
type RuntimeFreezeReason = RuntimeFreezeReason;
type MaxFreezes = ConstU32<1>;
}
parameter_types! {
pub const TransactionByteFee: Balance = 10 * MILLICENTS;
/// This value increases the priority of `Operational` transactions by adding
/// a "virtual tip" that's equal to the `OperationalFeeMultiplier * final_fee`.
pub const OperationalFeeMultiplier: u8 = 5;
}
impl pallet_transaction_payment::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
type OnChargeTransaction = CurrencyAdapter>;
type OperationalFeeMultiplier = OperationalFeeMultiplier;
type WeightToFee = WeightToFee;
type LengthToFee = ConstantMultiplier;
type FeeMultiplierUpdate = SlowAdjustingFeeUpdate;
}
parameter_types! {
pub const MinimumPeriod: u64 = SLOT_DURATION / 2;
}
impl pallet_timestamp::Config for Runtime {
type Moment = u64;
type OnTimestampSet = Babe;
type MinimumPeriod = MinimumPeriod;
type WeightInfo = weights::pallet_timestamp::WeightInfo;
}
impl pallet_authorship::Config for Runtime {
type FindAuthor = pallet_session::FindAccountFromAuthorIndex;
type EventHandler = ();
}
#[derive(Clone, Debug, PartialEq, Eq, Encode, Decode)]
pub struct OldSessionKeys {
pub grandpa: ::Public,
pub babe: ::Public,
pub im_online: pallet_im_online::sr25519::AuthorityId,
pub para_validator: ::Public,
pub para_assignment: ::Public,
pub authority_discovery: ::Public,
pub beefy: ::Public,
}
impl OpaqueKeys for OldSessionKeys {
type KeyTypeIdProviders = ();
fn key_ids() -> &'static [KeyTypeId] {
&[
<::Public>::ID,
<::Public>::ID,
sp_core::crypto::key_types::IM_ONLINE,
<::Public>::ID,
<::Public>::ID,
<::Public>::ID,
<::Public>::ID,
]
}
fn get_raw(&self, i: KeyTypeId) -> &[u8] {
match i {
<::Public>::ID => self.grandpa.as_ref(),
<::Public>::ID => self.babe.as_ref(),
sp_core::crypto::key_types::IM_ONLINE => self.im_online.as_ref(),
<::Public>::ID => self.para_validator.as_ref(),
<::Public>::ID =>
self.para_assignment.as_ref(),
<::Public>::ID =>
self.authority_discovery.as_ref(),
<::Public>::ID => self.beefy.as_ref(),
_ => &[],
}
}
}
impl_opaque_keys! {
pub struct SessionKeys {
pub grandpa: Grandpa,
pub babe: Babe,
pub para_validator: Initializer,
pub para_assignment: ParaSessionInfo,
pub authority_discovery: AuthorityDiscovery,
pub beefy: Beefy,
}
}
// remove this when removing `OldSessionKeys`
fn transform_session_keys(_val: AccountId, old: OldSessionKeys) -> SessionKeys {
SessionKeys {
grandpa: old.grandpa,
babe: old.babe,
para_validator: old.para_validator,
para_assignment: old.para_assignment,
authority_discovery: old.authority_discovery,
beefy: old.beefy,
}
}
/// Special `ValidatorIdOf` implementation that is just returning the input as result.
pub struct ValidatorIdOf;
impl sp_runtime::traits::Convert> for ValidatorIdOf {
fn convert(a: AccountId) -> Option {
Some(a)
}
}
impl pallet_session::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
type ValidatorId = AccountId;
type ValidatorIdOf = ValidatorIdOf;
type ShouldEndSession = Babe;
type NextSessionRotation = Babe;
type SessionManager = pallet_session::historical::NoteHistoricalRoot;
type SessionHandler = ::KeyTypeIdProviders;
type Keys = SessionKeys;
type WeightInfo = weights::pallet_session::WeightInfo;
}
pub struct FullIdentificationOf;
impl sp_runtime::traits::Convert> for FullIdentificationOf {
fn convert(_: AccountId) -> Option<()> {
Some(Default::default())
}
}
impl pallet_session::historical::Config for Runtime {
type FullIdentification = ();
type FullIdentificationOf = FullIdentificationOf;
}
parameter_types! {
pub const SessionsPerEra: SessionIndex = 6;
pub const BondingDuration: sp_staking::EraIndex = 28;
}
parameter_types! {
pub const ProposalBond: Permill = Permill::from_percent(5);
pub const ProposalBondMinimum: Balance = 2000 * CENTS;
pub const ProposalBondMaximum: Balance = 1 * GRAND;
pub const SpendPeriod: BlockNumber = 6 * DAYS;
pub const Burn: Permill = Permill::from_perthousand(2);
pub const TreasuryPalletId: PalletId = PalletId(*b"py/trsry");
pub const PayoutSpendPeriod: BlockNumber = 30 * DAYS;
// The asset's interior location for the paying account. This is the Treasury
// pallet instance (which sits at index 18).
pub TreasuryInteriorLocation: InteriorLocation = PalletInstance(18).into();
pub const TipCountdown: BlockNumber = 1 * DAYS;
pub const TipFindersFee: Percent = Percent::from_percent(20);
pub const TipReportDepositBase: Balance = 100 * CENTS;
pub const DataDepositPerByte: Balance = 1 * CENTS;
pub const MaxApprovals: u32 = 100;
pub const MaxAuthorities: u32 = 100_000;
pub const MaxKeys: u32 = 10_000;
pub const MaxPeerInHeartbeats: u32 = 10_000;
pub const MaxBalance: Balance = Balance::max_value();
}
impl pallet_treasury::Config for Runtime {
type PalletId = TreasuryPalletId;
type Currency = Balances;
type ApproveOrigin = EitherOfDiverse, Treasurer>;
type RejectOrigin = EitherOfDiverse, Treasurer>;
type RuntimeEvent = RuntimeEvent;
type OnSlash = Treasury;
type ProposalBond = ProposalBond;
type ProposalBondMinimum = ProposalBondMinimum;
type ProposalBondMaximum = ProposalBondMaximum;
type SpendPeriod = SpendPeriod;
type Burn = Burn;
type BurnDestination = Society;
type MaxApprovals = MaxApprovals;
type WeightInfo = weights::pallet_treasury::WeightInfo;
type SpendFunds = Bounties;
type SpendOrigin = TreasurySpender;
type AssetKind = VersionedLocatableAsset;
type Beneficiary = VersionedLocation;
type BeneficiaryLookup = IdentityLookup;
type Paymaster = PayOverXcm<
TreasuryInteriorLocation,
crate::xcm_config::XcmRouter,
crate::XcmPallet,
ConstU32<{ 6 * HOURS }>,
Self::Beneficiary,
Self::AssetKind,
LocatableAssetConverter,
VersionedLocationConverter,
>;
type BalanceConverter = AssetRate;
type PayoutPeriod = PayoutSpendPeriod;
#[cfg(feature = "runtime-benchmarks")]
type BenchmarkHelper = runtime_common::impls::benchmarks::TreasuryArguments;
}
parameter_types! {
pub const BountyDepositBase: Balance = 100 * CENTS;
pub const BountyDepositPayoutDelay: BlockNumber = 4 * DAYS;
pub const BountyUpdatePeriod: BlockNumber = 90 * DAYS;
pub const MaximumReasonLength: u32 = 16384;
pub const CuratorDepositMultiplier: Permill = Permill::from_percent(50);
pub const CuratorDepositMin: Balance = 10 * CENTS;
pub const CuratorDepositMax: Balance = 500 * CENTS;
pub const BountyValueMinimum: Balance = 200 * CENTS;
}
impl pallet_bounties::Config for Runtime {
type BountyDepositBase = BountyDepositBase;
type BountyDepositPayoutDelay = BountyDepositPayoutDelay;
type BountyUpdatePeriod = BountyUpdatePeriod;
type CuratorDepositMultiplier = CuratorDepositMultiplier;
type CuratorDepositMin = CuratorDepositMin;
type CuratorDepositMax = CuratorDepositMax;
type BountyValueMinimum = BountyValueMinimum;
type ChildBountyManager = ChildBounties;
type DataDepositPerByte = DataDepositPerByte;
type RuntimeEvent = RuntimeEvent;
type MaximumReasonLength = MaximumReasonLength;
type WeightInfo = weights::pallet_bounties::WeightInfo;
}
parameter_types! {
pub const MaxActiveChildBountyCount: u32 = 100;
pub ChildBountyValueMinimum: Balance = BountyValueMinimum::get() / 10;
}
impl pallet_child_bounties::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
type MaxActiveChildBountyCount = MaxActiveChildBountyCount;
type ChildBountyValueMinimum = ChildBountyValueMinimum;
type WeightInfo = weights::pallet_child_bounties::WeightInfo;
}
impl pallet_offences::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
type IdentificationTuple = pallet_session::historical::IdentificationTuple;
type OnOffenceHandler = ();
}
impl pallet_authority_discovery::Config for Runtime {
type MaxAuthorities = MaxAuthorities;
}
parameter_types! {
pub const MaxSetIdSessionEntries: u32 = BondingDuration::get() * SessionsPerEra::get();
}
impl pallet_grandpa::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
type WeightInfo = ();
type MaxAuthorities = MaxAuthorities;
type MaxNominators = ConstU32<0>;
type MaxSetIdSessionEntries = MaxSetIdSessionEntries;
type KeyOwnerProof = sp_session::MembershipProof;
type EquivocationReportSystem =
pallet_grandpa::EquivocationReportSystem;
}
/// Submits a transaction with the node's public and signature type. Adheres to the signed extension
/// format of the chain.
impl frame_system::offchain::CreateSignedTransaction for Runtime
where
RuntimeCall: From,
{
fn create_transaction>(
call: RuntimeCall,
public: ::Signer,
account: AccountId,
nonce: ::Nonce,
) -> Option<(RuntimeCall, ::SignaturePayload)> {
use sp_runtime::traits::StaticLookup;
// take the biggest period possible.
let period =
BlockHashCount::get().checked_next_power_of_two().map(|c| c / 2).unwrap_or(2) as u64;
let current_block = System::block_number()
.saturated_into::()
// The `System::block_number` is initialized with `n+1`,
// so the actual block number is `n`.
.saturating_sub(1);
let tip = 0;
let extra: SignedExtra = (
frame_system::CheckNonZeroSender::::new(),
frame_system::CheckSpecVersion::::new(),
frame_system::CheckTxVersion::::new(),
frame_system::CheckGenesis::::new(),
frame_system::CheckMortality::::from(generic::Era::mortal(
period,
current_block,
)),
frame_system::CheckNonce::::from(nonce),
frame_system::CheckWeight::::new(),
pallet_transaction_payment::ChargeTransactionPayment::::from(tip),
);
let raw_payload = SignedPayload::new(call, extra)
.map_err(|e| {
log::warn!("Unable to create signed payload: {:?}", e);
})
.ok()?;
let signature = raw_payload.using_encoded(|payload| C::sign(payload, public))?;
let (call, extra, _) = raw_payload.deconstruct();
let address = ::Lookup::unlookup(account);
Some((call, (address, signature, extra)))
}
}
impl frame_system::offchain::SigningTypes for Runtime {
type Public = ::Signer;
type Signature = Signature;
}
impl frame_system::offchain::SendTransactionTypes for Runtime
where
RuntimeCall: From,
{
type Extrinsic = UncheckedExtrinsic;
type OverarchingCall = RuntimeCall;
}
parameter_types! {
pub Prefix: &'static [u8] = b"Pay ROCs to the Rococo account:";
}
impl claims::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
type VestingSchedule = Vesting;
type Prefix = Prefix;
type MoveClaimOrigin = EnsureRoot;
type WeightInfo = weights::runtime_common_claims::WeightInfo;
}
parameter_types! {
// Minimum 100 bytes/ROC deposited (1 CENT/byte)
pub const BasicDeposit: Balance = 1000 * CENTS; // 258 bytes on-chain
pub const ByteDeposit: Balance = deposit(0, 1);
pub const SubAccountDeposit: Balance = 200 * CENTS; // 53 bytes on-chain
pub const MaxSubAccounts: u32 = 100;
pub const MaxAdditionalFields: u32 = 100;
pub const MaxRegistrars: u32 = 20;
}
impl pallet_identity::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
type Currency = Balances;
type BasicDeposit = BasicDeposit;
type ByteDeposit = ByteDeposit;
type SubAccountDeposit = SubAccountDeposit;
type MaxSubAccounts = MaxSubAccounts;
type IdentityInformation = IdentityInfo;
type MaxRegistrars = MaxRegistrars;
type Slashed = Treasury;
type ForceOrigin = EitherOf, GeneralAdmin>;
type RegistrarOrigin = EitherOf, GeneralAdmin>;
type OffchainSignature = Signature;
type SigningPublicKey = ::Signer;
type UsernameAuthorityOrigin = EnsureRoot;
type PendingUsernameExpiration = ConstU32<{ 7 * DAYS }>;
type MaxSuffixLength = ConstU32<7>;
type MaxUsernameLength = ConstU32<32>;
type WeightInfo = weights::pallet_identity::WeightInfo;
}
impl pallet_utility::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
type RuntimeCall = RuntimeCall;
type PalletsOrigin = OriginCaller;
type WeightInfo = weights::pallet_utility::WeightInfo;
}
parameter_types! {
// One storage item; key size is 32; value is size 4+4+16+32 bytes = 56 bytes.
pub const DepositBase: Balance = deposit(1, 88);
// Additional storage item size of 32 bytes.
pub const DepositFactor: Balance = deposit(0, 32);
pub const MaxSignatories: u32 = 100;
}
impl pallet_multisig::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
type RuntimeCall = RuntimeCall;
type Currency = Balances;
type DepositBase = DepositBase;
type DepositFactor = DepositFactor;
type MaxSignatories = MaxSignatories;
type WeightInfo = weights::pallet_multisig::WeightInfo;
}
parameter_types! {
pub const ConfigDepositBase: Balance = 500 * CENTS;
pub const FriendDepositFactor: Balance = 50 * CENTS;
pub const MaxFriends: u16 = 9;
pub const RecoveryDeposit: Balance = 500 * CENTS;
}
impl pallet_recovery::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
type WeightInfo = ();
type RuntimeCall = RuntimeCall;
type Currency = Balances;
type ConfigDepositBase = ConfigDepositBase;
type FriendDepositFactor = FriendDepositFactor;
type MaxFriends = MaxFriends;
type RecoveryDeposit = RecoveryDeposit;
}
parameter_types! {
pub const SocietyPalletId: PalletId = PalletId(*b"py/socie");
}
impl pallet_society::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
type Currency = Balances;
type Randomness = pallet_babe::RandomnessFromOneEpochAgo;
type GraceStrikes = ConstU32<1>;
type PeriodSpend = ConstU128<{ 50_000 * CENTS }>;
type VotingPeriod = ConstU32<{ 5 * DAYS }>;
type ClaimPeriod = ConstU32<{ 2 * DAYS }>;
type MaxLockDuration = ConstU32<{ 36 * 30 * DAYS }>;
type FounderSetOrigin = EnsureRoot;
type ChallengePeriod = ConstU32<{ 7 * DAYS }>;
type MaxPayouts = ConstU32<8>;
type MaxBids = ConstU32<512>;
type PalletId = SocietyPalletId;
type WeightInfo = ();
}
parameter_types! {
pub const MinVestedTransfer: Balance = 100 * CENTS;
pub UnvestedFundsAllowedWithdrawReasons: WithdrawReasons =
WithdrawReasons::except(WithdrawReasons::TRANSFER | WithdrawReasons::RESERVE);
}
impl pallet_vesting::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
type Currency = Balances;
type BlockNumberToBalance = ConvertInto;
type MinVestedTransfer = MinVestedTransfer;
type WeightInfo = weights::pallet_vesting::WeightInfo;
type UnvestedFundsAllowedWithdrawReasons = UnvestedFundsAllowedWithdrawReasons;
type BlockNumberProvider = System;
const MAX_VESTING_SCHEDULES: u32 = 28;
}
parameter_types! {
// One storage item; key size 32, value size 8; .
pub const ProxyDepositBase: Balance = deposit(1, 8);
// Additional storage item size of 33 bytes.
pub const ProxyDepositFactor: Balance = deposit(0, 33);
pub const MaxProxies: u16 = 32;
pub const AnnouncementDepositBase: Balance = deposit(1, 8);
pub const AnnouncementDepositFactor: Balance = deposit(0, 66);
pub const MaxPending: u16 = 32;
}
/// The type used to represent the kinds of proxying allowed.
#[derive(
Copy,
Clone,
Eq,
PartialEq,
Ord,
PartialOrd,
Encode,
Decode,
RuntimeDebug,
MaxEncodedLen,
TypeInfo,
)]
pub enum ProxyType {
Any,
NonTransfer,
Governance,
IdentityJudgement,
CancelProxy,
Auction,
Society,
OnDemandOrdering,
}
impl Default for ProxyType {
fn default() -> Self {
Self::Any
}
}
impl InstanceFilter for ProxyType {
fn filter(&self, c: &RuntimeCall) -> bool {
match self {
ProxyType::Any => true,
ProxyType::NonTransfer => matches!(
c,
RuntimeCall::System(..) |
RuntimeCall::Babe(..) |
RuntimeCall::Timestamp(..) |
RuntimeCall::Indices(pallet_indices::Call::claim {..}) |
RuntimeCall::Indices(pallet_indices::Call::free {..}) |
RuntimeCall::Indices(pallet_indices::Call::freeze {..}) |
// Specifically omitting Indices `transfer`, `force_transfer`
// Specifically omitting the entire Balances pallet
RuntimeCall::Session(..) |
RuntimeCall::Grandpa(..) |
RuntimeCall::Treasury(..) |
RuntimeCall::Bounties(..) |
RuntimeCall::ChildBounties(..) |
RuntimeCall::ConvictionVoting(..) |
RuntimeCall::Referenda(..) |
RuntimeCall::FellowshipCollective(..) |
RuntimeCall::FellowshipReferenda(..) |
RuntimeCall::Whitelist(..) |
RuntimeCall::Claims(..) |
RuntimeCall::Utility(..) |
RuntimeCall::Identity(..) |
RuntimeCall::Society(..) |
RuntimeCall::Recovery(pallet_recovery::Call::as_recovered {..}) |
RuntimeCall::Recovery(pallet_recovery::Call::vouch_recovery {..}) |
RuntimeCall::Recovery(pallet_recovery::Call::claim_recovery {..}) |
RuntimeCall::Recovery(pallet_recovery::Call::close_recovery {..}) |
RuntimeCall::Recovery(pallet_recovery::Call::remove_recovery {..}) |
RuntimeCall::Recovery(pallet_recovery::Call::cancel_recovered {..}) |
// Specifically omitting Recovery `create_recovery`, `initiate_recovery`
RuntimeCall::Vesting(pallet_vesting::Call::vest {..}) |
RuntimeCall::Vesting(pallet_vesting::Call::vest_other {..}) |
// Specifically omitting Vesting `vested_transfer`, and `force_vested_transfer`
RuntimeCall::Scheduler(..) |
RuntimeCall::Proxy(..) |
RuntimeCall::Multisig(..) |
RuntimeCall::Nis(..) |
RuntimeCall::Registrar(paras_registrar::Call::register {..}) |
RuntimeCall::Registrar(paras_registrar::Call::deregister {..}) |
// Specifically omitting Registrar `swap`
RuntimeCall::Registrar(paras_registrar::Call::reserve {..}) |
RuntimeCall::Crowdloan(..) |
RuntimeCall::Slots(..) |
RuntimeCall::Auctions(..) // Specifically omitting the entire XCM Pallet
),
ProxyType::Governance => matches!(
c,
RuntimeCall::Bounties(..) |
RuntimeCall::Utility(..) |
RuntimeCall::ChildBounties(..) |
// OpenGov calls
RuntimeCall::ConvictionVoting(..) |
RuntimeCall::Referenda(..) |
RuntimeCall::FellowshipCollective(..) |
RuntimeCall::FellowshipReferenda(..) |
RuntimeCall::Whitelist(..)
),
ProxyType::IdentityJudgement => matches!(
c,
RuntimeCall::Identity(pallet_identity::Call::provide_judgement { .. }) |
RuntimeCall::Utility(..)
),
ProxyType::CancelProxy => {
matches!(c, RuntimeCall::Proxy(pallet_proxy::Call::reject_announcement { .. }))
},
ProxyType::Auction => matches!(
c,
RuntimeCall::Auctions { .. } |
RuntimeCall::Crowdloan { .. } |
RuntimeCall::Registrar { .. } |
RuntimeCall::Multisig(..) |
RuntimeCall::Slots { .. }
),
ProxyType::Society => matches!(c, RuntimeCall::Society(..)),
ProxyType::OnDemandOrdering => matches!(c, RuntimeCall::OnDemandAssignmentProvider(..)),
}
}
fn is_superset(&self, o: &Self) -> bool {
match (self, o) {
(x, y) if x == y => true,
(ProxyType::Any, _) => true,
(_, ProxyType::Any) => false,
(ProxyType::NonTransfer, _) => true,
_ => false,
}
}
}
impl pallet_proxy::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
type RuntimeCall = RuntimeCall;
type Currency = Balances;
type ProxyType = ProxyType;
type ProxyDepositBase = ProxyDepositBase;
type ProxyDepositFactor = ProxyDepositFactor;
type MaxProxies = MaxProxies;
type WeightInfo = weights::pallet_proxy::WeightInfo;
type MaxPending = MaxPending;
type CallHasher = BlakeTwo256;
type AnnouncementDepositBase = AnnouncementDepositBase;
type AnnouncementDepositFactor = AnnouncementDepositFactor;
}
impl parachains_origin::Config for Runtime {}
impl parachains_configuration::Config for Runtime {
type WeightInfo = weights::runtime_parachains_configuration::WeightInfo;
}
impl parachains_shared::Config for Runtime {
type DisabledValidators = Session;
}
impl parachains_session_info::Config for Runtime {
type ValidatorSet = Historical;
}
/// Special `RewardValidators` that does nothing ;)
pub struct RewardValidators;
impl runtime_parachains::inclusion::RewardValidators for RewardValidators {
fn reward_backing(_: impl IntoIterator- ) {}
fn reward_bitfields(_: impl IntoIterator
- ) {}
}
impl parachains_inclusion::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
type DisputesHandler = ParasDisputes;
type RewardValidators = RewardValidators;
type MessageQueue = MessageQueue;
type WeightInfo = weights::runtime_parachains_inclusion::WeightInfo;
}
parameter_types! {
pub const ParasUnsignedPriority: TransactionPriority = TransactionPriority::max_value();
}
impl parachains_paras::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
type WeightInfo = weights::runtime_parachains_paras::WeightInfo;
type UnsignedPriority = ParasUnsignedPriority;
type QueueFootprinter = ParaInclusion;
type NextSessionRotation = Babe;
type OnNewHead = Registrar;
type AssignCoretime = CoretimeAssignmentProvider;
}
parameter_types! {
/// Amount of weight that can be spent per block to service messages.
///
/// # WARNING
///
/// This is not a good value for para-chains since the `Scheduler` already uses up to 80% block weight.
pub MessageQueueServiceWeight: Weight = Perbill::from_percent(20) * BlockWeights::get().max_block;
pub const MessageQueueHeapSize: u32 = 32 * 1024;
pub const MessageQueueMaxStale: u32 = 96;
}
/// Message processor to handle any messages that were enqueued into the `MessageQueue` pallet.
pub struct MessageProcessor;
impl ProcessMessage for MessageProcessor {
type Origin = AggregateMessageOrigin;
fn process_message(
message: &[u8],
origin: Self::Origin,
meter: &mut WeightMeter,
id: &mut [u8; 32],
) -> Result {
let para = match origin {
AggregateMessageOrigin::Ump(UmpQueueId::Para(para)) => para,
};
xcm_builder::ProcessXcmMessage::<
Junction,
xcm_executor::XcmExecutor,
RuntimeCall,
>::process_message(message, Junction::Parachain(para.into()), meter, id)
}
}
impl pallet_message_queue::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
type Size = u32;
type HeapSize = MessageQueueHeapSize;
type MaxStale = MessageQueueMaxStale;
type ServiceWeight = MessageQueueServiceWeight;
type IdleMaxServiceWeight = MessageQueueServiceWeight;
#[cfg(not(feature = "runtime-benchmarks"))]
type MessageProcessor = MessageProcessor;
#[cfg(feature = "runtime-benchmarks")]
type MessageProcessor =
pallet_message_queue::mock_helpers::NoopMessageProcessor;
type QueueChangeHandler = ParaInclusion;
type QueuePausedQuery = ();
type WeightInfo = weights::pallet_message_queue::WeightInfo;
}
impl parachains_dmp::Config for Runtime {}
impl parachains_hrmp::Config for Runtime {
type RuntimeOrigin = RuntimeOrigin;
type RuntimeEvent = RuntimeEvent;
type ChannelManager = EnsureRoot;
type Currency = Balances;
type WeightInfo = weights::runtime_parachains_hrmp::WeightInfo;
}
impl parachains_paras_inherent::Config for Runtime {
type WeightInfo = weights::runtime_parachains_paras_inherent::WeightInfo;
}
impl parachains_scheduler::Config for Runtime {
// If you change this, make sure the `Assignment` type of the new provider is binary compatible,
// otherwise provide a migration.
type AssignmentProvider = CoretimeAssignmentProvider;
}
parameter_types! {
pub const BrokerId: u32 = BROKER_ID;
}
impl coretime::Config for Runtime {
type RuntimeOrigin = RuntimeOrigin;
type RuntimeEvent = RuntimeEvent;
type Currency = Balances;
type BrokerId = BrokerId;
type WeightInfo = weights::runtime_parachains_coretime::WeightInfo;
type SendXcm = crate::xcm_config::XcmRouter;
}
parameter_types! {
pub const OnDemandTrafficDefaultValue: FixedU128 = FixedU128::from_u32(1);
}
impl parachains_assigner_on_demand::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
type Currency = Balances;
type TrafficDefaultValue = OnDemandTrafficDefaultValue;
type WeightInfo = weights::runtime_parachains_assigner_on_demand::WeightInfo;
}
impl parachains_assigner_coretime::Config for Runtime {}
impl parachains_initializer::Config for Runtime {
type Randomness = pallet_babe::RandomnessFromOneEpochAgo;
type ForceOrigin = EnsureRoot;
type WeightInfo = weights::runtime_parachains_initializer::WeightInfo;
type CoretimeOnNewSession = Coretime;
}
impl parachains_disputes::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
type RewardValidators = ();
type SlashingHandler = parachains_slashing::SlashValidatorsForDisputes;
type WeightInfo = weights::runtime_parachains_disputes::WeightInfo;
}
impl parachains_slashing::Config for Runtime {
type KeyOwnerProofSystem = Historical;
type KeyOwnerProof =
>::Proof;
type KeyOwnerIdentification = >::IdentificationTuple;
type HandleReports = parachains_slashing::SlashingReportHandler<
Self::KeyOwnerIdentification,
Offences,
ReportLongevity,
>;
type WeightInfo = parachains_slashing::TestWeightInfo;
type BenchmarkingConfig = parachains_slashing::BenchConfig<200>;
}
parameter_types! {
pub const ParaDeposit: Balance = 40 * UNITS;
}
impl paras_registrar::Config for Runtime {
type RuntimeOrigin = RuntimeOrigin;
type RuntimeEvent = RuntimeEvent;
type Currency = Balances;
type OnSwap = (Crowdloan, Slots, SwapLeases);
type ParaDeposit = ParaDeposit;
type DataDepositPerByte = DataDepositPerByte;
type WeightInfo = weights::runtime_common_paras_registrar::WeightInfo;
}
parameter_types! {
pub LeasePeriod: BlockNumber = prod_or_fast!(1 * DAYS, 1 * DAYS, "ROC_LEASE_PERIOD");
}
impl slots::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
type Currency = Balances;
type Registrar = Registrar;
type LeasePeriod = LeasePeriod;
type LeaseOffset = ();
type ForceOrigin = EitherOf, LeaseAdmin>;
type WeightInfo = weights::runtime_common_slots::WeightInfo;
}
parameter_types! {
pub const CrowdloanId: PalletId = PalletId(*b"py/cfund");
pub const SubmissionDeposit: Balance = 3 * GRAND;
pub const MinContribution: Balance = 3_000 * CENTS;
pub const RemoveKeysLimit: u32 = 1000;
// Allow 32 bytes for an additional memo to a crowdloan.
pub const MaxMemoLength: u8 = 32;
}
impl crowdloan::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
type PalletId = CrowdloanId;
type SubmissionDeposit = SubmissionDeposit;
type MinContribution = MinContribution;
type RemoveKeysLimit = RemoveKeysLimit;
type Registrar = Registrar;
type Auctioneer = Auctions;
type MaxMemoLength = MaxMemoLength;
type WeightInfo = weights::runtime_common_crowdloan::WeightInfo;
}
parameter_types! {
// The average auction is 7 days long, so this will be 70% for ending period.
// 5 Days = 72000 Blocks @ 6 sec per block
pub const EndingPeriod: BlockNumber = 5 * DAYS;
// ~ 1000 samples per day -> ~ 20 blocks per sample -> 2 minute samples
pub const SampleLength: BlockNumber = 2 * MINUTES;
}
impl auctions::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
type Leaser = Slots;
type Registrar = Registrar;
type EndingPeriod = EndingPeriod;
type SampleLength = SampleLength;
type Randomness = pallet_babe::RandomnessFromOneEpochAgo;
type InitiateOrigin = EitherOf, AuctionAdmin>;
type WeightInfo = weights::runtime_common_auctions::WeightInfo;
}
impl identity_migrator::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
type Reaper = EnsureSigned;
type ReapIdentityHandler = ToParachainIdentityReaper;
type WeightInfo = weights::runtime_common_identity_migrator::WeightInfo;
}
type NisCounterpartInstance = pallet_balances::Instance2;
impl pallet_balances::Config for Runtime {
type Balance = Balance;
type DustRemoval = ();
type RuntimeEvent = RuntimeEvent;
type ExistentialDeposit = ConstU128<10_000_000_000>; // One RTC cent
type AccountStore = StorageMapShim<
pallet_balances::Account,
AccountId,
pallet_balances::AccountData,
>;
type MaxLocks = ConstU32<4>;
type MaxReserves = ConstU32<4>;
type ReserveIdentifier = [u8; 8];
type WeightInfo = weights::pallet_balances_nis_counterpart_balances::WeightInfo;
type RuntimeHoldReason = RuntimeHoldReason;
type RuntimeFreezeReason = RuntimeFreezeReason;
type FreezeIdentifier = ();
type MaxFreezes = ConstU32<1>;
}
parameter_types! {
pub const NisBasePeriod: BlockNumber = 30 * DAYS;
pub const MinBid: Balance = 100 * UNITS;
pub MinReceipt: Perquintill = Perquintill::from_rational(1u64, 10_000_000u64);
pub const IntakePeriod: BlockNumber = 5 * MINUTES;
pub MaxIntakeWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 10;
pub const ThawThrottle: (Perquintill, BlockNumber) = (Perquintill::from_percent(25), 5);
pub storage NisTarget: Perquintill = Perquintill::zero();
pub const NisPalletId: PalletId = PalletId(*b"py/nis ");
}
impl pallet_nis::Config for Runtime {
type WeightInfo = weights::pallet_nis::WeightInfo;
type RuntimeEvent = RuntimeEvent;
type Currency = Balances;
type CurrencyBalance = Balance;
type FundOrigin = frame_system::EnsureSigned;
type Counterpart = NisCounterpartBalances;
type CounterpartAmount = WithMaximumOf>;
type Deficit = (); // Mint
type IgnoredIssuance = ();
type Target = NisTarget;
type PalletId = NisPalletId;
type QueueCount = ConstU32<300>;
type MaxQueueLen = ConstU32<1000>;
type FifoQueueLen = ConstU32<250>;
type BasePeriod = NisBasePeriod;
type MinBid = MinBid;
type MinReceipt = MinReceipt;
type IntakePeriod = IntakePeriod;
type MaxIntakeWeight = MaxIntakeWeight;
type ThawThrottle = ThawThrottle;
type RuntimeHoldReason = RuntimeHoldReason;
}
parameter_types! {
pub BeefySetIdSessionEntries: u32 = BondingDuration::get() * SessionsPerEra::get();
}
impl pallet_beefy::Config for Runtime {
type BeefyId = BeefyId;
type MaxAuthorities = MaxAuthorities;
type MaxNominators = ConstU32<0>;
type MaxSetIdSessionEntries = BeefySetIdSessionEntries;
type OnNewValidatorSet = MmrLeaf;
type WeightInfo = ();
type KeyOwnerProof = >::Proof;
type EquivocationReportSystem =
pallet_beefy::EquivocationReportSystem;
}
/// MMR helper types.
mod mmr {
use super::Runtime;
pub use pallet_mmr::primitives::*;
pub type Leaf = <::LeafData as LeafDataProvider>::LeafData;
pub type Hashing = ::Hashing;
pub type Hash = ::Output;
}
impl pallet_mmr::Config for Runtime {
const INDEXING_PREFIX: &'static [u8] = mmr::INDEXING_PREFIX;
type Hashing = Keccak256;
type OnNewRoot = pallet_beefy_mmr::DepositBeefyDigest;
type WeightInfo = ();
type LeafData = pallet_beefy_mmr::Pallet;
}
parameter_types! {
pub LeafVersion: MmrLeafVersion = MmrLeafVersion::new(0, 0);
}
pub struct ParaHeadsRootProvider;
impl BeefyDataProvider for ParaHeadsRootProvider {
fn extra_data() -> H256 {
let mut para_heads: Vec<(u32, Vec)> = Paras::parachains()
.into_iter()
.filter_map(|id| Paras::para_head(&id).map(|head| (id.into(), head.0)))
.collect();
para_heads.sort();
binary_merkle_tree::merkle_root::(
para_heads.into_iter().map(|pair| pair.encode()),
)
.into()
}
}
impl pallet_beefy_mmr::Config for Runtime {
type LeafVersion = LeafVersion;
type BeefyAuthorityToMerkleLeaf = pallet_beefy_mmr::BeefyEcdsaToEthereum;
type LeafExtra = H256;
type BeefyDataProvider = ParaHeadsRootProvider;
}
impl paras_sudo_wrapper::Config for Runtime {}
parameter_types! {
pub const PermanentSlotLeasePeriodLength: u32 = 365;
pub const TemporarySlotLeasePeriodLength: u32 = 5;
pub const MaxTemporarySlotPerLeasePeriod: u32 = 5;
}
impl assigned_slots::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
type AssignSlotOrigin = EnsureRoot;
type Leaser = Slots;
type PermanentSlotLeasePeriodLength = PermanentSlotLeasePeriodLength;
type TemporarySlotLeasePeriodLength = TemporarySlotLeasePeriodLength;
type MaxTemporarySlotPerLeasePeriod = MaxTemporarySlotPerLeasePeriod;
type WeightInfo = weights::runtime_common_assigned_slots::WeightInfo;
}
impl validator_manager::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
type PrivilegedOrigin = EnsureRoot;
}
impl pallet_sudo::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
type RuntimeCall = RuntimeCall;
type WeightInfo = weights::pallet_sudo::WeightInfo;
}
impl pallet_root_testing::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
}
impl pallet_asset_rate::Config for Runtime {
type WeightInfo = weights::pallet_asset_rate::WeightInfo;
type RuntimeEvent = RuntimeEvent;
type CreateOrigin = EnsureRoot;
type RemoveOrigin = EnsureRoot;
type UpdateOrigin = EnsureRoot;
type Currency = Balances;
type AssetKind = ::AssetKind;
#[cfg(feature = "runtime-benchmarks")]
type BenchmarkHelper = runtime_common::impls::benchmarks::AssetRateArguments;
}
// Notify `coretime` pallet when a lease swap occurs
pub struct SwapLeases;
impl OnSwap for SwapLeases {
fn on_swap(one: ParaId, other: ParaId) {
coretime::Pallet::::on_legacy_lease_swap(one, other);
}
}
construct_runtime! {
pub enum Runtime
{
// Basic stuff; balances is uncallable initially.
System: frame_system = 0,
// Babe must be before session.
Babe: pallet_babe = 1,
Timestamp: pallet_timestamp = 2,
Indices: pallet_indices = 3,
Balances: pallet_balances = 4,
TransactionPayment: pallet_transaction_payment = 33,
// Consensus support.
// Authorship must be before session in order to note author in the correct session and era.
Authorship: pallet_authorship = 5,
Offences: pallet_offences = 7,
Historical: session_historical = 34,
Session: pallet_session = 8,
Grandpa: pallet_grandpa = 10,
AuthorityDiscovery: pallet_authority_discovery = 12,
// Governance stuff; uncallable initially.
Treasury: pallet_treasury = 18,
ConvictionVoting: pallet_conviction_voting = 20,
Referenda: pallet_referenda = 21,
// pub type FellowshipCollectiveInstance = pallet_ranked_collective::Instance1;
FellowshipCollective: pallet_ranked_collective:: = 22,
// pub type FellowshipReferendaInstance = pallet_referenda::Instance2;
FellowshipReferenda: pallet_referenda:: = 23,
Origins: pallet_custom_origins = 43,
Whitelist: pallet_whitelist = 44,
// Claims. Usable initially.
Claims: claims = 19,
// Utility module.
Utility: pallet_utility = 24,
// Less simple identity module.
Identity: pallet_identity = 25,
// Society module.
Society: pallet_society = 26,
// Social recovery module.
Recovery: pallet_recovery = 27,
// Vesting. Usable initially, but removed once all vesting is finished.
Vesting: pallet_vesting = 28,
// System scheduler.
Scheduler: pallet_scheduler = 29,
// Proxy module. Late addition.
Proxy: pallet_proxy = 30,
// Multisig module. Late addition.
Multisig: pallet_multisig = 31,
// Preimage registrar.
Preimage: pallet_preimage = 32,
// Asset rate.
AssetRate: pallet_asset_rate = 39,
// Bounties modules.
Bounties: pallet_bounties = 35,
ChildBounties: pallet_child_bounties = 40,
// NIS pallet.
Nis: pallet_nis = 38,
// pub type NisCounterpartInstance = pallet_balances::Instance2;
NisCounterpartBalances: pallet_balances:: = 45,
// Parachains pallets. Start indices at 50 to leave room.
ParachainsOrigin: parachains_origin = 50,
Configuration: parachains_configuration = 51,
ParasShared: parachains_shared = 52,
ParaInclusion: parachains_inclusion = 53,
ParaInherent: parachains_paras_inherent = 54,
ParaScheduler: parachains_scheduler = 55,
Paras: parachains_paras = 56,
Initializer: parachains_initializer = 57,
Dmp: parachains_dmp = 58,
Hrmp: parachains_hrmp = 60,
ParaSessionInfo: parachains_session_info = 61,
ParasDisputes: parachains_disputes = 62,
ParasSlashing: parachains_slashing = 63,
MessageQueue: pallet_message_queue = 64,
OnDemandAssignmentProvider: parachains_assigner_on_demand = 66,
CoretimeAssignmentProvider: parachains_assigner_coretime = 68,
// Parachain Onboarding Pallets. Start indices at 70 to leave room.
Registrar: paras_registrar = 70,
Slots: slots = 71,
Auctions: auctions = 72,
Crowdloan: crowdloan = 73,
Coretime: coretime = 74,
// Pallet for sending XCM.
XcmPallet: pallet_xcm = 99,
// BEEFY Bridges support.
Beefy: pallet_beefy = 240,
// MMR leaf construction must be after session in order to have a leaf's next_auth_set
// refer to block. See issue polkadot-fellows/runtimes#160 for details.
Mmr: pallet_mmr = 241,
MmrLeaf: pallet_beefy_mmr = 242,
// Pallet for migrating Identity to a parachain. To be removed post-migration.
IdentityMigrator: identity_migrator = 248,
ParasSudoWrapper: paras_sudo_wrapper = 250,
AssignedSlots: assigned_slots = 251,
// Validator Manager pallet.
ValidatorManager: validator_manager = 252,
// State trie migration pallet, only temporary.
StateTrieMigration: pallet_state_trie_migration = 254,
// Root testing pallet.
RootTesting: pallet_root_testing = 249,
// Sudo.
Sudo: pallet_sudo = 255,
}
}
/// The address format for describing accounts.
pub type Address = sp_runtime::MultiAddress;
/// Block header type as expected by this runtime.
pub type Header = generic::Header;
/// Block type as expected by this runtime.
pub type Block = generic::Block;
/// A Block signed with a Justification
pub type SignedBlock = generic::SignedBlock;
/// `BlockId` type as expected by this runtime.
pub type BlockId = generic::BlockId;
/// The `SignedExtension` to the basic transaction logic.
pub type SignedExtra = (
frame_system::CheckNonZeroSender,
frame_system::CheckSpecVersion,
frame_system::CheckTxVersion,
frame_system::CheckGenesis,
frame_system::CheckMortality,
frame_system::CheckNonce,
frame_system::CheckWeight,
pallet_transaction_payment::ChargeTransactionPayment,
);
/// Unchecked extrinsic type as expected by this runtime.
pub type UncheckedExtrinsic =
generic::UncheckedExtrinsic;
/// All migrations that will run on the next runtime upgrade.
///
/// This contains the combined migrations of the last 10 releases. It allows to skip runtime
/// upgrades in case governance decides to do so. THE ORDER IS IMPORTANT.
pub type Migrations = migrations::Unreleased;
/// The runtime migrations per release.
#[allow(deprecated, missing_docs)]
pub mod migrations {
use super::*;
use frame_support::traits::LockIdentifier;
use frame_system::pallet_prelude::BlockNumberFor;
#[cfg(feature = "try-runtime")]
use sp_core::crypto::ByteArray;
pub struct GetLegacyLeaseImpl;
impl coretime::migration::GetLegacyLease for GetLegacyLeaseImpl {
fn get_parachain_lease_in_blocks(para: ParaId) -> Option {
let now = frame_system::Pallet::::block_number();
let lease = slots::Pallet::::lease(para);
if lease.is_empty() {
return None;
}
// Lease not yet started, ignore:
if lease.iter().any(Option::is_none) {
return None;
}
let (index, _) =
as Leaser>::lease_period_index(now)?;
Some(index.saturating_add(lease.len() as u32).saturating_mul(LeasePeriod::get()))
}
}
parameter_types! {
pub const DemocracyPalletName: &'static str = "Democracy";
pub const CouncilPalletName: &'static str = "Council";
pub const TechnicalCommitteePalletName: &'static str = "TechnicalCommittee";
pub const PhragmenElectionPalletName: &'static str = "PhragmenElection";
pub const TechnicalMembershipPalletName: &'static str = "TechnicalMembership";
pub const TipsPalletName: &'static str = "Tips";
pub const ImOnlinePalletName: &'static str = "ImOnline";
pub const PhragmenElectionPalletId: LockIdentifier = *b"phrelect";
}
// Special Config for Gov V1 pallets, allowing us to run migrations for them without
// implementing their configs on [`Runtime`].
pub struct UnlockConfig;
impl pallet_democracy::migrations::unlock_and_unreserve_all_funds::UnlockConfig for UnlockConfig {
type Currency = Balances;
type MaxVotes = ConstU32<100>;
type MaxDeposits = ConstU32<100>;
type AccountId = AccountId;
type BlockNumber = BlockNumberFor;
type DbWeight = ::DbWeight;
type PalletName = DemocracyPalletName;
}
impl pallet_elections_phragmen::migrations::unlock_and_unreserve_all_funds::UnlockConfig
for UnlockConfig
{
type Currency = Balances;
type MaxVotesPerVoter = ConstU32<16>;
type PalletId = PhragmenElectionPalletId;
type AccountId = AccountId;
type DbWeight = ::DbWeight;
type PalletName = PhragmenElectionPalletName;
}
impl pallet_tips::migrations::unreserve_deposits::UnlockConfig<()> for UnlockConfig {
type Currency = Balances;
type Hash = Hash;
type DataDepositPerByte = DataDepositPerByte;
type TipReportDepositBase = TipReportDepositBase;
type AccountId = AccountId;
type BlockNumber = BlockNumberFor;
type DbWeight = ::DbWeight;
type PalletName = TipsPalletName;
}
/// Upgrade Session keys to exclude `ImOnline` key.
/// When this is removed, should also remove `OldSessionKeys`.
pub struct UpgradeSessionKeys;
const UPGRADE_SESSION_KEYS_FROM_SPEC: u32 = 104000;
impl frame_support::traits::OnRuntimeUpgrade for UpgradeSessionKeys {
#[cfg(feature = "try-runtime")]
fn pre_upgrade() -> Result, sp_runtime::TryRuntimeError> {
if System::last_runtime_upgrade_spec_version() > UPGRADE_SESSION_KEYS_FROM_SPEC {
log::warn!(target: "runtime::session_keys", "Skipping session keys migration pre-upgrade check due to spec version (already applied?)");
return Ok(Vec::new());
}
log::info!(target: "runtime::session_keys", "Collecting pre-upgrade session keys state");
let key_ids = SessionKeys::key_ids();
frame_support::ensure!(
key_ids.into_iter().find(|&k| *k == sp_core::crypto::key_types::IM_ONLINE) == None,
"New session keys contain the ImOnline key that should have been removed",
);
let storage_key = pallet_session::QueuedKeys::::hashed_key();
let mut state: Vec = Vec::new();
frame_support::storage::unhashed::get::>(
&storage_key,
)
.ok_or::("Queued keys are not available".into())?
.into_iter()
.for_each(|(id, keys)| {
state.extend_from_slice(id.as_slice());
for key_id in key_ids {
state.extend_from_slice(keys.get_raw(*key_id));
}
});
frame_support::ensure!(state.len() > 0, "Queued keys are not empty before upgrade");
Ok(state)
}
fn on_runtime_upgrade() -> Weight {
if System::last_runtime_upgrade_spec_version() > UPGRADE_SESSION_KEYS_FROM_SPEC {
log::info!("Skipping session keys upgrade: already applied");
return ::DbWeight::get().reads(1);
}
log::trace!("Upgrading session keys");
Session::upgrade_keys::(transform_session_keys);
Perbill::from_percent(50) * BlockWeights::get().max_block
}
#[cfg(feature = "try-runtime")]
fn post_upgrade(
old_state: sp_std::vec::Vec,
) -> Result<(), sp_runtime::TryRuntimeError> {
if System::last_runtime_upgrade_spec_version() > UPGRADE_SESSION_KEYS_FROM_SPEC {
log::warn!(target: "runtime::session_keys", "Skipping session keys migration post-upgrade check due to spec version (already applied?)");
return Ok(());
}
let key_ids = SessionKeys::key_ids();
let mut new_state: Vec = Vec::new();
pallet_session::QueuedKeys::::get().into_iter().for_each(|(id, keys)| {
new_state.extend_from_slice(id.as_slice());
for key_id in key_ids {
new_state.extend_from_slice(keys.get_raw(*key_id));
}
});
frame_support::ensure!(new_state.len() > 0, "Queued keys are not empty after upgrade");
frame_support::ensure!(
old_state == new_state,
"Pre-upgrade and post-upgrade keys do not match!"
);
log::info!(target: "runtime::session_keys", "Session keys migrated successfully");
Ok(())
}
}
// We don't have a limit in the Relay Chain.
const IDENTITY_MIGRATION_KEY_LIMIT: u64 = u64::MAX;
/// Unreleased migrations. Add new ones here:
pub type Unreleased = (
pallet_society::migrations::MigrateToV2,
parachains_configuration::migration::v7::MigrateToV7,
assigned_slots::migration::v1::MigrateToV1,
parachains_scheduler::migration::MigrateV1ToV2,
parachains_configuration::migration::v8::MigrateToV8,
parachains_configuration::migration::v9::MigrateToV9,
paras_registrar::migration::MigrateToV1,
pallet_referenda::migration::v1::MigrateV0ToV1,
pallet_referenda::migration::v1::MigrateV0ToV1,
// Unlock & unreserve Gov1 funds
pallet_elections_phragmen::migrations::unlock_and_unreserve_all_funds::UnlockAndUnreserveAllFunds,
pallet_democracy::migrations::unlock_and_unreserve_all_funds::UnlockAndUnreserveAllFunds,
pallet_tips::migrations::unreserve_deposits::UnreserveDeposits,
// Delete all Gov v1 pallet storage key/values.
frame_support::migrations::RemovePallet::DbWeight>,
frame_support::migrations::RemovePallet::DbWeight>,
frame_support::migrations::RemovePallet::DbWeight>,
frame_support::migrations::RemovePallet::DbWeight>,
frame_support::migrations::RemovePallet::DbWeight>,
frame_support::migrations::RemovePallet::DbWeight>,
pallet_grandpa::migrations::MigrateV4ToV5,
parachains_configuration::migration::v10::MigrateToV10,
// Upgrade `SessionKeys` to exclude `ImOnline`
UpgradeSessionKeys,
// Remove `im-online` pallet on-chain storage
frame_support::migrations::RemovePallet::DbWeight>,
// Migrate Identity pallet for Usernames
pallet_identity::migration::versioned::V0ToV1,
parachains_configuration::migration::v11::MigrateToV11,
// This needs to come after the `parachains_configuration` above as we are reading the configuration.
coretime::migration::MigrateToCoretime,
parachains_configuration::migration::v12::MigrateToV12,
parachains_assigner_on_demand::migration::MigrateV0ToV1,
// permanent
pallet_xcm::migration::MigrateToLatestXcmVersion,
parachains_inclusion::migration::MigrateToV1,
);
}
/// Executive: handles dispatch to the various modules.
pub type Executive = frame_executive::Executive<
Runtime,
Block,
frame_system::ChainContext,
Runtime,
AllPalletsWithSystem,
Migrations,
>;
/// The payload being signed in transactions.
pub type SignedPayload = generic::SignedPayload;
parameter_types! {
// The deposit configuration for the singed migration. Specially if you want to allow any signed account to do the migration (see `SignedFilter`, these deposits should be high)
pub const MigrationSignedDepositPerItem: Balance = 1 * CENTS;
pub const MigrationSignedDepositBase: Balance = 20 * CENTS * 100;
pub const MigrationMaxKeyLen: u32 = 512;
}
impl pallet_state_trie_migration::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
type Currency = Balances;
type RuntimeHoldReason = RuntimeHoldReason;
type SignedDepositPerItem = MigrationSignedDepositPerItem;
type SignedDepositBase = MigrationSignedDepositBase;
type ControlOrigin = EnsureRoot;
// specific account for the migration, can trigger the signed migrations.
type SignedFilter = frame_system::EnsureSignedBy;
// Use same weights as substrate ones.
type WeightInfo = pallet_state_trie_migration::weights::SubstrateWeight;
type MaxKeyLen = MigrationMaxKeyLen;
}
frame_support::ord_parameter_types! {
pub const MigController: AccountId = AccountId::from(hex_literal::hex!("52bc71c1eca5353749542dfdf0af97bf764f9c2f44e860cd485f1cd86400f649"));
}
#[cfg(feature = "runtime-benchmarks")]
mod benches {
frame_benchmarking::define_benchmarks!(
// Polkadot
// NOTE: Make sure to prefix these with `runtime_common::` so
// the that path resolves correctly in the generated file.
[runtime_common::assigned_slots, AssignedSlots]
[runtime_common::auctions, Auctions]
[runtime_common::coretime, Coretime]
[runtime_common::crowdloan, Crowdloan]
[runtime_common::claims, Claims]
[runtime_common::identity_migrator, IdentityMigrator]
[runtime_common::slots, Slots]
[runtime_common::paras_registrar, Registrar]
[runtime_parachains::configuration, Configuration]
[runtime_parachains::hrmp, Hrmp]
[runtime_parachains::disputes, ParasDisputes]
[runtime_parachains::inclusion, ParaInclusion]
[runtime_parachains::initializer, Initializer]
[runtime_parachains::paras_inherent, ParaInherent]
[runtime_parachains::paras, Paras]
[runtime_parachains::assigner_on_demand, OnDemandAssignmentProvider]
// Substrate
[pallet_balances, Balances]
[pallet_balances, NisCounterpartBalances]
[frame_benchmarking::baseline, Baseline::]
[pallet_bounties, Bounties]
[pallet_child_bounties, ChildBounties]
[pallet_conviction_voting, ConvictionVoting]
[pallet_nis, Nis]
[pallet_identity, Identity]
[pallet_indices, Indices]
[pallet_message_queue, MessageQueue]
[pallet_multisig, Multisig]
[pallet_preimage, Preimage]
[pallet_proxy, Proxy]
[pallet_ranked_collective, FellowshipCollective]
[pallet_recovery, Recovery]
[pallet_referenda, Referenda]
[pallet_referenda, FellowshipReferenda]
[pallet_scheduler, Scheduler]
[pallet_sudo, Sudo]
[frame_system, SystemBench::]
[pallet_timestamp, Timestamp]
[pallet_treasury, Treasury]
[pallet_utility, Utility]
[pallet_vesting, Vesting]
[pallet_asset_rate, AssetRate]
[pallet_whitelist, Whitelist]
// XCM
[pallet_xcm, PalletXcmExtrinsicsBenchmark::]
[pallet_xcm_benchmarks::fungible, pallet_xcm_benchmarks::fungible::Pallet::]
[pallet_xcm_benchmarks::generic, pallet_xcm_benchmarks::generic::Pallet::]
);
}
sp_api::impl_runtime_apis! {
impl sp_api::Core for Runtime {
fn version() -> RuntimeVersion {
VERSION
}
fn execute_block(block: Block) {
Executive::execute_block(block);
}
fn initialize_block(header: &::Header) -> sp_runtime::ExtrinsicInclusionMode {
Executive::initialize_block(header)
}
}
impl xcm_fee_payment_runtime_api::XcmPaymentApi for Runtime {
fn query_acceptable_payment_assets(xcm_version: xcm::Version) -> Result, XcmPaymentApiError> {
if !matches!(xcm_version, 3 | 4) {
return Err(XcmPaymentApiError::UnhandledXcmVersion);
}
Ok([VersionedAssetId::V4(xcm_config::TokenLocation::get().into())]
.into_iter()
.filter_map(|asset| asset.into_version(xcm_version).ok())
.collect())
}
fn query_weight_to_asset_fee(weight: Weight, asset: VersionedAssetId) -> Result {
let local_asset = VersionedAssetId::V4(xcm_config::TokenLocation::get().into());
let asset = asset
.into_version(4)
.map_err(|_| XcmPaymentApiError::VersionedConversionFailed)?;
if asset != local_asset { return Err(XcmPaymentApiError::AssetNotFound); }
Ok(WeightToFee::weight_to_fee(&weight))
}
fn query_xcm_weight(message: VersionedXcm<()>) -> Result {
XcmPallet::query_xcm_weight(message)
}
fn query_delivery_fees(destination: VersionedLocation, message: VersionedXcm<()>) -> Result {
XcmPallet::query_delivery_fees(destination, message)
}
}
impl sp_api::Metadata for Runtime {
fn metadata() -> OpaqueMetadata {
OpaqueMetadata::new(Runtime::metadata().into())
}
fn metadata_at_version(version: u32) -> Option {
Runtime::metadata_at_version(version)
}
fn metadata_versions() -> sp_std::vec::Vec {
Runtime::metadata_versions()
}
}
impl block_builder_api::BlockBuilder for Runtime {
fn apply_extrinsic(extrinsic: ::Extrinsic) -> ApplyExtrinsicResult {
Executive::apply_extrinsic(extrinsic)
}
fn finalize_block() -> ::Header {
Executive::finalize_block()
}
fn inherent_extrinsics(data: inherents::InherentData) -> Vec<::Extrinsic> {
data.create_extrinsics()
}
fn check_inherents(
block: Block,
data: inherents::InherentData,
) -> inherents::CheckInherentsResult {
data.check_extrinsics(&block)
}
}
impl tx_pool_api::runtime_api::TaggedTransactionQueue for Runtime {
fn validate_transaction(
source: TransactionSource,
tx: ::Extrinsic,
block_hash: ::Hash,
) -> TransactionValidity {
Executive::validate_transaction(source, tx, block_hash)
}
}
impl offchain_primitives::OffchainWorkerApi for Runtime {
fn offchain_worker(header: &::Header) {
Executive::offchain_worker(header)
}
}
#[api_version(10)]
impl primitives::runtime_api::ParachainHost for Runtime {
fn validators() -> Vec {
parachains_runtime_api_impl::validators::()
}
fn validator_groups() -> (Vec>, GroupRotationInfo) {
parachains_runtime_api_impl::validator_groups::()
}
fn availability_cores() -> Vec> {
parachains_runtime_api_impl::availability_cores::()
}
fn persisted_validation_data(para_id: ParaId, assumption: OccupiedCoreAssumption)
-> Option> {
parachains_runtime_api_impl::persisted_validation_data::(para_id, assumption)
}
fn assumed_validation_data(
para_id: ParaId,
expected_persisted_validation_data_hash: Hash,
) -> Option<(PersistedValidationData, ValidationCodeHash)> {
parachains_runtime_api_impl::assumed_validation_data::(
para_id,
expected_persisted_validation_data_hash,
)
}
fn check_validation_outputs(
para_id: ParaId,
outputs: primitives::CandidateCommitments,
) -> bool {
parachains_runtime_api_impl::check_validation_outputs::