lib.rs 50.8 KB
Newer Older
ddorgan's avatar
ddorgan committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Copyright 2017-2020 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/>.

//! The Polkadot runtime. This can be compiled with `#[no_std]`, ready for Wasm.

#![cfg_attr(not(feature = "std"), no_std)]
// `construct_runtime!` does a lot of recursion and requires us to increase the limit to 256.
21
#![recursion_limit = "256"]
ddorgan's avatar
ddorgan committed
22

Albrecht's avatar
Albrecht committed
23
use pallet_transaction_payment::CurrencyAdapter;
24
use parity_scale_codec::{Decode, Encode, MaxEncodedLen};
25
use primitives::v1::{
26
	AccountId, AccountIndex, Balance, BlockNumber, CandidateEvent, CommittedCandidateReceipt,
27
28
29
	CoreState, GroupRotationInfo, Hash, Id as ParaId, InboundDownwardMessage, InboundHrmpMessage,
	Moment, Nonce, OccupiedCoreAssumption, PersistedValidationData, SessionInfo, Signature,
	ValidationCode, ValidationCodeHash, ValidatorId, ValidatorIndex,
ddorgan's avatar
ddorgan committed
30
};
31
use runtime_common::{
32
33
34
35
36
37
38
39
40
41
42
43
44
	auctions, crowdloan, impls::ToAuthor, paras_registrar, paras_sudo_wrapper, slots, xcm_sender,
	BlockHashCount, BlockLength, BlockWeights, CurrencyToVote, OffchainSolutionLengthLimit,
	OffchainSolutionWeightLimit, RocksDbWeight, SlowAdjustingFeeUpdate,
};
use sp_std::{collections::btree_map::BTreeMap, prelude::*};

use runtime_parachains::{
	configuration as parachains_configuration, dmp as parachains_dmp, hrmp as parachains_hrmp,
	inclusion as parachains_inclusion, initializer as parachains_initializer,
	origin as parachains_origin, paras as parachains_paras,
	paras_inherent as parachains_paras_inherent, reward_points as parachains_reward_points,
	runtime_api_impl::v1 as parachains_runtime_api_impl, scheduler as parachains_scheduler,
	session_info as parachains_session_info, shared as parachains_shared, ump as parachains_ump,
ddorgan's avatar
ddorgan committed
45
};
46

Gavin Wood's avatar
Gavin Wood committed
47
use xcm::latest::prelude::*;
48
use xcm_builder::{
49
50
51
52
53
	AccountId32Aliases, AllowTopLevelPaidExecutionFrom, AllowUnpaidExecutionFrom,
	ChildParachainAsNative, ChildParachainConvertsVia, ChildSystemParachainAsSuperuser,
	CurrencyAdapter as XcmCurrencyAdapter, FixedWeightBounds, IsChildSystemParachain, IsConcrete,
	LocationInverter, SignedAccountId32AsNative, SignedToAccountId32, SovereignSignedViaLocation,
	TakeWeightCredit, UsingComponents,
54
};
55
use xcm_executor::XcmExecutor;
56

57
58
59
60
use authority_discovery_primitives::AuthorityId as AuthorityDiscoveryId;
use beefy_primitives::crypto::AuthorityId as BeefyId;
use frame_support::{
	construct_runtime, parameter_types,
61
	traits::{Contains, Everything, InstanceFilter, KeyOwnerProofSystem, OnRuntimeUpgrade},
62
63
64
65
66
67
68
69
70
71
	weights::Weight,
	PalletId, RuntimeDebug,
};
use frame_system::EnsureRoot;
use pallet_grandpa::{fg_primitives, AuthorityId as GrandpaId};
use pallet_im_online::sr25519::AuthorityId as ImOnlineId;
use pallet_mmr_primitives as mmr;
use pallet_session::historical as session_historical;
use pallet_transaction_payment::{FeeDetails, RuntimeDispatchInfo};
use sp_core::OpaqueMetadata;
ddorgan's avatar
ddorgan committed
72
use sp_runtime::{
73
74
75
	create_runtime_str,
	curve::PiecewiseLinear,
	generic, impl_opaque_keys,
ddorgan's avatar
ddorgan committed
76
	traits::{
77
78
		AccountIdLookup, BlakeTwo256, Block as BlockT, ConvertInto, Extrinsic as ExtrinsicT,
		OpaqueKeys, SaturatedConversion, Verify,
ddorgan's avatar
ddorgan committed
79
	},
80
81
	transaction_validity::{TransactionPriority, TransactionSource, TransactionValidity},
	ApplyExtrinsicResult, KeyTypeId, Perbill,
ddorgan's avatar
ddorgan committed
82
};
83
use sp_staking::SessionIndex;
ddorgan's avatar
ddorgan committed
84
#[cfg(any(feature = "std", test))]
85
use sp_version::NativeVersion;
86
use sp_version::RuntimeVersion;
ddorgan's avatar
ddorgan committed
87

88
89
pub use pallet_balances::Call as BalancesCall;
pub use pallet_election_provider_multi_phase::Call as EPMCall;
ddorgan's avatar
ddorgan committed
90
#[cfg(feature = "std")]
91
pub use pallet_staking::StakerStatus;
92
pub use pallet_timestamp::Call as TimestampCall;
ddorgan's avatar
ddorgan committed
93
94
95
96
97
#[cfg(any(feature = "std", test))]
pub use sp_runtime::BuildStorage;

/// Constant values used within the runtime.
pub mod constants;
98
use constants::{currency::*, fee::*, time::*};
ddorgan's avatar
ddorgan committed
99

100
101
102
// Weights used in the runtime
mod weights;

103
104
105
#[cfg(test)]
mod tests;

ddorgan's avatar
ddorgan committed
106
107
108
109
// Make the WASM binary available.
#[cfg(feature = "std")]
include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));

110
/// Runtime version (Westend).
ddorgan's avatar
ddorgan committed
111
112
113
114
pub const VERSION: RuntimeVersion = RuntimeVersion {
	spec_name: create_runtime_str!("westend"),
	impl_name: create_runtime_str!("parity-westend"),
	authoring_version: 2,
115
	spec_version: 9090,
116
	impl_version: 0,
117
	#[cfg(not(feature = "disable-runtime-api"))]
ddorgan's avatar
ddorgan committed
118
	apis: RUNTIME_API_VERSIONS,
119
	#[cfg(feature = "disable-runtime-api")]
120
	apis: version::create_apis_vec![[]],
121
	transaction_version: 5,
ddorgan's avatar
ddorgan committed
122
123
};

