lib.rs 31.6 KB
Newer Older
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"]
22

Albrecht's avatar
Albrecht committed
23
use pallet_transaction_payment::CurrencyAdapter;
24
use parity_scale_codec::Encode;
Shawn Tabrizi's avatar
Shawn Tabrizi committed
25
26
27
28
29
use sp_std::{collections::btree_map::BTreeMap, prelude::*};

use polkadot_runtime_parachains::{
	configuration as parachains_configuration, disputes as parachains_disputes,
	dmp as parachains_dmp, hrmp as parachains_hrmp, inclusion as parachains_inclusion,
30
	initializer as parachains_initializer, origin as parachains_origin, paras as parachains_paras,
Shawn Tabrizi's avatar
Shawn Tabrizi committed
31
32
33
34
	paras_inherent as parachains_paras_inherent, runtime_api_impl::v1 as runtime_impl,
	scheduler as parachains_scheduler, session_info as parachains_session_info,
	shared as parachains_shared, ump as parachains_ump,
};
Sergey Pepyakin's avatar
Sergey Pepyakin committed
35

Shawn Tabrizi's avatar
Shawn Tabrizi committed
36
37
use authority_discovery_primitives::AuthorityId as AuthorityDiscoveryId;
use beefy_primitives::crypto::AuthorityId as BeefyId;
Shawn Tabrizi's avatar
Shawn Tabrizi committed
38
39
40
41
use frame_support::{
	construct_runtime, parameter_types,
	traits::{Everything, KeyOwnerProofSystem},
};
Shawn Tabrizi's avatar
Shawn Tabrizi committed
42
43
44
45
46
use pallet_grandpa::{fg_primitives, AuthorityId as GrandpaId};
use pallet_mmr_primitives as mmr;
use pallet_session::historical as session_historical;
use pallet_transaction_payment::{FeeDetails, RuntimeDispatchInfo};
use polkadot_runtime_parachains::reward_points::RewardValidatorsWithEraPoints;
47
use primitives::v1::{
48
	AccountId, AccountIndex, Balance, BlockNumber, CandidateEvent, CommittedCandidateReceipt,
Shawn Tabrizi's avatar
Shawn Tabrizi committed
49
50
	CoreState, GroupRotationInfo, Hash as HashT, Id as ParaId, InboundDownwardMessage,
	InboundHrmpMessage, Moment, Nonce, OccupiedCoreAssumption, PersistedValidationData,
51
52
	ScrapedOnChainVotes, SessionInfo as SessionInfoData, Signature, ValidationCode,
	ValidationCodeHash, ValidatorId, ValidatorIndex,
53
};
54
use runtime_common::{
Shawn Tabrizi's avatar
Shawn Tabrizi committed
55
	claims, paras_sudo_wrapper, BlockHashCount, BlockLength, BlockWeights, SlowAdjustingFeeUpdate,
56
};
Shawn Tabrizi's avatar
Shawn Tabrizi committed
57
use sp_core::OpaqueMetadata;
58
use sp_runtime::{
Shawn Tabrizi's avatar
Shawn Tabrizi committed
59
	create_runtime_str,
60
	curve::PiecewiseLinear,
Shawn Tabrizi's avatar
Shawn Tabrizi committed
61
	generic, impl_opaque_keys,
62
	traits::{
Shawn Tabrizi's avatar
Shawn Tabrizi committed
63
64
		BlakeTwo256, Block as BlockT, ConvertInto, Extrinsic as ExtrinsicT, OpaqueKeys,
		SaturatedConversion, StaticLookup, Verify,
65
	},
Shawn Tabrizi's avatar
Shawn Tabrizi committed
66
67
	transaction_validity::{TransactionSource, TransactionValidity},
	ApplyExtrinsicResult, KeyTypeId, Perbill,
68
};
Shawn Tabrizi's avatar
Shawn Tabrizi committed
69
use sp_staking::SessionIndex;
70
#[cfg(any(feature = "std", test))]
71
use sp_version::NativeVersion;
Shawn Tabrizi's avatar
Shawn Tabrizi committed
72
use sp_version::RuntimeVersion;
73

Shawn Tabrizi's avatar
Shawn Tabrizi committed
74
pub use pallet_balances::Call as BalancesCall;
75
#[cfg(feature = "std")]
76
pub use pallet_staking::StakerStatus;
Shawn Tabrizi's avatar
Shawn Tabrizi committed
77
pub use pallet_sudo::Call as SudoCall;
78
pub use pallet_timestamp::Call as TimestampCall;
79
pub use paras_sudo_wrapper::Call as ParasSudoWrapperCall;
Shawn Tabrizi's avatar
Shawn Tabrizi committed
80
81
#[cfg(any(feature = "std", test))]
pub use sp_runtime::BuildStorage;
82
83
84

/// Constant values used within the runtime.
pub mod constants;
85
pub mod xcm_config;
Shawn Tabrizi's avatar
Shawn Tabrizi committed
86
use constants::{currency::*, fee::*, time::*};
87
88
89
90
91

// Make the WASM binary available.
#[cfg(feature = "std")]
include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));

92
/// Runtime version (Test).
93
94
95
96
pub const VERSION: RuntimeVersion = RuntimeVersion {
	spec_name: create_runtime_str!("polkadot-test-runtime"),
	impl_name: create_runtime_str!("parity-polkadot-test-runtime"),
	authoring_version: 2,
97
	spec_version: 1056,
98
	impl_version: 0,
99
	apis: RUNTIME_API_VERSIONS,
100
	transaction_version: 1,
101
102
};

