lib.rs 25.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 sp_std::prelude::*;
Sergey Pepyakin's avatar
Sergey Pepyakin committed
25
use sp_std::collections::btree_map::BTreeMap;
26
use parity_scale_codec::Encode;
Sergey Pepyakin's avatar
Sergey Pepyakin committed
27
28

use polkadot_runtime_parachains::configuration as parachains_configuration;
29
use polkadot_runtime_parachains::shared as parachains_shared;
Sergey Pepyakin's avatar
Sergey Pepyakin committed
30
31
32
use polkadot_runtime_parachains::inclusion as parachains_inclusion;
use polkadot_runtime_parachains::inclusion_inherent as parachains_inclusion_inherent;
use polkadot_runtime_parachains::initializer as parachains_initializer;
33
use polkadot_runtime_parachains::session_info as parachains_session_info;
Sergey Pepyakin's avatar
Sergey Pepyakin committed
34
use polkadot_runtime_parachains::paras as parachains_paras;
35
36
37
use polkadot_runtime_parachains::dmp as parachains_dmp;
use polkadot_runtime_parachains::ump as parachains_ump;
use polkadot_runtime_parachains::hrmp as parachains_hrmp;
Sergey Pepyakin's avatar
Sergey Pepyakin committed
38
39
40
use polkadot_runtime_parachains::scheduler as parachains_scheduler;
use polkadot_runtime_parachains::runtime_api_impl::v1 as runtime_impl;

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

#[cfg(feature = "std")]
76
pub use pallet_staking::StakerStatus;
77
78
#[cfg(any(feature = "std", test))]
pub use sp_runtime::BuildStorage;
79
80
pub use pallet_timestamp::Call as TimestampCall;
pub use pallet_balances::Call as BalancesCall;
81
pub use paras_sudo_wrapper::Call as ParasSudoWrapperCall;
82
pub use pallet_sudo::Call as SudoCall;
83
84
85
86
87
88
89
90
91

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

// 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: 1055,
98
	impl_version: 0,
99
	apis: RUNTIME_API_VERSIONS,
100
	transaction_version: 1,
101
102
};

103
104
105
106
107
108
109
/// 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
	};

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

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

126
127
parameter_types! {
	pub const Version: RuntimeVersion = VERSION;
128
	pub const SS58Prefix: u8 = 42;
129
130
}

131
impl frame_system::Config for Runtime {
132
	type BaseCallFilter = ();
133
134
135
	type BlockWeights = BlockWeights;
	type BlockLength = BlockLength;
	type DbWeight = ();
136
137
138
139
140
141
142
143
144
145
146
147
	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;
148
	type PalletInfo = PalletInfo;
149
	type AccountData = pallet_balances::AccountData<Balance>;
Gavin Wood's avatar
Gavin Wood committed
150
	type OnNewAccount = ();
151
	type OnKilledAccount = ();
152
	type SystemWeightInfo = ();
153
	type SS58Prefix = SS58Prefix;
154
155
}

156
impl<C> frame_system::offchain::SendTransactionTypes<C> for Runtime where
157
158
159
160
161
162
	Call: From<C>,
{
	type OverarchingCall = Call;
	type Extrinsic = UncheckedExtrinsic;
}

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

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

	// session module is the trigger
173
	type EpochChangeTrigger = pallet_babe::ExternalTrigger;
174
175
176
177
178

	type KeyOwnerProofSystem = ();

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

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

	type HandleEquivocation = ();
188
189

	type WeightInfo = ();
190
191
192
}

parameter_types! {
193
	pub storage IndexDeposit: Balance = 1 * DOLLARS;
194
195
}

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

parameter_types! {
205
	pub storage ExistentialDeposit: Balance = 1 * CENTS;
206
	pub storage MaxLocks: u32 = 50;
207
208
}

209
impl pallet_balances::Config for Runtime {
210
211
212
213
214
	type Balance = Balance;
	type DustRemoval = ();
	type Event = Event;
	type ExistentialDeposit = ExistentialDeposit;
	type AccountStore = System;
215
	type MaxLocks = MaxLocks;
216
	type WeightInfo = ();
217
218
219
}

parameter_types! {
220
	pub storage TransactionByteFee: Balance = 10 * MILLICENTS;
221
222
}

