lib.rs 57.2 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
// 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"]
ddorgan's avatar
ddorgan committed
22

Albrecht's avatar
Albrecht committed
23
use pallet_transaction_payment::CurrencyAdapter;
24
use parity_scale_codec::{Decode, Encode, MaxEncodedLen};
25
use primitives::v1::{
26
	AccountId, AccountIndex, Balance, BlockNumber, CandidateEvent, CommittedCandidateReceipt,
27
	CoreState, GroupRotationInfo, Hash, Id as ParaId, InboundDownwardMessage, InboundHrmpMessage,
28
29
	Moment, Nonce, OccupiedCoreAssumption, PersistedValidationData, ScrapedOnChainVotes,
	SessionInfo, Signature, ValidationCode, ValidationCodeHash, ValidatorId, ValidatorIndex,
ddorgan's avatar
ddorgan committed
30
};
31
use runtime_common::{
32
33
34
35
36
37
38
39
40
41
42
43
44
	auctions, crowdloan, impls::ToAuthor, paras_registrar, paras_sudo_wrapper, slots, xcm_sender,
	BlockHashCount, BlockLength, BlockWeights, CurrencyToVote, OffchainSolutionLengthLimit,
	OffchainSolutionWeightLimit, RocksDbWeight, SlowAdjustingFeeUpdate,
};
use sp_std::{collections::btree_map::BTreeMap, prelude::*};

use runtime_parachains::{
	configuration as parachains_configuration, dmp as parachains_dmp, hrmp as parachains_hrmp,
	inclusion as parachains_inclusion, initializer as parachains_initializer,
	origin as parachains_origin, paras as parachains_paras,
	paras_inherent as parachains_paras_inherent, reward_points as parachains_reward_points,
	runtime_api_impl::v1 as parachains_runtime_api_impl, scheduler as parachains_scheduler,
	session_info as parachains_session_info, shared as parachains_shared, ump as parachains_ump,
ddorgan's avatar
ddorgan committed
45
};
46

Gavin Wood's avatar
Gavin Wood committed
47
use xcm::latest::prelude::*;
48
use xcm_builder::{
49
50
51
	AccountId32Aliases, AllowKnownQueryResponses, AllowSubscriptionsFrom,
	AllowTopLevelPaidExecutionFrom, AllowUnpaidExecutionFrom, ChildParachainAsNative,
	ChildParachainConvertsVia, ChildSystemParachainAsSuperuser,
52
53
54
	CurrencyAdapter as XcmCurrencyAdapter, IsChildSystemParachain, IsConcrete, LocationInverter,
	SignedAccountId32AsNative, SignedToAccountId32, SovereignSignedViaLocation, TakeWeightCredit,
	UsingComponents, WeightInfoBounds,
55
};
56
use xcm_executor::XcmExecutor;
57

58
59
60
61
use authority_discovery_primitives::AuthorityId as AuthorityDiscoveryId;
use beefy_primitives::crypto::AuthorityId as BeefyId;
use frame_support::{
	construct_runtime, parameter_types,
62
63
64
	traits::{
		Contains, Everything, InstanceFilter, KeyOwnerProofSystem, Nothing, OnRuntimeUpgrade,
	},
65
66
67
68
69
70
71
72
73
74
	weights::Weight,
	PalletId, RuntimeDebug,
};
use frame_system::EnsureRoot;
use pallet_grandpa::{fg_primitives, AuthorityId as GrandpaId};
use pallet_im_online::sr25519::AuthorityId as ImOnlineId;
use pallet_mmr_primitives as mmr;
use pallet_session::historical as session_historical;
use pallet_transaction_payment::{FeeDetails, RuntimeDispatchInfo};
use sp_core::OpaqueMetadata;
ddorgan's avatar
ddorgan committed
75
use sp_runtime::{
76
77
78
	create_runtime_str,
	curve::PiecewiseLinear,
	generic, impl_opaque_keys,
ddorgan's avatar
ddorgan committed
79
	traits::{
80
81
		AccountIdLookup, BlakeTwo256, Block as BlockT, ConvertInto, Extrinsic as ExtrinsicT,
		OpaqueKeys, SaturatedConversion, Verify,
ddorgan's avatar
ddorgan committed
82
	},
83
84
	transaction_validity::{TransactionPriority, TransactionSource, TransactionValidity},
	ApplyExtrinsicResult, KeyTypeId, Perbill,
ddorgan's avatar
ddorgan committed
85
};
86
use sp_staking::SessionIndex;
ddorgan's avatar
ddorgan committed
87
#[cfg(any(feature = "std", test))]
88
use sp_version::NativeVersion;
89
use sp_version::RuntimeVersion;
ddorgan's avatar
ddorgan committed
90

91
92
pub use pallet_balances::Call as BalancesCall;
pub use pallet_election_provider_multi_phase::Call as EPMCall;
ddorgan's avatar
ddorgan committed
93
#[cfg(feature = "std")]
94
pub use pallet_staking::StakerStatus;
95
pub use pallet_timestamp::Call as TimestampCall;
ddorgan's avatar
ddorgan committed
96
97
98
99
100
#[cfg(any(feature = "std", test))]
pub use sp_runtime::BuildStorage;

/// Constant values used within the runtime.
pub mod constants;
101
use constants::{currency::*, fee::*, time::*};
ddorgan's avatar
ddorgan committed
102

103
104
105
// Weights used in the runtime
mod weights;

106
// Voter bag threshold definitions.
107
mod bag_thresholds;
108

109
110
111
#[cfg(test)]
mod tests;

ddorgan's avatar
ddorgan committed
112
113
114
115
// Make the WASM binary available.
#[cfg(feature = "std")]
include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));