103
104
105
106
/// The BABE epoch configuration at genesis.
pub const BABE_GENESIS_EPOCH_CONFIG: babe_primitives::BabeEpochConfiguration =
	babe_primitives::BabeEpochConfiguration {
		c: PRIMARY_PROBABILITY,
Shawn Tabrizi's avatar
Shawn Tabrizi committed
107
		allowed_slots: babe_primitives::AllowedSlots::PrimaryAndSecondaryVRFSlots,
108
109
	};

110
111
112
/// Native version.
#[cfg(any(feature = "std", test))]
pub fn native_version() -> NativeVersion {
Shawn Tabrizi's avatar
Shawn Tabrizi committed
113
	NativeVersion { runtime_version: VERSION, can_author_with: Default::default() }
114
115
}

116
117
118
119
120
121
122
sp_api::decl_runtime_apis! {
	pub trait GetLastTimestamp {
		/// Returns the last timestamp of a runtime.
		fn get_last_timestamp() -> u64;
	}
}

123
124
parameter_types! {
	pub const Version: RuntimeVersion = VERSION;
125
	pub const SS58Prefix: u8 = 42;
126
127
}

128
impl frame_system::Config for Runtime {
129
	type BaseCallFilter = frame_support::traits::Everything;
130
131
132
	type BlockWeights = BlockWeights;
	type BlockLength = BlockLength;
	type DbWeight = ();
133
134
135
136
137
138
139
140
141
142
143
144
	type Origin = Origin;
	type Call = Call;
	type Index = Nonce;
	type BlockNumber = BlockNumber;
	type Hash = HashT;
	type Hashing = BlakeTwo256;
	type AccountId = AccountId;
	type Lookup = Indices;
	type Header = generic::Header<BlockNumber, BlakeTwo256>;
	type Event = Event;
	type BlockHashCount = BlockHashCount;
	type Version = Version;
145
	type PalletInfo = PalletInfo;
146
	type AccountData = pallet_balances::AccountData<Balance>;
Gavin Wood's avatar
Gavin Wood committed
147
	type OnNewAccount = ();
148
	type OnKilledAccount = ();
149
	type SystemWeightInfo = ();
150
	type SS58Prefix = SS58Prefix;
151
	type OnSetCode = ();
152
153
}

Shawn Tabrizi's avatar
Shawn Tabrizi committed
154
155
impl<C> frame_system::offchain::SendTransactionTypes<C> for Runtime
where
156
157
158
159
160
161
	Call: From<C>,
{
	type OverarchingCall = Call;
	type Extrinsic = UncheckedExtrinsic;
}

162
parameter_types! {
163
	pub storage EpochDuration: u64 = EPOCH_DURATION_IN_SLOTS as u64;
164
	pub storage ExpectedBlockTime: Moment = MILLISECS_PER_BLOCK;
165
166
}

167
impl pallet_babe::Config for Runtime {
168
169
170
171
	type EpochDuration = EpochDuration;
	type ExpectedBlockTime = ExpectedBlockTime;

	// session module is the trigger
172
	type EpochChangeTrigger = pallet_babe::ExternalTrigger;
173

174
175
	type DisabledValidators = ();

176
177
178
179
	type KeyOwnerProofSystem = ();

	type KeyOwnerProof = <Self::KeyOwnerProofSystem as KeyOwnerProofSystem<(
		KeyTypeId,
180
		pallet_babe::AuthorityId,
181
182
183
184
	)>>::Proof;

	type KeyOwnerIdentification = <Self::KeyOwnerProofSystem as KeyOwnerProofSystem<(
		KeyTypeId,
185
		pallet_babe::AuthorityId,
186
187
188
	)>>::IdentificationTuple;

	type HandleEquivocation = ();
189
190

	type WeightInfo = ();
191
	type MaxAuthorities = MaxAuthorities;
192
193
194
}

parameter_types! {
195
	pub storage IndexDeposit: Balance = 1 * DOLLARS;
196
197
}

198
impl pallet_indices::Config for Runtime {
199
200
201
202
	type AccountIndex = AccountIndex;
	type Currency = Balances;
	type Deposit = IndexDeposit;
	type Event = Event;
203
	type WeightInfo = ();
204
205
206
}

parameter_types! {
207
	pub storage ExistentialDeposit: Balance = 1 * CENTS;
208
	pub storage MaxLocks: u32 = 50;
Gavin Wood's avatar
Gavin Wood committed
209
	pub const MaxReserves: u32 = 50;
210
211
}

212
impl pallet_balances::Config for Runtime {
213
214
215
216
217
	type Balance = Balance;
	type DustRemoval = ();
	type Event = Event;
	type ExistentialDeposit = ExistentialDeposit;
	type AccountStore = System;
218
	type MaxLocks = MaxLocks;
Gavin Wood's avatar
Gavin Wood committed
219
220
	type MaxReserves = MaxReserves;
	type ReserveIdentifier = [u8; 8];
221
	type WeightInfo = ();
222
223
224
}

parameter_types! {
225
	pub storage TransactionByteFee: Balance = 10 * MILLICENTS;
226
227
228
	/// 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;
229
230
}

231
impl pallet_transaction_payment::Config for Runtime {
Albrecht's avatar
Albrecht committed
232
	type OnChargeTransaction = CurrencyAdapter<Balances, ()>;
233
	type TransactionByteFee = TransactionByteFee;
234
	type OperationalFeeMultiplier = OperationalFeeMultiplier;
235
	type WeightToFee = WeightToFee;
236
	type FeeMultiplierUpdate = SlowAdjustingFeeUpdate<Self>;
237
238
239
}

