lib.rs 51.4 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;
ddorgan's avatar
ddorgan committed
24
use sp_std::prelude::*;
Sergey Pepyakin's avatar
Sergey Pepyakin committed
25
use sp_std::collections::btree_map::BTreeMap;
26
use parity_scale_codec::{Encode, Decode};
27
use primitives::v1::{
28
	AccountId, AccountIndex, Balance, BlockNumber, CandidateEvent, CommittedCandidateReceipt,
29
	CoreState, GroupRotationInfo, Hash, Id as ParaId, Moment, Nonce, OccupiedCoreAssumption,
30
31
	PersistedValidationData, Signature, ValidationCode, ValidationCodeHash, ValidatorId,
	ValidatorIndex, InboundDownwardMessage, InboundHrmpMessage, SessionInfo,
ddorgan's avatar
ddorgan committed
32
};
33
use runtime_common::{
34
	paras_sudo_wrapper, paras_registrar, xcm_sender, slots, crowdloan, auctions,
35
36
	SlowAdjustingFeeUpdate, CurrencyToVote,
	impls::ToAuthor,
37
38
	BlockHashCount, BlockWeights, BlockLength, RocksDbWeight,
	OffchainSolutionWeightLimit, OffchainSolutionLengthLimit,
39
	elections::fee_for_submit_call,
ddorgan's avatar
ddorgan committed
40
};
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

use runtime_parachains::origin as parachains_origin;
use runtime_parachains::configuration as parachains_configuration;
use runtime_parachains::shared as parachains_shared;
use runtime_parachains::inclusion as parachains_inclusion;
use runtime_parachains::paras_inherent as parachains_paras_inherent;
use runtime_parachains::initializer as parachains_initializer;
use runtime_parachains::session_info as parachains_session_info;
use runtime_parachains::paras as parachains_paras;
use runtime_parachains::dmp as parachains_dmp;
use runtime_parachains::ump as parachains_ump;
use runtime_parachains::hrmp as parachains_hrmp;
use runtime_parachains::scheduler as parachains_scheduler;
use runtime_parachains::reward_points as parachains_reward_points;
use runtime_parachains::runtime_api_impl::v1 as parachains_runtime_api_impl;

57
58
use xcm::v0::{MultiLocation::{self, Null, X1}, NetworkId, Xcm, Junction::Parachain};
use xcm::v0::MultiAsset::{self, AllConcreteFungible};
59
60
61
62
use xcm_executor::XcmExecutor;
use xcm_builder::{
	AccountId32Aliases, ChildParachainConvertsVia, SovereignSignedViaLocation, CurrencyAdapter as XcmCurrencyAdapter,
	ChildParachainAsNative, SignedAccountId32AsNative, ChildSystemParachainAsSuperuser, LocationInverter, IsConcrete,
63
64
	FixedWeightBounds, TakeWeightCredit, AllowTopLevelPaidExecutionFrom, AllowUnpaidExecutionFrom,
	IsChildSystemParachain, UsingComponents, SignedToAccountId32,
65
};
66

ddorgan's avatar
ddorgan committed
67
use sp_runtime::{
Kian Paimani's avatar
Kian Paimani committed
68
	create_runtime_str, generic, impl_opaque_keys, FixedPointNumber,
69
	ApplyExtrinsicResult, KeyTypeId, Perbill, curve::PiecewiseLinear,
Gavin Wood's avatar
Gavin Wood committed
70
	transaction_validity::{TransactionValidity, TransactionSource, TransactionPriority},
ddorgan's avatar
ddorgan committed
71
	traits::{
72
		BlakeTwo256, Block as BlockT, OpaqueKeys, ConvertInto, AccountIdLookup,
Gavin Wood's avatar
Gavin Wood committed
73
		Extrinsic as ExtrinsicT, SaturatedConversion, Verify,
ddorgan's avatar
ddorgan committed
74
75
76
77
	},
};
#[cfg(feature = "runtime-benchmarks")]
use sp_runtime::RuntimeString;
78
79
use sp_version::RuntimeVersion;
use pallet_grandpa::{AuthorityId as GrandpaId, fg_primitives};
ddorgan's avatar
ddorgan committed
80
#[cfg(any(feature = "std", test))]
81
use sp_version::NativeVersion;
ddorgan's avatar
ddorgan committed
82
83
use sp_core::OpaqueMetadata;
use sp_staking::SessionIndex;
84
use frame_support::{
85
	parameter_types, construct_runtime, RuntimeDebug, PalletId,
86
	traits::{KeyOwnerProofSystem, Filter, InstanceFilter, All, MaxEncodedLen},
87
	weights::Weight,
88
};
89
use pallet_im_online::sr25519::AuthorityId as ImOnlineId;
ddorgan's avatar
ddorgan committed
90
use authority_discovery_primitives::AuthorityId as AuthorityDiscoveryId;
91
use pallet_transaction_payment::{FeeDetails, RuntimeDispatchInfo};
92
use pallet_session::historical as session_historical;
93
use frame_system::{EnsureRoot};
Andreas Doerr's avatar
Andreas Doerr committed
94
use beefy_primitives::crypto::AuthorityId as BeefyId;
95
use pallet_mmr_primitives as mmr;
ddorgan's avatar
ddorgan committed
96
97