116
/// Runtime version (Westend).
ddorgan's avatar
ddorgan committed
117
118
119
120
pub const VERSION: RuntimeVersion = RuntimeVersion {
	spec_name: create_runtime_str!("westend"),
	impl_name: create_runtime_str!("parity-westend"),
	authoring_version: 2,
Bastian Köcher's avatar
Bastian Köcher committed
121
	spec_version: 9130,
122
	impl_version: 0,
123
	#[cfg(not(feature = "disable-runtime-api"))]
ddorgan's avatar
ddorgan committed
124
	apis: RUNTIME_API_VERSIONS,
125
	#[cfg(feature = "disable-runtime-api")]
126
	apis: version::create_apis_vec![[]],
127
	transaction_version: 7,
ddorgan's avatar
ddorgan committed
128
129
};

130
131
132
133
/// The BABE epoch configuration at genesis.
pub const BABE_GENESIS_EPOCH_CONFIG: babe_primitives::BabeEpochConfiguration =
	babe_primitives::BabeEpochConfiguration {
		c: PRIMARY_PROBABILITY,
134
		allowed_slots: babe_primitives::AllowedSlots::PrimaryAndSecondaryVRFSlots,
135
136
	};

ddorgan's avatar
ddorgan committed
137
138
139
/// Native version.
#[cfg(any(feature = "std", test))]
pub fn native_version() -> NativeVersion {
140
	NativeVersion { runtime_version: VERSION, can_author_with: Default::default() }
ddorgan's avatar
ddorgan committed
141
142
}

143
/// Allow everything.
144
pub struct BaseFilter;
145
146
impl Contains<Call> for BaseFilter {
	fn contains(_: &Call) -> bool {
147
		true
ddorgan's avatar
ddorgan committed
148
149
150
151
152
	}
}

parameter_types! {
	pub const Version: RuntimeVersion = VERSION;
153
	pub const SS58Prefix: u8 = 42;
ddorgan's avatar
ddorgan committed
154
155
}

156
impl frame_system::Config for Runtime {
157
	type BaseCallFilter = BaseFilter;
158
159
	type BlockWeights = BlockWeights;
	type BlockLength = BlockLength;
ddorgan's avatar
ddorgan committed
160
161
162
163
164
165
166
	type Origin = Origin;
	type Call = Call;
	type Index = Nonce;
	type BlockNumber = BlockNumber;
	type Hash = Hash;
	type Hashing = BlakeTwo256;
	type AccountId = AccountId;
167
	type Lookup = AccountIdLookup<AccountId, ()>;
ddorgan's avatar
ddorgan committed
168
169
170
	type Header = generic::Header<BlockNumber, BlakeTwo256>;
	type Event = Event;
	type BlockHashCount = BlockHashCount;
171
	type DbWeight = RocksDbWeight;
ddorgan's avatar
ddorgan committed
172
	type Version = Version;
173
	type PalletInfo = PalletInfo;
174
	type AccountData = pallet_balances::AccountData<Balance>;
ddorgan's avatar
ddorgan committed
175
176
	type OnNewAccount = ();
	type OnKilledAccount = ();
177
	type SystemWeightInfo = weights::frame_system::WeightInfo<Runtime>;
178
	type SS58Prefix = SS58Prefix;
179
	type OnSetCode = ();
ddorgan's avatar
ddorgan committed
180
181
}

182
parameter_types! {
183
184
	pub MaximumSchedulerWeight: Weight = Perbill::from_percent(80) *
		BlockWeights::get().max_block;
185
186
187
	pub const MaxScheduledPerBlock: u32 = 50;
}

188
impl pallet_scheduler::Config for Runtime {
ddorgan's avatar
ddorgan committed
189
190
	type Event = Event;
	type Origin = Origin;
191
	type PalletsOrigin = OriginCaller;
ddorgan's avatar
ddorgan committed
192
	type Call = Call;
193
	type MaximumWeight = MaximumSchedulerWeight;
194
	type ScheduleOrigin = EnsureRoot<AccountId>;
195
	type MaxScheduledPerBlock = MaxScheduledPerBlock;
196
	type WeightInfo = weights::pallet_scheduler::WeightInfo<Runtime>;
197
	type OriginPrivilegeCmp = frame_support::traits::EqualPrivilegeOnly;
ddorgan's avatar
ddorgan committed
198
199
200
}

parameter_types! {
201
	pub const EpochDuration: u64 = EPOCH_DURATION_IN_SLOTS as u64;
ddorgan's avatar
ddorgan committed
202
	pub const ExpectedBlockTime: Moment = MILLISECS_PER_BLOCK;
203
204
	pub const ReportLongevity: u64 =
		BondingDuration::get() as u64 * SessionsPerEra::get() as u64 * EpochDuration::get();
ddorgan's avatar
ddorgan committed
205
206
}

207
impl pallet_babe::Config for Runtime {
ddorgan's avatar
ddorgan committed
208
209
210
211
	type EpochDuration = EpochDuration;
	type ExpectedBlockTime = ExpectedBlockTime;

	// session module is the trigger
212
	type EpochChangeTrigger = pallet_babe::ExternalTrigger;
213

214
215
	type DisabledValidators = Session;

216
217
218
219
	type KeyOwnerProofSystem = Historical;

	type KeyOwnerProof = <Self::KeyOwnerProofSystem as KeyOwnerProofSystem<(
		KeyTypeId,
220
		pallet_babe::AuthorityId,
221
222
223
224
	)>>::Proof;

	type KeyOwnerIdentification = <Self::KeyOwnerProofSystem as KeyOwnerProofSystem<(
		KeyTypeId,
225
		pallet_babe::AuthorityId,
226
227
228
	)>>::IdentificationTuple;

	type HandleEquivocation =
229
		pallet_babe::EquivocationHandler<Self::KeyOwnerIdentification, Offences, ReportLongevity>;
230
231

	type WeightInfo = ();
232
233

	type MaxAuthorities = MaxAuthorities;
ddorgan's avatar
ddorgan committed
234
235
236
}