parameter_types! {
240
241
	pub storage SlotDuration: u64 = SLOT_DURATION;
	pub storage MinimumPeriod: u64 = SlotDuration::get() / 2;
242
}
243
impl pallet_timestamp::Config for Runtime {
244
245
246
	type Moment = u64;
	type OnTimestampSet = Babe;
	type MinimumPeriod = MinimumPeriod;
247
	type WeightInfo = ();
248
249
250
}

parameter_types! {
251
	pub storage UncleGenerations: u32 = 0;
252
253
}

254
impl pallet_authorship::Config for Runtime {
255
	type FindAuthor = pallet_session::FindAccountFromAuthorIndex<Self, Babe>;
256
257
258
259
260
261
	type UncleGenerations = UncleGenerations;
	type FilterUncle = ();
	type EventHandler = Staking;
}

parameter_types! {
262
263
	pub storage Period: BlockNumber = 10 * MINUTES;
	pub storage Offset: BlockNumber = 0;
264
265
266
267
268
269
}

impl_opaque_keys! {
	pub struct SessionKeys {
		pub grandpa: Grandpa,
		pub babe: Babe,
270
		pub para_validator: Initializer,
271
		pub para_assignment: ParaSessionInfo,
272
		pub authority_discovery: AuthorityDiscovery,
273
274
275
	}
}

276
impl pallet_session::Config for Runtime {
277
278
	type Event = Event;
	type ValidatorId = AccountId;
279
	type ValidatorIdOf = pallet_staking::StashOf<Self>;
280
	type ShouldEndSession = Babe;
281
	type NextSessionRotation = Babe;
282
283
284
	type SessionManager = Staking;
	type SessionHandler = <SessionKeys as OpaqueKeys>::KeyTypeIdProviders;
	type Keys = SessionKeys;
285
	type WeightInfo = ();
286
287
}

288
impl pallet_session::historical::Config for Runtime {
289
290
	type FullIdentification = pallet_staking::Exposure<AccountId, Balance>;
	type FullIdentificationOf = pallet_staking::ExposureOf<Runtime>;
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
}

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).
306
	pub storage SessionsPerEra: SessionIndex = 6;
307
	// 28 eras for unbonding (7 days).
308
	pub storage BondingDuration: pallet_staking::EraIndex = 28;
309
	// 27 eras in which slashes can be cancelled (a bit less than 7 days).
310
	pub storage SlashDeferDuration: pallet_staking::EraIndex = 27;
311
	pub const RewardCurve: &'static PiecewiseLinear<'static> = &REWARD_CURVE;
312
	pub storage MaxNominatorRewardedPerValidator: u32 = 64;
313
	pub storage OffendingValidatorsThreshold: Perbill = Perbill::from_percent(17);
314
	pub const MaxAuthorities: u32 = 100_000;
315
316
}

Kian Paimani's avatar
Kian Paimani committed
317
impl frame_election_provider_support::onchain::Config for Runtime {
Kian Paimani's avatar
Kian Paimani committed
318
	type Accuracy = runtime_common::elections::OnOnChainAccuracy;
Shawn Tabrizi's avatar
Shawn Tabrizi committed
319
	type DataProvider = Staking;
320
321
}

322
impl pallet_staking::Config for Runtime {
323
	const MAX_NOMINATIONS: u32 = 16;
324
	type Currency = Balances;
325
	type UnixTime = Timestamp;
326
	type CurrencyToVote = frame_support::traits::U128CurrencyToVote;
327
328
329
330
331
332
333
334
	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.
335
	type SlashCancelOrigin = frame_system::EnsureNever<()>;
336
	type SessionInterface = Self;
Kian Paimani's avatar
Kian Paimani committed
337
	type EraPayout = pallet_staking::ConvertCurve<RewardCurve>;
338
	type MaxNominatorRewardedPerValidator = MaxNominatorRewardedPerValidator;
339
	type OffendingValidatorsThreshold = OffendingValidatorsThreshold;
340
	type NextNewSession = Session;
Shawn Tabrizi's avatar
Shawn Tabrizi committed
341
342
	type ElectionProvider =
		frame_election_provider_support::onchain::OnChainSequentialPhragmen<Self>;
343
344
	type GenesisElectionProvider =
		frame_election_provider_support::onchain::OnChainSequentialPhragmen<Self>;
345
346
347
	// Use the nominator map to iter voter AND no-ops for all SortedListProvider hooks. The migration
	// to bags-list is a no-op, but the storage version will be updated.
	type SortedListProvider = pallet_staking::UseNominatorsMap<Runtime>;
348
	type BenchmarkingConfig = runtime_common::StakingBenchmarkingConfig;
349
	type WeightInfo = ();
350
351
}

352
impl pallet_grandpa::Config for Runtime {
353
	type Event = Event;
354
355
356
357
358
359
360
361
362
363
364
365
366
	type Call = Call;

	type KeyOwnerProofSystem = ();

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

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

	type HandleEquivocation = ();
367
368

	type WeightInfo = ();
369
	type MaxAuthorities = MaxAuthorities;
370
371
}