#[cfg(feature = "std")]
98
pub use pallet_staking::StakerStatus;
ddorgan's avatar
ddorgan committed
99
100
#[cfg(any(feature = "std", test))]
pub use sp_runtime::BuildStorage;
101
102
pub use pallet_timestamp::Call as TimestampCall;
pub use pallet_balances::Call as BalancesCall;
Kian Paimani's avatar
Kian Paimani committed
103
pub use pallet_election_provider_multi_phase::Call as EPMCall;
ddorgan's avatar
ddorgan committed
104
105
106
107
108

/// Constant values used within the runtime.
pub mod constants;
use constants::{time::*, currency::*, fee::*};

109
110
111
// Weights used in the runtime
mod weights;

112
113
114
#[cfg(test)]
mod tests;

ddorgan's avatar
ddorgan committed
115
116
117
118
// Make the WASM binary available.
#[cfg(feature = "std")]
include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));

119
/// Runtime version (Westend).
ddorgan's avatar
ddorgan committed
120
121
122
123
pub const VERSION: RuntimeVersion = RuntimeVersion {
	spec_name: create_runtime_str!("westend"),
	impl_name: create_runtime_str!("parity-westend"),
	authoring_version: 2,
124
	spec_version: 9080,
125
	impl_version: 0,
126
	#[cfg(not(feature = "disable-runtime-api"))]
ddorgan's avatar
ddorgan committed
127
	apis: RUNTIME_API_VERSIONS,
128
	#[cfg(feature = "disable-runtime-api")]
129
	apis: version::create_apis_vec![[]],
130
	transaction_version: 5,
ddorgan's avatar
ddorgan committed
131
132
};

133
134
135
136
137
138
139
/// 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
	};

ddorgan's avatar
ddorgan committed
140
141
142
143
144
145
146
147
148
/// Native version.
#[cfg(any(feature = "std", test))]
pub fn native_version() -> NativeVersion {
	NativeVersion {
		runtime_version: VERSION,
		can_author_with: Default::default(),
	}
}

149
/// Allow everything.
150
151
pub struct BaseFilter;
impl Filter<Call> for BaseFilter {
152
153
	fn filter(_: &Call) -> bool {
		true
ddorgan's avatar
ddorgan committed
154
155
156
157
158
	}
}

parameter_types! {
	pub const Version: RuntimeVersion = VERSION;
159
	pub const SS58Prefix: u8 = 42;
ddorgan's avatar
ddorgan committed
160
161
}

162
impl frame_system::Config for Runtime {
163
	type BaseCallFilter = BaseFilter;
164
165
	type BlockWeights = BlockWeights;
	type BlockLength = BlockLength;
ddorgan's avatar
ddorgan committed
166
167
168
169
170
171
172
	type Origin = Origin;
	type Call = Call;
	type Index = Nonce;
	type BlockNumber = BlockNumber;
	type Hash = Hash;
	type Hashing = BlakeTwo256;
	type AccountId = AccountId;
173
	type Lookup = AccountIdLookup<AccountId, ()>;
ddorgan's avatar
ddorgan committed
174
175
176
	type Header = generic::Header<BlockNumber, BlakeTwo256>;
	type Event = Event;
	type BlockHashCount = BlockHashCount;
177
	type DbWeight = RocksDbWeight;
ddorgan's avatar
ddorgan committed
178
	type Version = Version;
179
	type PalletInfo = PalletInfo;
180
	type AccountData = pallet_balances::AccountData<Balance>;
ddorgan's avatar
ddorgan committed
181
182
	type OnNewAccount = ();
	type OnKilledAccount = ();
183
	type SystemWeightInfo = weights::frame_system::WeightInfo<Runtime>;
184
	type SS58Prefix = SS58Prefix;
185
	type OnSetCode = ();
ddorgan's avatar
ddorgan committed
186
187
}

