lib.rs 33.7 KB
Newer Older
ddorgan's avatar
ddorgan committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// 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.
#![recursion_limit="256"]

use sp_std::prelude::*;
use codec::{Encode, Decode};
25
use primitives::v1::{
ddorgan's avatar
ddorgan committed
26
27
	AccountId, AccountIndex, Balance, BlockNumber, Hash, Nonce, Signature, Moment,
};
28
use primitives::v0 as p_v0;
29
use runtime_common::{
30
	dummy, purchase, SlowAdjustingFeeUpdate,
31
	impls::{CurrencyToVoteHandler, ToAuthor},
ddorgan's avatar
ddorgan committed
32
	BlockHashCount, MaximumBlockWeight, AvailableBlockRatio, MaximumBlockLength,
Gavin Wood's avatar
Gavin Wood committed
33
	BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, MaximumExtrinsicWeight,
34
	ParachainSessionKeyPlaceholder,
ddorgan's avatar
ddorgan committed
35
36
37
};
use sp_runtime::{
	create_runtime_str, generic, impl_opaque_keys,
38
	ApplyExtrinsicResult, KeyTypeId, Perbill, curve::PiecewiseLinear,
Gavin Wood's avatar
Gavin Wood committed
39
	transaction_validity::{TransactionValidity, TransactionSource, TransactionPriority},
ddorgan's avatar
ddorgan committed
40
	traits::{
Gavin Wood's avatar
Gavin Wood committed
41
42
		BlakeTwo256, Block as BlockT, OpaqueKeys, ConvertInto, IdentityLookup,
		Extrinsic as ExtrinsicT, SaturatedConversion, Verify,
ddorgan's avatar
ddorgan committed
43
44
45
46
	},
};
#[cfg(feature = "runtime-benchmarks")]
use sp_runtime::RuntimeString;
47
48
use sp_version::RuntimeVersion;
use pallet_grandpa::{AuthorityId as GrandpaId, fg_primitives};
ddorgan's avatar
ddorgan committed
49
#[cfg(any(feature = "std", test))]
50
use sp_version::NativeVersion;
ddorgan's avatar
ddorgan committed
51
52
use sp_core::OpaqueMetadata;
use sp_staking::SessionIndex;
53
use frame_support::{
54
	parameter_types, construct_runtime, debug, RuntimeDebug,
55
	traits::{KeyOwnerProofSystem, Randomness, Filter, InstanceFilter},
56
	weights::Weight,
57
};
58
use pallet_im_online::sr25519::AuthorityId as ImOnlineId;
ddorgan's avatar
ddorgan committed
59
use authority_discovery_primitives::AuthorityId as AuthorityDiscoveryId;
60
61
use pallet_transaction_payment_rpc_runtime_api::RuntimeDispatchInfo;
use pallet_session::historical as session_historical;
62
use frame_system::{EnsureRoot};
ddorgan's avatar
ddorgan committed
63
64

#[cfg(feature = "std")]
65
pub use pallet_staking::StakerStatus;
ddorgan's avatar
ddorgan committed
66
67
#[cfg(any(feature = "std", test))]
pub use sp_runtime::BuildStorage;
68
69
pub use pallet_timestamp::Call as TimestampCall;
pub use pallet_balances::Call as BalancesCall;
ddorgan's avatar
ddorgan committed
70
71
72
73
74

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

75
76
77
// Weights used in the runtime
mod weights;

ddorgan's avatar
ddorgan committed
78
79
80
81
// Make the WASM binary available.
#[cfg(feature = "std")]
include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));

82
/// Runtime version (Westend).
ddorgan's avatar
ddorgan committed
83
84
85
86
pub const VERSION: RuntimeVersion = RuntimeVersion {
	spec_name: create_runtime_str!("westend"),
	impl_name: create_runtime_str!("parity-westend"),
	authoring_version: 2,
87
	spec_version: 43,
88
	impl_version: 1,
89
	#[cfg(not(feature = "disable-runtime-api"))]
ddorgan's avatar
ddorgan committed
90
	apis: RUNTIME_API_VERSIONS,
91
	#[cfg(feature = "disable-runtime-api")]
92
93
	apis: version::create_apis_vec![[]],
	transaction_version: 3,
ddorgan's avatar
ddorgan committed
94
95
96
97
98
99
100
101
102
103
104
};

/// Native version.
#[cfg(any(feature = "std", test))]
pub fn native_version() -> NativeVersion {
	NativeVersion {
		runtime_version: VERSION,
		can_author_with: Default::default(),
	}
}

105
/// Accept all transactions.
106
107
pub struct BaseFilter;
impl Filter<Call> for BaseFilter {
108
109
	fn filter(_: &Call) -> bool {
		true
ddorgan's avatar
ddorgan committed
110
111
112
113
114
115
116
	}
}

parameter_types! {
	pub const Version: RuntimeVersion = VERSION;
}