Shawn Tabrizi's avatar
Shawn Tabrizi committed
372
373
impl<LocalCall> frame_system::offchain::CreateSignedTransaction<LocalCall> for Runtime
where
374
375
	Call: From<LocalCall>,
{
376
	fn create_transaction<C: frame_system::offchain::AppCrypto<Self::Public, Self::Signature>>(
377
378
379
		call: Call,
		public: <Signature as Verify>::Signer,
		account: AccountId,
380
		nonce: <Runtime as frame_system::Config>::Index,
381
	) -> Option<(Call, <UncheckedExtrinsic as ExtrinsicT>::SignaturePayload)> {
Shawn Tabrizi's avatar
Shawn Tabrizi committed
382
383
384
385
		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>().saturating_sub(1);
386
387
		let tip = 0;
		let extra: SignedExtra = (
388
389
390
			frame_system::CheckSpecVersion::<Runtime>::new(),
			frame_system::CheckTxVersion::<Runtime>::new(),
			frame_system::CheckGenesis::<Runtime>::new(),
Shawn Tabrizi's avatar
Shawn Tabrizi committed
391
392
393
394
			frame_system::CheckMortality::<Runtime>::from(generic::Era::mortal(
				period,
				current_block,
			)),
395
396
397
			frame_system::CheckNonce::<Runtime>::from(nonce),
			frame_system::CheckWeight::<Runtime>::new(),
			pallet_transaction_payment::ChargeTransactionPayment::<Runtime>::from(tip),
398
		);
Shawn Tabrizi's avatar
Shawn Tabrizi committed
399
400
401
402
403
404
		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))?;
405
406
407
408
		let (call, extra, _) = raw_payload.deconstruct();
		let address = Indices::unlookup(account);
		Some((call, (address, signature, extra)))
	}
409
410
}

411
impl frame_system::offchain::SigningTypes for Runtime {
412
413
414
415
	type Public = <Signature as Verify>::Signer;
	type Signature = Signature;
}

416
impl pallet_offences::Config for Runtime {
417
	type Event = Event;
418
	type IdentificationTuple = pallet_session::historical::IdentificationTuple<Self>;
419
	type OnOffenceHandler = Staking;
420
421
}

422
423
424
impl pallet_authority_discovery::Config for Runtime {
	type MaxAuthorities = MaxAuthorities;
}
425

426
parameter_types! {
427
428
	pub storage LeasePeriod: BlockNumber = 100_000;
	pub storage EndingPeriod: BlockNumber = 1000;
429
430
431
}

parameter_types! {
432
	pub Prefix: &'static [u8] = b"Pay KSMs to the Kusama account:";
433
434
}

435
impl claims::Config for Runtime {
436
437
438
	type Event = Event;
	type VestingSchedule = Vesting;
	type Prefix = Prefix;
439
	type MoveClaimOrigin = frame_system::EnsureRoot<AccountId>;
440
	type WeightInfo = claims::TestWeightInfo;
441
442
443
}

parameter_types! {
444
	pub storage MinVestedTransfer: Balance = 100 * DOLLARS;
445
446
}

447
impl pallet_vesting::Config for Runtime {
448
449
450
451
	type Event = Event;
	type Currency = Balances;
	type BlockNumberToBalance = ConvertInto;
	type MinVestedTransfer = MinVestedTransfer;
452
	type WeightInfo = ();
453
	const MAX_VESTING_SCHEDULES: u32 = 28;
454
455
}

456
impl pallet_sudo::Config for Runtime {
457
458
459
460
	type Event = Event;
	type Call = Call;
}

461
impl parachains_configuration::Config for Runtime {
462
	type WeightInfo = parachains_configuration::TestWeightInfo;
463
}
464

465
466
impl parachains_shared::Config for Runtime {}

467
impl parachains_inclusion::Config for Runtime {
468
	type Event = Event;
asynchronous rob's avatar
asynchronous rob committed
469
	type DisputesHandler = ParasDisputes;
470
	type RewardValidators = RewardValidatorsWithEraPoints<Runtime>;
471
472
}

asynchronous rob's avatar
asynchronous rob committed
473
474
475
476
impl parachains_disputes::Config for Runtime {
	type Event = Event;
	type RewardValidators = ();
	type PunishValidators = ();
477
	type WeightInfo = parachains_disputes::TestWeightInfo;
asynchronous rob's avatar
asynchronous rob committed
478
479
}

480
481
482
impl parachains_paras_inherent::Config for Runtime {
	type WeightInfo = parachains_paras_inherent::TestWeightInfo;
}
483

484
impl parachains_initializer::Config for Runtime {
485
	type Randomness = pallet_babe::RandomnessFromOneEpochAgo<Runtime>;
486
	type ForceOrigin = frame_system::EnsureRoot<AccountId>;
487
	type WeightInfo = ();
488
489
}

490
impl parachains_session_info::Config for Runtime {}
491

492
impl parachains_paras::Config for Runtime {
493
	type Event = Event;
494
	type WeightInfo = parachains_paras::TestWeightInfo;
495
496
}

497
impl parachains_dmp::Config for Runtime {}
498

Gavin Wood's avatar
Gavin Wood committed
499
500
501
502
parameter_types! {
	pub const FirstMessageFactorPercent: u64 = 100;
}

503
impl parachains_ump::Config for Runtime {
504
	type Event = Event;
505
	type UmpSink = ();
Gavin Wood's avatar
Gavin Wood committed
506
	type FirstMessageFactorPercent = FirstMessageFactorPercent;
507
	type ExecuteOverweightOrigin = frame_system::EnsureRoot<AccountId>;
508
}
509