188
parameter_types! {
189
190
	pub MaximumSchedulerWeight: Weight = Perbill::from_percent(80) *
		BlockWeights::get().max_block;
191
192
193
	pub const MaxScheduledPerBlock: u32 = 50;
}

194
impl pallet_scheduler::Config for Runtime {
ddorgan's avatar
ddorgan committed
195
196
	type Event = Event;
	type Origin = Origin;
197
	type PalletsOrigin = OriginCaller;
ddorgan's avatar
ddorgan committed
198
	type Call = Call;
199
	type MaximumWeight = MaximumSchedulerWeight;
200
	type ScheduleOrigin = EnsureRoot<AccountId>;
201
	type MaxScheduledPerBlock = MaxScheduledPerBlock;
202
	type WeightInfo = weights::pallet_scheduler::WeightInfo<Runtime>;
ddorgan's avatar
ddorgan committed
203
204
205
}

parameter_types! {
206
	pub const EpochDuration: u64 = EPOCH_DURATION_IN_SLOTS as u64;
ddorgan's avatar
ddorgan committed
207
	pub const ExpectedBlockTime: Moment = MILLISECS_PER_BLOCK;
208
209
	pub const ReportLongevity: u64 =
		BondingDuration::get() as u64 * SessionsPerEra::get() as u64 * EpochDuration::get();
ddorgan's avatar
ddorgan committed
210
211
}

212
impl pallet_babe::Config for Runtime {
ddorgan's avatar
ddorgan committed
213
214
215
216
	type EpochDuration = EpochDuration;
	type ExpectedBlockTime = ExpectedBlockTime;

	// session module is the trigger
217
	type EpochChangeTrigger = pallet_babe::ExternalTrigger;
218
219
220
221
222

	type KeyOwnerProofSystem = Historical;

	type KeyOwnerProof = <Self::KeyOwnerProofSystem as KeyOwnerProofSystem<(
		KeyTypeId,
223
		pallet_babe::AuthorityId,
224
225
226
227
	)>>::Proof;

	type KeyOwnerIdentification = <Self::KeyOwnerProofSystem as KeyOwnerProofSystem<(
		KeyTypeId,
228
		pallet_babe::AuthorityId,
229
230
231
	)>>::IdentificationTuple;

	type HandleEquivocation =
232
		pallet_babe::EquivocationHandler<Self::KeyOwnerIdentification, Offences, ReportLongevity>;
233
234

	type WeightInfo = ();
ddorgan's avatar
ddorgan committed
235
236
237
}

parameter_types! {
238
	pub const IndexDeposit: Balance = 100 * CENTS;
ddorgan's avatar
ddorgan committed
239
240
}

241
impl pallet_indices::Config for Runtime {
ddorgan's avatar
ddorgan committed
242
243
244
245
	type AccountIndex = AccountIndex;
	type Currency = Balances;
	type Deposit = IndexDeposit;
	type Event = Event;
246
	type WeightInfo = weights::pallet_indices::WeightInfo<Runtime>;
ddorgan's avatar
ddorgan committed
247
248
249
250
}

parameter_types! {
	pub const ExistentialDeposit: Balance = 1 * CENTS;
251
	pub const MaxLocks: u32 = 50;
Gavin Wood's avatar
Gavin Wood committed
252
	pub const MaxReserves: u32 = 50;
ddorgan's avatar
ddorgan committed
253
254
}

255
impl pallet_balances::Config for Runtime {
ddorgan's avatar
ddorgan committed
256
257
258
259
260
	type Balance = Balance;
	type DustRemoval = ();
	type Event = Event;
	type ExistentialDeposit = ExistentialDeposit;
	type AccountStore = System;
261
	type MaxLocks = MaxLocks;
Gavin Wood's avatar
Gavin Wood committed
262
263
	type MaxReserves = MaxReserves;
	type ReserveIdentifier = [u8; 8];
264
	type WeightInfo = weights::pallet_balances::WeightInfo<Runtime>;
ddorgan's avatar
ddorgan committed
265
266
267
268
269
270
}

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