parameter_types! {
237
	pub const IndexDeposit: Balance = 100 * CENTS;
ddorgan's avatar
ddorgan committed
238
239
}

240
impl pallet_indices::Config for Runtime {
ddorgan's avatar
ddorgan committed
241
242
243
244
	type AccountIndex = AccountIndex;
	type Currency = Balances;
	type Deposit = IndexDeposit;
	type Event = Event;
245
	type WeightInfo = weights::pallet_indices::WeightInfo<Runtime>;
ddorgan's avatar
ddorgan committed
246
247
248
249
}

parameter_types! {
	pub const ExistentialDeposit: Balance = 1 * CENTS;
250
	pub const MaxLocks: u32 = 50;
Gavin Wood's avatar
Gavin Wood committed
251
	pub const MaxReserves: u32 = 50;
ddorgan's avatar
ddorgan committed
252
253
}

254
impl pallet_balances::Config for Runtime {
ddorgan's avatar
ddorgan committed
255
256
257
258
259
	type Balance = Balance;
	type DustRemoval = ();
	type Event = Event;
	type ExistentialDeposit = ExistentialDeposit;
	type AccountStore = System;
260
	type MaxLocks = MaxLocks;
Gavin Wood's avatar
Gavin Wood committed
261
262
	type MaxReserves = MaxReserves;
	type ReserveIdentifier = [u8; 8];
263
	type WeightInfo = weights::pallet_balances::WeightInfo<Runtime>;
ddorgan's avatar
ddorgan committed
264
265
266
267
}

parameter_types! {
	pub const TransactionByteFee: Balance = 10 * MILLICENTS;
268
269
270
	/// This value increases the priority of `Operational` transactions by adding
	/// a "virtual tip" that's equal to the `OperationalFeeMultiplier * final_fee`.
	pub const OperationalFeeMultiplier: u8 = 5;
ddorgan's avatar
ddorgan committed
271
272
}

273
impl pallet_transaction_payment::Config for Runtime {
Albrecht's avatar
Albrecht committed
274
	type OnChargeTransaction = CurrencyAdapter<Balances, ToAuthor<Runtime>>;
ddorgan's avatar
ddorgan committed
275
	type TransactionByteFee = TransactionByteFee;
276
	type OperationalFeeMultiplier = OperationalFeeMultiplier;
ddorgan's avatar
ddorgan committed
277
	type WeightToFee = WeightToFee;
278
	type FeeMultiplierUpdate = SlowAdjustingFeeUpdate<Self>;
ddorgan's avatar
ddorgan committed
279
280
281
282
283
}

parameter_types! {
	pub const MinimumPeriod: u64 = SLOT_DURATION / 2;
}
284
impl pallet_timestamp::Config for Runtime {
ddorgan's avatar
ddorgan committed
285
286
287
	type Moment = u64;
	type OnTimestampSet = Babe;
	type MinimumPeriod = MinimumPeriod;
288
	type WeightInfo = weights::pallet_timestamp::WeightInfo<Runtime>;
ddorgan's avatar
ddorgan committed
289
290
291
292
293
294
}

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

295
impl pallet_authorship::Config for Runtime {
296
	type FindAuthor = pallet_session::FindAccountFromAuthorIndex<Self, Babe>;
ddorgan's avatar
ddorgan committed
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
	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,
312
		pub para_validator: Initializer,
313
		pub para_assignment: ParaSessionInfo,
ddorgan's avatar
ddorgan committed
314
315
316
317
		pub authority_discovery: AuthorityDiscovery,
	}
}

318
impl pallet_session::Config for Runtime {
ddorgan's avatar
ddorgan committed
319
320
	type Event = Event;
	type ValidatorId = AccountId;
321
	type ValidatorIdOf = pallet_staking::StashOf<Self>;
ddorgan's avatar
ddorgan committed
322
323
	type ShouldEndSession = Babe;
	type NextSessionRotation = Babe;
324
	type SessionManager = pallet_session::historical::NoteHistoricalRoot<Self, Staking>;
ddorgan's avatar
ddorgan committed
325
326
	type SessionHandler = <SessionKeys as OpaqueKeys>::KeyTypeIdProviders;
	type Keys = SessionKeys;
327
	type WeightInfo = weights::pallet_session::WeightInfo<Runtime>;
ddorgan's avatar
ddorgan committed
328
329
}

330
impl pallet_session::historical::Config for Runtime {
331
332
	type FullIdentification = pallet_staking::Exposure<AccountId, Balance>;
	type FullIdentificationOf = pallet_staking::ExposureOf<Runtime>;
ddorgan's avatar
ddorgan committed
333
334
}

335
parameter_types! {
336
337
	// phase durations. 1/4 of the last session for each.
	pub const SignedPhase: u32 = EPOCH_DURATION_IN_SLOTS / 4;
338
	pub const UnsignedPhase: u32 = EPOCH_DURATION_IN_SLOTS / 4;
339

340
341
	// signed config
	pub const SignedMaxSubmissions: u32 = 128;
342
343
	pub const SignedDepositBase: Balance = deposit(2, 0);
	pub const SignedDepositByte: Balance = deposit(0, 10) / 1024;
344
345
	// Each good submission will get 1 WND as reward
	pub SignedRewardBase: Balance = 1 * UNITS;
346
	pub SolutionImprovementThreshold: Perbill = Perbill::from_rational(5u32, 10_000);
347

348
349
	// 1 hour session, 15 minutes unsigned phase, 4 offchain executions.
	pub OffchainRepeat: BlockNumber = UnsignedPhase::get() / 4;
350
351
352
353
354

	/// Whilst `UseNominatorsAndUpdateBagsList` or `UseNominatorsMap` is in use, this can still be a
	/// very large value. Once the `BagsList` is in full motion, staking might open its door to many
	/// more nominators, and this value should instead be what is a "safe" number (e.g. 22500).
	pub const VoterSnapshotPerBlock: u32 = 22_500;
355
356
}