117
impl frame_system::Trait for Runtime {
118
	type BaseCallFilter = BaseFilter;
ddorgan's avatar
ddorgan committed
119
120
121
122
123
124
125
126
127
128
129
130
	type Origin = Origin;
	type Call = Call;
	type Index = Nonce;
	type BlockNumber = BlockNumber;
	type Hash = Hash;
	type Hashing = BlakeTwo256;
	type AccountId = AccountId;
	type Lookup = IdentityLookup<Self::AccountId>;
	type Header = generic::Header<BlockNumber, BlakeTwo256>;
	type Event = Event;
	type BlockHashCount = BlockHashCount;
	type MaximumBlockWeight = MaximumBlockWeight;
131
132
	type DbWeight = RocksDbWeight;
	type BlockExecutionWeight = BlockExecutionWeight;
133
	type ExtrinsicBaseWeight = ExtrinsicBaseWeight;
Tomasz Drwięga's avatar
Tomasz Drwięga committed
134
	type MaximumExtrinsicWeight = MaximumExtrinsicWeight;
ddorgan's avatar
ddorgan committed
135
136
137
138
	type MaximumBlockLength = MaximumBlockLength;
	type AvailableBlockRatio = AvailableBlockRatio;
	type Version = Version;
	type ModuleToIndex = ModuleToIndex;
139
	type AccountData = pallet_balances::AccountData<Balance>;
ddorgan's avatar
ddorgan committed
140
141
	type OnNewAccount = ();
	type OnKilledAccount = ();
142
	type SystemWeightInfo = weights::frame_system::WeightInfo;
ddorgan's avatar
ddorgan committed
143
144
}

145
impl pallet_scheduler::Trait for Runtime {
ddorgan's avatar
ddorgan committed
146
147
	type Event = Event;
	type Origin = Origin;
148
	type PalletsOrigin = OriginCaller;
ddorgan's avatar
ddorgan committed
149
150
	type Call = Call;
	type MaximumWeight = MaximumBlockWeight;
151
	type ScheduleOrigin = EnsureRoot<AccountId>;
152
	type WeightInfo = ();
ddorgan's avatar
ddorgan committed
153
154
155
156
157
158
159
}

parameter_types! {
	pub const EpochDuration: u64 = EPOCH_DURATION_IN_BLOCKS as u64;
	pub const ExpectedBlockTime: Moment = MILLISECS_PER_BLOCK;
}

160
impl pallet_babe::Trait for Runtime {
ddorgan's avatar
ddorgan committed
161
162
163
164
	type EpochDuration = EpochDuration;
	type ExpectedBlockTime = ExpectedBlockTime;

	// session module is the trigger
165
	type EpochChangeTrigger = pallet_babe::ExternalTrigger;
166
167
168
169
170

	type KeyOwnerProofSystem = Historical;

	type KeyOwnerProof = <Self::KeyOwnerProofSystem as KeyOwnerProofSystem<(
		KeyTypeId,
171
		pallet_babe::AuthorityId,
172
173
174
175
	)>>::Proof;

	type KeyOwnerIdentification = <Self::KeyOwnerProofSystem as KeyOwnerProofSystem<(
		KeyTypeId,
176
		pallet_babe::AuthorityId,
177
178
179
	)>>::IdentificationTuple;

	type HandleEquivocation =
180
		pallet_babe::EquivocationHandler<Self::KeyOwnerIdentification, Offences>;
ddorgan's avatar
ddorgan committed
181
182
183
184
185
186
}

parameter_types! {
	pub const IndexDeposit: Balance = 1 * DOLLARS;
}

187
impl pallet_indices::Trait for Runtime {
ddorgan's avatar
ddorgan committed
188
189
190
191
	type AccountIndex = AccountIndex;
	type Currency = Balances;
	type Deposit = IndexDeposit;
	type Event = Event;
192
	type WeightInfo = ();
ddorgan's avatar
ddorgan committed
193
194
195
196
197
198
}

parameter_types! {
	pub const ExistentialDeposit: Balance = 1 * CENTS;
}

199
impl pallet_balances::Trait for Runtime {
ddorgan's avatar
ddorgan committed
200
201
202
203
204
	type Balance = Balance;
	type DustRemoval = ();
	type Event = Event;
	type ExistentialDeposit = ExistentialDeposit;
	type AccountStore = System;
205
	type WeightInfo = weights::pallet_balances::WeightInfo;
ddorgan's avatar
ddorgan committed
206
207
208
209
210
211
}

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

212
impl pallet_transaction_payment::Trait for Runtime {
ddorgan's avatar
ddorgan committed
213
214
215
216
	type Currency = Balances;
	type OnTransactionPayment = ToAuthor<Runtime>;
	type TransactionByteFee = TransactionByteFee;
	type WeightToFee = WeightToFee;
217
	type FeeMultiplierUpdate = SlowAdjustingFeeUpdate<Self>;
ddorgan's avatar
ddorgan committed
218
219
220
221
222
}

parameter_types! {
	pub const MinimumPeriod: u64 = SLOT_DURATION / 2;
}
223
impl pallet_timestamp::Trait for Runtime {
ddorgan's avatar
ddorgan committed
224
225
226
	type Moment = u64;
	type OnTimestampSet = Babe;
	type MinimumPeriod = MinimumPeriod;
227
	type WeightInfo = weights::pallet_timestamp::WeightInfo;
ddorgan's avatar
ddorgan committed
228
229
230
231
232
233
234
}

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

// TODO: substrate#2986 implement this properly
235
236
impl pallet_authorship::Trait for Runtime {
	type FindAuthor = pallet_session::FindAccountFromAuthorIndex<Self, Babe>;
ddorgan's avatar
ddorgan committed
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
	type UncleGenerations = UncleGenerations;
	type FilterUncle = ();
	type EventHandler = (Staking, ImOnline);
}