271
impl pallet_transaction_payment::Config for Runtime {
Albrecht's avatar
Albrecht committed
272
	type OnChargeTransaction = CurrencyAdapter<Balances, ToAuthor<Runtime>>;
ddorgan's avatar
ddorgan committed
273
274
	type TransactionByteFee = TransactionByteFee;
	type WeightToFee = WeightToFee;
275
	type FeeMultiplierUpdate = SlowAdjustingFeeUpdate<Self>;
ddorgan's avatar
ddorgan committed
276
277
278
279
280
}

parameter_types! {
	pub const MinimumPeriod: u64 = SLOT_DURATION / 2;
}
281
impl pallet_timestamp::Config for Runtime {
ddorgan's avatar
ddorgan committed
282
283
284
	type Moment = u64;
	type OnTimestampSet = Babe;
	type MinimumPeriod = MinimumPeriod;
285
	type WeightInfo = weights::pallet_timestamp::WeightInfo<Runtime>;
ddorgan's avatar
ddorgan committed
286
287
288
289
290
291
}

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

292
impl pallet_authorship::Config for Runtime {
293
	type FindAuthor = pallet_session::FindAccountFromAuthorIndex<Self, Babe>;
ddorgan's avatar
ddorgan committed
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
	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,
309
310
		pub para_validator: ParasInitializer,
		pub para_assignment: ParasSessionInfo,
ddorgan's avatar
ddorgan committed
311
312
313
314
315
316
317
318
		pub authority_discovery: AuthorityDiscovery,
	}
}

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

319
impl pallet_session::Config for Runtime {
ddorgan's avatar
ddorgan committed
320
321
	type Event = Event;
	type ValidatorId = AccountId;
322
	type ValidatorIdOf = pallet_staking::StashOf<Self>;
ddorgan's avatar
ddorgan committed
323
324
	type ShouldEndSession = Babe;
	type NextSessionRotation = Babe;
325
	type SessionManager = pallet_session::historical::NoteHistoricalRoot<Self, Staking>;
ddorgan's avatar
ddorgan committed
326
327
328
	type SessionHandler = <SessionKeys as OpaqueKeys>::KeyTypeIdProviders;
	type Keys = SessionKeys;
	type DisabledValidatorsThreshold = DisabledValidatorsThreshold;
329
	type WeightInfo = weights::pallet_session::WeightInfo<Runtime>;
ddorgan's avatar
ddorgan committed
330
331
}

332
impl pallet_session::historical::Config for Runtime {
333
334
	type FullIdentification = pallet_staking::Exposure<AccountId, Balance>;
	type FullIdentificationOf = pallet_staking::ExposureOf<Runtime>;
ddorgan's avatar
ddorgan committed
335
336
}

Kian Paimani's avatar
Kian Paimani committed
337
use pallet_election_provider_multi_phase::WeightInfo;
338
parameter_types! {
339
340
	// phase durations. 1/4 of the last session for each.
	pub const SignedPhase: u32 = EPOCH_DURATION_IN_SLOTS / 4;
341
	pub const UnsignedPhase: u32 = EPOCH_DURATION_IN_SLOTS / 4;
342

343
344
345
346
347
348
349
	// signed config
	pub const SignedMaxSubmissions: u32 = 128;
	pub const SignedDepositBase: Balance = deposit(1, 0);
	// A typical solution occupies within an order of magnitude of 50kb.
	// This formula is currently adjusted such that a typical solution will spend an amount equal
	// to the base deposit for every 50 kb.
	pub const SignedDepositByte: Balance = deposit(1, 0) / (50 * 1024);
Kian Paimani's avatar
Kian Paimani committed
350
351
352
353
354
355
356
357
	pub SignedRewardBase: Balance = fee_for_submit_call::<Runtime>(
		// give 20% threshold.
		sp_runtime::FixedU128::saturating_from_rational(12, 10),
		// maximum weight possible.
		weights::pallet_election_provider_multi_phase::WeightInfo::<Runtime>::submit(SignedMaxSubmissions::get()),
		// assume a solution of 100kb length.
		100 * 1024
	);
358
359

	// fallback: emergency phase.
360
	pub const Fallback: pallet_election_provider_multi_phase::FallbackStrategy =
361
		pallet_election_provider_multi_phase::FallbackStrategy::Nothing;
362

363
	pub SolutionImprovementThreshold: Perbill = Perbill::from_rational(5u32, 10_000);
364
365
366

	// miner configs
	pub const MinerMaxIterations: u32 = 10;
367
	pub OffchainRepeat: BlockNumber = 5;
368
369
}