357
358
sp_npos_elections::generate_solution_type!(
	#[compact]
359
360
361
362
363
	pub struct NposCompactSolution16::<
		VoterIndex = u32,
		TargetIndex = u16,
		Accuracy = sp_runtime::PerU16,
	>(16)
364
365
);

366
367
368
impl pallet_election_provider_multi_phase::Config for Runtime {
	type Event = Event;
	type Currency = Balances;
369
	type EstimateCallFee = TransactionPayment;
370
371
	type SignedPhase = SignedPhase;
	type UnsignedPhase = UnsignedPhase;
372
373
374
375
376
377
378
379
	type SignedMaxSubmissions = SignedMaxSubmissions;
	type SignedRewardBase = SignedRewardBase;
	type SignedDepositBase = SignedDepositBase;
	type SignedDepositByte = SignedDepositByte;
	type SignedDepositWeight = ();
	type SignedMaxWeight = Self::MinerMaxWeight;
	type SlashHandler = (); // burn slashes
	type RewardHandler = (); // nothing to do upon rewards
380
	type SolutionImprovementThreshold = SolutionImprovementThreshold;
381
	type MinerMaxWeight = OffchainSolutionWeightLimit; // For now use the one from staking.
382
	type MinerMaxLength = OffchainSolutionLengthLimit;
383
	type OffchainRepeat = OffchainRepeat;
384
	type MinerTxPriority = NposSolutionPriority;
385
	type DataProvider = Staking;
386
	type Solution = NposCompactSolution16;
Kian Paimani's avatar
Kian Paimani committed
387
	type Fallback = pallet_election_provider_multi_phase::NoFallback<Self>;
388
389
	type Solver = frame_election_provider_support::SequentialPhragmen<
		AccountId,
Kian Paimani's avatar
Kian Paimani committed
390
		pallet_election_provider_multi_phase::SolutionAccuracyOf<Self>,
391
392
		runtime_common::elections::OffchainRandomBalancing,
	>;
393
	type BenchmarkingConfig = runtime_common::elections::BenchmarkConfig;
394
	type ForceOrigin = EnsureRoot<AccountId>;
Kian Paimani's avatar
Kian Paimani committed
395
	type WeightInfo = weights::pallet_election_provider_multi_phase::WeightInfo<Self>;
396
397
398
399
	type VoterSnapshotPerBlock = VoterSnapshotPerBlock;
}

parameter_types! {
400
	pub const BagThresholds: &'static [u64] = &bag_thresholds::THRESHOLDS;
401
402
403
404
405
406
407
}

impl pallet_bags_list::Config for Runtime {
	type Event = Event;
	type VoteWeightProvider = Staking;
	type WeightInfo = weights::pallet_bags_list::WeightInfo<Runtime>;
	type BagThresholds = BagThresholds;
408
409
}

ddorgan's avatar
ddorgan committed
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
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).
425
	pub const BondingDuration: pallet_staking::EraIndex = 28;
426
	// 27 eras in which slashes can be cancelled (slightly less than 7 days).
427
	pub const SlashDeferDuration: pallet_staking::EraIndex = 27;
ddorgan's avatar
ddorgan committed
428
429
	pub const RewardCurve: &'static PiecewiseLinear<'static> = &REWARD_CURVE;
	pub const MaxNominatorRewardedPerValidator: u32 = 64;
430
	pub const OffendingValidatorsThreshold: Perbill = Perbill::from_percent(17);
ddorgan's avatar
ddorgan committed
431
432
}

Kian Paimani's avatar
Kian Paimani committed
433
434
435
436
437
impl frame_election_provider_support::onchain::Config for Runtime {
	type Accuracy = runtime_common::elections::OnOnChainAccuracy;
	type DataProvider = Staking;
}

438
impl pallet_staking::Config for Runtime {
439
	const MAX_NOMINATIONS: u32 =
440
		<NposCompactSolution16 as sp_npos_elections::NposSolution>::LIMIT as u32;
ddorgan's avatar
ddorgan committed
441
442
	type Currency = Balances;
	type UnixTime = Timestamp;
443
	type CurrencyToVote = CurrencyToVote;
ddorgan's avatar
ddorgan committed
444
445
446
447
448
449
450
451
	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.
452
	type SlashCancelOrigin = EnsureRoot<AccountId>;
ddorgan's avatar
ddorgan committed
453
	type SessionInterface = Self;
Kian Paimani's avatar
Kian Paimani committed
454
	type EraPayout = pallet_staking::ConvertCurve<RewardCurve>;
ddorgan's avatar
ddorgan committed
455
	type MaxNominatorRewardedPerValidator = MaxNominatorRewardedPerValidator;
456
	type OffendingValidatorsThreshold = OffendingValidatorsThreshold;
ddorgan's avatar
ddorgan committed
457
	type NextNewSession = Session;
458
	type ElectionProvider = ElectionProviderMultiPhase;
Kian Paimani's avatar
Kian Paimani committed
459
	type GenesisElectionProvider = runtime_common::elections::GenesisElectionOf<Self>;
460
	// Use the nominators map to iter voters, but also keep bags-list up-to-date.
461
	type SortedListProvider = BagsList;
462
	type WeightInfo = weights::pallet_staking::WeightInfo<Runtime>;
ddorgan's avatar
ddorgan committed
463
464
465
466
467
468
}

parameter_types! {
	pub const LaunchPeriod: BlockNumber = 7 * DAYS;
	pub const VotingPeriod: BlockNumber = 7 * DAYS;
	pub const FastTrackVotingPeriod: BlockNumber = 3 * HOURS;
469
	pub const MinimumDeposit: Balance = 100 * CENTS;
ddorgan's avatar
ddorgan committed
470
471
472
473
474
	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;
475
	pub const MaxAuthorities: u32 = 100_000;
ddorgan's avatar
ddorgan committed
476
477
}