parameter_types! {
	pub const Period: BlockNumber = 10 * MINUTES;
	pub const Offset: BlockNumber = 0;
}

impl_opaque_keys! {
	pub struct SessionKeys {
		pub grandpa: Grandpa,
		pub babe: Babe,
		pub im_online: ImOnline,
252
		pub parachain_validator: ParachainSessionKeyPlaceholder<Runtime>,
ddorgan's avatar
ddorgan committed
253
254
255
256
257
258
259
260
		pub authority_discovery: AuthorityDiscovery,
	}
}

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

261
impl pallet_session::Trait for Runtime {
ddorgan's avatar
ddorgan committed
262
263
	type Event = Event;
	type ValidatorId = AccountId;
264
	type ValidatorIdOf = pallet_staking::StashOf<Self>;
ddorgan's avatar
ddorgan committed
265
266
	type ShouldEndSession = Babe;
	type NextSessionRotation = Babe;
267
	type SessionManager = pallet_session::historical::NoteHistoricalRoot<Self, Staking>;
ddorgan's avatar
ddorgan committed
268
269
270
	type SessionHandler = <SessionKeys as OpaqueKeys>::KeyTypeIdProviders;
	type Keys = SessionKeys;
	type DisabledValidatorsThreshold = DisabledValidatorsThreshold;
271
	type WeightInfo = ();
ddorgan's avatar
ddorgan committed
272
273
}

274
275
276
impl pallet_session::historical::Trait for Runtime {
	type FullIdentification = pallet_staking::Exposure<AccountId, Balance>;
	type FullIdentificationOf = pallet_staking::ExposureOf<Runtime>;
ddorgan's avatar
ddorgan committed
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
}

pallet_staking_reward_curve::build! {
	const REWARD_CURVE: PiecewiseLinear<'static> = curve!(
		min_inflation: 0_025_000,
		max_inflation: 0_100_000,
		ideal_stake: 0_500_000,
		falloff: 0_050_000,
		max_piece_count: 40,
		test_precision: 0_005_000,
	);
}

parameter_types! {
	// Six sessions in an era (6 hours).
	pub const SessionsPerEra: SessionIndex = 6;
	// 28 eras for unbonding (7 days).
294
	pub const BondingDuration: pallet_staking::EraIndex = 28;
295
	// 27 eras in which slashes can be cancelled (slightly less than 7 days).
296
	pub const SlashDeferDuration: pallet_staking::EraIndex = 27;
ddorgan's avatar
ddorgan committed
297
298
299
300
	pub const RewardCurve: &'static PiecewiseLinear<'static> = &REWARD_CURVE;
	pub const MaxNominatorRewardedPerValidator: u32 = 64;
	// quarter of the last session will be for election.
	pub const ElectionLookahead: BlockNumber = EPOCH_DURATION_IN_BLOCKS / 4;
301
	pub const MaxIterations: u32 = 10;
302
	pub MinSolutionScoreBump: Perbill = Perbill::from_rational_approximation(5u32, 10_000);
ddorgan's avatar
ddorgan committed
303
304
}

305
impl pallet_staking::Trait for Runtime {
ddorgan's avatar
ddorgan committed
306
307
308
309
310
311
312
313
314
315
316
	type Currency = Balances;
	type UnixTime = Timestamp;
	type CurrencyToVote = CurrencyToVoteHandler<Self>;
	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.
317
	type SlashCancelOrigin = EnsureRoot<AccountId>;
ddorgan's avatar
ddorgan committed
318
319
320
321
322
323
324
	type SessionInterface = Self;
	type RewardCurve = RewardCurve;
	type MaxNominatorRewardedPerValidator = MaxNominatorRewardedPerValidator;
	type NextNewSession = Session;
	type ElectionLookahead = ElectionLookahead;
	type Call = Call;
	type UnsignedPriority = StakingUnsignedPriority;
325
	type MaxIterations = MaxIterations;
326
	type MinSolutionScoreBump = MinSolutionScoreBump;
327
	type WeightInfo = weights::pallet_staking::WeightInfo;
ddorgan's avatar
ddorgan committed
328
329
330
331
332
333
334
335
336
337
338
339
340
341
}

parameter_types! {
	pub const LaunchPeriod: BlockNumber = 7 * DAYS;
	pub const VotingPeriod: BlockNumber = 7 * DAYS;
	pub const FastTrackVotingPeriod: BlockNumber = 3 * HOURS;
	pub const MinimumDeposit: Balance = 1 * DOLLARS;
	pub const EnactmentPeriod: BlockNumber = 8 * DAYS;
	pub const CooloffPeriod: BlockNumber = 7 * DAYS;
	// One cent: $10,000 / MB
	pub const PreimageByteDeposit: Balance = 10 * MILLICENTS;
	pub const InstantAllowed: bool = true;
}

342
parameter_types! {
343
	pub OffencesWeightSoftLimit: Weight = Perbill::from_percent(60) * MaximumBlockWeight::get();
344
345
}

346
impl pallet_offences::Trait for Runtime {
ddorgan's avatar
ddorgan committed
347
	type Event = Event;
348
	type IdentificationTuple = pallet_session::historical::IdentificationTuple<Self>;
ddorgan's avatar
ddorgan committed
349
	type OnOffenceHandler = Staking;
350
	type WeightSoftLimit = OffencesWeightSoftLimit;
351
	type WeightInfo = ();
ddorgan's avatar
ddorgan committed
352
353
}