124
125
126
127
/// The BABE epoch configuration at genesis.
pub const BABE_GENESIS_EPOCH_CONFIG: babe_primitives::BabeEpochConfiguration =
	babe_primitives::BabeEpochConfiguration {
		c: PRIMARY_PROBABILITY,
128
		allowed_slots: babe_primitives::AllowedSlots::PrimaryAndSecondaryVRFSlots,
129
130
	};

ddorgan's avatar
ddorgan committed
131
132
133
/// Native version.
#[cfg(any(feature = "std", test))]
pub fn native_version() -> NativeVersion {
134
	NativeVersion { runtime_version: VERSION, can_author_with: Default::default() }
ddorgan's avatar
ddorgan committed
135
136
}

137
/// Allow everything.
138
pub struct BaseFilter;
139
140
impl Contains<Call> for BaseFilter {
	fn contains(_: &Call) -> bool {
141
		true
ddorgan's avatar
ddorgan committed
142
143
144
145
146
	}
}

parameter_types! {
	pub const Version: RuntimeVersion = VERSION;
147
	pub const SS58Prefix: u8 = 42;
ddorgan's avatar
ddorgan committed
148
149
}

150
impl frame_system::Config for Runtime {
151
	type BaseCallFilter = BaseFilter;
152
153
	type BlockWeights = BlockWeights;
	type BlockLength = BlockLength;
ddorgan's avatar
ddorgan committed
154
155
156
157
158
159
160
	type Origin = Origin;
	type Call = Call;
	type Index = Nonce;
	type BlockNumber = BlockNumber;
	type Hash = Hash;
	type Hashing = BlakeTwo256;
	type AccountId = AccountId;
161
	type Lookup = AccountIdLookup<AccountId, ()>;
ddorgan's avatar
ddorgan committed
162
163
164
	type Header = generic::Header<BlockNumber, BlakeTwo256>;
	type Event = Event;
	type BlockHashCount = BlockHashCount;
165
	type DbWeight = RocksDbWeight;
ddorgan's avatar
ddorgan committed
166
	type Version = Version;
167
	type PalletInfo = PalletInfo;
168
	type AccountData = pallet_balances::AccountData<Balance>;
ddorgan's avatar
ddorgan committed
169
170
	type OnNewAccount = ();
	type OnKilledAccount = ();
171
	type SystemWeightInfo = weights::frame_system::WeightInfo<Runtime>;
172
	type SS58Prefix = SS58Prefix;
173
	type OnSetCode = ();
ddorgan's avatar
ddorgan committed
174
175
}

176
parameter_types! {
177
178
	pub MaximumSchedulerWeight: Weight = Perbill::from_percent(80) *
		BlockWeights::get().max_block;
179
180
181
	pub const MaxScheduledPerBlock: u32 = 50;
}

182
impl pallet_scheduler::Config for Runtime {
ddorgan's avatar
ddorgan committed
183
184
	type Event = Event;
	type Origin = Origin;
185
	type PalletsOrigin = OriginCaller;
ddorgan's avatar
ddorgan committed
186
	type Call = Call;
187
	type MaximumWeight = MaximumSchedulerWeight;
188
	type ScheduleOrigin = EnsureRoot<AccountId>;
189
	type MaxScheduledPerBlock = MaxScheduledPerBlock;
190
	type WeightInfo = weights::pallet_scheduler::WeightInfo<Runtime>;
ddorgan's avatar
ddorgan committed
191
192
193
}

parameter_types! {
194
	pub const EpochDuration: u64 = EPOCH_DURATION_IN_SLOTS as u64;
ddorgan's avatar
ddorgan committed
195
	pub const ExpectedBlockTime: Moment = MILLISECS_PER_BLOCK;
196
197
	pub const ReportLongevity: u64 =
		BondingDuration::get() as u64 * SessionsPerEra::get() as u64 * EpochDuration::get();
ddorgan's avatar
ddorgan committed
198
199
}

200
impl pallet_babe::Config for Runtime {
ddorgan's avatar
ddorgan committed
201
202
203
204
	type EpochDuration = EpochDuration;
	type ExpectedBlockTime = ExpectedBlockTime;

	// session module is the trigger
205
	type EpochChangeTrigger = pallet_babe::ExternalTrigger;
206

207
208
	type DisabledValidators = Session;

209
210
211
212
	type KeyOwnerProofSystem = Historical;

	type KeyOwnerProof = <Self::KeyOwnerProofSystem as KeyOwnerProofSystem<(
		KeyTypeId,
213
		pallet_babe::AuthorityId,
214
215
216
217
	)>>::Proof;

	type KeyOwnerIdentification = <Self::KeyOwnerProofSystem as KeyOwnerProofSystem<(
		KeyTypeId,
218
		pallet_babe::AuthorityId,
219
220
221
	)>>::IdentificationTuple;

	type HandleEquivocation =
222
		pallet_babe::EquivocationHandler<Self::KeyOwnerIdentification, Offences, ReportLongevity>;
223
224

	type WeightInfo = ();
ddorgan's avatar
ddorgan committed
225
226
227
}

parameter_types! {
228
	pub const IndexDeposit: Balance = 100 * CENTS;
ddorgan's avatar
ddorgan committed
229
230
}

231
impl pallet_indices::Config for Runtime {
ddorgan's avatar
ddorgan committed
232
233
234
235
	type AccountIndex = AccountIndex;
	type Currency = Balances;
	type Deposit = IndexDeposit;
	type Event = Event;
236
	type WeightInfo = weights::pallet_indices::WeightInfo<Runtime>;
ddorgan's avatar
ddorgan committed
237
238
239
240
}

parameter_types! {
	pub const ExistentialDeposit: Balance = 1 * CENTS;
241
	pub const MaxLocks: u32 = 50;
Gavin Wood's avatar
Gavin Wood committed
242
	pub const MaxReserves: u32 = 50;
ddorgan's avatar
ddorgan committed
243
244
}

