lib.rs 26.2 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
use polkadot_runtime_parachains::inclusion as parachains_inclusion;
31
use polkadot_runtime_parachains::paras_inherent as parachains_paras_inherent;
Sergey Pepyakin's avatar
Sergey Pepyakin committed
32
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, ValidationCodeHash, 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::{TransactionValidity, TransactionSource},
55
	curve::PiecewiseLinear,
56
	traits::{
57
58
		BlakeTwo256, Block as BlockT, StaticLookup, OpaqueKeys, ConvertInto,
		Extrinsic as ExtrinsicT, SaturatedConversion, Verify,
59
	},
60
};
61
62
use sp_version::RuntimeVersion;
use pallet_grandpa::{AuthorityId as GrandpaId, fg_primitives};
63
#[cfg(any(feature = "std", test))]
64
use sp_version::NativeVersion;
65
66
use sp_core::OpaqueMetadata;
use sp_staking::SessionIndex;
67
use frame_support::{parameter_types, construct_runtime, traits::KeyOwnerProofSystem};
68
use authority_discovery_primitives::AuthorityId as AuthorityDiscoveryId;
69
use pallet_transaction_payment::{FeeDetails, RuntimeDispatchInfo};
70
use pallet_session::historical as session_historical;
71
use polkadot_runtime_parachains::reward_points::RewardValidatorsWithEraPoints;
Andreas Doerr's avatar
Andreas Doerr committed
72
use beefy_primitives::crypto::AuthorityId as BeefyId;
73
use pallet_mmr_primitives as mmr;
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: 1056,
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
	type OnSetCode = ();
155
156
}

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

Qinxuan Chen's avatar
Qinxuan Chen committed
164
165
impl pallet_randomness_collective_flip::Config for Runtime {}

166
parameter_types! {
167
	pub storage EpochDuration: u64 = EPOCH_DURATION_IN_SLOTS as u64;
168
	pub storage ExpectedBlockTime: Moment = MILLISECS_PER_BLOCK;
169
170
}

171
impl pallet_babe::Config for Runtime {
172
173
174
175
	type EpochDuration = EpochDuration;
	type ExpectedBlockTime = ExpectedBlockTime;

	// session module is the trigger
176
	type EpochChangeTrigger = pallet_babe::ExternalTrigger;
177
178
179
180
181

	type KeyOwnerProofSystem = ();

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

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

	type HandleEquivocation = ();
191
192

	type WeightInfo = ();
193
194
195
}

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

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

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

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

parameter_types! {
226
	pub storage TransactionByteFee: Balance = 10 * MILLICENTS;
227
228
}

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

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

parameter_types! {
248
	pub storage UncleGenerations: u32 = 0;
249
250
}

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

parameter_types! {
259
260
	pub storage Period: BlockNumber = 10 * MINUTES;
	pub storage Offset: BlockNumber = 0;
261
262
263
264
265
266
}

impl_opaque_keys! {
	pub struct SessionKeys {
		pub grandpa: Grandpa,
		pub babe: Babe,
267
268
		pub para_validator: Initializer,
		pub para_assignment: SessionInfo,
269
		pub authority_discovery: AuthorityDiscovery,
270
271
272
273
	}
}

parameter_types! {
274
	pub storage DisabledValidatorsThreshold: Perbill = Perbill::from_percent(17);
275
276
}

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

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

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

Kian Paimani's avatar
Kian Paimani committed
317
impl frame_election_provider_support::onchain::Config for Runtime {
318
319
	type AccountId = <Self as frame_system::Config>::AccountId;
	type BlockNumber = <Self as frame_system::Config>::BlockNumber;
Kian Paimani's avatar
Kian Paimani committed
320
	type BlockWeights = ();
321
	type Accuracy = sp_runtime::Perbill;
Shawn Tabrizi's avatar
Shawn Tabrizi committed
322
	type DataProvider = Staking;
323
324
}