510
511
512
parameter_types! {
	pub const BaseXcmWeight: frame_support::weights::Weight = 1_000;
	pub const AnyNetwork: xcm::latest::NetworkId = xcm::latest::NetworkId::Any;
513
	pub const MaxInstructions: u32 = 100;
514
515
516
517
518
519
520
521
522
523
524
}

pub type LocalOriginToLocation = xcm_builder::SignedToAccountId32<Origin, AccountId, AnyNetwork>;

impl pallet_xcm::Config for Runtime {
	// The config types here are entirely configurable, since the only one that is sorely needed
	// is `XcmExecutor`, which will be used in unit tests located in xcm-executor.
	type Event = Event;
	type ExecuteXcmOrigin = xcm_builder::EnsureXcmOrigin<Origin, LocalOriginToLocation>;
	type LocationInverter = xcm_config::InvertNothing;
	type SendXcmOrigin = xcm_builder::EnsureXcmOrigin<Origin, LocalOriginToLocation>;
525
	type Weigher = xcm_builder::FixedWeightBounds<BaseXcmWeight, Call, MaxInstructions>;
526
	type XcmRouter = xcm_config::DoNothingRouter;
Shawn Tabrizi's avatar
Shawn Tabrizi committed
527
	type XcmExecuteFilter = Everything;
528
	type XcmExecutor = xcm_executor::XcmExecutor<xcm_config::XcmConfig>;
Shawn Tabrizi's avatar
Shawn Tabrizi committed
529
530
	type XcmTeleportFilter = Everything;
	type XcmReserveTransferFilter = Everything;
531
532
	type Origin = Origin;
	type Call = Call;
533
534
	const VERSION_DISCOVERY_QUEUE_SIZE: u32 = 100;
	type AdvertisedXcmVersion = pallet_xcm::CurrentXcmVersion;
535
536
}

537
impl parachains_hrmp::Config for Runtime {
538
	type Event = Event;
539
	type Origin = Origin;
540
	type Currency = Balances;
541
542
}

543
impl parachains_scheduler::Config for Runtime {}
544

545
impl paras_sudo_wrapper::Config for Runtime {}
546

547
548
impl parachains_origin::Config for Runtime {}

549
550
551
552
553
554
555
556
557
558
impl pallet_test_notifier::Config for Runtime {
	type Event = Event;
	type Origin = Origin;
	type Call = Call;
}

#[frame_support::pallet]
pub mod pallet_test_notifier {
	use frame_support::pallet_prelude::*;
	use frame_system::pallet_prelude::*;
559
	use pallet_xcm::ensure_response;
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
	use sp_runtime::DispatchResult;
	use xcm::latest::prelude::*;

	#[pallet::pallet]
	#[pallet::generate_store(pub(super) trait Store)]
	pub struct Pallet<T>(_);

	#[pallet::config]
	pub trait Config: frame_system::Config + pallet_xcm::Config {
		type Event: IsType<<Self as frame_system::Config>::Event> + From<Event<Self>>;
		type Origin: IsType<<Self as frame_system::Config>::Origin>
			+ Into<Result<pallet_xcm::Origin, <Self as Config>::Origin>>;
		type Call: IsType<<Self as pallet_xcm::Config>::Call> + From<Call<Self>>;
	}

	#[pallet::event]
	#[pallet::generate_deposit(pub(super) fn deposit_event)]
	pub enum Event<T: Config> {
		QueryPrepared(QueryId),
		NotifyQueryPrepared(QueryId),
		ResponseReceived(MultiLocation, QueryId, Response),
	}

	#[pallet::error]
	pub enum Error<T> {
		UnexpectedId,
		BadAccountFormat,
	}

	#[pallet::call]
	impl<T: Config> Pallet<T> {
		#[pallet::weight(1_000_000)]
		pub fn prepare_new_query(origin: OriginFor<T>) -> DispatchResult {
			let who = ensure_signed(origin)?;
			let id = who
				.using_encoded(|mut d| <[u8; 32]>::decode(&mut d))
				.map_err(|_| Error::<T>::BadAccountFormat)?;
			let qid = pallet_xcm::Pallet::<T>::new_query(
				Junction::AccountId32 { network: Any, id }.into(),
				100u32.into(),
			);
			Self::deposit_event(Event::<T>::QueryPrepared(qid));
			Ok(())
		}

		#[pallet::weight(1_000_000)]
		pub fn prepare_new_notify_query(origin: OriginFor<T>) -> DispatchResult {
			let who = ensure_signed(origin)?;
			let id = who
				.using_encoded(|mut d| <[u8; 32]>::decode(&mut d))
				.map_err(|_| Error::<T>::BadAccountFormat)?;
611
612
			let call =
				Call::<T>::notification_received { query_id: 0, response: Default::default() };
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
			let qid = pallet_xcm::Pallet::<T>::new_notify_query(
				Junction::AccountId32 { network: Any, id }.into(),
				<T as Config>::Call::from(call),
				100u32.into(),
			);
			Self::deposit_event(Event::<T>::NotifyQueryPrepared(qid));
			Ok(())
		}

		#[pallet::weight(1_000_000)]
		pub fn notification_received(
			origin: OriginFor<T>,
			query_id: QueryId,
			response: Response,
		) -> DispatchResult {
			let responder = ensure_response(<T as Config>::Origin::from(origin))?;
			Self::deposit_event(Event::<T>::ResponseReceived(responder, query_id, response));
			Ok(())
		}
	}
}