245
impl pallet_balances::Config for Runtime {
ddorgan's avatar
ddorgan committed
246
247
248
249
250
	type Balance = Balance;
	type DustRemoval = ();
	type Event = Event;
	type ExistentialDeposit = ExistentialDeposit;
	type AccountStore = System;
251
	type MaxLocks = MaxLocks;
Gavin Wood's avatar
Gavin Wood committed
252
253
	type MaxReserves = MaxReserves;
	type ReserveIdentifier = [u8; 8];
254
	type WeightInfo = weights::pallet_balances::WeightInfo<Runtime>;
ddorgan's avatar
ddorgan committed
255
256
257
258
259
260
}

parameter_types! {
	pub const TransactionByteFee: Balance = 10 * MILLICENTS;
}

261
impl pallet_transaction_payment::Config for Runtime {
Albrecht's avatar
Albrecht committed
262
	type OnChargeTransaction = CurrencyAdapter<Balances, ToAuthor<Runtime>>;
ddorgan's avatar
ddorgan committed
263
264
	type TransactionByteFee = TransactionByteFee;
	type WeightToFee = WeightToFee;
265
	type FeeMultiplierUpdate = SlowAdjustingFeeUpdate<Self>;
ddorgan's avatar
ddorgan committed
266
267
268
269
270
}

parameter_types! {
	pub const MinimumPeriod: u64 = SLOT_DURATION / 2;
}
271
impl pallet_timestamp::Config for Runtime {
ddorgan's avatar
ddorgan committed
272
273
274
	type Moment = u64;
	type OnTimestampSet = Babe;
	type MinimumPeriod = MinimumPeriod;
275
	type WeightInfo = weights::pallet_timestamp::WeightInfo<Runtime>;
ddorgan's avatar
ddorgan committed
276
277
278
279
280
281
}

parameter_types! {
	pub const UncleGenerations: u32 = 0;
}

282
impl pallet_authorship::Config for Runtime {
283
	type FindAuthor = pallet_session::FindAccountFromAuthorIndex<Self, Babe>;
ddorgan's avatar
ddorgan committed
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
	type UncleGenerations = UncleGenerations;
	type FilterUncle = ();
	type EventHandler = (Staking, ImOnline);
}

parameter_types! {
	pub const Period: BlockNumber = 10 * MINUTES;
	pub const Offset: BlockNumber = 0;
}

impl_opaque_keys! {
	pub struct SessionKeys {
		pub grandpa: Grandpa,
		pub babe: Babe,
		pub im_online: ImOnline,
299
		pub para_validator: Initializer,
300
		pub para_assignment: ParaSessionInfo,
ddorgan's avatar
ddorgan committed
301
302
303
304
305
306
307
308
		pub authority_discovery: AuthorityDiscovery,
	}
}

parameter_types! {
	pub const DisabledValidatorsThreshold: Perbill = Perbill::from_percent(17);
}

309
impl pallet_session::Config for Runtime {
ddorgan's avatar
ddorgan committed
310
311
	type Event = Event;
	type ValidatorId = AccountId;
312
	type ValidatorIdOf = pallet_staking::StashOf<Self>;
ddorgan's avatar
ddorgan committed
313
314
	type ShouldEndSession = Babe;
	type NextSessionRotation = Babe;
315
	type SessionManager = pallet_session::historical::NoteHistoricalRoot<Self, Staking>;
ddorgan's avatar
ddorgan committed
316
317
318
	type SessionHandler = <SessionKeys as OpaqueKeys>::KeyTypeIdProviders;
	type Keys = SessionKeys;
	type DisabledValidatorsThreshold = DisabledValidatorsThreshold;
319
	type WeightInfo = weights::pallet_session::WeightInfo<Runtime>;
ddorgan's avatar
ddorgan committed
320
321
}

322
impl pallet_session::historical::Config for Runtime {
323
324
	type FullIdentification = pallet_staking::Exposure<AccountId, Balance>;
	type FullIdentificationOf = pallet_staking::ExposureOf<Runtime>;
ddorgan's avatar
ddorgan committed
325
326
}

327
parameter_types! {
328
329
	// phase durations. 1/4 of the last session for each.
	pub const SignedPhase: u32 = EPOCH_DURATION_IN_SLOTS / 4;
330
	pub const UnsignedPhase: u32 = EPOCH_DURATION_IN_SLOTS / 4;
331

332
333
	// signed config
	pub const SignedMaxSubmissions: u32 = 128;
334
335
	pub const SignedDepositBase: Balance = deposit(2, 0);
	pub const SignedDepositByte: Balance = deposit(0, 10) / 1024;
336
337
	// Each good submission will get 1 WND as reward
	pub SignedRewardBase: Balance = 1 * UNITS;
338
	// fallback: emergency phase.
339
	pub const Fallback: pallet_election_provider_multi_phase::FallbackStrategy =
340
		pallet_election_provider_multi_phase::FallbackStrategy::Nothing;
341

342
	pub SolutionImprovementThreshold: Perbill = Perbill::from_rational(5u32, 10_000);
343
344
345

	// miner configs
	pub const MinerMaxIterations: u32 = 10;
346
	pub OffchainRepeat: BlockNumber = 5;
347
348
}

349
350
sp_npos_elections::generate_solution_type!(
	#[compact]
351
352
353
354
355
	pub struct NposCompactSolution16::<
		VoterIndex = u32,
		TargetIndex = u16,
		Accuracy = sp_runtime::PerU16,
	>(16)
356
357
);

358
359
360
impl pallet_election_provider_multi_phase::Config for Runtime {
	type Event = Event;
	type Currency = Balances;
361
	type EstimateCallFee = TransactionPayment;
362
363
	type SignedPhase = SignedPhase;
	type UnsignedPhase = UnsignedPhase;
364
365
366
367
368
369
370
371
	type SignedMaxSubmissions = SignedMaxSubmissions;
	type SignedRewardBase = SignedRewardBase;
	type SignedDepositBase = SignedDepositBase;
	type SignedDepositByte = SignedDepositByte;
	type SignedDepositWeight = ();
	type SignedMaxWeight = Self::MinerMaxWeight;
	type SlashHandler = (); // burn slashes
	type RewardHandler = (); // nothing to do upon rewards
372
	type SolutionImprovementThreshold = SolutionImprovementThreshold;
373
	type MinerMaxIterations = MinerMaxIterations;
374
	type MinerMaxWeight = OffchainSolutionWeightLimit; // For now use the one from staking.
375
	type MinerMaxLength = OffchainSolutionLengthLimit;
376
	type OffchainRepeat = OffchainRepeat;
377
	type MinerTxPriority = NposSolutionPriority;
378
379
	type DataProvider = Staking;
	type OnChainAccuracy = Perbill;
380
	type Solution = NposCompactSolution16;
381
	type Fallback = Fallback;
382
	type BenchmarkingConfig = runtime_common::elections::BenchmarkConfig;
383
	type ForceOrigin = EnsureRoot<AccountId>;
384
	type WeightInfo = weights::pallet_election_provider_multi_phase::WeightInfo<Runtime>;
385
386
}