325
impl pallet_staking::Config for Runtime {
326
	const MAX_NOMINATIONS: u32 = 16;
327
	type Currency = Balances;
328
	type UnixTime = Timestamp;
329
	type CurrencyToVote = frame_support::traits::U128CurrencyToVote;
330
331
332
333
334
335
336
337
	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.
338
	type SlashCancelOrigin = frame_system::EnsureNever<()>;
339
	type SessionInterface = Self;
Kian Paimani's avatar
Kian Paimani committed
340
	type EraPayout = pallet_staking::ConvertCurve<RewardCurve>;
341
	type MaxNominatorRewardedPerValidator = MaxNominatorRewardedPerValidator;
342
	type NextNewSession = Session;
Kian Paimani's avatar
Kian Paimani committed
343
	type ElectionProvider = frame_election_provider_support::onchain::OnChainSequentialPhragmen<Self>;
344
345
	type GenesisElectionProvider =
		frame_election_provider_support::onchain::OnChainSequentialPhragmen<Self>;
346
	type WeightInfo = ();
347
348
}

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

	type WeightInfo = ();
366
367
}

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

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

412
impl pallet_offences::Config for Runtime {
413
	type Event = Event;
414
	type IdentificationTuple = pallet_session::historical::IdentificationTuple<Self>;
415
	type OnOffenceHandler = Staking;
416
417
}

418
impl pallet_authority_discovery::Config for Runtime {}
419

420
parameter_types! {
421
422
	pub storage LeasePeriod: BlockNumber = 100_000;
	pub storage EndingPeriod: BlockNumber = 1000;
423
424
425
}

parameter_types! {
426
	pub Prefix: &'static [u8] = b"Pay KSMs to the Kusama account:";
427
428
}

429
impl claims::Config for Runtime {
430
431
432
	type Event = Event;
	type VestingSchedule = Vesting;
	type Prefix = Prefix;
433
	type MoveClaimOrigin = frame_system::EnsureRoot<AccountId>;
434
	type WeightInfo = claims::TestWeightInfo;
435
436
437
}

parameter_types! {
438
	pub storage MinVestedTransfer: Balance = 100 * DOLLARS;
439
440
}

441
impl pallet_vesting::Config for Runtime {
442
443
444
445
	type Event = Event;
	type Currency = Balances;
	type BlockNumberToBalance = ConvertInto;
	type MinVestedTransfer = MinVestedTransfer;
446
	type WeightInfo = ();
447
448
}

449
impl pallet_sudo::Config for Runtime {
450
451
452
453
	type Event = Event;
	type Call = Call;
}

454
impl parachains_configuration::Config for Runtime {}
455

456
457
impl parachains_shared::Config for Runtime {}

458
impl parachains_inclusion::Config for Runtime {
459
	type Event = Event;
460
	type RewardValidators = RewardValidatorsWithEraPoints<Runtime>;
461
462
}

463
impl parachains_paras_inherent::Config for Runtime {}
464

465
impl parachains_initializer::Config for Runtime {
466
	type Randomness = pallet_babe::RandomnessFromOneEpochAgo<Runtime>;
467
	type ForceOrigin = frame_system::EnsureRoot<AccountId>;
468
469
}

470
impl parachains_session_info::Config for Runtime {}
471

472
impl parachains_paras::Config for Runtime {
473
	type Origin = Origin;
474
	type Event = Event;
475
476
}

477
impl parachains_dmp::Config for Runtime {}
478

Gavin Wood's avatar
Gavin Wood committed
479
480
481
482
parameter_types! {
	pub const FirstMessageFactorPercent: u64 = 100;
}

483
impl parachains_ump::Config for Runtime {
484
	type Event = Event;
485
	type UmpSink = ();
Gavin Wood's avatar
Gavin Wood committed
486
	type FirstMessageFactorPercent = FirstMessageFactorPercent;
487
}
488

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

495
impl parachains_scheduler::Config for Runtime {}
496

497
impl paras_sudo_wrapper::Config for Runtime {}
498

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

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