354
impl pallet_authority_discovery::Trait for Runtime {}
ddorgan's avatar
ddorgan committed
355
356
357
358
359
360
361
362
363
364

parameter_types! {
	pub const SessionDuration: BlockNumber = EPOCH_DURATION_IN_BLOCKS as _;
}

parameter_types! {
	pub const StakingUnsignedPriority: TransactionPriority = TransactionPriority::max_value() / 2;
	pub const ImOnlineUnsignedPriority: TransactionPriority = TransactionPriority::max_value();
}

365
impl pallet_im_online::Trait for Runtime {
ddorgan's avatar
ddorgan committed
366
367
368
369
370
	type AuthorityId = ImOnlineId;
	type Event = Event;
	type ReportUnresponsiveness = Offences;
	type SessionDuration = SessionDuration;
	type UnsignedPriority = StakingUnsignedPriority;
371
	type WeightInfo = ();
ddorgan's avatar
ddorgan committed
372
373
}

374
impl pallet_grandpa::Trait for Runtime {
ddorgan's avatar
ddorgan committed
375
	type Event = Event;
376
377
378
379
380
381
382
383
384
385
386
387
	type Call = Call;

	type KeyOwnerProofSystem = Historical;

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

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

388
	type HandleEquivocation = pallet_grandpa::EquivocationHandler<Self::KeyOwnerIdentification, Offences>;
ddorgan's avatar
ddorgan committed
389
390
391
}

parameter_types! {
392
393
	pub WindowSize: BlockNumber = pallet_finality_tracker::DEFAULT_WINDOW_SIZE.into();
	pub ReportLatency: BlockNumber = pallet_finality_tracker::DEFAULT_REPORT_LATENCY.into();
ddorgan's avatar
ddorgan committed
394
395
}

396
impl pallet_finality_tracker::Trait for Runtime {
ddorgan's avatar
ddorgan committed
397
398
399
400
401
	type OnFinalizationStalled = ();
	type WindowSize = WindowSize;
	type ReportLatency = ReportLatency;
}

402
403
/// Submits a transaction with the node's public and signature type. Adheres to the signed extension
/// format of the chain.
404
impl<LocalCall> frame_system::offchain::CreateSignedTransaction<LocalCall> for Runtime where
405
406
	Call: From<LocalCall>,
{
407
	fn create_transaction<C: frame_system::offchain::AppCrypto<Self::Public, Self::Signature>>(
408
409
410
		call: Call,
		public: <Signature as Verify>::Signer,
		account: AccountId,
411
		nonce: <Runtime as frame_system::Trait>::Index,
412
	) -> Option<(Call, <UncheckedExtrinsic as ExtrinsicT>::SignaturePayload)> {
413
		// take the biggest period possible.
414
415
416
417
418
419
420
		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>()
421
422
			// The `System::block_number` is initialized with `n+1`,
			// so the actual block number is `n`.
423
424
425
			.saturating_sub(1);
		let tip = 0;
		let extra: SignedExtra = (
426
427
428
429
430
431
432
			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),
433
434
		);
		let raw_payload = SignedPayload::new(call, extra).map_err(|e| {
435
			debug::warn!("Unable to create signed payload: {:?}", e);
436
		}).ok()?;
437
438
439
		let signature = raw_payload.using_encoded(|payload| {
			C::sign(payload, public)
		})?;
440
441
442
		let (call, extra, _) = raw_payload.deconstruct();
		Some((call, (account, signature, extra)))
	}
ddorgan's avatar
ddorgan committed
443
444
}

445
impl frame_system::offchain::SigningTypes for Runtime {
446
447
448
449
	type Public = <Signature as Verify>::Signer;
	type Signature = Signature;
}

450
impl<C> frame_system::offchain::SendTransactionTypes<C> for Runtime where
451
452
453
454
455
456
	Call: From<C>,
{
	type OverarchingCall = Call;
	type Extrinsic = UncheckedExtrinsic;
}

ddorgan's avatar
ddorgan committed
457
458
459
460
461
462
463
parameter_types! {
	// Minimum 100 bytes/KSM deposited (1 CENT/byte)
	pub const BasicDeposit: Balance = 10 * DOLLARS;       // 258 bytes on-chain
	pub const FieldDeposit: Balance = 250 * CENTS;        // 66 bytes on-chain
	pub const SubAccountDeposit: Balance = 2 * DOLLARS;   // 53 bytes on-chain
	pub const MaxSubAccounts: u32 = 100;
	pub const MaxAdditionalFields: u32 = 100;
464
	pub const MaxRegistrars: u32 = 20;
ddorgan's avatar
ddorgan committed
465
466
}

467
impl pallet_identity::Trait for Runtime {
ddorgan's avatar
ddorgan committed
468
469
470
471
472
473
474
475
	type Event = Event;
	type Currency = Balances;
	type Slashed = ();
	type BasicDeposit = BasicDeposit;
	type FieldDeposit = FieldDeposit;
	type SubAccountDeposit = SubAccountDeposit;
	type MaxSubAccounts = MaxSubAccounts;
	type MaxAdditionalFields = MaxAdditionalFields;
476
	type MaxRegistrars = MaxRegistrars;
477
478
	type RegistrarOrigin = frame_system::EnsureRoot<AccountId>;
	type ForceOrigin = frame_system::EnsureRoot<AccountId>;
479
	type WeightInfo = ();
ddorgan's avatar
ddorgan committed
480
481
}