370
371
sp_npos_elections::generate_solution_type!(
	#[compact]
372
373
374
375
376
	pub struct NposCompactSolution16::<
		VoterIndex = u32,
		TargetIndex = u16,
		Accuracy = sp_runtime::PerU16,
	>(16)
377
378
);

379
380
381
382
383
impl pallet_election_provider_multi_phase::Config for Runtime {
	type Event = Event;
	type Currency = Balances;
	type SignedPhase = SignedPhase;
	type UnsignedPhase = UnsignedPhase;
384
385
386
387
388
389
390
391
	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
392
	type SolutionImprovementThreshold = SolutionImprovementThreshold;
393
	type MinerMaxIterations = MinerMaxIterations;
394
	type MinerMaxWeight = OffchainSolutionWeightLimit; // For now use the one from staking.
395
	type MinerMaxLength = OffchainSolutionLengthLimit;
396
	type OffchainRepeat = OffchainRepeat;
397
	type MinerTxPriority = NposSolutionPriority;
398
399
	type DataProvider = Staking;
	type OnChainAccuracy = Perbill;
400
	type CompactSolution = NposCompactSolution16;
401
402
	type Fallback = Fallback;
	type BenchmarkingConfig = ();
403
	type ForceOrigin = EnsureRoot<AccountId>;
404
	type WeightInfo = weights::pallet_election_provider_multi_phase::WeightInfo<Runtime>;
405
406
}

ddorgan's avatar
ddorgan committed
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
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).
422
	pub const BondingDuration: pallet_staking::EraIndex = 28;
423
	// 27 eras in which slashes can be cancelled (slightly less than 7 days).
424
	pub const SlashDeferDuration: pallet_staking::EraIndex = 27;
ddorgan's avatar
ddorgan committed
425
426
427
428
	pub const RewardCurve: &'static PiecewiseLinear<'static> = &REWARD_CURVE;
	pub const MaxNominatorRewardedPerValidator: u32 = 64;
}

429
impl pallet_staking::Config for Runtime {
430
	const MAX_NOMINATIONS: u32 = <NposCompactSolution16 as sp_npos_elections::CompactSolution>::LIMIT as u32;
ddorgan's avatar
ddorgan committed
431
432
	type Currency = Balances;
	type UnixTime = Timestamp;
433
	type CurrencyToVote = CurrencyToVote;
ddorgan's avatar
ddorgan committed
434
435
436
437
438
439
440
441
	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.
442
	type SlashCancelOrigin = EnsureRoot<AccountId>;
ddorgan's avatar
ddorgan committed
443
	type SessionInterface = Self;
Kian Paimani's avatar
Kian Paimani committed
444
	type EraPayout = pallet_staking::ConvertCurve<RewardCurve>;
ddorgan's avatar
ddorgan committed
445
446
	type MaxNominatorRewardedPerValidator = MaxNominatorRewardedPerValidator;
	type NextNewSession = Session;
447
	type ElectionProvider = ElectionProviderMultiPhase;
448
449
450
451
	type GenesisElectionProvider =
		frame_election_provider_support::onchain::OnChainSequentialPhragmen<
			pallet_election_provider_multi_phase::OnChainConfig<Self>
		>;
452
	type WeightInfo = weights::pallet_staking::WeightInfo<Runtime>;
ddorgan's avatar
ddorgan committed
453
454
455
456
457
458
}

parameter_types! {
	pub const LaunchPeriod: BlockNumber = 7 * DAYS;
	pub const VotingPeriod: BlockNumber = 7 * DAYS;
	pub const FastTrackVotingPeriod: BlockNumber = 3 * HOURS;
459
	pub const MinimumDeposit: Balance = 100 * CENTS;
ddorgan's avatar
ddorgan committed
460
461
462
463
464
465
466
	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;
}

467
impl pallet_offences::Config for Runtime {
ddorgan's avatar
ddorgan committed
468
	type Event = Event;
469
	type IdentificationTuple = pallet_session::historical::IdentificationTuple<Self>;
ddorgan's avatar
ddorgan committed
470
471
472
	type OnOffenceHandler = Staking;
}

473
impl pallet_authority_discovery::Config for Runtime {}
ddorgan's avatar
ddorgan committed
474
475