512
513
514
515
		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},
516
517

		// Consensus support.
518
		Authorship: pallet_authorship::{Pallet, Call, Storage},
519
		Staking: pallet_staking::{Pallet, Call, Storage, Config<T>, Event<T>},
Keith Yeung's avatar
Keith Yeung committed
520
		Offences: pallet_offences::{Pallet, Storage, Event},
521
522
523
		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
524
		AuthorityDiscovery: pallet_authority_discovery::{Pallet, Config},
525
526

		// Claims. Usable initially.
527
		Claims: claims::{Pallet, Call, Storage, Event<T>, Config<T>, ValidateUnsigned},
528
529

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

532
		// Parachains runtime modules
533
534
		ParachainsConfiguration: parachains_configuration::{Pallet, Call, Storage, Config<T>},
		Inclusion: parachains_inclusion::{Pallet, Call, Storage, Event<T>},
535
		ParasInherent: parachains_paras_inherent::{Pallet, Call, Storage, Inherent},
536
		Initializer: parachains_initializer::{Pallet, Call, Storage},
537
		Paras: parachains_paras::{Pallet, Call, Storage, Origin, Event},
538
539
540
541
		Scheduler: parachains_scheduler::{Pallet, Call, Storage},
		ParasSudoWrapper: paras_sudo_wrapper::{Pallet, Call},
		SessionInfo: parachains_session_info::{Pallet, Call, Storage},
		Hrmp: parachains_hrmp::{Pallet, Call, Storage, Event},
542
		Ump: parachains_ump::{Pallet, Call, Storage, Event},
543
544

		Sudo: pallet_sudo::{Pallet, Call, Storage, Config<T>, Event<T>},
545
546
547
548
	}
}

/// The address format for describing accounts.
549
pub type Address = sp_runtime::MultiAddress<AccountId, AccountIndex>;
550
551
552
553
554
555
556
557
558
559
/// 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 = (
560
561
562
563
564
565
566
	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>,
567
568
569
570
);
/// Unchecked extrinsic type as expected by this runtime.
pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<Address, Call, Signature, SignedExtra>;
/// Executive: handles dispatch to the various modules.
571
pub type Executive = frame_executive::Executive<Runtime, Block, frame_system::ChainContext<Runtime>, Runtime, AllPallets>;
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
620
		}

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

	impl tx_pool_api::runtime_api::TaggedTransactionQueue<Block> for Runtime {
621
622
623
624
625
		fn validate_transaction(
			source: TransactionSource,
			tx: <Block as BlockT>::Extrinsic,
		) -> TransactionValidity {
			Executive::validate_transaction(source, tx)
626
627
628
		}
	}

629
630
631
632
633
634
635
636
	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> {
637
			AuthorityDiscovery::authorities()
638
639
640
		}
	}