ddorgan's avatar
ddorgan committed
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
pallet_staking_reward_curve::build! {
	const REWARD_CURVE: PiecewiseLinear<'static> = curve!(
		min_inflation: 0_025_000,
		max_inflation: 0_100_000,
		ideal_stake: 0_500_000,
		falloff: 0_050_000,
		max_piece_count: 40,
		test_precision: 0_005_000,
	);
}

parameter_types! {
	// Six sessions in an era (6 hours).
	pub const SessionsPerEra: SessionIndex = 6;
	// 28 eras for unbonding (7 days).
402
	pub const BondingDuration: pallet_staking::EraIndex = 28;
403
	// 27 eras in which slashes can be cancelled (slightly less than 7 days).
404
	pub const SlashDeferDuration: pallet_staking::EraIndex = 27;
ddorgan's avatar
ddorgan committed
405
406
407
408
	pub const RewardCurve: &'static PiecewiseLinear<'static> = &REWARD_CURVE;
	pub const MaxNominatorRewardedPerValidator: u32 = 64;
}

409
impl pallet_staking::Config for Runtime {
410
	const MAX_NOMINATIONS: u32 =
411
		<NposCompactSolution16 as sp_npos_elections::NposSolution>::LIMIT as u32;
ddorgan's avatar
ddorgan committed
412
413
	type Currency = Balances;
	type UnixTime = Timestamp;
414
	type CurrencyToVote = CurrencyToVote;
ddorgan's avatar
ddorgan committed
415
416
417
418
419
420
421
422
	type RewardRemainder = ();
	type Event = Event;
	type Slash = ();
	type Reward = ();
	type SessionsPerEra = SessionsPerEra;
	type BondingDuration = BondingDuration;
	type SlashDeferDuration = SlashDeferDuration;
	// A majority of the council can cancel the slash.
423
	type SlashCancelOrigin = EnsureRoot<AccountId>;
ddorgan's avatar
ddorgan committed
424
	type SessionInterface = Self;
Kian Paimani's avatar
Kian Paimani committed
425
	type EraPayout = pallet_staking::ConvertCurve<RewardCurve>;
ddorgan's avatar
ddorgan committed
426
427
	type MaxNominatorRewardedPerValidator = MaxNominatorRewardedPerValidator;
	type NextNewSession = Session;
428
	type ElectionProvider = ElectionProviderMultiPhase;
429
430
	type GenesisElectionProvider =
		frame_election_provider_support::onchain::OnChainSequentialPhragmen<
431
			pallet_election_provider_multi_phase::OnChainConfig<Self>,
432
		>;
433
	type WeightInfo = weights::pallet_staking::WeightInfo<Runtime>;
ddorgan's avatar
ddorgan committed
434
435
436
437
438
439
}

parameter_types! {
	pub const LaunchPeriod: BlockNumber = 7 * DAYS;
	pub const VotingPeriod: BlockNumber = 7 * DAYS;
	pub const FastTrackVotingPeriod: BlockNumber = 3 * HOURS;
440
	pub const MinimumDeposit: Balance = 100 * CENTS;
ddorgan's avatar
ddorgan committed
441
442
443
444
445
446
447
	pub const EnactmentPeriod: BlockNumber = 8 * DAYS;
	pub const CooloffPeriod: BlockNumber = 7 * DAYS;
	// One cent: $10,000 / MB
	pub const PreimageByteDeposit: Balance = 10 * MILLICENTS;
	pub const InstantAllowed: bool = true;
}

448
impl pallet_offences::Config for Runtime {
ddorgan's avatar
ddorgan committed
449
	type Event = Event;
450
	type IdentificationTuple = pallet_session::historical::IdentificationTuple<Self>;
ddorgan's avatar
ddorgan committed
451
452
453
	type OnOffenceHandler = Staking;
}

454
impl pallet_authority_discovery::Config for Runtime {}
ddorgan's avatar
ddorgan committed
455
456

parameter_types! {
457
	pub const NposSolutionPriority: TransactionPriority = TransactionPriority::max_value() / 2;
ddorgan's avatar
ddorgan committed
458
459
460
	pub const ImOnlineUnsignedPriority: TransactionPriority = TransactionPriority::max_value();
}

461
impl pallet_im_online::Config for Runtime {
ddorgan's avatar
ddorgan committed
462
463
	type AuthorityId = ImOnlineId;
	type Event = Event;
464
	type ValidatorSet = Historical;
465
	type NextSessionRotation = Babe;
ddorgan's avatar
ddorgan committed
466
	type ReportUnresponsiveness = Offences;
467
	type UnsignedPriority = ImOnlineUnsignedPriority;
468
	type WeightInfo = weights::pallet_im_online::WeightInfo<Runtime>;
ddorgan's avatar
ddorgan committed
469
470
}

471
impl pallet_grandpa::Config for Runtime {
ddorgan's avatar
ddorgan committed
472
	type Event = Event;
473
474
475
476
477
478
479
480
481
482
483
484
	type Call = Call;

	type KeyOwnerProofSystem = Historical;

	type KeyOwnerProof =
		<Self::KeyOwnerProofSystem as KeyOwnerProofSystem<(KeyTypeId, GrandpaId)>>::Proof;

	type KeyOwnerIdentification = <Self::KeyOwnerProofSystem as KeyOwnerProofSystem<(
		KeyTypeId,
		GrandpaId,
	)>>::IdentificationTuple;

485
486
487
488
489
	type HandleEquivocation = pallet_grandpa::EquivocationHandler<
		Self::KeyOwnerIdentification,
		Offences,
		ReportLongevity,
	>;
490
491