parameter_types! {
476
	pub const NposSolutionPriority: TransactionPriority = TransactionPriority::max_value() / 2;
ddorgan's avatar
ddorgan committed
477
478
479
	pub const ImOnlineUnsignedPriority: TransactionPriority = TransactionPriority::max_value();
}

480
impl pallet_im_online::Config for Runtime {
ddorgan's avatar
ddorgan committed
481
482
	type AuthorityId = ImOnlineId;
	type Event = Event;
483
	type ValidatorSet = Historical;
484
	type NextSessionRotation = Babe;
ddorgan's avatar
ddorgan committed
485
	type ReportUnresponsiveness = Offences;
486
	type UnsignedPriority = ImOnlineUnsignedPriority;
487
	type WeightInfo = weights::pallet_im_online::WeightInfo<Runtime>;
ddorgan's avatar
ddorgan committed
488
489
}

490
impl pallet_grandpa::Config for Runtime {
ddorgan's avatar
ddorgan committed
491
	type Event = Event;
492
493
494
495
496
497
498
499
500
501
502
503
	type Call = Call;

	type KeyOwnerProofSystem = Historical;

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

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

504
505
	type HandleEquivocation =
		pallet_grandpa::EquivocationHandler<Self::KeyOwnerIdentification, Offences, ReportLongevity>;
506
507

	type WeightInfo = ();
ddorgan's avatar
ddorgan committed
508
509
}

510
511
/// Submits a transaction with the node's public and signature type. Adheres to the signed extension
/// format of the chain.
512
impl<LocalCall> frame_system::offchain::CreateSignedTransaction<LocalCall> for Runtime where
513
514
	Call: From<LocalCall>,
{
515
	fn create_transaction<C: frame_system::offchain::AppCrypto<Self::Public, Self::Signature>>(
516
517
518
		call: Call,
		public: <Signature as Verify>::Signer,
		account: AccountId,
519
		nonce: <Runtime as frame_system::Config>::Index,
520
	) -> Option<(Call, <UncheckedExtrinsic as ExtrinsicT>::SignaturePayload)> {
521
		use sp_runtime::traits::StaticLookup;
522
		// take the biggest period possible.
523
524
525
526
527
528
529
		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::<u64>()
530
531
			// The `System::block_number` is initialized with `n+1`,
			// so the actual block number is `n`.
532
533
534
			.saturating_sub(1);
		let tip = 0;
		let extra: SignedExtra = (
535
536
537
538
539
540
541
			frame_system::CheckSpecVersion::<Runtime>::new(),
			frame_system::CheckTxVersion::<Runtime>::new(),
			frame_system::CheckGenesis::<Runtime>::new(),
			frame_system::CheckMortality::<Runtime>::from(generic::Era::mortal(period, current_block)),
			frame_system::CheckNonce::<Runtime>::from(nonce),
			frame_system::CheckWeight::<Runtime>::new(),
			pallet_transaction_payment::ChargeTransactionPayment::<Runtime>::from(tip),
542
543
		);
		let raw_payload = SignedPayload::new(call, extra).map_err(|e| {
544
			log::warn!("Unable to create signed payload: {:?}", e);
545
		}).ok()?;
546
547
548
		let signature = raw_payload.using_encoded(|payload| {
			C::sign(payload, public)
		})?;
549
		let (call, extra, _) = raw_payload.deconstruct();
550
551
		let address = <Runtime as frame_system::Config>::Lookup::unlookup(account);
		Some((call, (address, signature, extra)))
552
	}
ddorgan's avatar
ddorgan committed
553
554
}

555
impl frame_system::offchain::SigningTypes for Runtime {
556
557
558
559
	type Public = <Signature as Verify>::Signer;
	type Signature = Signature;
}

560
impl<C> frame_system::offchain::SendTransactionTypes<C> for Runtime where
561
562
563
564
565
566
	Call: From<C>,
{
	type OverarchingCall = Call;
	type Extrinsic = UncheckedExtrinsic;
}