223
impl pallet_transaction_payment::Config for Runtime {
Albrecht's avatar
Albrecht committed
224
	type OnChargeTransaction = CurrencyAdapter<Balances, ()>;
225
226
	type TransactionByteFee = TransactionByteFee;
	type WeightToFee = WeightToFee;
227
	type FeeMultiplierUpdate = SlowAdjustingFeeUpdate<Self>;
228
229
230
}

parameter_types! {
231
232
	pub storage SlotDuration: u64 = SLOT_DURATION;
	pub storage MinimumPeriod: u64 = SlotDuration::get() / 2;
233
}
234
impl pallet_timestamp::Config for Runtime {
235
236
237
	type Moment = u64;
	type OnTimestampSet = Babe;
	type MinimumPeriod = MinimumPeriod;
238
	type WeightInfo = ();
239
240
241
}

parameter_types! {
242
	pub storage UncleGenerations: u32 = 0;
243
244
245
}

// TODO: substrate#2986 implement this properly
246
impl pallet_authorship::Config for Runtime {
247
	type FindAuthor = pallet_session::FindAccountFromAuthorIndex<Self, Babe>;
248
249
250
251
252
253
	type UncleGenerations = UncleGenerations;
	type FilterUncle = ();
	type EventHandler = Staking;
}

parameter_types! {
254
255
	pub storage Period: BlockNumber = 10 * MINUTES;
	pub storage Offset: BlockNumber = 0;
256
257
258
259
260
261
}

impl_opaque_keys! {
	pub struct SessionKeys {
		pub grandpa: Grandpa,
		pub babe: Babe,
262
263
		pub para_validator: Initializer,
		pub para_assignment: SessionInfo,
264
		pub authority_discovery: AuthorityDiscovery,
265
266
267
268
	}
}

parameter_types! {
269
	pub storage DisabledValidatorsThreshold: Perbill = Perbill::from_percent(17);
270
271
}

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

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

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).
303
	pub storage SessionsPerEra: SessionIndex = 6;
304
	// 28 eras for unbonding (7 days).
305
	pub storage BondingDuration: pallet_staking::EraIndex = 28;
306
	// 27 eras in which slashes can be cancelled (a bit less than 7 days).
307
	pub storage SlashDeferDuration: pallet_staking::EraIndex = 27;
308
	pub const RewardCurve: &'static PiecewiseLinear<'static> = &REWARD_CURVE;
309
310
311
312
	pub storage MaxNominatorRewardedPerValidator: u32 = 64;
	pub storage ElectionLookahead: BlockNumber = 0;
	pub storage StakingUnsignedPriority: TransactionPriority = TransactionPriority::max_value() / 2;
	pub storage MaxIterations: u32 = 10;
313
	pub MinSolutionScoreBump: Perbill = Perbill::from_rational_approximation(5u32, 10_000);
314
315
}

316
317
318
319
320
321
322
impl sp_election_providers::onchain::Config for Runtime {
	type AccountId = <Self as frame_system::Config>::AccountId;
	type BlockNumber = <Self as frame_system::Config>::BlockNumber;
	type Accuracy = sp_runtime::Perbill;
	type DataProvider = pallet_staking::Module<Self>;
}

323
impl pallet_staking::Config for Runtime {
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
337
338
	type SessionInterface = Self;
	type RewardCurve = RewardCurve;
	type MaxNominatorRewardedPerValidator = MaxNominatorRewardedPerValidator;
339
340
341
	type NextNewSession = Session;
	type ElectionLookahead = ElectionLookahead;
	type Call = Call;
342
	type UnsignedPriority = StakingUnsignedPriority;
343
	type MaxIterations = MaxIterations;
344
	type OffchainSolutionWeightLimit = ();
345
	type MinSolutionScoreBump = MinSolutionScoreBump;
346
	type ElectionProvider = sp_election_providers::onchain::OnChainSequentialPhragmen<Self>;
347
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
369
}

370
impl<LocalCall> frame_system::offchain::CreateSignedTransaction<LocalCall> for Runtime where
371
372
	Call: From<LocalCall>,
{
373
	fn create_transaction<C: frame_system::offchain::AppCrypto<Self::Public, Self::Signature>>(
374
375
376
		call: Call,
		public: <Signature as Verify>::Signer,
		account: AccountId,
377
		nonce: <Runtime as frame_system::Config>::Index,
378
379
380
381
382
383
384
385
386
387
388
	) -> Option<(Call, <UncheckedExtrinsic as ExtrinsicT>::SignaturePayload)> {
		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);
		let tip = 0;
		let extra: SignedExtra = (
389
390
391
392
393
394
395
			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),
396
397
		);
		let raw_payload = SignedPayload::new(call, extra).map_err(|e| {
398
			log::warn!("Unable to create signed payload: {:?}", e);
399
		}).ok()?;