	type WeightInfo = ();
ddorgan's avatar
ddorgan committed
492
493
}

494
495
/// Submits a transaction with the node's public and signature type. Adheres to the signed extension
/// format of the chain.
496
497
impl<LocalCall> frame_system::offchain::CreateSignedTransaction<LocalCall> for Runtime
where
498
499
	Call: From<LocalCall>,
{
500
	fn create_transaction<C: frame_system::offchain::AppCrypto<Self::Public, Self::Signature>>(
501
502
503
		call: Call,
		public: <Signature as Verify>::Signer,
		account: AccountId,
504
		nonce: <Runtime as frame_system::Config>::Index,
505
	) -> Option<(Call, <UncheckedExtrinsic as ExtrinsicT>::SignaturePayload)> {
506
		use sp_runtime::traits::StaticLookup;
507
		// take the biggest period possible.
508
509
		let period =
			BlockHashCount::get().checked_next_power_of_two().map(|c| c / 2).unwrap_or(2) as u64;
510
511
512

		let current_block = System::block_number()
			.saturated_into::<u64>()
513
514
			// The `System::block_number` is initialized with `n+1`,
			// so the actual block number is `n`.
515
516
517
			.saturating_sub(1);
		let tip = 0;
		let extra: SignedExtra = (
518
519
520
			frame_system::CheckSpecVersion::<Runtime>::new(),
			frame_system::CheckTxVersion::<Runtime>::new(),
			frame_system::CheckGenesis::<Runtime>::new(),
521
522
523
524
			frame_system::CheckMortality::<Runtime>::from(generic::Era::mortal(
				period,
				current_block,
			)),
525
526
527
			frame_system::CheckNonce::<Runtime>::from(nonce),
			frame_system::CheckWeight::<Runtime>::new(),
			pallet_transaction_payment::ChargeTransactionPayment::<Runtime>::from(tip),
528
		);
529
530
531
532
533
534
		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))?;
535
		let (call, extra, _) = raw_payload.deconstruct();
536
537
		let address = <Runtime as frame_system::Config>::Lookup::unlookup(account);
		Some((call, (address, signature, extra)))
538
	}
ddorgan's avatar
ddorgan committed
539
540
}

541
impl frame_system::offchain::SigningTypes for Runtime {
542
543
544
545
	type Public = <Signature as Verify>::Signer;
	type Signature = Signature;
}

546
547
impl<C> frame_system::offchain::SendTransactionTypes<C> for Runtime
where
548
549
550
551
552
553
	Call: From<C>,
{
	type OverarchingCall = Call;
	type Extrinsic = UncheckedExtrinsic;
}

ddorgan's avatar
ddorgan committed
554
555
parameter_types! {
	// Minimum 100 bytes/KSM deposited (1 CENT/byte)
556
	pub const BasicDeposit: Balance = 1000 * CENTS;       // 258 bytes on-chain
ddorgan's avatar
ddorgan committed
557
	pub const FieldDeposit: Balance = 250 * CENTS;        // 66 bytes on-chain
558
	pub const SubAccountDeposit: Balance = 200 * CENTS;   // 53 bytes on-chain
ddorgan's avatar
ddorgan committed
559
560
	pub const MaxSubAccounts: u32 = 100;
	pub const MaxAdditionalFields: u32 = 100;
561
	pub const MaxRegistrars: u32 = 20;
ddorgan's avatar
ddorgan committed
562
563
}

564
impl pallet_identity::Config for Runtime {
ddorgan's avatar
ddorgan committed
565
566
567
568
569
570
571
572
	type Event = Event;
	type Currency = Balances;
	type Slashed = ();
	type BasicDeposit = BasicDeposit;
	type FieldDeposit = FieldDeposit;
	type SubAccountDeposit = SubAccountDeposit;
	type MaxSubAccounts = MaxSubAccounts;
	type MaxAdditionalFields = MaxAdditionalFields;
573
	type MaxRegistrars = MaxRegistrars;
574
575
	type RegistrarOrigin = frame_system::EnsureRoot<AccountId>;
	type ForceOrigin = frame_system::EnsureRoot<AccountId>;
576
	type WeightInfo = weights::pallet_identity::WeightInfo<Runtime>;
ddorgan's avatar
ddorgan committed
577
578
}

579
impl pallet_utility::Config for Runtime {
580
581
	type Event = Event;
	type Call = Call;
582
	type WeightInfo = weights::pallet_utility::WeightInfo<Runtime>;
583
584
}

ddorgan's avatar
ddorgan committed
585
parameter_types! {
586
587
	// One storage item; key size is 32; value is size 4+4+16+32 bytes = 56 bytes.
	pub const DepositBase: Balance = deposit(1, 88);
ddorgan's avatar
ddorgan committed
588
	// Additional storage item size of 32 bytes.
589
	pub const DepositFactor: Balance = deposit(0, 32);
ddorgan's avatar
ddorgan committed
590
591
592
	pub const MaxSignatories: u16 = 100;
}

593
impl pallet_multisig::Config for Runtime {
ddorgan's avatar
ddorgan committed
594
595
596
	type Event = Event;
	type Call = Call;
	type Currency = Balances;
597
598
	type DepositBase = DepositBase;
	type DepositFactor = DepositFactor;
ddorgan's avatar
ddorgan committed
599
	type MaxSignatories = MaxSignatories;
600
	type WeightInfo = weights::pallet_multisig::WeightInfo<Runtime>;
ddorgan's avatar
ddorgan committed
601
602
603
}

parameter_types! {
604
	pub const ConfigDepositBase: Balance = 500 * CENTS;
ddorgan's avatar
ddorgan committed
605
606
	pub const FriendDepositFactor: Balance = 50 * CENTS;
	pub const MaxFriends: u16 = 9;
607
	pub const RecoveryDeposit: Balance = 500 * CENTS;
ddorgan's avatar
ddorgan committed
608
609
}

610
impl pallet_recovery::Config for Runtime {
ddorgan's avatar
ddorgan committed
611
612
613
614
615
616
617
618
619
620
	type Event = Event;
	type Call = Call;
	type Currency = Balances;
	type ConfigDepositBase = ConfigDepositBase;
	type FriendDepositFactor = FriendDepositFactor;
	type MaxFriends = MaxFriends;
	type RecoveryDeposit = RecoveryDeposit;
}