ddorgan's avatar
ddorgan committed
567
568
parameter_types! {
	// Minimum 100 bytes/KSM deposited (1 CENT/byte)
569
	pub const BasicDeposit: Balance = 1000 * CENTS;       // 258 bytes on-chain
ddorgan's avatar
ddorgan committed
570
	pub const FieldDeposit: Balance = 250 * CENTS;        // 66 bytes on-chain
571
	pub const SubAccountDeposit: Balance = 200 * CENTS;   // 53 bytes on-chain
ddorgan's avatar
ddorgan committed
572
573
	pub const MaxSubAccounts: u32 = 100;
	pub const MaxAdditionalFields: u32 = 100;
574
	pub const MaxRegistrars: u32 = 20;
ddorgan's avatar
ddorgan committed
575
576
}

577
impl pallet_identity::Config for Runtime {
ddorgan's avatar
ddorgan committed
578
579
580
581
582
583
584
585
	type Event = Event;
	type Currency = Balances;
	type Slashed = ();
	type BasicDeposit = BasicDeposit;
	type FieldDeposit = FieldDeposit;
	type SubAccountDeposit = SubAccountDeposit;
	type MaxSubAccounts = MaxSubAccounts;
	type MaxAdditionalFields = MaxAdditionalFields;
586
	type MaxRegistrars = MaxRegistrars;
587
588
	type RegistrarOrigin = frame_system::EnsureRoot<AccountId>;
	type ForceOrigin = frame_system::EnsureRoot<AccountId>;
589
	type WeightInfo = weights::pallet_identity::WeightInfo<Runtime>;
ddorgan's avatar
ddorgan committed
590
591
}

592
impl pallet_utility::Config for Runtime {
593
594
	type Event = Event;
	type Call = Call;
595
	type WeightInfo = weights::pallet_utility::WeightInfo<Runtime>;
596
597
}

ddorgan's avatar
ddorgan committed
598
parameter_types! {
599
600
	// 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
601
	// Additional storage item size of 32 bytes.
602
	pub const DepositFactor: Balance = deposit(0, 32);
ddorgan's avatar
ddorgan committed
603
604
605
	pub const MaxSignatories: u16 = 100;
}

606
impl pallet_multisig::Config for Runtime {
ddorgan's avatar
ddorgan committed
607
608
609
	type Event = Event;
	type Call = Call;
	type Currency = Balances;
610
611
	type DepositBase = DepositBase;
	type DepositFactor = DepositFactor;
ddorgan's avatar
ddorgan committed
612
	type MaxSignatories = MaxSignatories;
613
	type WeightInfo = weights::pallet_multisig::WeightInfo<Runtime>;
ddorgan's avatar
ddorgan committed
614
615
616
}

parameter_types! {
617
	pub const ConfigDepositBase: Balance = 500 * CENTS;
ddorgan's avatar
ddorgan committed
618
619
	pub const FriendDepositFactor: Balance = 50 * CENTS;
	pub const MaxFriends: u16 = 9;
620
	pub const RecoveryDeposit: Balance = 500 * CENTS;
ddorgan's avatar
ddorgan committed
621
622
}

623
impl pallet_recovery::Config for Runtime {
ddorgan's avatar
ddorgan committed
624
625
626
627
628
629
630
631
632
633
	type Event = Event;
	type Call = Call;
	type Currency = Balances;
	type ConfigDepositBase = ConfigDepositBase;
	type FriendDepositFactor = FriendDepositFactor;
	type MaxFriends = MaxFriends;
	type RecoveryDeposit = RecoveryDeposit;
}

parameter_types! {
634
	pub const MinVestedTransfer: Balance = 100 * CENTS;
ddorgan's avatar
ddorgan committed
635
636
}

637
impl pallet_vesting::Config for Runtime {
ddorgan's avatar
ddorgan committed
638
639
640
641
	type Event = Event;
	type Currency = Balances;
	type BlockNumberToBalance = ConvertInto;
	type MinVestedTransfer = MinVestedTransfer;
642
	type WeightInfo = weights::pallet_vesting::WeightInfo<Runtime>;
ddorgan's avatar
ddorgan committed
643
644
}

645
impl pallet_sudo::Config for Runtime {
ddorgan's avatar
ddorgan committed
646
647
648
649
	type Event = Event;
	type Call = Call;
}

650
651
652
653
654
655
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;
656
657
658
	pub const AnnouncementDepositBase: Balance = deposit(1, 8);
	pub const AnnouncementDepositFactor: Balance = deposit(0, 66);
	pub const MaxPending: u16 = 32;
659
660
661
}

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