478
impl pallet_offences::Config for Runtime {
ddorgan's avatar
ddorgan committed
479
	type Event = Event;
480
	type IdentificationTuple = pallet_session::historical::IdentificationTuple<Self>;
ddorgan's avatar
ddorgan committed
481
482
483
	type OnOffenceHandler = Staking;
}

484
485
486
impl pallet_authority_discovery::Config for Runtime {
	type MaxAuthorities = MaxAuthorities;
}
ddorgan's avatar
ddorgan committed
487
488

parameter_types! {
489
	pub const NposSolutionPriority: TransactionPriority = TransactionPriority::max_value() / 2;
ddorgan's avatar
ddorgan committed
490
	pub const ImOnlineUnsignedPriority: TransactionPriority = TransactionPriority::max_value();
491
492
493
	pub const MaxKeys: u32 = 10_000;
	pub const MaxPeerInHeartbeats: u32 = 10_000;
	pub const MaxPeerDataEncodingSize: u32 = 1_000;
ddorgan's avatar
ddorgan committed
494
495
}

496
impl pallet_im_online::Config for Runtime {
ddorgan's avatar
ddorgan committed
497
498
	type AuthorityId = ImOnlineId;
	type Event = Event;
499
	type ValidatorSet = Historical;
500
	type NextSessionRotation = Babe;
ddorgan's avatar
ddorgan committed
501
	type ReportUnresponsiveness = Offences;
502
	type UnsignedPriority = ImOnlineUnsignedPriority;
503
	type WeightInfo = weights::pallet_im_online::WeightInfo<Runtime>;
504
505
506
	type MaxKeys = MaxKeys;
	type MaxPeerInHeartbeats = MaxPeerInHeartbeats;
	type MaxPeerDataEncodingSize = MaxPeerDataEncodingSize;
ddorgan's avatar
ddorgan committed
507
508
}

509
impl pallet_grandpa::Config for Runtime {
ddorgan's avatar
ddorgan committed
510
	type Event = Event;
511
512
513
514
515
516
517
518
519
520
521
522
	type Call = Call;

	type KeyOwnerProofSystem = Historical;

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

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

523
524
525
526
527
	type HandleEquivocation = pallet_grandpa::EquivocationHandler<
		Self::KeyOwnerIdentification,
		Offences,
		ReportLongevity,
	>;
528
529

	type WeightInfo = ();
530
	type MaxAuthorities = MaxAuthorities;
ddorgan's avatar
ddorgan committed
531
532
}

533
534
/// Submits a transaction with the node's public and signature type. Adheres to the signed extension
/// format of the chain.
535
536
impl<LocalCall> frame_system::offchain::CreateSignedTransaction<LocalCall> for Runtime
where
537
538
	Call: From<LocalCall>,
{
539
	fn create_transaction<C: frame_system::offchain::AppCrypto<Self::Public, Self::Signature>>(
540
541
542
		call: Call,
		public: <Signature as Verify>::Signer,
		account: AccountId,
543
		nonce: <Runtime as frame_system::Config>::Index,
544
	) -> Option<(Call, <UncheckedExtrinsic as ExtrinsicT>::SignaturePayload)> {
545
		use sp_runtime::traits::StaticLookup;
546
		// take the biggest period possible.
547
548
		let period =
			BlockHashCount::get().checked_next_power_of_two().map(|c| c / 2).unwrap_or(2) as u64;
549
550
551

		let current_block = System::block_number()
			.saturated_into::<u64>()
552
553
			// The `System::block_number` is initialized with `n+1`,
			// so the actual block number is `n`.
554
555
556
			.saturating_sub(1);
		let tip = 0;
		let extra: SignedExtra = (
557
558
559
			frame_system::CheckSpecVersion::<Runtime>::new(),
			frame_system::CheckTxVersion::<Runtime>::new(),
			frame_system::CheckGenesis::<Runtime>::new(),
560
561
562
563
			frame_system::CheckMortality::<Runtime>::from(generic::Era::mortal(
				period,
				current_block,
			)),
564
565
566
			frame_system::CheckNonce::<Runtime>::from(nonce),
			frame_system::CheckWeight::<Runtime>::new(),
			pallet_transaction_payment::ChargeTransactionPayment::<Runtime>::from(tip),
567
		);
568
569
570
571
572
573
		let raw_payload = SignedPayload::new(call, extra)
			.map_err(|e| {
				log::warn!("Unable to create signed payload: {:?}", e);
			})
			.ok()?;
		let signature = raw_payload.using_encoded(|payload| C::sign(payload, public))?;
574
		let (call, extra, _) = raw_payload.deconstruct();
575
576
		let address = <Runtime as frame_system::Config>::Lookup::unlookup(account);
		Some((call, (address, signature, extra)))
577
	}
ddorgan's avatar
ddorgan committed
578
579
}

580
impl frame_system::offchain::SigningTypes for Runtime {
581
582
583
584
	type Public = <Signature as Verify>::Signer;
	type Signature = Signature;
}

585
586
impl<C> frame_system::offchain::SendTransactionTypes<C> for Runtime
where
587
588
589
590
591
592
	Call: From<C>,
{
	type OverarchingCall = Call;
	type Extrinsic = UncheckedExtrinsic;
}

ddorgan's avatar
ddorgan committed
593
594
parameter_types! {
	// Minimum 100 bytes/KSM deposited (1 CENT/byte)
595
	pub const BasicDeposit: Balance = 1000 * CENTS;       // 258 bytes on-chain
ddorgan's avatar
ddorgan committed
596
	pub const FieldDeposit: Balance = 250 * CENTS;        // 66 bytes on-chain
597
	pub const SubAccountDeposit: Balance = 200 * CENTS;   // 53 bytes on-chain
ddorgan's avatar
ddorgan committed
598
599
	pub const MaxSubAccounts: u32 = 100;
	pub const MaxAdditionalFields: u32 = 100;
600
	pub const MaxRegistrars: u32 = 20;
ddorgan's avatar
ddorgan committed
601
602
}