482
impl pallet_utility::Trait for Runtime {
483
484
	type Event = Event;
	type Call = Call;
485
	type WeightInfo = weights::pallet_utility::WeightInfo;
486
487
}

ddorgan's avatar
ddorgan committed
488
parameter_types! {
489
490
	// One storage item; key size is 32; value is size 4+4+16+32 bytes = 56 bytes.
	pub const DepositBase: Balance = deposit(1, 88);
ddorgan's avatar
ddorgan committed
491
	// Additional storage item size of 32 bytes.
492
	pub const DepositFactor: Balance = deposit(0, 32);
ddorgan's avatar
ddorgan committed
493
494
495
	pub const MaxSignatories: u16 = 100;
}

496
impl pallet_multisig::Trait for Runtime {
ddorgan's avatar
ddorgan committed
497
498
499
	type Event = Event;
	type Call = Call;
	type Currency = Balances;
500
501
	type DepositBase = DepositBase;
	type DepositFactor = DepositFactor;
ddorgan's avatar
ddorgan committed
502
	type MaxSignatories = MaxSignatories;
503
	type WeightInfo = ();
ddorgan's avatar
ddorgan committed
504
505
506
507
508
509
510
511
512
}

parameter_types! {
	pub const ConfigDepositBase: Balance = 5 * DOLLARS;
	pub const FriendDepositFactor: Balance = 50 * CENTS;
	pub const MaxFriends: u16 = 9;
	pub const RecoveryDeposit: Balance = 5 * DOLLARS;
}

513
impl pallet_recovery::Trait for Runtime {
ddorgan's avatar
ddorgan committed
514
515
516
517
518
519
520
521
522
523
524
525
526
	type Event = Event;
	type Call = Call;
	type Currency = Balances;
	type ConfigDepositBase = ConfigDepositBase;
	type FriendDepositFactor = FriendDepositFactor;
	type MaxFriends = MaxFriends;
	type RecoveryDeposit = RecoveryDeposit;
}

parameter_types! {
	pub const MinVestedTransfer: Balance = 100 * DOLLARS;
}

527
impl pallet_vesting::Trait for Runtime {
ddorgan's avatar
ddorgan committed
528
529
530
531
	type Event = Event;
	type Currency = Balances;
	type BlockNumberToBalance = ConvertInto;
	type MinVestedTransfer = MinVestedTransfer;
532
	type WeightInfo = ();
ddorgan's avatar
ddorgan committed
533
534
}

535
impl pallet_sudo::Trait for Runtime {
ddorgan's avatar
ddorgan committed
536
537
538
539
	type Event = Event;
	type Call = Call;
}

540
541
542
543
544
545
parameter_types! {
	// One storage item; key size 32, value size 8; .
	pub const ProxyDepositBase: Balance = deposit(1, 8);
	// Additional storage item size of 33 bytes.
	pub const ProxyDepositFactor: Balance = deposit(0, 33);
	pub const MaxProxies: u16 = 32;
546
547
548
	pub const AnnouncementDepositBase: Balance = deposit(1, 8);
	pub const AnnouncementDepositFactor: Balance = deposit(0, 66);
	pub const MaxPending: u16 = 32;
549
550
551
552
553
554
555
556
}

/// The type used to represent the kinds of proxying allowed.
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Encode, Decode, RuntimeDebug)]
pub enum ProxyType {
	Any,
	NonTransfer,
	Staking,
557
	SudoBalances,
Chevdor's avatar
Chevdor committed
558
	IdentityJudgement,
559
560
561
562
563
564
}
impl Default for ProxyType { fn default() -> Self { Self::Any } }
impl InstanceFilter<Call> for ProxyType {
	fn filter(&self, c: &Call) -> bool {
		match self {
			ProxyType::Any => true,
565
566
567
568
			ProxyType::NonTransfer => matches!(c,
				Call::System(..) |
				Call::Babe(..) |
				Call::Timestamp(..) |
569
570
571
				Call::Indices(pallet_indices::Call::claim(..)) |
				Call::Indices(pallet_indices::Call::free(..)) |
				Call::Indices(pallet_indices::Call::freeze(..)) |
572
573
574
575
576
577
578
579
580
581
				// Specifically omitting Indices `transfer`, `force_transfer`
				// Specifically omitting the entire Balances pallet
				Call::Authorship(..) |
				Call::Staking(..) |
				Call::Offences(..) |
				Call::Session(..) |
				Call::FinalityTracker(..) |
				Call::Grandpa(..) |
				Call::ImOnline(..) |
				Call::AuthorityDiscovery(..) |
582
583
584
				Call::DummyParachains(..) |
				Call::DummyAttestations(..) |
				Call::DummyRegistrar(..) |
585
586
				Call::Utility(..) |
				Call::Identity(..) |
587
588
589
590
591
592
				Call::Recovery(pallet_recovery::Call::as_recovered(..)) |
				Call::Recovery(pallet_recovery::Call::vouch_recovery(..)) |
				Call::Recovery(pallet_recovery::Call::claim_recovery(..)) |
				Call::Recovery(pallet_recovery::Call::close_recovery(..)) |
				Call::Recovery(pallet_recovery::Call::remove_recovery(..)) |
				Call::Recovery(pallet_recovery::Call::cancel_recovered(..)) |
593
				// Specifically omitting Recovery `create_recovery`, `initiate_recovery`
594
595
				Call::Vesting(pallet_vesting::Call::vest(..)) |
				Call::Vesting(pallet_vesting::Call::vest_other(..)) |
596
597
598
599
600
				// Specifically omitting Vesting `vested_transfer`, and `force_vested_transfer`
				Call::Scheduler(..) |
				// Specifically omitting Sudo pallet
				Call::Proxy(..) |
				Call::Multisig(..)
601
602
			),
			ProxyType::Staking => matches!(c,
Gavin Wood's avatar
Gavin Wood committed
603
				Call::Staking(..) | Call::Utility(..)
604
			),
605
			ProxyType::SudoBalances => match c {
606
				Call::Sudo(pallet_sudo::Call::sudo(ref x)) => matches!(x.as_ref(), &Call::Balances(..)),
Gavin Wood's avatar
Gavin Wood committed
607
				Call::Utility(..) => true,
608
609
				_ => false,
			},
Chevdor's avatar
Chevdor committed
610
			ProxyType::IdentityJudgement => matches!(c,
611
612
				Call::Identity(pallet_identity::Call::provide_judgement(..))
				| Call::Utility(pallet_utility::Call::batch(..))
Chevdor's avatar
Chevdor committed
613
			)
614
615
616
617
618
619
620
621
622
		}
	}
	fn is_superset(&self, o: &Self) -> bool {
		match (self, o) {
			(x, y) if x == y => true,
			(ProxyType::Any, _) => true,
			(_, ProxyType::Any) => false,
			(ProxyType::NonTransfer, _) => true,
			_ => false,
623
624
625
626
		}
	}
}