745
impl pallet_proxy::Config for Runtime {
746
747
748
749
750
751
752
	type Event = Event;
	type Call = Call;
	type Currency = Balances;
	type ProxyType = ProxyType;
	type ProxyDepositBase = ProxyDepositBase;
	type ProxyDepositFactor = ProxyDepositFactor;
	type MaxProxies = MaxProxies;
753
	type WeightInfo = weights::pallet_proxy::WeightInfo<Runtime>;
754
755
756
757
	type MaxPending = MaxPending;
	type CallHasher = BlakeTwo256;
	type AnnouncementDepositBase = AnnouncementDepositBase;
	type AnnouncementDepositFactor = AnnouncementDepositFactor;
758
759
}

760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
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;
	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 {
783
784
	type Event = Event;
	type UmpSink = crate::parachains_ump::XcmSink<XcmExecutor<XcmConfig>, Runtime>;
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
810
811
812
813
814
815
	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;
816
	type OnSwap = (Crowdloan, Slots);
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
	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>;
}

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
868
869
870
871
872
873
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>;
}

874
875
876
877
parameter_types! {
	pub const WndLocation: MultiLocation = MultiLocation::Null;
	pub const Ancestry: MultiLocation = MultiLocation::Null;
	pub WestendNetwork: NetworkId = NetworkId::Named(b"Westend".to_vec());
878
	pub CheckAccount: AccountId = XcmPallet::check_account();
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
}

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,
896
897
		// It's a native asset so we keep track of the teleports to maintain total issuance.
		CheckAccount,
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
	>;

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.
	xcm_sender::ChildParachainRouter<Runtime>,
);

918
919
920
921
922
923
924
925
parameter_types! {
	pub const WestendForWestmint: (MultiAsset, MultiLocation) =
		(AllConcreteFungible { id: Null }, X1(Parachain(1000)));
}
pub type TrustedTeleporters = (
	xcm_builder::Case<WestendForWestmint>,
);

926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
/// 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.
	AllowTopLevelPaidExecutionFrom<All<MultiLocation>>,
	// 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 = ();
943
	type IsTeleporter = TrustedTeleporters;
944
	type LocationInverter = LocationInverter<Ancestry>;
945
	type Barrier = Barrier;
946
947
948
949
950
	type Weigher = FixedWeightBounds<BaseXcmWeight, Call>;
	type Trader = UsingComponents<WeightToFee, WndLocation, AccountId, Balances, ToAuthor<Runtime>>;
	type ResponseHandler = ();
}

951
952
953
954
955
956
957
958
959
960
961
962
/// 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>,
);

pub struct OnlyWithdrawTeleportForAccounts;
impl frame_support::traits::Contains<(MultiLocation, Xcm<Call>)> for OnlyWithdrawTeleportForAccounts {
	fn contains((ref origin, ref msg): &(MultiLocation, Xcm<Call>)) -> bool {
		use xcm::v0::{
			Xcm::WithdrawAsset, Order::{BuyExecution, InitiateTeleport, DepositAsset},
963
			MultiAsset::{All, ConcreteFungible}, Junction::AccountId32,
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
		};
		match origin {
			// Root is allowed to execute anything.
			Null => true,
			X1(AccountId32 { .. }) => {
				// An account ID trying to send a message. We ensure that it's sensible.
				// This checks that it's of the form:
				// WithdrawAsset {
				//   assets: [ ConcreteFungible { id: Null } ],
				//   effects: [ BuyExecution, InitiateTeleport {
				//     assets: All,
				//     dest: Parachain,
				//     effects: [ BuyExecution, DepositAssets {
				//       assets: All,
				//       dest: AccountId32,
				//     } ]
				//   } ]
				// }
				matches!(msg, WithdrawAsset { ref assets, ref effects }
					if assets.len() == 1
					&& matches!(assets[0], ConcreteFungible { id: Null, .. })
					&& effects.len() == 2
					&& matches!(effects[0], BuyExecution { .. })
					&& matches!(effects[1], InitiateTeleport { ref assets, dest: X1(Parachain(..)), ref effects }
						if assets.len() == 1
						&& matches!(assets[0], All)
						&& effects.len() == 2
						&& matches!(effects[0], BuyExecution { .. })
						&& matches!(effects[1], DepositAsset { ref assets, dest: X1(AccountId32{..}) }
							if assets.len() == 1
							&& matches!(assets[0], All)
						)
					)
				)
			}
			// Nobody else is allowed to execute anything.
			_ => false,
For faster browsing, not all history is shown. View entire blame