603
impl pallet_identity::Config for Runtime {
ddorgan's avatar
ddorgan committed
604
605
606
607
608
609
610
611
	type Event = Event;
	type Currency = Balances;
	type Slashed = ();
	type BasicDeposit = BasicDeposit;
	type FieldDeposit = FieldDeposit;
	type SubAccountDeposit = SubAccountDeposit;
	type MaxSubAccounts = MaxSubAccounts;
	type MaxAdditionalFields = MaxAdditionalFields;
612
	type MaxRegistrars = MaxRegistrars;
613
614
	type RegistrarOrigin = frame_system::EnsureRoot<AccountId>;
	type ForceOrigin = frame_system::EnsureRoot<AccountId>;
615
	type WeightInfo = weights::pallet_identity::WeightInfo<Runtime>;
ddorgan's avatar
ddorgan committed
616
617
}

618
impl pallet_utility::Config for Runtime {
619
620
	type Event = Event;
	type Call = Call;
Xiliang Chen's avatar
Xiliang Chen committed
621
	type PalletsOrigin = OriginCaller;
622
	type WeightInfo = weights::pallet_utility::WeightInfo<Runtime>;
623
624
}

ddorgan's avatar
ddorgan committed
625
parameter_types! {
626
627
	// 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
628
	// Additional storage item size of 32 bytes.
629
	pub const DepositFactor: Balance = deposit(0, 32);
ddorgan's avatar
ddorgan committed
630
631
632
	pub const MaxSignatories: u16 = 100;
}

633
impl pallet_multisig::Config for Runtime {
ddorgan's avatar
ddorgan committed
634
635
636
	type Event = Event;
	type Call = Call;
	type Currency = Balances;
637
638
	type DepositBase = DepositBase;
	type DepositFactor = DepositFactor;
ddorgan's avatar
ddorgan committed
639
	type MaxSignatories = MaxSignatories;
640
	type WeightInfo = weights::pallet_multisig::WeightInfo<Runtime>;
ddorgan's avatar
ddorgan committed
641
642
643
}

parameter_types! {
644
	pub const ConfigDepositBase: Balance = 500 * CENTS;
ddorgan's avatar
ddorgan committed
645
646
	pub const FriendDepositFactor: Balance = 50 * CENTS;
	pub const MaxFriends: u16 = 9;
647
	pub const RecoveryDeposit: Balance = 500 * CENTS;
ddorgan's avatar
ddorgan committed
648
649
}

650
impl pallet_recovery::Config for Runtime {
ddorgan's avatar
ddorgan committed
651
652
653
654
655
656
657
658
659
660
	type Event = Event;
	type Call = Call;
	type Currency = Balances;
	type ConfigDepositBase = ConfigDepositBase;
	type FriendDepositFactor = FriendDepositFactor;
	type MaxFriends = MaxFriends;
	type RecoveryDeposit = RecoveryDeposit;
}

parameter_types! {
661
	pub const MinVestedTransfer: Balance = 100 * CENTS;
ddorgan's avatar
ddorgan committed
662
663
}

664
impl pallet_vesting::Config for Runtime {
ddorgan's avatar
ddorgan committed
665
666
667
668
	type Event = Event;
	type Currency = Balances;
	type BlockNumberToBalance = ConvertInto;
	type MinVestedTransfer = MinVestedTransfer;
669
	type WeightInfo = weights::pallet_vesting::WeightInfo<Runtime>;
670
	const MAX_VESTING_SCHEDULES: u32 = 28;
ddorgan's avatar
ddorgan committed
671
672
}

673
impl pallet_sudo::Config for Runtime {
ddorgan's avatar
ddorgan committed
674
675
676
677
	type Event = Event;
	type Call = Call;
}

678
679
680
681
682
683
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;
684
685
686
	pub const AnnouncementDepositBase: Balance = deposit(1, 8);
	pub const AnnouncementDepositFactor: Balance = deposit(0, 66);
	pub const MaxPending: u16 = 32;
687
688
689
}

/// The type used to represent the kinds of proxying allowed.
690
#[derive(
691
692
693
694
695
696
697
698
699
700
701
	Copy,
	Clone,
	Eq,
	PartialEq,
	Ord,
	PartialOrd,
	Encode,
	Decode,
	RuntimeDebug,
	MaxEncodedLen,
	scale_info::TypeInfo,
