lib.rs 31 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
30
31
32
33
34
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,
	initializer as parachains_initializer, paras as parachains_paras,
	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
51
52
	CoreState, GroupRotationInfo, Hash as HashT, Id as ParaId, InboundDownwardMessage,
	InboundHrmpMessage, Moment, Nonce, OccupiedCoreAssumption, PersistedValidationData,
	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 WeightInfo = ();
349
350
}

351
impl pallet_grandpa::Config for Runtime {
352
	type Event = Event;
353
354
355
356
357
358
359
360
361
362
363
364
365
	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 = ();
366
367

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

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

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

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

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

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

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

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

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

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

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

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

464
465
impl parachains_shared::Config for Runtime {}

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

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

479
impl parachains_paras_inherent::Config for Runtime {}
480

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

487
impl parachains_session_info::Config for Runtime {}
488

489
impl parachains_paras::Config for Runtime {
490
	type Origin = Origin;
491
	type Event = Event;
492
	type WeightInfo = parachains_paras::TestWeightInfo;
493
494
}

495
impl parachains_dmp::Config for Runtime {}
496

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

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

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

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>;
523
	type Weigher = xcm_builder::FixedWeightBounds<BaseXcmWeight, Call, MaxInstructions>;
524
	type XcmRouter = xcm_config::DoNothingRouter;
Shawn Tabrizi's avatar
Shawn Tabrizi committed
525
	type XcmExecuteFilter = Everything;
526
	type XcmExecutor = xcm_executor::XcmExecutor<xcm_config::XcmConfig>;
Shawn Tabrizi's avatar
Shawn Tabrizi committed
527
528
	type XcmTeleportFilter = Everything;
	type XcmReserveTransferFilter = Everything;
529
530
	type Origin = Origin;
	type Call = Call;
531
532
	const VERSION_DISCOVERY_QUEUE_SIZE: u32 = 100;
	type AdvertisedXcmVersion = pallet_xcm::CurrentXcmVersion;
533
534
}

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

541
impl parachains_scheduler::Config for Runtime {}
542

543
impl paras_sudo_wrapper::Config for Runtime {}
544

545
546
547
548
549
550
551
552
553
554
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::*;
555
	use pallet_xcm::ensure_response;
556
557
558
559
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
	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)?;
607
608
			let call =
				Call::<T>::notification_received { query_id: 0, response: Default::default() };
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
			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(())
		}
	}
}

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

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

643
644
645
646
		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},
647
648

		// Consensus support.
649
		Authorship: pallet_authorship::{Pallet, Call, Storage},
650
		Staking: pallet_staking::{Pallet, Call, Storage, Config<T>, Event<T>},
Keith Yeung's avatar
Keith Yeung committed
651
		Offences: pallet_offences::{Pallet, Storage, Event},
652
653
654
		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
655
		AuthorityDiscovery: pallet_authority_discovery::{Pallet, Config},
656
657

		// Claims. Usable initially.
658
		Claims: claims::{Pallet, Call, Storage, Event<T>, Config<T>, ValidateUnsigned},
659
660

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

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

		Sudo: pallet_sudo::{Pallet, Call, Storage, Config<T>, Event<T>},
680
681

		TestNotifier: pallet_test_notifier::{Pallet, Call, Event<T>},
682
683
684
685
	}
}

/// The address format for describing accounts.
686
pub type Address = sp_runtime::MultiAddress<AccountId, AccountIndex>;
687
688
689
690
691
692
/// 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
693
/// `BlockId` type as expected by this runtime.
694
pub type BlockId = generic::BlockId<Block>;
Denis_P's avatar
Denis_P committed
695
/// The `SignedExtension` to the basic transaction logic.
696
pub type SignedExtra = (
697
698
699
700
701
702
	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
703
	pallet_transaction_payment::ChargeTransactionPayment<Runtime>,
704
705
706
707
);
/// 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
708
709
710
711
712
713
714
pub type Executive = frame_executive::Executive<
	Runtime,
	Block,
	frame_system::ChainContext<Runtime>,
	Runtime,
	AllPallets,
>;
715
716
/// The payload being signed in transactions.
pub type SignedPayload = generic::SignedPayload<Call, SignedExtra>;
717
718
719
720
721
722
723
724
725
726
727

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) {
728
			Executive::execute_block(block);
729
730
731
732
733
734
735
736
737
		}

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

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

	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 {
764
765
766
		fn validate_transaction(
			source: TransactionSource,
			tx: <Block as BlockT>::Extrinsic,
767
			block_hash: <Block as BlockT>::Hash,
768
		) -> TransactionValidity {
769
			Executive::validate_transaction(source, tx, block_hash)
770
771
772
		}
	}

773
774
775
776
777
778
779
780
	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> {
781
			AuthorityDiscovery::authorities()
782
783
784
		}
	}