627
impl pallet_proxy::Trait for Runtime {
628
629
630
631
632
633
634
	type Event = Event;
	type Call = Call;
	type Currency = Balances;
	type ProxyType = ProxyType;
	type ProxyDepositBase = ProxyDepositBase;
	type ProxyDepositFactor = ProxyDepositFactor;
	type MaxProxies = MaxProxies;
635
636
637
638
639
	type WeightInfo = weights::pallet_proxy::WeightInfo;
	type MaxPending = MaxPending;
	type CallHasher = BlakeTwo256;
	type AnnouncementDepositBase = AnnouncementDepositBase;
	type AnnouncementDepositFactor = AnnouncementDepositFactor;
640
641
}

642
impl<I: frame_support::traits::Instance> dummy::Trait<I> for Runtime {
643
644
645
	type Event = Event;
}

ddorgan's avatar
ddorgan committed
646
647
648
construct_runtime! {
	pub enum Runtime where
		Block = Block,
649
		NodeBlock = primitives::v1::Block,
ddorgan's avatar
ddorgan committed
650
651
652
		UncheckedExtrinsic = UncheckedExtrinsic
	{
		// Basic stuff; balances is uncallable initially.
653
654
		System: frame_system::{Module, Call, Storage, Config, Event<T>},
		RandomnessCollectiveFlip: pallet_randomness_collective_flip::{Module, Storage},
ddorgan's avatar
ddorgan committed
655
656

		// Must be before session.
657
		Babe: pallet_babe::{Module, Call, Storage, Config, Inherent, ValidateUnsigned},
ddorgan's avatar
ddorgan committed
658

659
660
661
662
		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},
ddorgan's avatar
ddorgan committed
663
664

		// Consensus support.
665
666
667
		Authorship: pallet_authorship::{Module, Call, Storage},
		Staking: pallet_staking::{Module, Call, Storage, Config<T>, Event<T>, ValidateUnsigned},
		Offences: pallet_offences::{Module, Call, Storage, Event},
ddorgan's avatar
ddorgan committed
668
		Historical: session_historical::{Module},
669
670
671
672
673
		Session: pallet_session::{Module, Call, Storage, Event, Config<T>},
		FinalityTracker: pallet_finality_tracker::{Module, Call, Storage, Inherent},
		Grandpa: pallet_grandpa::{Module, Call, Storage, Config, Event, ValidateUnsigned},
		ImOnline: pallet_im_online::{Module, Call, Storage, Event<T>, ValidateUnsigned, Config<T>},
		AuthorityDiscovery: pallet_authority_discovery::{Module, Call, Config},
ddorgan's avatar
ddorgan committed
674

675
676
677
		// Old Parachains stuff. All dummies to avoid messing up the transaction indices.
		DummyParachains: dummy::<Instance0>::{Module, Call},
		DummyAttestations: dummy::<Instance1>::{Module, Call},
678
		DummyRegistrar: dummy::<Instance2>::{Module, Call, Event<T>},
ddorgan's avatar
ddorgan committed
679
680

		// Utility module.
681
		Utility: pallet_utility::{Module, Call, Event},
ddorgan's avatar
ddorgan committed
682
683

		// Less simple identity module.
684
		Identity: pallet_identity::{Module, Call, Storage, Event<T>},
ddorgan's avatar
ddorgan committed
685
686

		// Social recovery module.
687
		Recovery: pallet_recovery::{Module, Call, Storage, Event<T>},
ddorgan's avatar
ddorgan committed
688
689

		// Vesting. Usable initially, but removed once all vesting is finished.
690
		Vesting: pallet_vesting::{Module, Call, Storage, Event<T>, Config<T>},
ddorgan's avatar
ddorgan committed
691
692

		// System scheduler.
693
		Scheduler: pallet_scheduler::{Module, Call, Storage, Event<T>},
ddorgan's avatar
ddorgan committed
694
695

		// Sudo.
696
		Sudo: pallet_sudo::{Module, Call, Storage, Event<T>, Config<T>},
697
698

		// Proxy module. Late addition.
699
		Proxy: pallet_proxy::{Module, Call, Storage, Event<T>},
700
701

		// Multisig module. Late addition.
702
		Multisig: pallet_multisig::{Module, Call, Storage, Event<T>},
ddorgan's avatar
ddorgan committed
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
	}
}