702
)]
703
704
705
706
pub enum ProxyType {
	Any,
	NonTransfer,
	Staking,
707
	SudoBalances,
Chevdor's avatar
Chevdor committed
708
	IdentityJudgement,
Shawn Tabrizi's avatar
Shawn Tabrizi committed
709
	CancelProxy,
710
	Auction,
711
}
712
713
714
715
716
impl Default for ProxyType {
	fn default() -> Self {
		Self::Any
	}
}
717
718
719
720
impl InstanceFilter<Call> for ProxyType {
	fn filter(&self, c: &Call) -> bool {
		match self {
			ProxyType::Any => true,
721
722
			ProxyType::NonTransfer => matches!(
				c,
723
724
725
				Call::System(..) |
				Call::Babe(..) |
				Call::Timestamp(..) |
726
727
728
				Call::Indices(pallet_indices::Call::claim{..}) |
				Call::Indices(pallet_indices::Call::free{..}) |
				Call::Indices(pallet_indices::Call::freeze{..}) |
729
730
731
732
733
734
735
736
737
				// Specifically omitting Indices `transfer`, `force_transfer`
				// Specifically omitting the entire Balances pallet
				Call::Authorship(..) |
				Call::Staking(..) |
				Call::Session(..) |
				Call::Grandpa(..) |
				Call::ImOnline(..) |
				Call::Utility(..) |
				Call::Identity(..) |
738
739
740
741
742
743
				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{..}) |
744
				// Specifically omitting Recovery `create_recovery`, `initiate_recovery`
745
746
				Call::Vesting(pallet_vesting::Call::vest{..}) |
				Call::Vesting(pallet_vesting::Call::vest_other{..}) |
747
748
749
750
				// Specifically omitting Vesting `vested_transfer`, and `force_vested_transfer`
				Call::Scheduler(..) |
				// Specifically omitting Sudo pallet
				Call::Proxy(..) |
751
				Call::Multisig(..) |
752
753
				Call::Registrar(paras_registrar::Call::register{..}) |
				Call::Registrar(paras_registrar::Call::deregister{..}) |
754
				// Specifically omitting Registrar `swap`
755
				Call::Registrar(paras_registrar::Call::reserve{..}) |
756
757
				Call::Crowdloan(..) |
				Call::Slots(..) |
758
759
				Call::Auctions(..) | // Specifically omitting the entire XCM Pallet
				Call::BagsList(..)
760
			),
761
762
763
			ProxyType::Staking => {
				matches!(c, Call::Staking(..) | Call::Session(..) | Call::Utility(..))
			},
764
			ProxyType::SudoBalances => match c {
765
				Call::Sudo(pallet_sudo::Call::sudo { call: ref x }) => {
766
767
					matches!(x.as_ref(), &Call::Balances(..))
				},
Gavin Wood's avatar
Gavin Wood committed
768
				Call::Utility(..) => true,
769
770
				_ => false,
			},
771
772
			ProxyType::IdentityJudgement => matches!(
				c,
773
				Call::Identity(pallet_identity::Call::provide_judgement { .. }) | Call::Utility(..)
Shawn Tabrizi's avatar
Shawn Tabrizi committed
774
			),
775
			ProxyType::CancelProxy => {
776
				matches!(c, Call::Proxy(pallet_proxy::Call::reject_announcement { .. }))
777
			},
778
779
780
781
			ProxyType::Auction => matches!(
				c,
				Call::Auctions(..) | Call::Crowdloan(..) | Call::Registrar(..) | Call::Slots(..)
			),
782
783
784
785
786
787
788
789
790
		}
	}
	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,
791
792
793
794
		}
	}
}

795
impl pallet_proxy::Config for Runtime {
796
797
798
799
800
801
802
	type Event = Event;
	type Call = Call;
	type Currency = Balances;
	type ProxyType = ProxyType;
	type ProxyDepositBase = ProxyDepositBase;
	type ProxyDepositFactor = ProxyDepositFactor;
	type MaxProxies = MaxProxies;
803
	type WeightInfo = weights::pallet_proxy::WeightInfo<Runtime>;
804
805
806
807
	type MaxPending = MaxPending;
	type CallHasher = BlakeTwo256;
	type AnnouncementDepositBase = AnnouncementDepositBase;
	type AnnouncementDepositFactor = AnnouncementDepositFactor;
808
809
}

810
811
impl parachains_origin::Config for Runtime {}

812
impl parachains_configuration::Config for Runtime {
813
	type WeightInfo = weights::runtime_parachains_configuration::WeightInfo<Runtime>;
814
}
815
816
817
818
819
820
821

impl parachains_shared::Config for Runtime {}

impl parachains_session_info::Config for Runtime {}

impl parachains_inclusion::Config for Runtime {
	type Event = Event;
asynchronous rob's avatar
asynchronous rob committed
822
	type DisputesHandler = ();
823
824
825
826
827
828
	type RewardValidators = parachains_reward_points::RewardValidatorsWithEraPoints<Runtime>;
}

impl parachains_paras::Config for Runtime {
	type Origin = Origin;
	type Event = Event;
829
	type WeightInfo = weights::runtime_parachains_paras::WeightInfo<Runtime>;
830
831
832
833
834
835
836
}

parameter_types! {
	pub const FirstMessageFactorPercent: u64 = 100;
}

impl parachains_ump::Config for Runtime {
837
838
	type Event = Event;
	type UmpSink = crate::parachains_ump::XcmSink<XcmExecutor<XcmConfig>, Runtime>;
839
	type FirstMessageFactorPercent = FirstMessageFactorPercent;
840
	type ExecuteOverweightOrigin = EnsureRoot<AccountId>;
841
842
843
844
845
846
847
848
849
850
}

impl parachains_dmp::Config for Runtime {}

impl parachains_hrmp::Config for Runtime {
	type Event = Event;
	type Origin = Origin;
	type Currency = Balances;
}

851
852
853
impl parachains_paras_inherent::Config for Runtime {
	type WeightInfo = weights::runtime_parachains_paras_inherent::WeightInfo<Runtime>;
}
854
855
856
857
858
859

impl parachains_scheduler::Config for Runtime {}

impl parachains_initializer::Config for Runtime {
	type Randomness = pallet_babe::RandomnessFromOneEpochAgo<Runtime>;
	type ForceOrigin = EnsureRoot<AccountId>;
860
	type WeightInfo = weights::runtime_parachains_initializer::WeightInfo<Runtime>;
861
862
863
864
865
866
867
868
869
870
871
872
873
}

impl paras_sudo_wrapper::Config for Runtime {}

parameter_types! {
	pub const ParaDeposit: Balance = 2000 * CENTS;
	pub const DataDepositPerByte: Balance = deposit(0, 1);
}

impl paras_registrar::Config for Runtime {
	type Event = Event;
	type Origin = Origin;
	type Currency = Balances;
874
	type OnSwap = (Crowdloan, Slots);
875
876
877
878
879
880
881
882
883
884
885
886
887
888
	type ParaDeposit = ParaDeposit;
	type DataDepositPerByte = DataDepositPerByte;
	type WeightInfo = weights::runtime_common_paras_registrar::WeightInfo<Runtime>;
}

parameter_types! {
	pub const LeasePeriod: BlockNumber = 28 * DAYS;
}