parameter_types! {
621
	pub const MinVestedTransfer: Balance = 100 * CENTS;
ddorgan's avatar
ddorgan committed
622
623
}

624
impl pallet_vesting::Config for Runtime {
ddorgan's avatar
ddorgan committed
625
626
627
628
	type Event = Event;
	type Currency = Balances;
	type BlockNumberToBalance = ConvertInto;
	type MinVestedTransfer = MinVestedTransfer;
629
	type WeightInfo = weights::pallet_vesting::WeightInfo<Runtime>;
ddorgan's avatar
ddorgan committed
630
631
}

632
impl pallet_sudo::Config for Runtime {
ddorgan's avatar
ddorgan committed
633
634
635
636
	type Event = Event;
	type Call = Call;
}

637
638
639
640
641
642
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;
643
644
645
	pub const AnnouncementDepositBase: Balance = deposit(1, 8);
	pub const AnnouncementDepositFactor: Balance = deposit(0, 66);
	pub const MaxPending: u16 = 32;
646
647
648
}

/// The type used to represent the kinds of proxying allowed.
649
650
651
#[derive(
	Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Encode, Decode, RuntimeDebug, MaxEncodedLen,
)]
652
653
654
655
pub enum ProxyType {
	Any,
	NonTransfer,
	Staking,
656
	SudoBalances,
Chevdor's avatar
Chevdor committed
657
	IdentityJudgement,
Shawn Tabrizi's avatar
Shawn Tabrizi committed
658
	CancelProxy,
659
}
660
661
662
663
664
impl Default for ProxyType {
	fn default() -> Self {
		Self::Any
	}
}
665
666
667
668
impl InstanceFilter<Call> for ProxyType {
	fn filter(&self, c: &Call) -> bool {
		match self {
			ProxyType::Any => true,
669
670
			ProxyType::NonTransfer => matches!(
				c,
671
672
673
				Call::System(..) |
				Call::Babe(..) |
				Call::Timestamp(..) |
674
675
676
				Call::Indices(pallet_indices::Call::claim(..)) |
				Call::Indices(pallet_indices::Call::free(..)) |
				Call::Indices(pallet_indices::Call::freeze(..)) |
677
678
679
680
681
682
683
684
685
				// Specifically omitting Indices `transfer`, `force_transfer`
				// Specifically omitting the entire Balances pallet
				Call::Authorship(..) |
				Call::Staking(..) |
				Call::Session(..) |
				Call::Grandpa(..) |
				Call::ImOnline(..) |
				Call::Utility(..) |
				Call::Identity(..) |
686
687
688
689
690
691
				Call::Recovery(pallet_recovery::Call::as_recovered(..)) |
				Call::Recovery(pallet_recovery::Call::vouch_recovery(..)) |
				Call::Recovery(pallet_recovery::Call::claim_recovery(..)) |
				Call::Recovery(pallet_recovery::Call::close_recovery(..)) |
				Call::Recovery(pallet_recovery::Call::remove_recovery(..)) |
				Call::Recovery(pallet_recovery::Call::cancel_recovered(..)) |
692
				// Specifically omitting Recovery `create_recovery`, `initiate_recovery`
693
694
				Call::Vesting(pallet_vesting::Call::vest(..)) |
				Call::Vesting(pallet_vesting::Call::vest_other(..)) |
695
696
697
698
				// Specifically omitting Vesting `vested_transfer`, and `force_vested_transfer`
				Call::Scheduler(..) |
				// Specifically omitting Sudo pallet
				Call::Proxy(..) |
699
700
701
702
703
704
705
				Call::Multisig(..) |
				Call::Registrar(paras_registrar::Call::register(..)) |
				Call::Registrar(paras_registrar::Call::deregister(..)) |
				// Specifically omitting Registrar `swap`
				Call::Registrar(paras_registrar::Call::reserve(..)) |
				Call::Crowdloan(..) |
				Call::Slots(..) |
706
				Call::Auctions(..) // Specifically omitting the entire XCM Pallet
707
			),
708
709
710
			ProxyType::Staking => {
				matches!(c, Call::Staking(..) | Call::Session(..) | Call::Utility(..))
			},
711
			ProxyType::SudoBalances => match c {
712
713
714
				Call::Sudo(pallet_sudo::Call::sudo(ref x)) => {
					matches!(x.as_ref(), &Call::Balances(..))
				},
Gavin Wood's avatar
Gavin Wood committed
715
				Call::Utility(..) => true,
716
717
				_ => false,
			},
718
719
720
			ProxyType::IdentityJudgement => matches!(
				c,
				Call::Identity(pallet_identity::Call::provide_judgement(..)) | Call::Utility(..)
Shawn Tabrizi's avatar
Shawn Tabrizi committed
721
			),
722
723
724
			ProxyType::CancelProxy => {
				matches!(c, Call::Proxy(pallet_proxy::Call::reject_announcement(..)))
			},
725
726
727
728
729
730
731
732
733
		}
	}
	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,
734
735
736
737
		}
	}
}

738
impl pallet_proxy::Config for Runtime {
739
740
741
742
743
744
745
	type Event = Event;
	type Call = Call;
	type Currency = Balances;
	type ProxyType = ProxyType;
	type ProxyDepositBase = ProxyDepositBase;
	type ProxyDepositFactor = ProxyDepositFactor;
	type MaxProxies = MaxProxies;
746
	type WeightInfo = weights::pallet_proxy::WeightInfo<Runtime>;
747
748
749
750
	type MaxPending = MaxPending;
	type CallHasher = BlakeTwo256;
	type AnnouncementDepositBase = AnnouncementDepositBase;
	type AnnouncementDepositFactor = AnnouncementDepositFactor;
751
752
}

753
754
755
756
757
758
759
760
761
762
impl parachains_origin::Config for Runtime {}

impl parachains_configuration::Config for Runtime {}

impl parachains_shared::Config for Runtime {}

impl parachains_session_info::Config for Runtime {}

impl parachains_inclusion::Config for Runtime {
	type Event = Event;
asynchronous rob's avatar
asynchronous rob committed
763
	type DisputesHandler = ();
764
765
766
767
768
769
770
771
772
773
774
775
776
	type RewardValidators = parachains_reward_points::RewardValidatorsWithEraPoints<Runtime>;
}