/// The address format for describing accounts.
pub type Address = AccountId;
/// 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 = (
718
719
720
721
722
723
724
	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>,
ddorgan's avatar
ddorgan committed
725
726
727
728
729
730
);
/// 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.
731
732
733
734
735
736
737
738
pub type Executive = frame_executive::Executive<
	Runtime,
	Block,
	frame_system::ChainContext<Runtime>,
	Runtime,
	AllModules,
	CustomOnRuntimeUpgrade,
>;
739
740
/// The payload being signed in transactions.
pub type SignedPayload = generic::SignedPayload<Call, SignedExtra>;
ddorgan's avatar
ddorgan committed
741

742
743
744
745
746
747
748
pub struct CustomOnRuntimeUpgrade;
impl frame_support::traits::OnRuntimeUpgrade for CustomOnRuntimeUpgrade {
	fn on_runtime_upgrade() -> frame_support::weights::Weight {
		purchase::remove_pallet::<Runtime>()
	}
}

749
#[cfg(not(feature = "disable-runtime-api"))]
ddorgan's avatar
ddorgan committed
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
sp_api::impl_runtime_apis! {
	impl sp_api::Core<Block> for Runtime {
		fn version() -> RuntimeVersion {
			VERSION
		}

		fn execute_block(block: Block) {
			Executive::execute_block(block)
		}

		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 {
			RandomnessCollectiveFlip::random_seed()
		}
	}

	impl tx_pool_api::runtime_api::TaggedTransactionQueue<Block> for Runtime {
		fn validate_transaction(
			source: TransactionSource,
			tx: <Block as BlockT>::Extrinsic,
		) -> TransactionValidity {
			Executive::validate_transaction(source, tx)
		}
	}

	impl offchain_primitives::OffchainWorkerApi<Block> for Runtime {
		fn offchain_worker(header: &<Block as BlockT>::Header) {
			Executive::offchain_worker(header)
		}
	}

811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
	// Dummy implementation to continue supporting old parachains runtime temporarily.
	impl p_v0::ParachainHost<Block> for Runtime {
		fn validators() -> Vec<p_v0::ValidatorId> {
			// this is a compile-time check of size equality. note that we don't invoke
			// the function and nothing here is unsafe.
			let _ = core::mem::transmute::<p_v0::ValidatorId, AccountId>;

			// Yes, these aren't actually the parachain session keys.
			// It doesn't matter, but we shouldn't return a zero-sized vector here.
			// As there are no parachains
			Session::validators()
				.into_iter()
				.map(|k| k.using_encoded(|s| Decode::decode(&mut &s[..]))
					.expect("correct size and raw-bytes; qed"))
				.collect()
ddorgan's avatar
ddorgan committed
826
		}
827
828
829
		fn duty_roster() -> p_v0::DutyRoster {
			let v = Session::validators();
			p_v0::DutyRoster { validator_duty: (0..v.len()).map(|_| p_v0::Chain::Relay).collect() }
ddorgan's avatar
ddorgan committed
830
		}
831
832
		fn active_parachains() -> Vec<(p_v0::Id, Option<(p_v0::CollatorId, p_v0::Retriable)>)> {
			Vec::new()
ddorgan's avatar
ddorgan committed
833
		}
834
835
836
837
838
839
		fn global_validation_data() -> p_v0::GlobalValidationData {
			p_v0::GlobalValidationData {
				max_code_size: 1,
				max_head_data_size: 1,
				block_number: System::block_number().saturating_sub(1),
			}
ddorgan's avatar
ddorgan committed
840
		}
841
842
		fn local_validation_data(_id: p_v0::Id) -> Option<p_v0::LocalValidationData> {
			None
ddorgan's avatar
ddorgan committed
843
		}
844
845
		fn parachain_code(_id: p_v0::Id) -> Option<p_v0::ValidationCode> {
			None
ddorgan's avatar
ddorgan committed
846
		}
847
848
		fn get_heads(_extrinsics: Vec<<Block as BlockT>::Extrinsic>)
			-> Option<Vec<p_v0::AbridgedCandidateReceipt>>
ddorgan's avatar
ddorgan committed
849
		{
850
			None
ddorgan's avatar
ddorgan committed
851
		}
852
853
854
855
856
		fn signing_context() -> p_v0::SigningContext {
			p_v0::SigningContext {
				parent_hash: System::parent_hash(),
				session_index: Session::current_index(),
			}
ddorgan's avatar
ddorgan committed
857
		}
858
859
		fn downward_messages(_id: p_v0::Id) -> Vec<p_v0::DownwardMessage> {
			Vec::new()
860
		}
ddorgan's avatar
ddorgan committed
861
862
863
864
865
866
	}

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

868
		fn submit_report_equivocation_unsigned_extrinsic(
869
870
871
872
873
874
875
876
			equivocation_proof: fg_primitives::EquivocationProof<
				<Block as BlockT>::Hash,
				sp_runtime::traits::NumberFor<Block>,
			>,
			key_owner_proof: fg_primitives::OpaqueKeyOwnershipProof,
		) -> Option<()> {
			let key_owner_proof = key_owner_proof.decode()?;

877
			Grandpa::submit_unsigned_equivocation_report(
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
				equivocation_proof,
				key_owner_proof,
			)
		}

		fn generate_key_ownership_proof(
			_set_id: fg_primitives::SetId,
			authority_id: fg_primitives::AuthorityId,
		) -> Option<fg_primitives::OpaqueKeyOwnershipProof> {
			use codec::Encode;

			Historical::prove((fg_primitives::KEY_TYPE, authority_id))
				.map(|p| p.encode())
				.map(fg_primitives::OpaqueKeyOwnershipProof::new)
		}
ddorgan's avatar
ddorgan committed
893
894
895
	}

	impl babe_primitives::BabeApi<Block> for Runtime {
896
		fn configuration() -> babe_primitives::BabeGenesisConfiguration {
ddorgan's avatar
ddorgan committed
897
898
899
900
901
			// 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>
902
			babe_primitives::BabeGenesisConfiguration {
ddorgan's avatar
ddorgan committed
903
904
905
906
907
				slot_duration: Babe::slot_duration(),
				epoch_length: EpochDuration::get(),
				c: PRIMARY_PROBABILITY,
				genesis_authorities: Babe::authorities(),
				randomness: Babe::randomness(),
908
				allowed_slots: babe_primitives::AllowedSlots::PrimaryAndSecondaryPlainSlots,
ddorgan's avatar
ddorgan committed
909
910
911
912
913
914
			}
		}

		fn current_epoch_start() -> babe_primitives::SlotNumber {
			Babe::current_epoch_start()
		}
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937

		fn generate_key_ownership_proof(
			_slot_number: babe_primitives::SlotNumber,
			authority_id: babe_primitives::AuthorityId,
		) -> Option<babe_primitives::OpaqueKeyOwnershipProof> {
			use codec::Encode;

			Historical::prove((babe_primitives::KEY_TYPE, authority_id))
				.map(|p| p.encode())
				.map(babe_primitives::OpaqueKeyOwnershipProof::new)
		}

		fn submit_report_equivocation_unsigned_extrinsic(
			equivocation_proof: babe_primitives::EquivocationProof<<Block as BlockT>::Header>,
			key_owner_proof: babe_primitives::OpaqueKeyOwnershipProof,
		) -> Option<()> {
			let key_owner_proof = key_owner_proof.decode()?;

			Babe::submit_unsigned_equivocation_report(
				equivocation_proof,
				key_owner_proof,
			)
		}
ddorgan's avatar
ddorgan committed
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
	}

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

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