785
786
787
	impl primitives::v1::ParachainHost<Block, Hash, BlockNumber> for Runtime {
		fn validators() -> Vec<ValidatorId> {
			runtime_impl::validators::<Runtime>()
788
		}
789
790
791

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

794
		fn availability_cores() -> Vec<CoreState<Hash, BlockNumber>> {
795
			runtime_impl::availability_cores::<Runtime>()
796
		}
797
798

		fn persisted_validation_data(para_id: ParaId, assumption: OccupiedCoreAssumption)
799
			-> Option<PersistedValidationData<Hash, BlockNumber>>
800
801
802
		{
			runtime_impl::persisted_validation_data::<Runtime>(para_id, assumption)
		}
803

804
805
		fn check_validation_outputs(
			para_id: ParaId,
806
			outputs: primitives::v1::CandidateCommitments,
807
808
809
810
		) -> bool {
			runtime_impl::check_validation_outputs::<Runtime>(para_id, outputs)
		}

811
812
		fn session_index_for_child() -> SessionIndex {
			runtime_impl::session_index_for_child::<Runtime>()
813
		}
814
815

		fn validation_code(para_id: ParaId, assumption: OccupiedCoreAssumption)
816
817
818
819
			-> Option<ValidationCode>
		{
			runtime_impl::validation_code::<Runtime>(para_id, assumption)
		}
820
821
822

		fn candidate_pending_availability(para_id: ParaId) -> Option<CommittedCandidateReceipt<Hash>> {
			runtime_impl::candidate_pending_availability::<Runtime>(para_id)
823
		}
824
825
826
827
828
829

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

830
		fn session_info(index: SessionIndex) -> Option<SessionInfoData> {
831
			runtime_impl::session_info::<Runtime>(index)
832
		}
833
834
835

		fn dmq_contents(
			recipient: ParaId,
Sergey Pepyakin's avatar
Sergey Pepyakin committed
836
		) -> Vec<InboundDownwardMessage<BlockNumber>> {
837
838
			runtime_impl::dmq_contents::<Runtime>(recipient)
		}
Sergey Pepyakin's avatar
Sergey Pepyakin committed
839
840
841
842
843
844

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

846
		fn validation_code_by_hash(hash: ValidationCodeHash) -> Option<ValidationCode> {
847
848
			runtime_impl::validation_code_by_hash::<Runtime>(hash)
		}
849
850
	}

Andreas Doerr's avatar
Andreas Doerr committed
851
	impl beefy_primitives::BeefyApi<Block> for Runtime {
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
		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)
		}
	}

883
884
885
886
	impl fg_primitives::GrandpaApi<Block> for Runtime {
		fn grandpa_authorities() -> Vec<(GrandpaId, u64)> {
			Grandpa::grandpa_authorities()
		}
887

888
889
890
891
		fn current_set_id() -> fg_primitives::SetId {
			Grandpa::current_set_id()
		}

892
		fn submit_report_equivocation_unsigned_extrinsic(
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
			_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
		}
908
909
910
	}

	impl babe_primitives::BabeApi<Block> for Runtime {
911
		fn configuration() -> babe_primitives::BabeGenesisConfiguration {
912
913
914
915
916
			// 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>
917
			babe_primitives::BabeGenesisConfiguration {
918
919
				slot_duration: Babe::slot_duration(),
				epoch_length: EpochDuration::get(),
920
				c: BABE_GENESIS_EPOCH_CONFIG.c,
921
				genesis_authorities: Babe::authorities().to_vec(),
922
				randomness: Babe::randomness(),
923
				allowed_slots: BABE_GENESIS_EPOCH_CONFIG.allowed_slots,
924
925
926
			}
		}

Bastian Köcher's avatar
Bastian Köcher committed
927
		fn current_epoch_start() -> babe_primitives::Slot {
928
929
			Babe::current_epoch_start()
		}
930

931
932
933
934
		fn current_epoch() -> babe_primitives::Epoch {
			Babe::current_epoch()
		}

935
936
937
938
		fn next_epoch() -> babe_primitives::Epoch {
			Babe::next_epoch()
		}

939
		fn generate_key_ownership_proof(
Bastian Köcher's avatar
Bastian Köcher committed
940
			_slot: babe_primitives::Slot,
941
942
943
944
945
946
947
948
949
950
951
			_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
		}
952
953
954
955
956
957
958
959
960
961
962
963
964
965
	}

	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)
		}
	}

966
	impl frame_system_rpc_runtime_api::AccountNonceApi<Block, AccountId, Nonce> for Runtime {
967
968
969
970
971
972
973
974
975
		fn account_nonce(account: AccountId) -> Nonce {
			System::account_nonce(account)
		}
	}

	impl pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi<
		Block,
		Balance,
	> for Runtime {
976
		fn query_info(uxt: <Block as BlockT>::Extrinsic, len: u32) -> RuntimeDispatchInfo<Balance> {
977
978
			TransactionPayment::query_info(uxt, len)
		}
979
980
981
		fn query_fee_details(uxt: <Block as BlockT>::Extrinsic, len: u32) -> FeeDetails<Balance> {
			TransactionPayment::query_fee_details(uxt, len)
		}
982
	}
983
984
985
986
987
988

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