400
401
402
		let signature = raw_payload.using_encoded(|payload| {
			C::sign(payload, public)
		})?;
403
404
405
406
		let (call, extra, _) = raw_payload.deconstruct();
		let address = Indices::unlookup(account);
		Some((call, (address, signature, extra)))
	}
407
408
}

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

414
parameter_types! {
415
	pub storage OffencesWeightSoftLimit: Weight = Perbill::from_percent(60) * BlockWeights::get().max_block;
416
417
}

418
impl pallet_offences::Config for Runtime {
419
	type Event = Event;
420
	type IdentificationTuple = pallet_session::historical::IdentificationTuple<Self>;
421
	type OnOffenceHandler = Staking;
422
	type WeightSoftLimit = OffencesWeightSoftLimit;
423
424
}

425
impl pallet_authority_discovery::Config for Runtime {}
426

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

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

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

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

448
impl pallet_vesting::Config for Runtime {
449
450
451
452
	type Event = Event;
	type Currency = Balances;
	type BlockNumberToBalance = ConvertInto;
	type MinVestedTransfer = MinVestedTransfer;
453
	type WeightInfo = ();
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

463
464
impl parachains_shared::Config for Runtime {}

465
impl parachains_inclusion::Config for Runtime {
466
	type Event = Event;
467
	type RewardValidators = RewardValidatorsWithEraPoints<Runtime>;
468
469
}

470
impl parachains_inclusion_inherent::Config for Runtime {}
471

472
impl parachains_initializer::Config for Runtime {
473
	type Randomness = pallet_babe::RandomnessFromOneEpochAgo<Runtime>;
474
475
}

476
impl parachains_session_info::Config for Runtime {}
477

478
impl parachains_paras::Config for Runtime {
479
480
481
	type Origin = Origin;
}

482
impl parachains_dmp::Config for Runtime {}
483

484
impl parachains_ump::Config for Runtime {
485
486
	type UmpSink = ();
}
487

488
impl parachains_hrmp::Config for Runtime {
489
	type Event = Event;
490
	type Origin = Origin;
491
	type Currency = Balances;
492
493
}

494
impl parachains_scheduler::Config for Runtime {}
495

496
impl paras_sudo_wrapper::Config for Runtime {}
497

498
499
500
construct_runtime! {
	pub enum Runtime where
		Block = Block,
501
		NodeBlock = primitives::v1::Block,
502
503
504
		UncheckedExtrinsic = UncheckedExtrinsic
	{
		// Basic stuff; balances is uncallable initially.
505
506
		System: frame_system::{Module, Call, Storage, Config, Event<T>},
		RandomnessCollectiveFlip: pallet_randomness_collective_flip::{Module, Storage},
507
508

		// Must be before session.
509
		Babe: pallet_babe::{Module, Call, Storage, Config},
510

511
512
513
514
		Timestamp: pallet_timestamp::{Module, Call, Storage, Inherent},
		Indices: pallet_indices::{Module, Call, Storage, Config<T>, Event<T>},
		Balances: pallet_balances::{Module, Call, Storage, Config<T>, Event<T>},
		TransactionPayment: pallet_transaction_payment::{Module, Storage},
515
516

		// Consensus support.
517
518
519
		Authorship: pallet_authorship::{Module, Call, Storage},
		Staking: pallet_staking::{Module, Call, Storage, Config<T>, Event<T>, ValidateUnsigned},
		Offences: pallet_offences::{Module, Call, Storage, Event},
520
		Historical: session_historical::{Module},
521
522
523
		Session: pallet_session::{Module, Call, Storage, Event, Config<T>},
		Grandpa: pallet_grandpa::{Module, Call, Storage, Config, Event},
		AuthorityDiscovery: pallet_authority_discovery::{Module, Call, Config},
524
525
526
527
528

		// Claims. Usable initially.
		Claims: claims::{Module, Call, Storage, Event<T>, Config<T>, ValidateUnsigned},

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

531
		// Parachains runtime modules
532
		ParachainsConfiguration: parachains_configuration::{Module, Call, Storage, Config<T>},
Sergey Pepyakin's avatar
Sergey Pepyakin committed
533
534
535
536
537
		Inclusion: parachains_inclusion::{Module, Call, Storage, Event<T>},
		InclusionInherent: parachains_inclusion_inherent::{Module, Call, Storage, Inherent},
		Initializer: parachains_initializer::{Module, Call, Storage},
		Paras: parachains_paras::{Module, Call, Storage, Origin},
		Scheduler: parachains_scheduler::{Module, Call, Storage},
538
		ParasSudoWrapper: paras_sudo_wrapper::{Module, Call},
539
		SessionInfo: parachains_session_info::{Module, Call, Storage},
540
		Hrmp: parachains_hrmp::{Module, Call, Storage, Event},
541

542
		Sudo: pallet_sudo::{Module, Call, Storage, Config<T>, Event<T>},
543
544
545
546
	}
}

/// The address format for describing accounts.
547
pub type Address = sp_runtime::MultiAddress<AccountId, AccountIndex>;
548
549
550
551
552
553
554
555
556
557
/// 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>;
/// BlockId type as expected by this runtime.
pub type BlockId = generic::BlockId<Block>;
/// The SignedExtension to the basic transaction logic.
pub type SignedExtra = (
558
559
560
561
562
563
564
	frame_system::CheckSpecVersion<Runtime>,
	frame_system::CheckTxVersion<Runtime>,
	frame_system::CheckGenesis<Runtime>,
	frame_system::CheckMortality<Runtime>,
	frame_system::CheckNonce<Runtime>,
	frame_system::CheckWeight<Runtime>,
	pallet_transaction_payment::ChargeTransactionPayment::<Runtime>,
565
566
567
568
569
570
);
/// Unchecked extrinsic type as expected by this runtime.
pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<Address, Call, Signature, SignedExtra>;
/// Extrinsic type that has already been checked.
pub type CheckedExtrinsic = generic::CheckedExtrinsic<AccountId, Nonce, Call>;
/// Executive: handles dispatch to the various modules.
571
pub type Executive = frame_executive::Executive<Runtime, Block, frame_system::ChainContext<Runtime>, Runtime, AllModules>;
572
573
/// The payload being signed in transactions.
pub type SignedPayload = generic::SignedPayload<Call, SignedExtra>;
574
575
576
577
578
579
580
581
582
583
584

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) {
585
			Executive::execute_block(block);
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
611
612
613
614
615
616
617
618
619
		}

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

	impl sp_api::Metadata<Block> for Runtime {
		fn metadata() -> OpaqueMetadata {
			Runtime::metadata().into()
		}
	}

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

		fn random_seed() -> <Block as BlockT>::Hash {
620
			RandomnessCollectiveFlip::random_seed().0
621
622
623
624
		}
	}

	impl tx_pool_api::runtime_api::TaggedTransactionQueue<Block> for Runtime {
625
626
627
628
629
		fn validate_transaction(
			source: TransactionSource,
			tx: <Block as BlockT>::Extrinsic,
		) -> TransactionValidity {
			Executive::validate_transaction(source, tx)
630
631
632
		}
	}