impl slots::Config for Runtime {
	type Event = Event;
	type Currency = Balances;
	type Registrar = Registrar;
	type LeasePeriod = LeasePeriod;
889
	type LeaseOffset = ();
890
891
892
	type WeightInfo = weights::runtime_common_slots::WeightInfo<Runtime>;
}

893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
parameter_types! {
	pub const CrowdloanId: PalletId = PalletId(*b"py/cfund");
	pub const SubmissionDeposit: Balance = 100 * 100 * CENTS;
	pub const MinContribution: Balance = 100 * CENTS;
	pub const RemoveKeysLimit: u32 = 500;
	// Allow 32 bytes for an additional memo to a crowdloan.
	pub const MaxMemoLength: u8 = 32;
}

impl crowdloan::Config for Runtime {
	type Event = Event;
	type PalletId = CrowdloanId;
	type SubmissionDeposit = SubmissionDeposit;
	type MinContribution = MinContribution;
	type RemoveKeysLimit = RemoveKeysLimit;
	type Registrar = Registrar;
	type Auctioneer = Auctions;
	type MaxMemoLength = MaxMemoLength;
	type WeightInfo = weights::runtime_common_crowdloan::WeightInfo<Runtime>;
}

parameter_types! {
	// The average auction is 7 days long, so this will be 70% for ending period.
	// 5 Days = 72000 Blocks @ 6 sec per block
	pub const EndingPeriod: BlockNumber = 5 * DAYS;
	// ~ 1000 samples per day -> ~ 20 blocks per sample -> 2 minute samples
	pub const SampleLength: BlockNumber = 2 * MINUTES;
}

impl auctions::Config for Runtime {
	type Event = Event;
	type Leaser = Slots;
	type Registrar = Registrar;
	type EndingPeriod = EndingPeriod;
	type SampleLength = SampleLength;
	type Randomness = pallet_babe::RandomnessFromOneEpochAgo<Runtime>;
	type InitiateOrigin = EnsureRoot<AccountId>;
	type WeightInfo = weights::runtime_common_auctions::WeightInfo<Runtime>;
}

933
parameter_types! {
934
935
	pub const WndLocation: MultiLocation = Here.into();
	pub const Ancestry: MultiLocation = Here.into();
936
	pub WestendNetwork: NetworkId = NetworkId::Named(b"Westend".to_vec());
937
	pub CheckAccount: AccountId = XcmPallet::check_account();
938
939
}

940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
pub type LocationConverter =
	(ChildParachainConvertsVia<ParaId, AccountId>, AccountId32Aliases<WestendNetwork, AccountId>);

pub type LocalAssetTransactor = XcmCurrencyAdapter<
	// Use this currency:
	Balances,
	// Use this currency when it is a fungible asset matching the given location or name:
	IsConcrete<WndLocation>,
	// We can convert the MultiLocations with our converter above:
	LocationConverter,
	// Our chain's account ID type (we can't get away without mentioning it explicitly):
	AccountId,
	// It's a native asset so we keep track of the teleports to maintain total issuance.
	CheckAccount,
>;
955
956
957
958
959
960
961
962
963
964
965
966

type LocalOriginConverter = (
	SovereignSignedViaLocation<LocationConverter, Origin>,
	ChildParachainAsNative<parachains_origin::Origin, Origin>,
	SignedAccountId32AsNative<WestendNetwork, Origin>,
	ChildSystemParachainAsSuperuser<ParaId, Origin>,
);

/// The XCM router. When we want to send an XCM message, we use this type. It amalgamates all of our
/// individual routers.
pub type XcmRouter = (
	// Only one router so far - use DMP to communicate with child parachains.
967
	xcm_sender::ChildParachainRouter<Runtime, XcmPallet>,
968
969
);

970
parameter_types! {
971
	pub const Westmint: MultiLocation = Parachain(1000).into();
Gavin Wood's avatar
Gavin Wood committed
972
	pub const WestendForWestmint: (MultiAssetFilter, MultiLocation) =
973
		(Wild(AllOf { fun: WildFungible, id: Concrete(WndLocation::get()) }), Westmint::get());
974
	pub const MaxInstructions: u32 = 100;
975
}
976
pub type TrustedTeleporters = (xcm_builder::Case<WestendForWestmint>,);
977

978
979
980
981
982
/// The barriers one of which must be passed for an XCM message to be executed.
pub type Barrier = (
	// Weight that is paid for may be consumed.
	TakeWeightCredit,
	// If the message is one that immediately attemps to pay for execution, then allow it.
983
	AllowTopLevelPaidExecutionFrom<Everything>,
984
985
	// Messages coming from system parachains need not pay for execution.
	AllowUnpaidExecutionFrom<IsChildSystemParachain<ParaId>>,
986
987
988
989
	// Expected responses are OK.
	AllowKnownQueryResponses<XcmPallet>,
	// Subscriptions for version tracking are OK.
	AllowSubscriptionsFrom<Everything>,
990
991
992
993
994
995
996
997
998
);

pub struct XcmConfig;
impl xcm_executor::Config for XcmConfig {
	type Call = Call;
	type XcmSender = XcmRouter;
	type AssetTransactor = LocalAssetTransactor;
	type OriginConverter = LocalOriginConverter;
	type IsReserve = ();
999
	type IsTeleporter = TrustedTeleporters;
1000
	type LocationInverter = LocationInverter<Ancestry>;
1001
	type Barrier = Barrier;
1002
	type Weigher = WeightInfoBounds<weights::xcm::WestendXcmWeight<Call>, Call, MaxInstructions>;
1003
	type Trader = UsingComponents<WeightToFee, WndLocation, AccountId, Balances, ToAuthor<Runtime>>;
1004
1005
1006
	type ResponseHandler = XcmPallet;
	type AssetTrap = XcmPallet;
	type AssetClaims = XcmPallet;