641
642
643
	impl primitives::v1::ParachainHost<Block, Hash, BlockNumber> for Runtime {
		fn validators() -> Vec<ValidatorId> {
			runtime_impl::validators::<Runtime>()
644
		}
645
646
647

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

650
		fn availability_cores() -> Vec<CoreState<Hash, BlockNumber>> {
651
			runtime_impl::availability_cores::<Runtime>()
652
		}
653
654

		fn persisted_validation_data(para_id: ParaId, assumption: OccupiedCoreAssumption)
655
			-> Option<PersistedValidationData<Hash, BlockNumber>>
656
657
658
		{
			runtime_impl::persisted_validation_data::<Runtime>(para_id, assumption)
		}
659

660
661
		fn check_validation_outputs(
			para_id: ParaId,
662
			outputs: primitives::v1::CandidateCommitments,
663
664
665
666
		) -> bool {
			runtime_impl::check_validation_outputs::<Runtime>(para_id, outputs)
		}

667
668
		fn session_index_for_child() -> SessionIndex {
			runtime_impl::session_index_for_child::<Runtime>()
669
		}
670
671

		fn validation_code(para_id: ParaId, assumption: OccupiedCoreAssumption)
672
673
674
675
			-> Option<ValidationCode>
		{
			runtime_impl::validation_code::<Runtime>(para_id, assumption)
		}
676
677
678

		fn candidate_pending_availability(para_id: ParaId) -> Option<CommittedCandidateReceipt<Hash>> {
			runtime_impl::candidate_pending_availability::<Runtime>(para_id)
679
		}
680
681
682
683
684
685

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

686
		fn session_info(index: SessionIndex) -> Option<SessionInfoData> {
687
			runtime_impl::session_info::<Runtime>(index)
688
		}
689
690
691

		fn dmq_contents(
			recipient: ParaId,
Sergey Pepyakin's avatar
Sergey Pepyakin committed
692
		) -> Vec<InboundDownwardMessage<BlockNumber>> {
693
694
			runtime_impl::dmq_contents::<Runtime>(recipient)
		}
Sergey Pepyakin's avatar
Sergey Pepyakin committed
695
696
697
698
699
700

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

702
		fn validation_code_by_hash(hash: ValidationCodeHash) -> Option<ValidationCode> {
703
704
			runtime_impl::validation_code_by_hash::<Runtime>(hash)
		}
705
706
	}

Andreas Doerr's avatar
Andreas Doerr committed
707
	impl beefy_primitives::BeefyApi<Block> for Runtime {
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
		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)
		}
	}

739
740
741
742
	impl fg_primitives::GrandpaApi<Block> for Runtime {
		fn grandpa_authorities() -> Vec<(GrandpaId, u64)> {
			Grandpa::grandpa_authorities()
		}
743

744
		fn submit_report_equivocation_unsigned_extrinsic(
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
			_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
		}
760
761
762
	}

	impl babe_primitives::BabeApi<Block> for Runtime {
763
		fn configuration() -> babe_primitives::BabeGenesisConfiguration {
764
765
766
767
768
			// 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>
769
			babe_primitives::BabeGenesisConfiguration {
770
771
				slot_duration: Babe::slot_duration(),
				epoch_length: EpochDuration::get(),
772
				c: BABE_GENESIS_EPOCH_CONFIG.c,
773
774
				genesis_authorities: Babe::authorities(),
				randomness: Babe::randomness(),
775
				allowed_slots: BABE_GENESIS_EPOCH_CONFIG.allowed_slots,
776
777
778
			}
		}

Bastian Köcher's avatar
Bastian Köcher committed
779
		fn current_epoch_start() -> babe_primitives::Slot {
780
781
			Babe::current_epoch_start()
		}
782

783
784
785
786
		fn current_epoch() -> babe_primitives::Epoch {
			Babe::current_epoch()
		}

787
788
789
790
		fn next_epoch() -> babe_primitives::Epoch {
			Babe::next_epoch()
		}

791
		fn generate_key_ownership_proof(
Bastian Köcher's avatar
Bastian Köcher committed
792
			_slot: babe_primitives::Slot,
793
794
795
796
797
798
799
800
801
802
803
			_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
		}
804
805
806
807
808
809
810
811
812
813
814
815
816
817
	}

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

818
	impl frame_system_rpc_runtime_api::AccountNonceApi<Block, AccountId, Nonce> for Runtime {
819
820
821
822
823
824
825
826
827
		fn account_nonce(account: AccountId) -> Nonce {
			System::account_nonce(account)
		}
	}

	impl pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi<
		Block,
		Balance,
	> for Runtime {
828
		fn query_info(uxt: <Block as BlockT>::Extrinsic, len: u32) -> RuntimeDispatchInfo<Balance> {
829
830
			TransactionPayment::query_info(uxt, len)
		}
831
832
833
		fn query_fee_details(uxt: <Block as BlockT>::Extrinsic, len: u32) -> FeeDetails<Balance> {
			TransactionPayment::query_fee_details(uxt, len)
		}
834
	}
835
836
837
838
839
840

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