impl parachains_paras::Config for Runtime {
	type Origin = Origin;
	type Event = Event;
}

parameter_types! {
	pub const FirstMessageFactorPercent: u64 = 100;
}

impl parachains_ump::Config for Runtime {
777
778
	type Event = Event;
	type UmpSink = crate::parachains_ump::XcmSink<XcmExecutor<XcmConfig>, Runtime>;
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
	type FirstMessageFactorPercent = FirstMessageFactorPercent;
}

impl parachains_dmp::Config for Runtime {}

impl parachains_hrmp::Config for Runtime {
	type Event = Event;
	type Origin = Origin;
	type Currency = Balances;
}

impl parachains_paras_inherent::Config for Runtime {}

impl parachains_scheduler::Config for Runtime {}

impl parachains_initializer::Config for Runtime {
	type Randomness = pallet_babe::RandomnessFromOneEpochAgo<Runtime>;
	type ForceOrigin = EnsureRoot<AccountId>;
}

impl paras_sudo_wrapper::Config for Runtime {}

parameter_types! {
	pub const ParaDeposit: Balance = 2000 * CENTS;
	pub const DataDepositPerByte: Balance = deposit(0, 1);
}

impl paras_registrar::Config for Runtime {
	type Event = Event;
	type Origin = Origin;
	type Currency = Balances;
810
	type OnSwap = (Crowdloan, Slots);
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
	type ParaDeposit = ParaDeposit;
	type DataDepositPerByte = DataDepositPerByte;
	type WeightInfo = weights::runtime_common_paras_registrar::WeightInfo<Runtime>;
}

parameter_types! {
	pub const LeasePeriod: BlockNumber = 28 * DAYS;
}

impl slots::Config for Runtime {
	type Event = Event;
	type Currency = Balances;
	type Registrar = Registrar;
	type LeasePeriod = LeasePeriod;
	type WeightInfo = weights::runtime_common_slots::WeightInfo<Runtime>;
}

828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
parameter_types! {
	pub const CrowdloanId: PalletId = PalletId(*b"py/cfund");
	pub const SubmissionDeposit: Balance = 100 * 100 * CENTS;
	pub const MinContribution: Balance = 100 * CENTS;
	pub const RemoveKeysLimit: u32 = 500;
	// Allow 32 bytes for an additional memo to a crowdloan.
	pub const MaxMemoLength: u8 = 32;
}

impl crowdloan::Config for Runtime {
	type Event = Event;
	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<Runtime>;
}

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 Event = Event;
	type Leaser = Slots;
	type Registrar = Registrar;
	type EndingPeriod = EndingPeriod;
	type SampleLength = SampleLength;
	type Randomness = pallet_babe::RandomnessFromOneEpochAgo<Runtime>;
	type InitiateOrigin = EnsureRoot<AccountId>;
	type WeightInfo = weights::runtime_common_auctions::WeightInfo<Runtime>;
}

868
parameter_types! {
869
870
	pub const WndLocation: MultiLocation = Here.into();
	pub const Ancestry: MultiLocation = Here.into();
871
	pub WestendNetwork: NetworkId = NetworkId::Named(b"Westend".to_vec());
872
	pub CheckAccount: AccountId = XcmPallet::check_account();
873
874
}

875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
pub type LocationConverter =
	(ChildParachainConvertsVia<ParaId, AccountId>, AccountId32Aliases<WestendNetwork, AccountId>);

pub type LocalAssetTransactor = XcmCurrencyAdapter<
	// Use this currency:
	Balances,
	// Use this currency when it is a fungible asset matching the given location or name:
	IsConcrete<WndLocation>,
	// We can convert the MultiLocations with our converter above:
	LocationConverter,
	// Our chain's account ID type (we can't get away without mentioning it explicitly):
	AccountId,
	// It's a native asset so we keep track of the teleports to maintain total issuance.
	CheckAccount,
>;
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905

type LocalOriginConverter = (
	SovereignSignedViaLocation<LocationConverter, Origin>,
	ChildParachainAsNative<parachains_origin::Origin, Origin>,
	SignedAccountId32AsNative<WestendNetwork, Origin>,
	ChildSystemParachainAsSuperuser<ParaId, Origin>,
);

parameter_types! {
	pub const BaseXcmWeight: Weight = 10_000_000;
}

/// The XCM router. When we want to send an XCM message, we use this type. It amalgamates all of our
/// individual routers.
pub type XcmRouter = (
	// Only one router so far - use DMP to communicate with child parachains.
Gavin Wood's avatar
Gavin Wood committed
906
	xcm_sender::ChildParachainRouter<Runtime, xcm::AlwaysRelease>,
907
908
);

909
parameter_types! {
Gavin Wood's avatar
Gavin Wood committed
910
	pub const WestendForWestmint: (MultiAssetFilter, MultiLocation) =
911
		(Wild(AllOf { fun: WildFungible, id: Concrete(WndLocation::get()) }), Parachain(1000).into());
912
}
913
pub type TrustedTeleporters = (xcm_builder::Case<WestendForWestmint>,);
914

915
916
917
918
919
/// The barriers one of which must be passed for an XCM message to be executed.
pub type Barrier = (
	// Weight that is paid for may be consumed.
	TakeWeightCredit,
	// If the message is one that immediately attemps to pay for execution, then allow it.
920
	AllowTopLevelPaidExecutionFrom<Everything>,
921
922
923
924
925
926
927
928
929
930
931
	// Messages coming from system parachains need not pay for execution.
	AllowUnpaidExecutionFrom<IsChildSystemParachain<ParaId>>,
);

pub struct XcmConfig;
impl xcm_executor::Config for XcmConfig {
	type Call = Call;
	type XcmSender = XcmRouter;
	type AssetTransactor = LocalAssetTransactor;
	type OriginConverter = LocalOriginConverter;
	type IsReserve = ();
932
	type IsTeleporter = TrustedTeleporters;
933
	type LocationInverter = LocationInverter<Ancestry>;
934
	type Barrier = Barrier;
935
936
937
938
939
	type Weigher = FixedWeightBounds<BaseXcmWeight, Call>;
	type Trader = UsingComponents<WeightToFee, WndLocation, AccountId, Balances, ToAuthor<Runtime>>;
	type ResponseHandler = ();
}