633
634
635
636
637
638
639
640
	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> {
641
			AuthorityDiscovery::authorities()
642
643
644
		}
	}

645
646
647
	impl primitives::v1::ParachainHost<Block, Hash, BlockNumber> for Runtime {
		fn validators() -> Vec<ValidatorId> {
			runtime_impl::validators::<Runtime>()
648
		}
649
650
651

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

654
		fn availability_cores() -> Vec<CoreState<Hash, BlockNumber>> {
655
			runtime_impl::availability_cores::<Runtime>()
656
		}
657
658

		fn persisted_validation_data(para_id: ParaId, assumption: OccupiedCoreAssumption)
659
660
661
662
			-> Option<PersistedValidationData<BlockNumber>>
		{
			runtime_impl::persisted_validation_data::<Runtime>(para_id, assumption)
		}
663

664
665
		fn check_validation_outputs(
			para_id: ParaId,
666
			outputs: primitives::v1::CandidateCommitments,
667
668
669
670
		) -> bool {
			runtime_impl::check_validation_outputs::<Runtime>(para_id, outputs)
		}

671
672
		fn session_index_for_child() -> SessionIndex {
			runtime_impl::session_index_for_child::<Runtime>()
673
		}
674
675

		fn validation_code(para_id: ParaId, assumption: OccupiedCoreAssumption)
676
677
678
679
			-> Option<ValidationCode>
		{
			runtime_impl::validation_code::<Runtime>(para_id, assumption)
		}
680

681
682
683
684
685
686
687
		fn historical_validation_code(para_id: ParaId, context_height: BlockNumber)
			-> Option<ValidationCode>
		{
			runtime_impl::historical_validation_code::<Runtime>(para_id, context_height)
		}


688
689
		fn candidate_pending_availability(para_id: ParaId) -> Option<CommittedCandidateReceipt<Hash>> {
			runtime_impl::candidate_pending_availability::<Runtime>(para_id)
690
		}
691
692
693
694
695
696

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

697
		fn session_info(index: SessionIndex) -> Option<SessionInfoData> {
698
			runtime_impl::session_info::<Runtime>(index)
699
		}
700
701
702

		fn dmq_contents(
			recipient: ParaId,
Sergey Pepyakin's avatar
Sergey Pepyakin committed
703
		) -> Vec<InboundDownwardMessage<BlockNumber>> {
704
705
			runtime_impl::dmq_contents::<Runtime>(recipient)
		}
Sergey Pepyakin's avatar
Sergey Pepyakin committed
706
707
708
709
710
711

		fn inbound_hrmp_channels_contents(
			recipient: ParaId,
		) -> BTreeMap<ParaId, Vec<InboundHrmpMessage<BlockNumber>>> {
			runtime_impl::inbound_hrmp_channels_contents::<Runtime>(recipient)
		}
712
713
714
715
716
717
	}

	impl fg_primitives::GrandpaApi<Block> for Runtime {
		fn grandpa_authorities() -> Vec<(GrandpaId, u64)> {
			Grandpa::grandpa_authorities()
		}
718

719
		fn submit_report_equivocation_unsigned_extrinsic(
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
			_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
		}
735
736
737
	}

	impl babe_primitives::BabeApi<Block> for Runtime {
738
		fn configuration() -> babe_primitives::BabeGenesisConfiguration {
739
740
741
742
743
			// 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>
744
			babe_primitives::BabeGenesisConfiguration {
745
746
				slot_duration: Babe::slot_duration(),
				epoch_length: EpochDuration::get(),
747
				c: BABE_GENESIS_EPOCH_CONFIG.c,
748
749
				genesis_authorities: Babe::authorities(),
				randomness: Babe::randomness(),
750
				allowed_slots: BABE_GENESIS_EPOCH_CONFIG.allowed_slots,
751
752
753
			}
		}

Bastian Köcher's avatar
Bastian Köcher committed
754
		fn current_epoch_start() -> babe_primitives::Slot {
755
756
			Babe::current_epoch_start()
		}
757

758
759
760
761
		fn current_epoch() -> babe_primitives::Epoch {
			Babe::current_epoch()
		}

762
763
764
765
		fn next_epoch() -> babe_primitives::Epoch {
			Babe::next_epoch()
		}

766
		fn generate_key_ownership_proof(
Bastian Köcher's avatar
Bastian Köcher committed
767
			_slot: babe_primitives::Slot,
768
769
770
771
772
773
774
775
776
777
778
			_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
		}
779
780
781
782
783
784
785
786
787
788
789
790
791
792
	}

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

793
	impl frame_system_rpc_runtime_api::AccountNonceApi<Block, AccountId, Nonce> for Runtime {
794
795
796
797
798
799
800
801
802
		fn account_nonce(account: AccountId) -> Nonce {
			System::account_nonce(account)
		}
	}

	impl pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi<
		Block,
		Balance,
	> for Runtime {
803
		fn query_info(uxt: <Block as BlockT>::Extrinsic, len: u32) -> RuntimeDispatchInfo<Balance> {
804
805
			TransactionPayment::query_info(uxt, len)
		}
806
807
808
		fn query_fee_details(uxt: <Block as BlockT>::Extrinsic, len: u32) -> FeeDetails<Balance> {
			TransactionPayment::query_fee_details(uxt, len)
		}
809
	}
810
811
812
813
814
815

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