635
636
637
construct_runtime! {
	pub enum Runtime where
		Block = Block,
638
		NodeBlock = primitives::v1::Block,
639
640
641
		UncheckedExtrinsic = UncheckedExtrinsic
	{
		// Basic stuff; balances is uncallable initially.
642
		System: frame_system::{Pallet, Call, Storage, Config, Event<T>},
643
644

		// Must be before session.
645
		Babe: pallet_babe::{Pallet, Call, Storage, Config},
646

647
648
649
650
		Timestamp: pallet_timestamp::{Pallet, Call, Storage, Inherent},
		Indices: pallet_indices::{Pallet, Call, Storage, Config<T>, Event<T>},
		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
		TransactionPayment: pallet_transaction_payment::{Pallet, Storage},
651
652

		// Consensus support.
653
		Authorship: pallet_authorship::{Pallet, Call, Storage},
654
		Staking: pallet_staking::{Pallet, Call, Storage, Config<T>, Event<T>},
Keith Yeung's avatar
Keith Yeung committed
655
		Offences: pallet_offences::{Pallet, Storage, Event},
656
657
658
		Historical: session_historical::{Pallet},
		Session: pallet_session::{Pallet, Call, Storage, Event, Config<T>},
		Grandpa: pallet_grandpa::{Pallet, Call, Storage, Config, Event},
Keith Yeung's avatar
Keith Yeung committed
659
		AuthorityDiscovery: pallet_authority_discovery::{Pallet, Config},
660
661

		// Claims. Usable initially.
662
		Claims: claims::{Pallet, Call, Storage, Event<T>, Config<T>, ValidateUnsigned},
663
664

		// Vesting. Usable initially, but removed once all vesting is finished.
665
		Vesting: pallet_vesting::{Pallet, Call, Storage, Event<T>, Config<T>},
666

667
		// Parachains runtime modules
668
		Configuration: parachains_configuration::{Pallet, Call, Storage, Config<T>},
669
		ParaInclusion: parachains_inclusion::{Pallet, Call, Storage, Event<T>},
670
		ParaInherent: parachains_paras_inherent::{Pallet, Call, Storage, Inherent},
671
		Initializer: parachains_initializer::{Pallet, Call, Storage},
672
		Paras: parachains_paras::{Pallet, Call, Storage, Event},
673
		ParasShared: parachains_shared::{Pallet, Call, Storage},
674
		Scheduler: parachains_scheduler::{Pallet, Storage},
675
		ParasSudoWrapper: paras_sudo_wrapper::{Pallet, Call},
676
		ParasOrigin: parachains_origin::{Pallet, Origin},
677
		ParaSessionInfo: parachains_session_info::{Pallet, Storage},
678
		Hrmp: parachains_hrmp::{Pallet, Call, Storage, Event<T>},
679
		Ump: parachains_ump::{Pallet, Call, Storage, Event},
680
		Dmp: parachains_dmp::{Pallet, Call, Storage},
681
		Xcm: pallet_xcm::{Pallet, Call, Event<T>, Origin},
asynchronous rob's avatar
asynchronous rob committed
682
		ParasDisputes: parachains_disputes::{Pallet, Storage, Event<T>},
683
684

		Sudo: pallet_sudo::{Pallet, Call, Storage, Config<T>, Event<T>},
685
686

		TestNotifier: pallet_test_notifier::{Pallet, Call, Event<T>},
687
688
689
690
	}
}

/// The address format for describing accounts.
691
pub type Address = sp_runtime::MultiAddress<AccountId, AccountIndex>;
692
693
694
695
696
697
/// Block header type as expected by this runtime.
pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
/// Block type as expected by this runtime.
pub type Block = generic::Block<Header, UncheckedExtrinsic>;
/// A Block signed with a Justification
pub type SignedBlock = generic::SignedBlock<Block>;
Denis_P's avatar
Denis_P committed
698
/// `BlockId` type as expected by this runtime.
699
pub type BlockId = generic::BlockId<Block>;
Denis_P's avatar
Denis_P committed
700
/// The `SignedExtension` to the basic transaction logic.
701
pub type SignedExtra = (
702
703
704
705
706
707
	frame_system::CheckSpecVersion<Runtime>,
	frame_system::CheckTxVersion<Runtime>,
	frame_system::CheckGenesis<Runtime>,
	frame_system::CheckMortality<Runtime>,
	frame_system::CheckNonce<Runtime>,
	frame_system::CheckWeight<Runtime>,
Shawn Tabrizi's avatar
Shawn Tabrizi committed
708
	pallet_transaction_payment::ChargeTransactionPayment<Runtime>,
709
710
711
712
);
/// Unchecked extrinsic type as expected by this runtime.
pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<Address, Call, Signature, SignedExtra>;
/// Executive: handles dispatch to the various modules.
Shawn Tabrizi's avatar
Shawn Tabrizi committed
713
714
715
716
717
718
719
pub type Executive = frame_executive::Executive<
	Runtime,
	Block,
	frame_system::ChainContext<Runtime>,
	Runtime,
	AllPallets,
>;
720
721
/// The payload being signed in transactions.
pub type SignedPayload = generic::SignedPayload<Call, SignedExtra>;
722
723
724
725
726
727
728
729
730
731
732

pub type Hash = <Block as BlockT>::Hash;
pub type Extrinsic = <Block as BlockT>::Extrinsic;