940
941
942
943
944
945
946
947
948
949
950
951
952
/// Type to convert an `Origin` type value into a `MultiLocation` value which represents an interior location
/// of this chain.
pub type LocalOriginToLocation = (
	// And a usual Signed origin to be used in XCM as a corresponding AccountId32
	SignedToAccountId32<Origin, AccountId, WestendNetwork>,
);

impl pallet_xcm::Config for Runtime {
	type Event = Event;
	type SendXcmOrigin = xcm_builder::EnsureXcmOrigin<Origin, LocalOriginToLocation>;
	type XcmRouter = XcmRouter;
	// Anyone can execute XCM messages locally...
	type ExecuteXcmOrigin = xcm_builder::EnsureXcmOrigin<Origin, LocalOriginToLocation>;
Gavin Wood's avatar
Gavin Wood committed
953
954
	// ...but they must match our filter, which rejects everything.
	type XcmExecuteFilter = ();
955
	type XcmExecutor = XcmExecutor<XcmConfig>;
956
957
	type XcmTeleportFilter = Everything;
	type XcmReserveTransferFilter = Everything;
958
	type Weigher = FixedWeightBounds<BaseXcmWeight, Call>;
959
	type LocationInverter = LocationInverter<Ancestry>;
960
961
}

ddorgan's avatar
ddorgan committed
962
963
964
construct_runtime! {
	pub enum Runtime where
		Block = Block,
965
		NodeBlock = primitives::v1::Block,
ddorgan's avatar
ddorgan committed
966
967
968
		UncheckedExtrinsic = UncheckedExtrinsic
	{
		// Basic stuff; balances is uncallable initially.
969
		System: frame_system::{Pallet, Call, Storage, Config, Event<T>} = 0,
ddorgan's avatar
ddorgan committed
970
971

		// Must be before session.
972
		Babe: pallet_babe::{Pallet, Call, Storage, Config, ValidateUnsigned} = 1,
ddorgan's avatar
ddorgan committed
973

974
975
976
977
		Timestamp: pallet_timestamp::{Pallet, Call, Storage, Inherent} = 2,
		Indices: pallet_indices::{Pallet, Call, Storage, Config<T>, Event<T>} = 3,
		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>} = 4,
		TransactionPayment: pallet_transaction_payment::{Pallet, Storage} = 26,
ddorgan's avatar
ddorgan committed
978
979

		// Consensus support.
980
		Authorship: pallet_authorship::{Pallet, Call, Storage} = 5,
981
		Staking: pallet_staking::{Pallet, Call, Storage, Config<T>, Event<T>} = 6,
Keith Yeung's avatar
Keith Yeung committed
982
		Offences: pallet_offences::{Pallet, Storage, Event} = 7,
983
984
985
986
		Historical: session_historical::{Pallet} = 27,
		Session: pallet_session::{Pallet, Call, Storage, Event, Config<T>} = 8,
		Grandpa: pallet_grandpa::{Pallet, Call, Storage, Config, Event, ValidateUnsigned} = 10,
		ImOnline: pallet_im_online::{Pallet, Call, Storage, Event<T>, ValidateUnsigned, Config<T>} = 11,
Keith Yeung's avatar
Keith Yeung committed
987
		AuthorityDiscovery: pallet_authority_discovery::{Pallet, Config} = 12,
ddorgan's avatar
ddorgan committed
988
989

		// Utility module.
990
		Utility: pallet_utility::{Pallet, Call, Event} = 16,
ddorgan's avatar
ddorgan committed
991
992

		// Less simple identity module.
993
		Identity: pallet_identity::{Pallet, Call, Storage, Event<T>} = 17,
ddorgan's avatar
ddorgan committed
994
995

		// Social recovery module.
996
		Recovery: pallet_recovery::{Pallet, Call, Storage, Event<T>} = 18,
ddorgan's avatar
ddorgan committed
997
998

		// Vesting. Usable initially, but removed once all vesting is finished.
999
		Vesting: pallet_vesting::{Pallet, Call, Storage, Event<T>, Config<T>} = 19,
ddorgan's avatar
ddorgan committed
1000
1001

		// System scheduler.
1002
		Scheduler: pallet_scheduler::{Pallet, Call, Storage, Event<T>} = 20,
ddorgan's avatar
ddorgan committed
1003
1004

		// Sudo.
1005
		Sudo: pallet_sudo::{Pallet, Call, Storage, Event<T>, Config<T>} = 21,
1006
1007

		// Proxy module. Late addition.
1008
		Proxy: pallet_proxy::{Pallet, Call, Storage, Event<T>} = 22,
1009
1010

		// Multisig module. Late addition.
1011
		Multisig: pallet_multisig::{Pallet, Call, Storage, Event<T>} = 23,
1012
1013

		// Election pallet. Only works with staking, but placed here to maintain indices.
1014
		ElectionProviderMultiPhase: pallet_election_provider_multi_phase::{Pallet, Call, Storage, Event<T>, ValidateUnsigned} = 24,
1015
1016
1017

		// Parachains pallets. Start indices at 40 to leave room.
		ParachainsOrigin: parachains_origin::{Pallet, Origin} = 41,
1018
		Configuration: parachains_configuration::{Pallet, Call, Storage, Config<T>} = 42,
1019
		ParasShared: parachains_shared::{Pallet, Call, Storage} = 43,
1020
		ParaInclusion: parachains_inclusion::{Pallet, Call, Storage, Event<T>} = 44,
1021
		ParaInherent: parachains_paras_inherent::{Pallet, Call, Storage, Inherent} = 45,
1022
		ParaScheduler: parachains_scheduler::{Pallet, Storage} = 46,
ferrell-code's avatar
ferrell-code committed
1023
		Paras: parachains_paras::{Pallet, Call, Storage, Event, Config} = 47,
1024
		Initializer: parachains_initializer::{Pallet, Call, Storage} = 48,
1025
		Dmp: parachains_dmp::{Pallet, Call, Storage} = 49,
1026
		Ump: parachains_ump::{Pallet, Call, Storage, Event} = 50,
1027
		Hrmp: parachains_hrmp::{Pallet, Call, Storage, Event<T>} = 51,