958
	impl frame_system_rpc_runtime_api::AccountNonceApi<Block, AccountId, Nonce> for Runtime {
ddorgan's avatar
ddorgan committed
959
960
961
962
963
		fn account_nonce(account: AccountId) -> Nonce {
			System::account_nonce(account)
		}
	}

964
	impl pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi<
ddorgan's avatar
ddorgan committed
965
966
967
		Block,
		Balance,
	> for Runtime {
968
		fn query_info(uxt: <Block as BlockT>::Extrinsic, len: u32) -> RuntimeDispatchInfo<Balance> {
ddorgan's avatar
ddorgan committed
969
970
971
972
973
974
975
			TransactionPayment::query_info(uxt, len)
		}
	}

	#[cfg(feature = "runtime-benchmarks")]
	impl frame_benchmarking::Benchmark<Block> for Runtime {
		fn dispatch_benchmark(
976
			config: frame_benchmarking::BenchmarkConfig,
ddorgan's avatar
ddorgan committed
977
		) -> Result<Vec<frame_benchmarking::BenchmarkBatch>, RuntimeString> {
978
			use frame_benchmarking::{Benchmarking, BenchmarkBatch, add_benchmark, TrackedStorageKey};
979
980
981
982
983
			// Trying to add benchmarks directly to the Session Pallet caused cyclic dependency issues.
			// To get around that, we separated the Session benchmarks into its own crate, which is why
			// we need these two lines below.
			use pallet_session_benchmarking::Module as SessionBench;
			use pallet_offences_benchmarking::Module as OffencesBench;
984
			use frame_system_benchmarking::Module as SystemBench;
985
986
987

			impl pallet_session_benchmarking::Trait for Runtime {}
			impl pallet_offences_benchmarking::Trait for Runtime {}
988
			impl frame_system_benchmarking::Trait for Runtime {}
ddorgan's avatar
ddorgan committed
989

990
			let whitelist: Vec<TrackedStorageKey> = vec![
991
				// Block Number
992
				hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef702a5c1b19ab7a04f536c519aca4983ac").to_vec().into(),
993
				// Total Issuance
994
				hex_literal::hex!("c2261276cc9d1f8598ea4b6a74b15c2f57c875e4cff74148e4628f264b974c80").to_vec().into(),
995
				// Execution Phase
996
				hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef7ff553b5a9862a516939d82b3d3d8661a").to_vec().into(),
997
				// Event Count
998
				hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef70a98fdbe9ce6c55837576c60c7af3850").to_vec().into(),
999
				// System Events
1000
				hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef780d41e5e16056765bc8461851072c9d7").to_vec().into(),
For faster browsing, not all history is shown. View entire blame