sp_api::impl_runtime_apis! {
	impl sp_api::Core<Block> for Runtime {
		fn version() -> RuntimeVersion {
			VERSION
		}

		fn execute_block(block: Block) {
733
			Executive::execute_block(block);
734
735
736
737
738
739
740
741
742
		}

		fn initialize_block(header: &<Block as BlockT>::Header) {
			Executive::initialize_block(header)
		}
	}

	impl sp_api::Metadata<Block> for Runtime {
		fn metadata() -> OpaqueMetadata {
743
			OpaqueMetadata::new(Runtime::metadata().into())
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
		}
	}

	impl block_builder_api::BlockBuilder<Block> for Runtime {
		fn apply_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) -> ApplyExtrinsicResult {
			Executive::apply_extrinsic(extrinsic)
		}

		fn finalize_block() -> <Block as BlockT>::Header {
			Executive::finalize_block()
		}

		fn inherent_extrinsics(data: inherents::InherentData) -> Vec<<Block as BlockT>::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<Block> for Runtime {
769
770
771
		fn validate_transaction(
			source: TransactionSource,
			tx: <Block as BlockT>::Extrinsic,
772
			block_hash: <Block as BlockT>::Hash,
773
		) -> TransactionValidity {
774
			Executive::validate_transaction(source, tx, block_hash)
775
776
777
		}
	}

778
779
780
781
782
783
784
785
	impl offchain_primitives::OffchainWorkerApi<Block> for Runtime {
		fn offchain_worker(header: &<Block as BlockT>::Header) {
			Executive::offchain_worker(header)
		}
	}

	impl authority_discovery_primitives::AuthorityDiscoveryApi<Block> for Runtime {
		fn authorities() -> Vec<AuthorityDiscoveryId> {
786
			AuthorityDiscovery::authorities()
787
788
789
		}
	}

790
791
792
	impl primitives::v1::ParachainHost<Block, Hash, BlockNumber> for Runtime {
		fn validators() -> Vec<ValidatorId> {
			runtime_impl::validators::<Runtime>()
793
		}
794
795
796

		fn validator_groups() -> (Vec<Vec<ValidatorIndex>>, GroupRotationInfo<BlockNumber>) {
			runtime_impl::validator_groups::<Runtime>()
797
		}
798

799
		fn availability_cores() -> Vec<CoreState<Hash, BlockNumber>> {
800
			runtime_impl::availability_cores::<Runtime>()
801
		}
802
803

		fn persisted_validation_data(para_id: ParaId, assumption: OccupiedCoreAssumption)
804
			-> Option<PersistedValidationData<Hash, BlockNumber>>
805
806
807
		{
			runtime_impl::persisted_validation_data::<Runtime>(para_id, assumption)
		}
808

809
810
811
812
813
814
815
816
817
818
		fn assumed_validation_data(
			para_id: ParaId,
			expected_persisted_validation_data_hash: Hash,
		) -> Option<(PersistedValidationData<Hash, BlockNumber>, ValidationCodeHash)> {
			runtime_impl::assumed_validation_data::<Runtime>(
				para_id,
				expected_persisted_validation_data_hash,
			)
		}

819
820
		fn check_validation_outputs(
			para_id: ParaId,
821
			outputs: primitives::v1::CandidateCommitments,
822
823
824
825
		) -> bool {
			runtime_impl::check_validation_outputs::<Runtime>(para_id, outputs)
		}

826
827
		fn session_index_for_child() -> SessionIndex {
			runtime_impl::session_index_for_child::<Runtime>()
828
		}
829
830

		fn validation_code(para_id: ParaId, assumption: OccupiedCoreAssumption)
831
832
833
834
			-> Option<ValidationCode>
		{
			runtime_impl::validation_code::<Runtime>(para_id, assumption)
		}
835
836
837

		fn candidate_pending_availability(para_id: ParaId) -> Option<CommittedCandidateReceipt<Hash>> {
			runtime_impl::candidate_pending_availability::<Runtime>(para_id)
838
		}
839
840
841
842
843
844

		fn candidate_events() -> Vec<CandidateEvent<Hash>> {
			use core::convert::TryInto;
			runtime_impl::candidate_events::<Runtime, _>(|trait_event| trait_event.try_into().ok())
		}

845
		fn session_info(index: SessionIndex) -> Option<SessionInfoData> {
846
			runtime_impl::session_info::<Runtime>(index)
847
		}
848
849
850

		fn dmq_contents(
			recipient: ParaId,
Sergey Pepyakin's avatar
Sergey Pepyakin committed
851
		) -> Vec<InboundDownwardMessage<BlockNumber>> {
852
853
			runtime_impl::dmq_contents::<Runtime>(recipient)
		}
Sergey Pepyakin's avatar
Sergey Pepyakin committed
854
855
856
857
858
859

		fn inbound_hrmp_channels_contents(
			recipient: ParaId,
		) -> BTreeMap<ParaId, Vec<InboundHrmpMessage<BlockNumber>>> {
			runtime_impl::inbound_hrmp_channels_contents::<Runtime>(recipient)
		}
860

861
		fn validation_code_by_hash(hash: ValidationCodeHash) -> Option<ValidationCode> {
862
863
			runtime_impl::validation_code_by_hash::<Runtime>(hash)
		}
864
865
866
867

		fn on_chain_votes() -> Option<ScrapedOnChainVotes<Hash>> {
			runtime_impl::on_chain_votes::<Runtime>()
		}
868
869
	}

Andreas Doerr's avatar
Andreas Doerr committed
870
	impl beefy_primitives::BeefyApi<Block> for Runtime {
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
		fn validator_set() -> beefy_primitives::ValidatorSet<BeefyId> {
			// dummy implementation due to lack of BEEFY pallet.
			beefy_primitives::ValidatorSet { validators: Vec::new(), id: 0 }
		}
	}

	impl mmr::MmrApi<Block, Hash> for Runtime {
		fn generate_proof(_leaf_index: u64)
			-> Result<(mmr::EncodableOpaqueLeaf, mmr::Proof<Hash>), mmr::Error>
		{
			// dummy implementation due to lack of MMR pallet.
			Err(mmr::Error::GenerateProof)
		}

		fn verify_proof(_leaf: mmr::EncodableOpaqueLeaf, _proof: mmr::Proof<Hash>)
			-> Result<(), mmr::Error>
		{
			// dummy implementation due to lack of MMR pallet.
			Err(mmr::Error::Verify)
		}

		fn verify_proof_stateless(
			_root: Hash,
			_leaf: mmr::EncodableOpaqueLeaf,
			_proof: mmr::Proof<Hash>
		) -> Result<(), mmr::Error> {
			// dummy implementation due to lack of MMR pallet.
			Err(mmr::Error::Verify)
		}
	}

902
903
904
905
	impl fg_primitives::GrandpaApi<Block> for Runtime {
		fn grandpa_authorities() -> Vec<(GrandpaId, u64)> {
			Grandpa::grandpa_authorities()
		}
906

907
908
909
910
		fn current_set_id() -> fg_primitives::SetId {
			Grandpa::current_set_id()
		}

911
		fn submit_report_equivocation_unsigned_extrinsic(
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
			_equivocation_proof: fg_primitives::EquivocationProof<
				<Block as BlockT>::Hash,
				sp_runtime::traits::NumberFor<Block>,
			>,
			_key_owner_proof: fg_primitives::OpaqueKeyOwnershipProof,
		) -> Option<()> {
			None
		}

		fn generate_key_ownership_proof(
			_set_id: fg_primitives::SetId,
			_authority_id: fg_primitives::AuthorityId,
		) -> Option<fg_primitives::OpaqueKeyOwnershipProof> {
			None
		}
927
928
929
	}

	impl babe_primitives::BabeApi<Block> for Runtime {
930
		fn configuration() -> babe_primitives::BabeGenesisConfiguration {
931
932
933
934
935
			// The choice of `c` parameter (where `1 - c` represents the
			// probability of a slot being empty), is done in accordance to the
			// slot duration and expected target block time, for safely
			// resisting network delays of maximum two seconds.
			// <https://research.web3.foundation/en/latest/polkadot/BABE/Babe/#6-practical-results>
936
			babe_primitives::BabeGenesisConfiguration {
937
938
				slot_duration: Babe::slot_duration(),
				epoch_length: EpochDuration::get(),
939
				c: BABE_GENESIS_EPOCH_CONFIG.c,
940
				genesis_authorities: Babe::authorities().to_vec(),
941
				randomness: Babe::randomness(),
942
				allowed_slots: BABE_GENESIS_EPOCH_CONFIG.allowed_slots,
943
944
945
			}
		}

Bastian Köcher's avatar
Bastian Köcher committed
946
		fn current_epoch_start() -> babe_primitives::Slot {
947
948
			Babe::current_epoch_start()
		}
949

950
951
952
953
		fn current_epoch() -> babe_primitives::Epoch {
			Babe::current_epoch()
		}

954
955
956
957
		fn next_epoch() -> babe_primitives::Epoch {
			Babe::next_epoch()
		}

958
		fn generate_key_ownership_proof(
Bastian Köcher's avatar
Bastian Köcher committed
959
			_slot: babe_primitives::Slot,
960
961
962
963
964
965
966
967
968
969
970
			_authority_id: babe_primitives::AuthorityId,
		) -> Option<babe_primitives::OpaqueKeyOwnershipProof> {
			None
		}

		fn submit_report_equivocation_unsigned_extrinsic(
			_equivocation_proof: babe_primitives::EquivocationProof<<Block as BlockT>::Header>,
			_key_owner_proof: babe_primitives::OpaqueKeyOwnershipProof,
		) -> Option<()> {
			None
		}
971
972
973
974
975
976
977
978
979
980
981
982
983
984
	}

	impl sp_session::SessionKeys<Block> for Runtime {
		fn generate_session_keys(seed: Option<Vec<u8>>) -> Vec<u8> {
			SessionKeys::generate(seed)
		}

		fn decode_session_keys(
			encoded: Vec<u8>,
		) -> Option<Vec<(Vec<u8>, sp_core::crypto::KeyTypeId)>> {
			SessionKeys::decode_into_raw_public_keys(&encoded)
		}
	}

985
	impl frame_system_rpc_runtime_api::AccountNonceApi<Block, AccountId, Nonce> for Runtime {
986
987
988
989
990
991
992
993
994
		fn account_nonce(account: AccountId) -> Nonce {
			System::account_nonce(account)
		}
	}

	impl pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi<
		Block,
		Balance,
	> for Runtime {
995
		fn query_info(uxt: <Block as BlockT>::Extrinsic, len: u32) -> RuntimeDispatchInfo<Balance> {
996
997
			TransactionPayment::query_info(uxt, len)
		}
998
999
1000
		fn query_fee_details(uxt: <Block as BlockT>::Extrinsic, len: u32) -> FeeDetails<Balance> {
			TransactionPayment::query_fee_details(uxt, len)
		}
1001
	}
1002
1003
1004
1005
1006
1007

	impl crate::GetLastTimestamp<Block> for Runtime {
		fn get_last_timestamp() -> u64 {
			Timestamp::now()
		}
	}
1008
}