1
// Copyright (C) Moondance Labs Ltd.
2
// This file is part of Tanssi.
3

            
4
// Tanssi is free software: you can redistribute it and/or modify
5
// it under the terms of the GNU General Public License as published by
6
// the Free Software Foundation, either version 3 of the License, or
7
// (at your option) any later version.
8

            
9
// Tanssi is distributed in the hope that it will be useful,
10
// but WITHOUT ANY WARRANTY; without even the implied warranty of
11
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
// GNU General Public License for more details.
13

            
14
// You should have received a copy of the GNU General Public License
15
// along with Tanssi.  If not, see <http://www.gnu.org/licenses/>
16

            
17
//! The Starlight runtime for v1 parachains.
18

            
19
#![cfg_attr(not(feature = "std"), no_std)]
20
// `construct_runtime!` does a lot of recursion and requires us to increase the limit.
21
#![recursion_limit = "512"]
22

            
23
use {
24
    authority_discovery_primitives::AuthorityId as AuthorityDiscoveryId,
25
    beefy_primitives::{
26
        ecdsa_crypto::{AuthorityId as BeefyId, Signature as BeefySignature},
27
        mmr::{BeefyDataProvider, MmrLeafVersion},
28
    },
29
    frame_support::{
30
        dispatch::DispatchResult,
31
        dynamic_params::{dynamic_pallet_params, dynamic_params},
32
        traits::FromContains,
33
    },
34
    frame_system::EnsureNever,
35
    pallet_initializer as tanssi_initializer,
36
    pallet_nis::WithMaximumOf,
37
    pallet_registrar_runtime_api::ContainerChainGenesisData,
38
    pallet_session::ShouldEndSession,
39
    parity_scale_codec::{Decode, Encode, MaxEncodedLen},
40
    primitives::{
41
        slashing, AccountIndex, ApprovalVotingParams, BlockNumber, CandidateEvent, CandidateHash,
42
        CommittedCandidateReceipt, CoreIndex, CoreState, DisputeState, ExecutorParams,
43
        GroupRotationInfo, Hash, Id as ParaId, InboundDownwardMessage, InboundHrmpMessage, Moment,
44
        NodeFeatures, Nonce, OccupiedCoreAssumption, PersistedValidationData, ScrapedOnChainVotes,
45
        SessionInfo, Signature, ValidationCode, ValidationCodeHash, ValidatorId, ValidatorIndex,
46
        PARACHAIN_KEY_TYPE_ID,
47
    },
48
    runtime_common::{
49
        assigned_slots, auctions, claims, crowdloan, identity_migrator, impl_runtime_weights,
50
        impls::{
51
            ContainsParts, LocatableAssetConverter, ToAuthor, VersionedLocatableAsset,
52
            VersionedLocationConverter,
53
        },
54
        paras_registrar, paras_sudo_wrapper, prod_or_fast, slots,
55
        traits::{Leaser, OnSwap},
56
        BlockHashCount, BlockLength, SlowAdjustingFeeUpdate,
57
    },
58
    runtime_parachains::{
59
        assigner_coretime as parachains_assigner_coretime,
60
        assigner_on_demand as parachains_assigner_on_demand,
61
        configuration as parachains_configuration, coretime,
62
        disputes::{self as parachains_disputes, slashing as parachains_slashing},
63
        dmp as parachains_dmp, hrmp as parachains_hrmp,
64
        inclusion::{self as parachains_inclusion, AggregateMessageOrigin, UmpQueueId},
65
        initializer as parachains_initializer, origin as parachains_origin,
66
        paras as parachains_paras, paras_inherent as parachains_paras_inherent,
67
        runtime_api_impl::{
68
            v10 as parachains_runtime_api_impl, vstaging as vstaging_parachains_runtime_api_impl,
69
        },
70
        scheduler as parachains_scheduler, session_info as parachains_session_info,
71
        shared as parachains_shared,
72
    },
73
    scale_info::TypeInfo,
74
    sp_genesis_builder::PresetId,
75
    sp_std::{
76
        cmp::Ordering,
77
        collections::{btree_map::BTreeMap, vec_deque::VecDeque},
78
        prelude::*,
79
    },
80
    starlight_runtime_constants::system_parachain::BROKER_ID,
81
    tp_traits::{GetSessionContainerChains, Slot, SlotFrequency},
82
};
83

            
84
#[cfg(any(feature = "std", test))]
85
use sp_version::NativeVersion;
86
use {
87
    frame_support::{
88
        construct_runtime, derive_impl,
89
        genesis_builder_helper::{build_state, get_preset},
90
        parameter_types,
91
        traits::{
92
            fungible::HoldConsideration, tokens::UnityOrOuterConversion, Contains, EitherOf,
93
            EitherOfDiverse, EnsureOrigin, EnsureOriginWithArg, EverythingBut, InstanceFilter,
94
            KeyOwnerProofSystem, LinearStoragePrice, PrivilegeCmp, ProcessMessage,
95
            ProcessMessageError, StorageMapShim, WithdrawReasons,
96
        },
97
        weights::{ConstantMultiplier, WeightMeter, WeightToFee as _},
98
        PalletId,
99
    },
100
    frame_system::{EnsureRoot, EnsureSigned},
101
    pallet_grandpa::{fg_primitives, AuthorityId as GrandpaId},
102
    pallet_identity::legacy::IdentityInfo,
103
    pallet_session::historical as session_historical,
104
    pallet_transaction_payment::{FeeDetails, FungibleAdapter, RuntimeDispatchInfo},
105
    sp_core::{ConstU128, ConstU8, OpaqueMetadata, H256},
106
    sp_runtime::{
107
        create_runtime_str, generic, impl_opaque_keys,
108
        traits::{
109
            BlakeTwo256, Block as BlockT, ConstU32, ConvertInto, Extrinsic as ExtrinsicT,
110
            IdentityLookup, Keccak256, OpaqueKeys, SaturatedConversion, Verify,
111
        },
112
        transaction_validity::{TransactionPriority, TransactionSource, TransactionValidity},
113
        ApplyExtrinsicResult, FixedU128, KeyTypeId, Perbill, Percent, Permill, RuntimeDebug,
114
    },
115
    sp_staking::SessionIndex,
116
    sp_version::RuntimeVersion,
117
    xcm::{
118
        latest::prelude::*, IntoVersion, VersionedAssetId, VersionedAssets, VersionedLocation,
119
        VersionedXcm,
120
    },
121
    xcm_builder::PayOverXcm,
122
};
123

            
124
pub use {
125
    frame_system::Call as SystemCall,
126
    pallet_balances::Call as BalancesCall,
127
    primitives::{AccountId, Balance},
128
};
129

            
130
/// Constant values used within the runtime.
131
use starlight_runtime_constants::{currency::*, fee::*, time::*};
132

            
133
// XCM configurations.
134
pub mod xcm_config;
135

            
136
// Implemented types.
137
mod impls;
138
use impls::ToParachainIdentityReaper;
139

            
140
// Governance and configurations.
141
pub mod governance;
142
use {
143
    governance::{
144
        pallet_custom_origins, AuctionAdmin, Fellows, GeneralAdmin, LeaseAdmin, Treasurer,
145
        TreasurySpender,
146
    },
147
    xcm_fee_payment_runtime_api::Error as XcmPaymentApiError,
148
};
149

            
150
#[cfg(test)]
151
mod tests;
152

            
153
pub mod genesis_config_presets;
154
mod validator_manager;
155

            
156
impl_runtime_weights!(starlight_runtime_constants);
157

            
158
// Make the WASM binary available.
159
#[cfg(feature = "std")]
160
include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));
161

            
162
/// Provides the `WASM_BINARY` build with `fast-runtime` feature enabled.
163
///
164
/// This is for example useful for local test chains.
165
#[cfg(feature = "std")]
166
pub mod fast_runtime_binary {
167
    include!(concat!(env!("OUT_DIR"), "/fast_runtime_binary.rs"));
168
}
169

            
170
/// Runtime version (Starlight).
171
#[sp_version::runtime_version]
172
pub const VERSION: RuntimeVersion = RuntimeVersion {
173
    spec_name: create_runtime_str!("starlight"),
174
    impl_name: create_runtime_str!("tanssi-starlight-v2.0"),
175
    authoring_version: 0,
176
    spec_version: 1_011_000,
177
    impl_version: 0,
178
    apis: RUNTIME_API_VERSIONS,
179
    transaction_version: 25,
180
    state_version: 1,
181
};
182

            
183
/// The BABE epoch configuration at genesis.
184
pub const BABE_GENESIS_EPOCH_CONFIG: babe_primitives::BabeEpochConfiguration =
185
    babe_primitives::BabeEpochConfiguration {
186
        c: PRIMARY_PROBABILITY,
187
        allowed_slots: babe_primitives::AllowedSlots::PrimaryAndSecondaryVRFSlots,
188
    };
189

            
190
/// Native version.
191
#[cfg(any(feature = "std", test))]
192
pub fn native_version() -> NativeVersion {
193
    NativeVersion {
194
        runtime_version: VERSION,
195
        can_author_with: Default::default(),
196
    }
197
}
198

            
199
/// A type to identify calls to the Identity pallet. These will be filtered to prevent invocation,
200
/// locking the state of the pallet and preventing further updates to identities and sub-identities.
201
/// The locked state will be the genesis state of a new system chain and then removed from the Relay
202
/// Chain.
203
pub struct IsIdentityCall;
204
impl Contains<RuntimeCall> for IsIdentityCall {
205
    fn contains(c: &RuntimeCall) -> bool {
206
        matches!(c, RuntimeCall::Identity(_))
207
    }
208
}
209

            
210
parameter_types! {
211
    pub const Version: RuntimeVersion = VERSION;
212
    pub const SS58Prefix: u8 = 42;
213
}
214

            
215
#[derive_impl(frame_system::config_preludes::RelayChainDefaultConfig)]
216
impl frame_system::Config for Runtime {
217
    type BaseCallFilter = EverythingBut<IsIdentityCall>;
218
    type BlockWeights = BlockWeights;
219
    type BlockLength = BlockLength;
220
    type DbWeight = RocksDbWeight;
221
    type Nonce = Nonce;
222
    type Hash = Hash;
223
    type AccountId = AccountId;
224
    type Block = Block;
225
    type BlockHashCount = BlockHashCount;
226
    type Version = Version;
227
    type AccountData = pallet_balances::AccountData<Balance>;
228
    type SystemWeightInfo = ();
229
    type SS58Prefix = SS58Prefix;
230
    type MaxConsumers = frame_support::traits::ConstU32<16>;
231
}
232

            
233
parameter_types! {
234
    pub MaximumSchedulerWeight: Weight = Perbill::from_percent(80) *
235
        BlockWeights::get().max_block;
236
    pub const MaxScheduledPerBlock: u32 = 50;
237
    pub const NoPreimagePostponement: Option<u32> = Some(10);
238
}
239

            
240
/// Used the compare the privilege of an origin inside the scheduler.
241
pub struct OriginPrivilegeCmp;
242

            
243
impl PrivilegeCmp<OriginCaller> for OriginPrivilegeCmp {
244
    fn cmp_privilege(left: &OriginCaller, right: &OriginCaller) -> Option<Ordering> {
245
        if left == right {
246
            return Some(Ordering::Equal);
247
        }
248

            
249
        match (left, right) {
250
            // Root is greater than anything.
251
            (OriginCaller::system(frame_system::RawOrigin::Root), _) => Some(Ordering::Greater),
252
            // For every other origin we don't care, as they are not used for `ScheduleOrigin`.
253
            _ => None,
254
        }
255
    }
256
}
257

            
258
/// Dynamic params that can be adjusted at runtime.
259
#[dynamic_params(RuntimeParameters, pallet_parameters::Parameters::<Runtime>)]
260
pub mod dynamic_params {
261
    use super::*;
262

            
263
    #[dynamic_pallet_params]
264
    #[codec(index = 0)]
265
    pub mod nis {
266
        use super::*;
267

            
268
        #[codec(index = 0)]
269
        pub static Target: Perquintill = Perquintill::zero();
270

            
271
        #[codec(index = 1)]
272
        pub static MinBid: Balance = 100 * UNITS;
273
    }
274

            
275
    #[dynamic_pallet_params]
276
    #[codec(index = 1)]
277
    pub mod preimage {
278
        use super::*;
279

            
280
        #[codec(index = 0)]
281
        pub static BaseDeposit: Balance = deposit(2, 64);
282

            
283
        #[codec(index = 1)]
284
        pub static ByteDeposit: Balance = deposit(0, 1);
285
    }
286
}
287

            
288
#[cfg(feature = "runtime-benchmarks")]
289
impl Default for RuntimeParameters {
290
    fn default() -> Self {
291
        RuntimeParameters::Preimage(dynamic_params::preimage::Parameters::BaseDeposit(
292
            dynamic_params::preimage::BaseDeposit,
293
            Some(1u32.into()),
294
        ))
295
    }
296
}
297

            
298
/// Defines what origin can modify which dynamic parameters.
299
pub struct DynamicParameterOrigin;
300
impl EnsureOriginWithArg<RuntimeOrigin, RuntimeParametersKey> for DynamicParameterOrigin {
301
    type Success = ();
302

            
303
    fn try_origin(
304
        origin: RuntimeOrigin,
305
        key: &RuntimeParametersKey,
306
    ) -> Result<Self::Success, RuntimeOrigin> {
307
        use crate::{dynamic_params::*, governance::*, RuntimeParametersKey::*};
308

            
309
        match key {
310
            Nis(nis::ParametersKey::MinBid(_)) => StakingAdmin::ensure_origin(origin.clone()),
311
            Nis(nis::ParametersKey::Target(_)) => GeneralAdmin::ensure_origin(origin.clone()),
312
            Preimage(_) => frame_system::ensure_root(origin.clone()),
313
        }
314
        .map_err(|_| origin)
315
    }
316

            
317
    #[cfg(feature = "runtime-benchmarks")]
318
    fn try_successful_origin(_key: &RuntimeParametersKey) -> Result<RuntimeOrigin, ()> {
319
        // Provide the origin for the parameter returned by `Default`:
320
        Ok(RuntimeOrigin::root())
321
    }
322
}
323

            
324
impl pallet_scheduler::Config for Runtime {
325
    type RuntimeOrigin = RuntimeOrigin;
326
    type RuntimeEvent = RuntimeEvent;
327
    type PalletsOrigin = OriginCaller;
328
    type RuntimeCall = RuntimeCall;
329
    type MaximumWeight = MaximumSchedulerWeight;
330
    // The goal of having ScheduleOrigin include AuctionAdmin is to allow the auctions track of
331
    // OpenGov to schedule periodic auctions.
332
    type ScheduleOrigin = EitherOf<EnsureRoot<AccountId>, AuctionAdmin>;
333
    type MaxScheduledPerBlock = MaxScheduledPerBlock;
334
    type WeightInfo = ();
335
    type OriginPrivilegeCmp = OriginPrivilegeCmp;
336
    type Preimages = Preimage;
337
}
338

            
339
parameter_types! {
340
    pub const PreimageHoldReason: RuntimeHoldReason = RuntimeHoldReason::Preimage(pallet_preimage::HoldReason::Preimage);
341
}
342

            
343
impl pallet_preimage::Config for Runtime {
344
    type WeightInfo = ();
345
    type RuntimeEvent = RuntimeEvent;
346
    type Currency = Balances;
347
    type ManagerOrigin = EnsureRoot<AccountId>;
348
    type Consideration = HoldConsideration<
349
        AccountId,
350
        Balances,
351
        PreimageHoldReason,
352
        LinearStoragePrice<
353
            dynamic_params::preimage::BaseDeposit,
354
            dynamic_params::preimage::ByteDeposit,
355
            Balance,
356
        >,
357
    >;
358
}
359

            
360
parameter_types! {
361
    pub const ExpectedBlockTime: Moment = MILLISECS_PER_BLOCK;
362
    pub ReportLongevity: u64 = u64::from(EpochDurationInBlocks::get()) * 10;
363
}
364

            
365
impl pallet_babe::Config for Runtime {
366
    type EpochDuration = EpochDurationInBlocks;
367
    type ExpectedBlockTime = ExpectedBlockTime;
368
    // session module is the trigger
369
    type EpochChangeTrigger = pallet_babe::ExternalTrigger;
370
    type DisabledValidators = Session;
371
    type WeightInfo = ();
372
    type MaxAuthorities = MaxAuthorities;
373
    type MaxNominators = ConstU32<0>;
374
    type KeyOwnerProof = sp_session::MembershipProof;
375
    type EquivocationReportSystem =
376
        pallet_babe::EquivocationReportSystem<Self, Offences, Historical, ReportLongevity>;
377
}
378

            
379
parameter_types! {
380
    pub const IndexDeposit: Balance = 100 * CENTS;
381
}
382

            
383
impl pallet_indices::Config for Runtime {
384
    type AccountIndex = AccountIndex;
385
    type Currency = Balances;
386
    type Deposit = IndexDeposit;
387
    type RuntimeEvent = RuntimeEvent;
388
    type WeightInfo = ();
389
}
390

            
391
parameter_types! {
392
    pub const ExistentialDeposit: Balance = EXISTENTIAL_DEPOSIT;
393
    pub const MaxLocks: u32 = 50;
394
    pub const MaxReserves: u32 = 50;
395
}
396

            
397
impl pallet_balances::Config for Runtime {
398
    type Balance = Balance;
399
    type DustRemoval = ();
400
    type RuntimeEvent = RuntimeEvent;
401
    type ExistentialDeposit = ExistentialDeposit;
402
    type AccountStore = System;
403
    type MaxLocks = MaxLocks;
404
    type MaxReserves = MaxReserves;
405
    type ReserveIdentifier = [u8; 8];
406
    type WeightInfo = ();
407
    type FreezeIdentifier = ();
408
    type RuntimeHoldReason = RuntimeHoldReason;
409
    type RuntimeFreezeReason = RuntimeFreezeReason;
410
    type MaxFreezes = ConstU32<1>;
411
}
412

            
413
parameter_types! {
414
    pub const TransactionByteFee: Balance = 10 * MILLICENTS;
415
    /// This value increases the priority of `Operational` transactions by adding
416
    /// a "virtual tip" that's equal to the `OperationalFeeMultiplier * final_fee`.
417
    pub const OperationalFeeMultiplier: u8 = 5;
418
}
419

            
420
impl pallet_transaction_payment::Config for Runtime {
421
    type RuntimeEvent = RuntimeEvent;
422
    type OnChargeTransaction = FungibleAdapter<Balances, ToAuthor<Runtime>>;
423
    type OperationalFeeMultiplier = OperationalFeeMultiplier;
424
    type WeightToFee = WeightToFee;
425
    type LengthToFee = ConstantMultiplier<Balance, TransactionByteFee>;
426
    type FeeMultiplierUpdate = SlowAdjustingFeeUpdate<Self>;
427
}
428

            
429
parameter_types! {
430
    pub const MinimumPeriod: u64 = SLOT_DURATION / 2;
431
}
432
impl pallet_timestamp::Config for Runtime {
433
    type Moment = u64;
434
    type OnTimestampSet = Babe;
435
    type MinimumPeriod = MinimumPeriod;
436
    type WeightInfo = ();
437
}
438

            
439
impl pallet_authorship::Config for Runtime {
440
    type FindAuthor = pallet_session::FindAccountFromAuthorIndex<Self, Babe>;
441
    type EventHandler = ();
442
}
443

            
444
impl_opaque_keys! {
445
    pub struct SessionKeys {
446
        pub grandpa: Grandpa,
447
        pub babe: Babe,
448
        pub para_validator: TanssiInitializer,
449
        pub para_assignment: ParaSessionInfo,
450
        pub authority_discovery: AuthorityDiscovery,
451
        pub beefy: Beefy,
452
    }
453
}
454

            
455
/// Special `ValidatorIdOf` implementation that is just returning the input as result.
456
pub struct ValidatorIdOf;
457
impl sp_runtime::traits::Convert<AccountId, Option<AccountId>> for ValidatorIdOf {
458
    fn convert(a: AccountId) -> Option<AccountId> {
459
        Some(a)
460
    }
461
}
462

            
463
impl pallet_session::Config for Runtime {
464
    type RuntimeEvent = RuntimeEvent;
465
    type ValidatorId = AccountId;
466
    type ValidatorIdOf = ValidatorIdOf;
467
    type ShouldEndSession = Babe;
468
    type NextSessionRotation = Babe;
469
    type SessionManager = pallet_session::historical::NoteHistoricalRoot<Self, ValidatorManager>;
470
    type SessionHandler = <SessionKeys as OpaqueKeys>::KeyTypeIdProviders;
471
    type Keys = SessionKeys;
472
    type WeightInfo = ();
473
}
474

            
475
pub struct FullIdentificationOf;
476
impl sp_runtime::traits::Convert<AccountId, Option<()>> for FullIdentificationOf {
477
140
    fn convert(_: AccountId) -> Option<()> {
478
140
        Some(())
479
140
    }
480
}
481

            
482
impl pallet_session::historical::Config for Runtime {
483
    type FullIdentification = ();
484
    type FullIdentificationOf = FullIdentificationOf;
485
}
486

            
487
parameter_types! {
488
    pub const SessionsPerEra: SessionIndex = 6;
489
    pub const BondingDuration: sp_staking::EraIndex = 28;
490
}
491

            
492
parameter_types! {
493
    pub const ProposalBond: Permill = Permill::from_percent(5);
494
    pub const ProposalBondMinimum: Balance = 2000 * CENTS;
495
    pub const ProposalBondMaximum: Balance = 1 * GRAND;
496
    pub const SpendPeriod: BlockNumber = 6 * DAYS;
497
    pub const Burn: Permill = Permill::from_perthousand(2);
498
    pub const TreasuryPalletId: PalletId = PalletId(*b"py/trsry");
499
    pub const PayoutSpendPeriod: BlockNumber = 30 * DAYS;
500
    // The asset's interior location for the paying account. This is the Treasury
501
    // pallet instance (which sits at index 18).
502
    pub TreasuryInteriorLocation: InteriorLocation = PalletInstance(18).into();
503

            
504
    pub const TipCountdown: BlockNumber = 1 * DAYS;
505
    pub const TipFindersFee: Percent = Percent::from_percent(20);
506
    pub const TipReportDepositBase: Balance = 100 * CENTS;
507
    pub const DataDepositPerByte: Balance = 1 * CENTS;
508
    pub const MaxApprovals: u32 = 100;
509
    pub const MaxAuthorities: u32 = 100_000;
510
    pub const MaxKeys: u32 = 10_000;
511
    pub const MaxPeerInHeartbeats: u32 = 10_000;
512
    pub const MaxBalance: Balance = Balance::max_value();
513
}
514

            
515
impl pallet_treasury::Config for Runtime {
516
    type PalletId = TreasuryPalletId;
517
    type Currency = Balances;
518
    type ApproveOrigin = EitherOfDiverse<EnsureRoot<AccountId>, Treasurer>;
519
    type RejectOrigin = EitherOfDiverse<EnsureRoot<AccountId>, Treasurer>;
520
    type RuntimeEvent = RuntimeEvent;
521
    type OnSlash = Treasury;
522
    type ProposalBond = ProposalBond;
523
    type ProposalBondMinimum = ProposalBondMinimum;
524
    type ProposalBondMaximum = ProposalBondMaximum;
525
    type SpendPeriod = SpendPeriod;
526
    type Burn = Burn;
527
    type BurnDestination = Society;
528
    type MaxApprovals = MaxApprovals;
529
    type WeightInfo = ();
530
    type SpendFunds = Bounties;
531
    type SpendOrigin = TreasurySpender;
532
    type AssetKind = VersionedLocatableAsset;
533
    type Beneficiary = VersionedLocation;
534
    type BeneficiaryLookup = IdentityLookup<Self::Beneficiary>;
535
    type Paymaster = PayOverXcm<
536
        TreasuryInteriorLocation,
537
        crate::xcm_config::XcmRouter,
538
        crate::XcmPallet,
539
        ConstU32<{ 6 * HOURS }>,
540
        Self::Beneficiary,
541
        Self::AssetKind,
542
        LocatableAssetConverter,
543
        VersionedLocationConverter,
544
    >;
545
    type BalanceConverter = UnityOrOuterConversion<
546
        ContainsParts<
547
            FromContains<
548
                xcm_builder::IsChildSystemParachain<ParaId>,
549
                xcm_builder::IsParentsOnly<ConstU8<1>>,
550
            >,
551
        >,
552
        AssetRate,
553
    >;
554
    type PayoutPeriod = PayoutSpendPeriod;
555
    #[cfg(feature = "runtime-benchmarks")]
556
    type BenchmarkHelper = runtime_common::impls::benchmarks::TreasuryArguments;
557
}
558

            
559
parameter_types! {
560
    pub const BountyDepositBase: Balance = 100 * CENTS;
561
    pub const BountyDepositPayoutDelay: BlockNumber = 4 * DAYS;
562
    pub const BountyUpdatePeriod: BlockNumber = 90 * DAYS;
563
    pub const MaximumReasonLength: u32 = 16384;
564
    pub const CuratorDepositMultiplier: Permill = Permill::from_percent(50);
565
    pub const CuratorDepositMin: Balance = 10 * CENTS;
566
    pub const CuratorDepositMax: Balance = 500 * CENTS;
567
    pub const BountyValueMinimum: Balance = 200 * CENTS;
568
}
569

            
570
impl pallet_bounties::Config for Runtime {
571
    type BountyDepositBase = BountyDepositBase;
572
    type BountyDepositPayoutDelay = BountyDepositPayoutDelay;
573
    type BountyUpdatePeriod = BountyUpdatePeriod;
574
    type CuratorDepositMultiplier = CuratorDepositMultiplier;
575
    type CuratorDepositMin = CuratorDepositMin;
576
    type CuratorDepositMax = CuratorDepositMax;
577
    type BountyValueMinimum = BountyValueMinimum;
578
    type ChildBountyManager = ChildBounties;
579
    type DataDepositPerByte = DataDepositPerByte;
580
    type RuntimeEvent = RuntimeEvent;
581
    type MaximumReasonLength = MaximumReasonLength;
582
    type WeightInfo = ();
583
}
584

            
585
parameter_types! {
586
    pub const MaxActiveChildBountyCount: u32 = 100;
587
    pub ChildBountyValueMinimum: Balance = BountyValueMinimum::get() / 10;
588
}
589

            
590
impl pallet_child_bounties::Config for Runtime {
591
    type RuntimeEvent = RuntimeEvent;
592
    type MaxActiveChildBountyCount = MaxActiveChildBountyCount;
593
    type ChildBountyValueMinimum = ChildBountyValueMinimum;
594
    type WeightInfo = ();
595
}
596

            
597
impl pallet_offences::Config for Runtime {
598
    type RuntimeEvent = RuntimeEvent;
599
    type IdentificationTuple = pallet_session::historical::IdentificationTuple<Self>;
600
    type OnOffenceHandler = ();
601
}
602

            
603
impl pallet_authority_discovery::Config for Runtime {
604
    type MaxAuthorities = MaxAuthorities;
605
}
606

            
607
parameter_types! {
608
    pub const MaxSetIdSessionEntries: u32 = BondingDuration::get() * SessionsPerEra::get();
609
}
610

            
611
impl pallet_grandpa::Config for Runtime {
612
    type RuntimeEvent = RuntimeEvent;
613
    type WeightInfo = ();
614
    type MaxAuthorities = MaxAuthorities;
615
    type MaxNominators = ConstU32<0>;
616
    type MaxSetIdSessionEntries = MaxSetIdSessionEntries;
617
    type KeyOwnerProof = sp_session::MembershipProof;
618
    type EquivocationReportSystem =
619
        pallet_grandpa::EquivocationReportSystem<Self, Offences, Historical, ReportLongevity>;
620
}
621

            
622
/// Submits a transaction with the node's public and signature type. Adheres to the signed extension
623
/// format of the chain.
624
impl<LocalCall> frame_system::offchain::CreateSignedTransaction<LocalCall> for Runtime
625
where
626
    RuntimeCall: From<LocalCall>,
627
{
628
    fn create_transaction<C: frame_system::offchain::AppCrypto<Self::Public, Self::Signature>>(
629
        call: RuntimeCall,
630
        public: <Signature as Verify>::Signer,
631
        account: AccountId,
632
        nonce: <Runtime as frame_system::Config>::Nonce,
633
    ) -> Option<(
634
        RuntimeCall,
635
        <UncheckedExtrinsic as ExtrinsicT>::SignaturePayload,
636
    )> {
637
        use sp_runtime::traits::StaticLookup;
638
        // take the biggest period possible.
639
        let period = BlockHashCount::get()
640
            .checked_next_power_of_two()
641
            .map(|c| c / 2)
642
            .unwrap_or(2) as u64;
643

            
644
        let current_block = System::block_number()
645
            .saturated_into::<u64>()
646
            // The `System::block_number` is initialized with `n+1`,
647
            // so the actual block number is `n`.
648
            .saturating_sub(1);
649
        let tip = 0;
650
        let extra: SignedExtra = (
651
            frame_system::CheckNonZeroSender::<Runtime>::new(),
652
            frame_system::CheckSpecVersion::<Runtime>::new(),
653
            frame_system::CheckTxVersion::<Runtime>::new(),
654
            frame_system::CheckGenesis::<Runtime>::new(),
655
            frame_system::CheckMortality::<Runtime>::from(generic::Era::mortal(
656
                period,
657
                current_block,
658
            )),
659
            frame_system::CheckNonce::<Runtime>::from(nonce),
660
            frame_system::CheckWeight::<Runtime>::new(),
661
            pallet_transaction_payment::ChargeTransactionPayment::<Runtime>::from(tip),
662
        );
663
        let raw_payload = SignedPayload::new(call, extra)
664
            .map_err(|e| {
665
                log::warn!("Unable to create signed payload: {:?}", e);
666
            })
667
            .ok()?;
668
        let signature = raw_payload.using_encoded(|payload| C::sign(payload, public))?;
669
        let (call, extra, _) = raw_payload.deconstruct();
670
        let address = <Runtime as frame_system::Config>::Lookup::unlookup(account);
671
        Some((call, (address, signature, extra)))
672
    }
673
}
674

            
675
impl frame_system::offchain::SigningTypes for Runtime {
676
    type Public = <Signature as Verify>::Signer;
677
    type Signature = Signature;
678
}
679

            
680
impl<C> frame_system::offchain::SendTransactionTypes<C> for Runtime
681
where
682
    RuntimeCall: From<C>,
683
{
684
    type Extrinsic = UncheckedExtrinsic;
685
    type OverarchingCall = RuntimeCall;
686
}
687

            
688
parameter_types! {
689
    pub Prefix: &'static [u8] = b"Pay ROCs to the Starlight account:";
690
}
691

            
692
impl claims::Config for Runtime {
693
    type RuntimeEvent = RuntimeEvent;
694
    type VestingSchedule = Vesting;
695
    type Prefix = Prefix;
696
    type MoveClaimOrigin = EnsureRoot<AccountId>;
697
    type WeightInfo = claims::TestWeightInfo;
698
}
699

            
700
parameter_types! {
701
    // Minimum 100 bytes/STAR deposited (1 CENT/byte)
702
    pub const BasicDeposit: Balance = 1000 * CENTS;       // 258 bytes on-chain
703
    pub const ByteDeposit: Balance = deposit(0, 1);
704
    pub const SubAccountDeposit: Balance = 200 * CENTS;   // 53 bytes on-chain
705
    pub const MaxSubAccounts: u32 = 100;
706
    pub const MaxAdditionalFields: u32 = 100;
707
    pub const MaxRegistrars: u32 = 20;
708
}
709

            
710
impl pallet_identity::Config for Runtime {
711
    type RuntimeEvent = RuntimeEvent;
712
    type Currency = Balances;
713
    type BasicDeposit = BasicDeposit;
714
    type ByteDeposit = ByteDeposit;
715
    type SubAccountDeposit = SubAccountDeposit;
716
    type MaxSubAccounts = MaxSubAccounts;
717
    type IdentityInformation = IdentityInfo<MaxAdditionalFields>;
718
    type MaxRegistrars = MaxRegistrars;
719
    type Slashed = Treasury;
720
    type ForceOrigin = EitherOf<EnsureRoot<Self::AccountId>, GeneralAdmin>;
721
    type RegistrarOrigin = EitherOf<EnsureRoot<Self::AccountId>, GeneralAdmin>;
722
    type OffchainSignature = Signature;
723
    type SigningPublicKey = <Signature as Verify>::Signer;
724
    type UsernameAuthorityOrigin = EnsureRoot<Self::AccountId>;
725
    type PendingUsernameExpiration = ConstU32<{ 7 * DAYS }>;
726
    type MaxSuffixLength = ConstU32<7>;
727
    type MaxUsernameLength = ConstU32<32>;
728
    type WeightInfo = ();
729
}
730

            
731
impl pallet_utility::Config for Runtime {
732
    type RuntimeEvent = RuntimeEvent;
733
    type RuntimeCall = RuntimeCall;
734
    type PalletsOrigin = OriginCaller;
735
    type WeightInfo = ();
736
}
737

            
738
parameter_types! {
739
    // One storage item; key size is 32; value is size 4+4+16+32 bytes = 56 bytes.
740
    pub const DepositBase: Balance = deposit(1, 88);
741
    // Additional storage item size of 32 bytes.
742
    pub const DepositFactor: Balance = deposit(0, 32);
743
    pub const MaxSignatories: u32 = 100;
744
}
745

            
746
impl pallet_multisig::Config for Runtime {
747
    type RuntimeEvent = RuntimeEvent;
748
    type RuntimeCall = RuntimeCall;
749
    type Currency = Balances;
750
    type DepositBase = DepositBase;
751
    type DepositFactor = DepositFactor;
752
    type MaxSignatories = MaxSignatories;
753
    type WeightInfo = ();
754
}
755

            
756
parameter_types! {
757
    pub const ConfigDepositBase: Balance = 500 * CENTS;
758
    pub const FriendDepositFactor: Balance = 50 * CENTS;
759
    pub const MaxFriends: u16 = 9;
760
    pub const RecoveryDeposit: Balance = 500 * CENTS;
761
}
762

            
763
impl pallet_recovery::Config for Runtime {
764
    type RuntimeEvent = RuntimeEvent;
765
    type WeightInfo = ();
766
    type RuntimeCall = RuntimeCall;
767
    type Currency = Balances;
768
    type ConfigDepositBase = ConfigDepositBase;
769
    type FriendDepositFactor = FriendDepositFactor;
770
    type MaxFriends = MaxFriends;
771
    type RecoveryDeposit = RecoveryDeposit;
772
}
773

            
774
parameter_types! {
775
    pub const SocietyPalletId: PalletId = PalletId(*b"py/socie");
776
}
777

            
778
impl pallet_society::Config for Runtime {
779
    type RuntimeEvent = RuntimeEvent;
780
    type Currency = Balances;
781
    type Randomness = pallet_babe::RandomnessFromOneEpochAgo<Runtime>;
782
    type GraceStrikes = ConstU32<1>;
783
    type PeriodSpend = ConstU128<{ 50_000 * CENTS }>;
784
    type VotingPeriod = ConstU32<{ 5 * DAYS }>;
785
    type ClaimPeriod = ConstU32<{ 2 * DAYS }>;
786
    type MaxLockDuration = ConstU32<{ 36 * 30 * DAYS }>;
787
    type FounderSetOrigin = EnsureRoot<AccountId>;
788
    type ChallengePeriod = ConstU32<{ 7 * DAYS }>;
789
    type MaxPayouts = ConstU32<8>;
790
    type MaxBids = ConstU32<512>;
791
    type PalletId = SocietyPalletId;
792
    type WeightInfo = ();
793
}
794

            
795
parameter_types! {
796
    pub const MinVestedTransfer: Balance = 100 * CENTS;
797
    pub UnvestedFundsAllowedWithdrawReasons: WithdrawReasons =
798
        WithdrawReasons::except(WithdrawReasons::TRANSFER | WithdrawReasons::RESERVE);
799
}
800

            
801
impl pallet_vesting::Config for Runtime {
802
    type RuntimeEvent = RuntimeEvent;
803
    type Currency = Balances;
804
    type BlockNumberToBalance = ConvertInto;
805
    type MinVestedTransfer = MinVestedTransfer;
806
    type WeightInfo = ();
807
    type UnvestedFundsAllowedWithdrawReasons = UnvestedFundsAllowedWithdrawReasons;
808
    type BlockNumberProvider = System;
809
    const MAX_VESTING_SCHEDULES: u32 = 28;
810
}
811

            
812
parameter_types! {
813
    // One storage item; key size 32, value size 8; .
814
    pub const ProxyDepositBase: Balance = deposit(1, 8);
815
    // Additional storage item size of 33 bytes.
816
    pub const ProxyDepositFactor: Balance = deposit(0, 33);
817
    pub const MaxProxies: u16 = 32;
818
    pub const AnnouncementDepositBase: Balance = deposit(1, 8);
819
    pub const AnnouncementDepositFactor: Balance = deposit(0, 66);
820
    pub const MaxPending: u16 = 32;
821
}
822

            
823
/// The type used to represent the kinds of proxying allowed.
824
#[derive(
825
    Copy,
826
    Clone,
827
    Eq,
828
    PartialEq,
829
    Ord,
830
    PartialOrd,
831
    Encode,
832
    Decode,
833
    RuntimeDebug,
834
    MaxEncodedLen,
835
    TypeInfo,
836
)]
837
pub enum ProxyType {
838
    Any,
839
    NonTransfer,
840
    Governance,
841
    IdentityJudgement,
842
    CancelProxy,
843
    Auction,
844
    Society,
845
    OnDemandOrdering,
846
}
847
impl Default for ProxyType {
848
    fn default() -> Self {
849
        Self::Any
850
    }
851
}
852
impl InstanceFilter<RuntimeCall> for ProxyType {
853
    fn filter(&self, c: &RuntimeCall) -> bool {
854
        match self {
855
            ProxyType::Any => true,
856
            ProxyType::NonTransfer => matches!(
857
                c,
858
                RuntimeCall::System(..) |
859
				RuntimeCall::Babe(..) |
860
				RuntimeCall::Timestamp(..) |
861
				RuntimeCall::Indices(pallet_indices::Call::claim {..}) |
862
				RuntimeCall::Indices(pallet_indices::Call::free {..}) |
863
				RuntimeCall::Indices(pallet_indices::Call::freeze {..}) |
864
				// Specifically omitting Indices `transfer`, `force_transfer`
865
				// Specifically omitting the entire Balances pallet
866
				RuntimeCall::Session(..) |
867
				RuntimeCall::Grandpa(..) |
868
				RuntimeCall::Treasury(..) |
869
				RuntimeCall::Bounties(..) |
870
				RuntimeCall::ChildBounties(..) |
871
				RuntimeCall::ConvictionVoting(..) |
872
				RuntimeCall::Referenda(..) |
873
				RuntimeCall::FellowshipCollective(..) |
874
				RuntimeCall::FellowshipReferenda(..) |
875
				RuntimeCall::Whitelist(..) |
876
				RuntimeCall::Claims(..) |
877
				RuntimeCall::Utility(..) |
878
				RuntimeCall::Identity(..) |
879
				RuntimeCall::Society(..) |
880
				RuntimeCall::Recovery(pallet_recovery::Call::as_recovered {..}) |
881
				RuntimeCall::Recovery(pallet_recovery::Call::vouch_recovery {..}) |
882
				RuntimeCall::Recovery(pallet_recovery::Call::claim_recovery {..}) |
883
				RuntimeCall::Recovery(pallet_recovery::Call::close_recovery {..}) |
884
				RuntimeCall::Recovery(pallet_recovery::Call::remove_recovery {..}) |
885
				RuntimeCall::Recovery(pallet_recovery::Call::cancel_recovered {..}) |
886
				// Specifically omitting Recovery `create_recovery`, `initiate_recovery`
887
				RuntimeCall::Vesting(pallet_vesting::Call::vest {..}) |
888
				RuntimeCall::Vesting(pallet_vesting::Call::vest_other {..}) |
889
				// Specifically omitting Vesting `vested_transfer`, and `force_vested_transfer`
890
				RuntimeCall::Scheduler(..) |
891
				RuntimeCall::Proxy(..) |
892
				RuntimeCall::Multisig(..) |
893
				RuntimeCall::Nis(..) |
894
				RuntimeCall::Registrar(paras_registrar::Call::register {..}) |
895
				RuntimeCall::Registrar(paras_registrar::Call::deregister {..}) |
896
				// Specifically omitting Registrar `swap`
897
				RuntimeCall::Registrar(paras_registrar::Call::reserve {..}) |
898
				RuntimeCall::Crowdloan(..) |
899
				RuntimeCall::Slots(..) |
900
				RuntimeCall::Auctions(..) // Specifically omitting the entire XCM Pallet
901
            ),
902
            ProxyType::Governance => matches!(
903
                c,
904
                RuntimeCall::Bounties(..) |
905
					RuntimeCall::Utility(..) |
906
					RuntimeCall::ChildBounties(..) |
907
					// OpenGov calls
908
					RuntimeCall::ConvictionVoting(..) |
909
					RuntimeCall::Referenda(..) |
910
					RuntimeCall::FellowshipCollective(..) |
911
					RuntimeCall::FellowshipReferenda(..) |
912
					RuntimeCall::Whitelist(..)
913
            ),
914
            ProxyType::IdentityJudgement => matches!(
915
                c,
916
                RuntimeCall::Identity(pallet_identity::Call::provide_judgement { .. })
917
                    | RuntimeCall::Utility(..)
918
            ),
919
            ProxyType::CancelProxy => {
920
                matches!(
921
                    c,
922
                    RuntimeCall::Proxy(pallet_proxy::Call::reject_announcement { .. })
923
                )
924
            }
925
            ProxyType::Auction => matches!(
926
                c,
927
                RuntimeCall::Auctions { .. }
928
                    | RuntimeCall::Crowdloan { .. }
929
                    | RuntimeCall::Registrar { .. }
930
                    | RuntimeCall::Multisig(..)
931
                    | RuntimeCall::Slots { .. }
932
            ),
933
            ProxyType::Society => matches!(c, RuntimeCall::Society(..)),
934
            ProxyType::OnDemandOrdering => matches!(c, RuntimeCall::OnDemandAssignmentProvider(..)),
935
        }
936
    }
937
    fn is_superset(&self, o: &Self) -> bool {
938
        match (self, o) {
939
            (x, y) if x == y => true,
940
            (ProxyType::Any, _) => true,
941
            (_, ProxyType::Any) => false,
942
            (ProxyType::NonTransfer, _) => true,
943
            _ => false,
944
        }
945
    }
946
}
947

            
948
impl pallet_proxy::Config for Runtime {
949
    type RuntimeEvent = RuntimeEvent;
950
    type RuntimeCall = RuntimeCall;
951
    type Currency = Balances;
952
    type ProxyType = ProxyType;
953
    type ProxyDepositBase = ProxyDepositBase;
954
    type ProxyDepositFactor = ProxyDepositFactor;
955
    type MaxProxies = MaxProxies;
956
    type WeightInfo = ();
957
    type MaxPending = MaxPending;
958
    type CallHasher = BlakeTwo256;
959
    type AnnouncementDepositBase = AnnouncementDepositBase;
960
    type AnnouncementDepositFactor = AnnouncementDepositFactor;
961
}
962

            
963
impl parachains_origin::Config for Runtime {}
964

            
965
impl parachains_configuration::Config for Runtime {
966
    type WeightInfo = parachains_configuration::TestWeightInfo;
967
}
968

            
969
impl parachains_shared::Config for Runtime {
970
    type DisabledValidators = Session;
971
}
972

            
973
impl parachains_session_info::Config for Runtime {
974
    type ValidatorSet = Historical;
975
}
976

            
977
/// Special `RewardValidators` that does nothing ;)
978
pub struct RewardValidators;
979
impl runtime_parachains::inclusion::RewardValidators for RewardValidators {
980
    fn reward_backing(_: impl IntoIterator<Item = ValidatorIndex>) {}
981
    fn reward_bitfields(_: impl IntoIterator<Item = ValidatorIndex>) {}
982
}
983

            
984
impl parachains_inclusion::Config for Runtime {
985
    type RuntimeEvent = RuntimeEvent;
986
    type DisputesHandler = ParasDisputes;
987
    type RewardValidators = RewardValidators;
988
    type MessageQueue = MessageQueue;
989
    type WeightInfo = ();
990
}
991

            
992
parameter_types! {
993
    pub const ParasUnsignedPriority: TransactionPriority = TransactionPriority::max_value();
994
}
995

            
996
impl parachains_paras::Config for Runtime {
997
    type RuntimeEvent = RuntimeEvent;
998
    type WeightInfo = parachains_paras::TestWeightInfo;
999
    type UnsignedPriority = ParasUnsignedPriority;
    type QueueFootprinter = ParaInclusion;
    type NextSessionRotation = Babe;
    type OnNewHead = Registrar;
    type AssignCoretime = CoretimeAssignmentProvider;
}
parameter_types! {
    /// Amount of weight that can be spent per block to service messages.
    ///
    /// # WARNING
    ///
    /// This is not a good value for para-chains since the `Scheduler` already uses up to 80% block weight.
    pub MessageQueueServiceWeight: Weight = Perbill::from_percent(20) * BlockWeights::get().max_block;
    pub const MessageQueueHeapSize: u32 = 32 * 1024;
    pub const MessageQueueMaxStale: u32 = 96;
}
/// Message processor to handle any messages that were enqueued into the `MessageQueue` pallet.
pub struct MessageProcessor;
impl ProcessMessage for MessageProcessor {
    type Origin = AggregateMessageOrigin;
    fn process_message(
        message: &[u8],
        origin: Self::Origin,
        meter: &mut WeightMeter,
        id: &mut [u8; 32],
    ) -> Result<bool, ProcessMessageError> {
        let para = match origin {
            AggregateMessageOrigin::Ump(UmpQueueId::Para(para)) => para,
        };
        xcm_builder::ProcessXcmMessage::<
            Junction,
            xcm_executor::XcmExecutor<xcm_config::XcmConfig>,
            RuntimeCall,
        >::process_message(message, Junction::Parachain(para.into()), meter, id)
    }
}
impl pallet_message_queue::Config for Runtime {
    type RuntimeEvent = RuntimeEvent;
    type Size = u32;
    type HeapSize = MessageQueueHeapSize;
    type MaxStale = MessageQueueMaxStale;
    type ServiceWeight = MessageQueueServiceWeight;
    type IdleMaxServiceWeight = MessageQueueServiceWeight;
    #[cfg(not(feature = "runtime-benchmarks"))]
    type MessageProcessor = MessageProcessor;
    #[cfg(feature = "runtime-benchmarks")]
    type MessageProcessor =
        pallet_message_queue::mock_helpers::NoopMessageProcessor<AggregateMessageOrigin>;
    type QueueChangeHandler = ParaInclusion;
    type QueuePausedQuery = ();
    type WeightInfo = ();
}
impl parachains_dmp::Config for Runtime {}
parameter_types! {
    pub const DefaultChannelSizeAndCapacityWithSystem: (u32, u32) = (51200, 500);
}
impl parachains_hrmp::Config for Runtime {
    type RuntimeOrigin = RuntimeOrigin;
    type RuntimeEvent = RuntimeEvent;
    type ChannelManager = EnsureRoot<AccountId>;
    type Currency = Balances;
    type DefaultChannelSizeAndCapacityWithSystem = DefaultChannelSizeAndCapacityWithSystem;
    type WeightInfo = parachains_hrmp::TestWeightInfo;
}
impl parachains_paras_inherent::Config for Runtime {
    type WeightInfo = parachains_paras_inherent::TestWeightInfo;
}
impl parachains_scheduler::Config for Runtime {
    // If you change this, make sure the `Assignment` type of the new provider is binary compatible,
    // otherwise provide a migration.
    type AssignmentProvider = CoretimeAssignmentProvider;
}
parameter_types! {
    pub const BrokerId: u32 = BROKER_ID;
    pub MaxXcmTransactWeight: Weight = Weight::from_parts(200_000_000, 20_000);
}
impl coretime::Config for Runtime {
    type RuntimeOrigin = RuntimeOrigin;
    type RuntimeEvent = RuntimeEvent;
    type Currency = Balances;
    type BrokerId = BrokerId;
    type WeightInfo = coretime::TestWeightInfo;
    type SendXcm = crate::xcm_config::XcmRouter;
    type MaxXcmTransactWeight = MaxXcmTransactWeight;
}
parameter_types! {
    pub const OnDemandTrafficDefaultValue: FixedU128 = FixedU128::from_u32(1);
}
impl parachains_assigner_on_demand::Config for Runtime {
    type RuntimeEvent = RuntimeEvent;
    type Currency = Balances;
    type TrafficDefaultValue = OnDemandTrafficDefaultValue;
    type WeightInfo = parachains_assigner_on_demand::TestWeightInfo;
}
impl parachains_assigner_coretime::Config for Runtime {}
impl parachains_initializer::Config for Runtime {
    type Randomness = pallet_babe::RandomnessFromOneEpochAgo<Runtime>;
    type ForceOrigin = EnsureRoot<AccountId>;
    type WeightInfo = ();
    type CoretimeOnNewSession = Coretime;
}
impl parachains_disputes::Config for Runtime {
    type RuntimeEvent = RuntimeEvent;
    type RewardValidators = ();
    type SlashingHandler = parachains_slashing::SlashValidatorsForDisputes<ParasSlashing>;
    type WeightInfo = parachains_disputes::TestWeightInfo;
}
impl parachains_slashing::Config for Runtime {
    type KeyOwnerProofSystem = Historical;
    type KeyOwnerProof =
        <Self::KeyOwnerProofSystem as KeyOwnerProofSystem<(KeyTypeId, ValidatorId)>>::Proof;
    type KeyOwnerIdentification = <Self::KeyOwnerProofSystem as KeyOwnerProofSystem<(
        KeyTypeId,
        ValidatorId,
    )>>::IdentificationTuple;
    type HandleReports = parachains_slashing::SlashingReportHandler<
        Self::KeyOwnerIdentification,
        Offences,
        ReportLongevity,
    >;
    type WeightInfo = parachains_slashing::TestWeightInfo;
    type BenchmarkingConfig = parachains_slashing::BenchConfig<200>;
}
parameter_types! {
    pub const ParaDeposit: Balance = 40 * UNITS;
}
impl paras_registrar::Config for Runtime {
    type RuntimeOrigin = RuntimeOrigin;
    type RuntimeEvent = RuntimeEvent;
    type Currency = Balances;
    type OnSwap = (Crowdloan, Slots, SwapLeases);
    type ParaDeposit = ParaDeposit;
    type DataDepositPerByte = DataDepositPerByte;
    type WeightInfo = paras_registrar::TestWeightInfo;
}
parameter_types! {
    pub LeasePeriod: BlockNumber = prod_or_fast!(1 * DAYS, 1 * DAYS, "ROC_LEASE_PERIOD");
}
impl slots::Config for Runtime {
    type RuntimeEvent = RuntimeEvent;
    type Currency = Balances;
    type Registrar = Registrar;
    type LeasePeriod = LeasePeriod;
    type LeaseOffset = ();
    type ForceOrigin = EitherOf<EnsureRoot<Self::AccountId>, LeaseAdmin>;
    type WeightInfo = slots::TestWeightInfo;
}
parameter_types! {
    pub const CrowdloanId: PalletId = PalletId(*b"py/cfund");
    pub const SubmissionDeposit: Balance = 3 * GRAND;
    pub const MinContribution: Balance = 3_000 * CENTS;
    pub const RemoveKeysLimit: u32 = 1000;
    // Allow 32 bytes for an additional memo to a crowdloan.
    pub const MaxMemoLength: u8 = 32;
}
impl crowdloan::Config for Runtime {
    type RuntimeEvent = RuntimeEvent;
    type PalletId = CrowdloanId;
    type SubmissionDeposit = SubmissionDeposit;
    type MinContribution = MinContribution;
    type RemoveKeysLimit = RemoveKeysLimit;
    type Registrar = Registrar;
    type Auctioneer = Auctions;
    type MaxMemoLength = MaxMemoLength;
    type WeightInfo = crowdloan::TestWeightInfo;
}
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 RuntimeEvent = RuntimeEvent;
    type Leaser = Slots;
    type Registrar = Registrar;
    type EndingPeriod = EndingPeriod;
    type SampleLength = SampleLength;
    type Randomness = pallet_babe::RandomnessFromOneEpochAgo<Runtime>;
    type InitiateOrigin = EitherOf<EnsureRoot<Self::AccountId>, AuctionAdmin>;
    type WeightInfo = auctions::TestWeightInfo;
}
impl identity_migrator::Config for Runtime {
    type RuntimeEvent = RuntimeEvent;
    type Reaper = EnsureSigned<AccountId>;
    type ReapIdentityHandler = ToParachainIdentityReaper<Runtime, Self::AccountId>;
    type WeightInfo = ();
}
type NisCounterpartInstance = pallet_balances::Instance2;
impl pallet_balances::Config<NisCounterpartInstance> for Runtime {
    type Balance = Balance;
    type DustRemoval = ();
    type RuntimeEvent = RuntimeEvent;
    type ExistentialDeposit = ConstU128<10_000_000_000>; // One RTC cent
    type AccountStore = StorageMapShim<
        pallet_balances::Account<Runtime, NisCounterpartInstance>,
        AccountId,
        pallet_balances::AccountData<u128>,
    >;
    type MaxLocks = ConstU32<4>;
    type MaxReserves = ConstU32<4>;
    type ReserveIdentifier = [u8; 8];
    type WeightInfo = ();
    type RuntimeHoldReason = RuntimeHoldReason;
    type RuntimeFreezeReason = RuntimeFreezeReason;
    type FreezeIdentifier = ();
    type MaxFreezes = ConstU32<1>;
}
parameter_types! {
    pub const NisBasePeriod: BlockNumber = 30 * DAYS;
    pub MinReceipt: Perquintill = Perquintill::from_rational(1u64, 10_000_000u64);
    pub const IntakePeriod: BlockNumber = 5 * MINUTES;
    pub MaxIntakeWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 10;
    pub const ThawThrottle: (Perquintill, BlockNumber) = (Perquintill::from_percent(25), 5);
    pub const NisPalletId: PalletId = PalletId(*b"py/nis  ");
}
impl pallet_nis::Config for Runtime {
    type WeightInfo = ();
    type RuntimeEvent = RuntimeEvent;
    type Currency = Balances;
    type CurrencyBalance = Balance;
    type FundOrigin = frame_system::EnsureSigned<AccountId>;
    type Counterpart = NisCounterpartBalances;
    type CounterpartAmount = WithMaximumOf<ConstU128<21_000_000_000_000_000_000u128>>;
    type Deficit = (); // Mint
    type IgnoredIssuance = ();
    type Target = dynamic_params::nis::Target;
    type PalletId = NisPalletId;
    type QueueCount = ConstU32<300>;
    type MaxQueueLen = ConstU32<1000>;
    type FifoQueueLen = ConstU32<250>;
    type BasePeriod = NisBasePeriod;
    type MinBid = dynamic_params::nis::MinBid;
    type MinReceipt = MinReceipt;
    type IntakePeriod = IntakePeriod;
    type MaxIntakeWeight = MaxIntakeWeight;
    type ThawThrottle = ThawThrottle;
    type RuntimeHoldReason = RuntimeHoldReason;
    #[cfg(feature = "runtime-benchmarks")]
    type BenchmarkSetup = ();
}
impl pallet_parameters::Config for Runtime {
    type RuntimeEvent = RuntimeEvent;
    type RuntimeParameters = RuntimeParameters;
    type AdminOrigin = DynamicParameterOrigin;
    type WeightInfo = ();
}
parameter_types! {
    pub BeefySetIdSessionEntries: u32 = BondingDuration::get() * SessionsPerEra::get();
}
impl pallet_beefy::Config for Runtime {
    type BeefyId = BeefyId;
    type MaxAuthorities = MaxAuthorities;
    type MaxNominators = ConstU32<0>;
    type MaxSetIdSessionEntries = BeefySetIdSessionEntries;
    type OnNewValidatorSet = MmrLeaf;
    type WeightInfo = ();
    type KeyOwnerProof = <Historical as KeyOwnerProofSystem<(KeyTypeId, BeefyId)>>::Proof;
    type EquivocationReportSystem =
        pallet_beefy::EquivocationReportSystem<Self, Offences, Historical, ReportLongevity>;
}
/// MMR helper types.
mod mmr {
    use super::Runtime;
    pub use pallet_mmr::primitives::*;
    pub type Leaf = <<Runtime as pallet_mmr::Config>::LeafData as LeafDataProvider>::LeafData;
    pub type Hashing = <Runtime as pallet_mmr::Config>::Hashing;
    pub type Hash = <Hashing as sp_runtime::traits::Hash>::Output;
}
impl pallet_mmr::Config for Runtime {
    const INDEXING_PREFIX: &'static [u8] = mmr::INDEXING_PREFIX;
    type Hashing = Keccak256;
    type OnNewRoot = pallet_beefy_mmr::DepositBeefyDigest<Runtime>;
    type WeightInfo = ();
    type LeafData = pallet_beefy_mmr::Pallet<Runtime>;
    type BlockHashProvider = pallet_mmr::DefaultBlockHashProvider<Runtime>;
}
parameter_types! {
    pub LeafVersion: MmrLeafVersion = MmrLeafVersion::new(0, 0);
}
pub struct ParaHeadsRootProvider;
impl BeefyDataProvider<H256> for ParaHeadsRootProvider {
    fn extra_data() -> H256 {
        let mut para_heads: Vec<(u32, Vec<u8>)> = parachains_paras::Parachains::<Runtime>::get()
            .into_iter()
            .filter_map(|id| {
                parachains_paras::Heads::<Runtime>::get(&id).map(|head| (id.into(), head.0))
            })
            .collect();
        para_heads.sort();
        binary_merkle_tree::merkle_root::<mmr::Hashing, _>(
            para_heads.into_iter().map(|pair| pair.encode()),
        )
    }
}
impl pallet_beefy_mmr::Config for Runtime {
    type LeafVersion = LeafVersion;
    type BeefyAuthorityToMerkleLeaf = pallet_beefy_mmr::BeefyEcdsaToEthereum;
    type LeafExtra = H256;
    type BeefyDataProvider = ParaHeadsRootProvider;
}
impl paras_sudo_wrapper::Config for Runtime {}
parameter_types! {
    pub const PermanentSlotLeasePeriodLength: u32 = 365;
    pub const TemporarySlotLeasePeriodLength: u32 = 5;
    pub const MaxTemporarySlotPerLeasePeriod: u32 = 5;
}
impl assigned_slots::Config for Runtime {
    type RuntimeEvent = RuntimeEvent;
    type AssignSlotOrigin = EnsureRoot<AccountId>;
    type Leaser = Slots;
    type PermanentSlotLeasePeriodLength = PermanentSlotLeasePeriodLength;
    type TemporarySlotLeasePeriodLength = TemporarySlotLeasePeriodLength;
    type MaxTemporarySlotPerLeasePeriod = MaxTemporarySlotPerLeasePeriod;
    type WeightInfo = assigned_slots::TestWeightInfo;
}
impl validator_manager::Config for Runtime {
    type RuntimeEvent = RuntimeEvent;
    type PrivilegedOrigin = EnsureRoot<AccountId>;
}
impl pallet_sudo::Config for Runtime {
    type RuntimeEvent = RuntimeEvent;
    type RuntimeCall = RuntimeCall;
    type WeightInfo = ();
}
impl pallet_root_testing::Config for Runtime {
    type RuntimeEvent = RuntimeEvent;
}
impl pallet_asset_rate::Config for Runtime {
    type WeightInfo = ();
    type RuntimeEvent = RuntimeEvent;
    type CreateOrigin = EnsureRoot<AccountId>;
    type RemoveOrigin = EnsureRoot<AccountId>;
    type UpdateOrigin = EnsureRoot<AccountId>;
    type Currency = Balances;
    type AssetKind = <Runtime as pallet_treasury::Config>::AssetKind;
    #[cfg(feature = "runtime-benchmarks")]
    type BenchmarkHelper = runtime_common::impls::benchmarks::AssetRateArguments;
}
// Notify `coretime` pallet when a lease swap occurs
pub struct SwapLeases;
impl OnSwap for SwapLeases {
    fn on_swap(one: ParaId, other: ParaId) {
        coretime::Pallet::<Runtime>::on_legacy_lease_swap(one, other);
    }
}
pub struct CurrentSessionIndexGetter;
impl tp_traits::GetSessionIndex<SessionIndex> for CurrentSessionIndexGetter {
    /// Returns current session index.
63
    fn session_index() -> SessionIndex {
63
        Session::current_index()
63
    }
}
impl pallet_configuration::Config for Runtime {
    type SessionDelay = ConstU32<2>;
    type SessionIndex = SessionIndex;
    type CurrentSessionIndex = CurrentSessionIndexGetter;
    type AuthorityId = BeefyId;
    type WeightInfo = ();
}
parameter_types! {
    pub const MaxLengthTokenSymbol: u32 = 255;
}
10791
construct_runtime! {
504
    pub enum Runtime
504
    {
504
        // Basic stuff; balances is uncallable initially.
504
        System: frame_system = 0,
504

            
504
        // Babe must be before session.
504
        Babe: pallet_babe = 1,
504

            
504
        Timestamp: pallet_timestamp = 2,
504
        Indices: pallet_indices = 3,
504
        Balances: pallet_balances = 4,
504
        Parameters: pallet_parameters = 6,
504
        TransactionPayment: pallet_transaction_payment = 33,
504

            
504
        // Consensus support.
504
        // Authorship must be before session in order to note author in the correct session and era.
504
        Authorship: pallet_authorship = 5,
504
        Offences: pallet_offences = 7,
504
        Historical: session_historical = 34,
504

            
504
        Session: pallet_session = 8,
504
        Grandpa: pallet_grandpa = 10,
504
        AuthorityDiscovery: pallet_authority_discovery = 12,
504

            
504
        // Governance stuff; uncallable initially.
504
        Treasury: pallet_treasury = 18,
504
        ConvictionVoting: pallet_conviction_voting = 20,
504
        Referenda: pallet_referenda = 21,
504
        //	pub type FellowshipCollectiveInstance = pallet_ranked_collective::Instance1;
504
        FellowshipCollective: pallet_ranked_collective::<Instance1> = 22,
504
        // pub type FellowshipReferendaInstance = pallet_referenda::Instance2;
504
        FellowshipReferenda: pallet_referenda::<Instance2> = 23,
504
        Origins: pallet_custom_origins = 43,
504
        Whitelist: pallet_whitelist = 44,
504
        // Claims. Usable initially.
504
        Claims: claims = 19,
504

            
504
        // Utility module.
504
        Utility: pallet_utility = 24,
504

            
504
        // Less simple identity module.
504
        Identity: pallet_identity = 25,
504

            
504
        // Society module.
504
        Society: pallet_society = 26,
504

            
504
        // Social recovery module.
504
        Recovery: pallet_recovery = 27,
504

            
504
        // Vesting. Usable initially, but removed once all vesting is finished.
504
        Vesting: pallet_vesting = 28,
504

            
504
        // System scheduler.
504
        Scheduler: pallet_scheduler = 29,
504

            
504
        // Proxy module. Late addition.
504
        Proxy: pallet_proxy = 30,
504

            
504
        // Multisig module. Late addition.
504
        Multisig: pallet_multisig = 31,
504

            
504
        // Preimage registrar.
504
        Preimage: pallet_preimage = 32,
504

            
504
        // Asset rate.
504
        AssetRate: pallet_asset_rate = 39,
504

            
504
        // Bounties modules.
504
        Bounties: pallet_bounties = 35,
504
        ChildBounties: pallet_child_bounties = 40,
504

            
504
        // NIS pallet.
504
        Nis: pallet_nis = 38,
504
        // pub type NisCounterpartInstance = pallet_balances::Instance2;
504
        NisCounterpartBalances: pallet_balances::<Instance2> = 45,
504

            
504
        // Parachains pallets. Start indices at 50 to leave room.
504
        ParachainsOrigin: parachains_origin = 50,
504
        Configuration: parachains_configuration = 51,
504
        ParasShared: parachains_shared = 52,
504
        ParaInclusion: parachains_inclusion = 53,
504
        ParaInherent: parachains_paras_inherent = 54,
504
        ParaScheduler: parachains_scheduler = 55,
504
        Paras: parachains_paras = 56,
504
        Initializer: parachains_initializer = 57,
504
        Dmp: parachains_dmp = 58,
504
        Hrmp: parachains_hrmp = 60,
504
        ParaSessionInfo: parachains_session_info = 61,
504
        ParasDisputes: parachains_disputes = 62,
504
        ParasSlashing: parachains_slashing = 63,
504
        MessageQueue: pallet_message_queue = 64,
504
        OnDemandAssignmentProvider: parachains_assigner_on_demand = 66,
504
        CoretimeAssignmentProvider: parachains_assigner_coretime = 68,
504

            
504
        // Parachain Onboarding Pallets. Start indices at 70 to leave room.
504
        Registrar: paras_registrar = 70,
504
        Slots: slots = 71,
504
        Auctions: auctions = 72,
504
        Crowdloan: crowdloan = 73,
504
        Coretime: coretime = 74,
504

            
504
        // Pallet for sending XCM.
504
        XcmPallet: pallet_xcm = 99,
504

            
504
        // BEEFY Bridges support.
504
        Beefy: pallet_beefy = 240,
504
        // MMR leaf construction must be after session in order to have a leaf's next_auth_set
504
        // refer to block<N>. See issue polkadot-fellows/runtimes#160 for details.
504
        Mmr: pallet_mmr = 241,
504
        MmrLeaf: pallet_beefy_mmr = 242,
504

            
504
        // Pallet for migrating Identity to a parachain. To be removed post-migration.
504
        IdentityMigrator: identity_migrator = 248,
504

            
504
        ParasSudoWrapper: paras_sudo_wrapper = 250,
504
        AssignedSlots: assigned_slots = 251,
504

            
504
        // Validator Manager pallet.
504
        ValidatorManager: validator_manager = 252,
504

            
504
        // State trie migration pallet, only temporary.
504
        StateTrieMigration: pallet_state_trie_migration = 254,
504

            
504
        // Root testing pallet.
504
        RootTesting: pallet_root_testing = 249,
504

            
504
        // Sudo.
504
        Sudo: pallet_sudo = 255,
504

            
504
        // FIXME: correct ordering
504
        TanssiInitializer: tanssi_initializer = 100,
504
        CollatorConfiguration: pallet_configuration = 101,
504
        ContainerRegistrar: pallet_registrar = 102,
504

            
504
    }
10791
}
/// The address format for describing accounts.
pub type Address = sp_runtime::MultiAddress<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 = (
    frame_system::CheckNonZeroSender<Runtime>,
    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>,
);
/// Unchecked extrinsic type as expected by this runtime.
pub type UncheckedExtrinsic =
    generic::UncheckedExtrinsic<Address, RuntimeCall, Signature, SignedExtra>;
/// All migrations that will run on the next runtime upgrade.
///
/// This contains the combined migrations of the last 10 releases. It allows to skip runtime
/// upgrades in case governance decides to do so. THE ORDER IS IMPORTANT.
pub type Migrations = migrations::Unreleased;
/// The runtime migrations per release.
#[allow(deprecated, missing_docs)]
pub mod migrations {
    use super::*;
    use {frame_support::traits::LockIdentifier, frame_system::pallet_prelude::BlockNumberFor};
    pub struct GetLegacyLeaseImpl;
    impl coretime::migration::GetLegacyLease<BlockNumber> for GetLegacyLeaseImpl {
        fn get_parachain_lease_in_blocks(para: ParaId) -> Option<BlockNumber> {
            let now = frame_system::Pallet::<Runtime>::block_number();
            let lease = slots::Leases::<Runtime>::get(para);
            if lease.is_empty() {
                return None;
            }
            // Lease not yet started, ignore:
            if lease.iter().any(Option::is_none) {
                return None;
            }
            let (index, _) =
                <slots::Pallet<Runtime> as Leaser<BlockNumber>>::lease_period_index(now)?;
            Some(
                index
                    .saturating_add(lease.len() as u32)
                    .saturating_mul(LeasePeriod::get()),
            )
        }
    }
    parameter_types! {
        pub const DemocracyPalletName: &'static str = "Democracy";
        pub const CouncilPalletName: &'static str = "Council";
        pub const TechnicalCommitteePalletName: &'static str = "TechnicalCommittee";
        pub const PhragmenElectionPalletName: &'static str = "PhragmenElection";
        pub const TechnicalMembershipPalletName: &'static str = "TechnicalMembership";
        pub const TipsPalletName: &'static str = "Tips";
        pub const PhragmenElectionPalletId: LockIdentifier = *b"phrelect";
    }
    // Special Config for Gov V1 pallets, allowing us to run migrations for them without
    // implementing their configs on [`Runtime`].
    pub struct UnlockConfig;
    impl pallet_democracy::migrations::unlock_and_unreserve_all_funds::UnlockConfig for UnlockConfig {
        type Currency = Balances;
        type MaxVotes = ConstU32<100>;
        type MaxDeposits = ConstU32<100>;
        type AccountId = AccountId;
        type BlockNumber = BlockNumberFor<Runtime>;
        type DbWeight = <Runtime as frame_system::Config>::DbWeight;
        type PalletName = DemocracyPalletName;
    }
    impl pallet_elections_phragmen::migrations::unlock_and_unreserve_all_funds::UnlockConfig
        for UnlockConfig
    {
        type Currency = Balances;
        type MaxVotesPerVoter = ConstU32<16>;
        type PalletId = PhragmenElectionPalletId;
        type AccountId = AccountId;
        type DbWeight = <Runtime as frame_system::Config>::DbWeight;
        type PalletName = PhragmenElectionPalletName;
    }
    impl pallet_tips::migrations::unreserve_deposits::UnlockConfig<()> for UnlockConfig {
        type Currency = Balances;
        type Hash = Hash;
        type DataDepositPerByte = DataDepositPerByte;
        type TipReportDepositBase = TipReportDepositBase;
        type AccountId = AccountId;
        type BlockNumber = BlockNumberFor<Runtime>;
        type DbWeight = <Runtime as frame_system::Config>::DbWeight;
        type PalletName = TipsPalletName;
    }
    // We don't have a limit in the Relay Chain.
    const IDENTITY_MIGRATION_KEY_LIMIT: u64 = u64::MAX;
    /// Unreleased migrations. Add new ones here:
    pub type Unreleased = (
		pallet_society::migrations::MigrateToV2<Runtime, (), ()>,
		parachains_configuration::migration::v7::MigrateToV7<Runtime>,
		assigned_slots::migration::v1::MigrateToV1<Runtime>,
		parachains_scheduler::migration::MigrateV1ToV2<Runtime>,
		parachains_configuration::migration::v8::MigrateToV8<Runtime>,
		parachains_configuration::migration::v9::MigrateToV9<Runtime>,
		paras_registrar::migration::MigrateToV1<Runtime, ()>,
		pallet_referenda::migration::v1::MigrateV0ToV1<Runtime, ()>,
		pallet_referenda::migration::v1::MigrateV0ToV1<Runtime, pallet_referenda::Instance2>,
		// Unlock & unreserve Gov1 funds
		pallet_elections_phragmen::migrations::unlock_and_unreserve_all_funds::UnlockAndUnreserveAllFunds<UnlockConfig>,
		pallet_democracy::migrations::unlock_and_unreserve_all_funds::UnlockAndUnreserveAllFunds<UnlockConfig>,
		pallet_tips::migrations::unreserve_deposits::UnreserveDeposits<UnlockConfig, ()>,
		// Delete all Gov v1 pallet storage key/values.
		frame_support::migrations::RemovePallet<DemocracyPalletName, <Runtime as frame_system::Config>::DbWeight>,
		frame_support::migrations::RemovePallet<CouncilPalletName, <Runtime as frame_system::Config>::DbWeight>,
		frame_support::migrations::RemovePallet<TechnicalCommitteePalletName, <Runtime as frame_system::Config>::DbWeight>,
		frame_support::migrations::RemovePallet<PhragmenElectionPalletName, <Runtime as frame_system::Config>::DbWeight>,
		frame_support::migrations::RemovePallet<TechnicalMembershipPalletName, <Runtime as frame_system::Config>::DbWeight>,
		frame_support::migrations::RemovePallet<TipsPalletName, <Runtime as frame_system::Config>::DbWeight>,
		pallet_grandpa::migrations::MigrateV4ToV5<Runtime>,
		parachains_configuration::migration::v10::MigrateToV10<Runtime>,
		// Migrate Identity pallet for Usernames
		pallet_identity::migration::versioned::V0ToV1<Runtime, IDENTITY_MIGRATION_KEY_LIMIT>,
		parachains_configuration::migration::v11::MigrateToV11<Runtime>,
		// This needs to come after the `parachains_configuration` above as we are reading the configuration.
		coretime::migration::MigrateToCoretime<Runtime, crate::xcm_config::XcmRouter, GetLegacyLeaseImpl>,
		parachains_configuration::migration::v12::MigrateToV12<Runtime>,
		parachains_assigner_on_demand::migration::MigrateV0ToV1<Runtime>,
		// permanent
		pallet_xcm::migration::MigrateToLatestXcmVersion<Runtime>,
		parachains_inclusion::migration::MigrateToV1<Runtime>,
	);
}
/// Executive: handles dispatch to the various modules.
pub type Executive = frame_executive::Executive<
    Runtime,
    Block,
    frame_system::ChainContext<Runtime>,
    Runtime,
    AllPalletsWithSystem,
    Migrations,
>;
/// The payload being signed in transactions.
pub type SignedPayload = generic::SignedPayload<RuntimeCall, SignedExtra>;
parameter_types! {
    // The deposit configuration for the singed migration. Specially if you want to allow any signed account to do the migration (see `SignedFilter`, these deposits should be high)
    pub const MigrationSignedDepositPerItem: Balance = 1 * CENTS;
    pub const MigrationSignedDepositBase: Balance = 20 * CENTS * 100;
    pub const MigrationMaxKeyLen: u32 = 512;
}
impl pallet_state_trie_migration::Config for Runtime {
    type RuntimeEvent = RuntimeEvent;
    type Currency = Balances;
    type RuntimeHoldReason = RuntimeHoldReason;
    type SignedDepositPerItem = MigrationSignedDepositPerItem;
    type SignedDepositBase = MigrationSignedDepositBase;
    type ControlOrigin = EnsureRoot<AccountId>;
    // specific account for the migration, can trigger the signed migrations.
    type SignedFilter = frame_system::EnsureSignedBy<MigController, AccountId>;
    // Use same weights as substrate ones.
    type WeightInfo = pallet_state_trie_migration::weights::SubstrateWeight<Runtime>;
    type MaxKeyLen = MigrationMaxKeyLen;
}
pub struct NoRelayStorageRoots;
impl tp_traits::RelayStorageRootProvider for NoRelayStorageRoots {
    fn get_relay_storage_root(_relay_block_number: u32) -> Option<H256> {
        // We can probably get this from frame_system::Digest, but this is needed to do relay storage proofs
        // which doesn't make sense since we are the relay chain now, so the register_with_proof extrinsic
        // should be disabled in this runtime
        None
    }
    #[cfg(feature = "runtime-benchmarks")]
    fn set_relay_storage_root(_relay_block_number: u32, _storage_root: Option<H256>) {}
}
parameter_types! {
    pub const DepositAmount: Balance = 100 * UNITS;
    #[derive(Clone)]
    pub const MaxLengthParaIds: u32 = 100u32;
    pub const MaxEncodedGenesisDataSize: u32 = 5_000_000u32; // 5MB
}
impl pallet_registrar::Config for Runtime {
    type RuntimeEvent = RuntimeEvent;
    type RegistrarOrigin = EnsureRoot<AccountId>;
    type MarkValidForCollatingOrigin = EnsureRoot<AccountId>;
    type MaxLengthParaIds = MaxLengthParaIds;
    type MaxGenesisDataSize = MaxEncodedGenesisDataSize;
    type MaxLengthTokenSymbol = MaxLengthTokenSymbol;
    type RegisterWithRelayProofOrigin = EnsureNever<AccountId>;
    type RelayStorageRootProvider = NoRelayStorageRoots;
    type SessionDelay = ConstU32<2>;
    type SessionIndex = u32;
    type CurrentSessionIndex = CurrentSessionIndexGetter;
    type Currency = Balances;
    type DepositAmount = DepositAmount;
    type RegistrarHooks = StarlightRegistrarHooks;
    type WeightInfo = pallet_registrar::weights::SubstrateWeight<Runtime>;
}
pub struct StarlightRegistrarHooks;
impl pallet_registrar::RegistrarHooks for StarlightRegistrarHooks {
    fn para_marked_valid_for_collating(_para_id: ParaId) -> Weight {
        // Give free credits but only once per para id
        // TODO: uncomment when ServicesPayment pallet exists
        //ServicesPayment::give_free_credits(&para_id)
        Weight::default()
    }
21
    fn para_deregistered(_para_id: ParaId) -> Weight {
21
        // Clear pallet_author_noting storage
21
        // TODO: uncomment when pallets exists
21
        /*
21
        if let Err(e) = AuthorNoting::kill_author_data(RuntimeOrigin::root(), para_id) {
21
            log::warn!(
21
                "Failed to kill_author_data after para id {} deregistered: {:?}",
21
                u32::from(para_id),
21
                e,
21
            );
21
        }
21
        // Remove bootnodes from pallet_data_preservers
21
        DataPreservers::para_deregistered(para_id);
21

            
21
        ServicesPayment::para_deregistered(para_id);
21

            
21
        XcmCoreBuyer::para_deregistered(para_id);
21
         */
21

            
21
        Weight::default()
21
    }
    fn check_valid_for_collating(_para_id: ParaId) -> DispatchResult {
        // TODO: uncomment when DataPreservers pallet exists
        // To be able to call mark_valid_for_collating, a container chain must have bootnodes
        //DataPreservers::check_valid_for_collating(para_id)
        Ok(())
    }
    #[cfg(feature = "runtime-benchmarks")]
    fn benchmarks_ensure_valid_for_collating(_para_id: ParaId) {
        // TODO: uncomment when pallets exist and we run benchmarks for this runtime
        todo!("benchmarks_ensure_valid_for_collating not implemented yet")
        /*
        use {
            frame_support::traits::EnsureOriginWithArg,
            pallet_data_preservers::{ParaIdsFilter, Profile, ProfileMode},
        };
        let profile = Profile {
            url: b"/ip4/127.0.0.1/tcp/33049/ws/p2p/12D3KooWHVMhQDHBpj9vQmssgyfspYecgV6e3hH1dQVDUkUbCYC9"
                .to_vec()
                .try_into()
                .expect("to fit in BoundedVec"),
            para_ids: ParaIdsFilter::AnyParaId,
            mode: ProfileMode::Bootnode,
            assignment_request: PreserversAssignementPaymentRequest::Free,
        };
        let profile_id = pallet_data_preservers::NextProfileId::<Runtime>::get();
        let profile_owner = AccountId::new([1u8; 32]);
        DataPreservers::force_create_profile(RuntimeOrigin::root(), profile, profile_owner)
            .expect("profile create to succeed");
        let para_manager =
            <Runtime as pallet_data_preservers::Config>::AssignmentOrigin::try_successful_origin(
                &para_id,
            )
                .expect("should be able to get para manager");
        DataPreservers::start_assignment(
            para_manager,
            profile_id,
            para_id,
            PreserversAssignementPaymentExtra::Free,
        )
            .expect("assignement to work");
        assert!(
            pallet_data_preservers::Assignments::<Runtime>::get(para_id).contains(&profile_id),
            "profile should be correctly assigned"
        );
         */
    }
}
frame_support::ord_parameter_types! {
    pub const MigController: AccountId = AccountId::from(hex_literal::hex!("52bc71c1eca5353749542dfdf0af97bf764f9c2f44e860cd485f1cd86400f649"));
}
#[cfg(feature = "runtime-benchmarks")]
mod benches {
    frame_benchmarking::define_benchmarks!(
        // Polkadot
        // NOTE: Make sure to prefix these with `runtime_common::` so
        // the that path resolves correctly in the generated file.
        [runtime_common::assigned_slots, AssignedSlots]
        [runtime_common::auctions, Auctions]
        [runtime_common::coretime, Coretime]
        [runtime_common::crowdloan, Crowdloan]
        [runtime_common::claims, Claims]
        [runtime_common::identity_migrator, IdentityMigrator]
        [runtime_common::slots, Slots]
        [runtime_common::paras_registrar, Registrar]
        [runtime_parachains::configuration, Configuration]
        [runtime_parachains::hrmp, Hrmp]
        [runtime_parachains::disputes, ParasDisputes]
        [runtime_parachains::inclusion, ParaInclusion]
        [runtime_parachains::initializer, Initializer]
        [runtime_parachains::paras_inherent, ParaInherent]
        [runtime_parachains::paras, Paras]
        [runtime_parachains::assigner_on_demand, OnDemandAssignmentProvider]
        // Substrate
        [pallet_balances, Balances]
        [pallet_balances, NisCounterpartBalances]
        [frame_benchmarking::baseline, Baseline::<Runtime>]
        [pallet_bounties, Bounties]
        [pallet_child_bounties, ChildBounties]
        [pallet_conviction_voting, ConvictionVoting]
        [pallet_nis, Nis]
        [pallet_identity, Identity]
        [pallet_indices, Indices]
        [pallet_message_queue, MessageQueue]
        [pallet_multisig, Multisig]
        [pallet_parameters, Parameters]
        [pallet_preimage, Preimage]
        [pallet_proxy, Proxy]
        [pallet_ranked_collective, FellowshipCollective]
        [pallet_recovery, Recovery]
        [pallet_referenda, Referenda]
        [pallet_referenda, FellowshipReferenda]
        [pallet_scheduler, Scheduler]
        [pallet_sudo, Sudo]
        [frame_system, SystemBench::<Runtime>]
        [pallet_timestamp, Timestamp]
        [pallet_treasury, Treasury]
        [pallet_utility, Utility]
        [pallet_vesting, Vesting]
        [pallet_asset_rate, AssetRate]
        [pallet_whitelist, Whitelist]
        // XCM
        [pallet_xcm, PalletXcmExtrinsicsBenchmark::<Runtime>]
        [pallet_xcm_benchmarks::fungible, pallet_xcm_benchmarks::fungible::Pallet::<Runtime>]
        [pallet_xcm_benchmarks::generic, pallet_xcm_benchmarks::generic::Pallet::<Runtime>]
    );
}
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) -> sp_runtime::ExtrinsicInclusionMode {
            Executive::initialize_block(header)
        }
    }
    impl xcm_fee_payment_runtime_api::XcmPaymentApi<Block> for Runtime {
        fn query_acceptable_payment_assets(xcm_version: xcm::Version) -> Result<Vec<VersionedAssetId>, XcmPaymentApiError> {
            if !matches!(xcm_version, 3 | 4) {
                return Err(XcmPaymentApiError::UnhandledXcmVersion);
            }
            Ok([VersionedAssetId::V4(xcm_config::TokenLocation::get().into())]
                .into_iter()
                .filter_map(|asset| asset.into_version(xcm_version).ok())
                .collect())
        }
        fn query_weight_to_asset_fee(weight: Weight, asset: VersionedAssetId) -> Result<u128, XcmPaymentApiError> {
            let local_asset = VersionedAssetId::V4(xcm_config::TokenLocation::get().into());
            let asset = asset
                .into_version(4)
                .map_err(|_| XcmPaymentApiError::VersionedConversionFailed)?;
            if  asset != local_asset { return Err(XcmPaymentApiError::AssetNotFound); }
            Ok(WeightToFee::weight_to_fee(&weight))
        }
        fn query_xcm_weight(message: VersionedXcm<()>) -> Result<Weight, XcmPaymentApiError> {
            XcmPallet::query_xcm_weight(message)
        }
        fn query_delivery_fees(destination: VersionedLocation, message: VersionedXcm<()>) -> Result<VersionedAssets, XcmPaymentApiError> {
            XcmPallet::query_delivery_fees(destination, message)
        }
    }
    impl sp_api::Metadata<Block> for Runtime {
        fn metadata() -> OpaqueMetadata {
            OpaqueMetadata::new(Runtime::metadata().into())
        }
        fn metadata_at_version(version: u32) -> Option<OpaqueMetadata> {
            Runtime::metadata_at_version(version)
        }
        fn metadata_versions() -> sp_std::vec::Vec<u32> {
            Runtime::metadata_versions()
        }
    }
    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 {
        fn validate_transaction(
            source: TransactionSource,
            tx: <Block as BlockT>::Extrinsic,
            block_hash: <Block as BlockT>::Hash,
        ) -> TransactionValidity {
            Executive::validate_transaction(source, tx, block_hash)
        }
    }
    impl offchain_primitives::OffchainWorkerApi<Block> for Runtime {
        fn offchain_worker(header: &<Block as BlockT>::Header) {
            Executive::offchain_worker(header)
        }
    }
    #[api_version(11)]
    impl primitives::runtime_api::ParachainHost<Block> for Runtime {
        fn validators() -> Vec<ValidatorId> {
            parachains_runtime_api_impl::validators::<Runtime>()
        }
        fn validator_groups() -> (Vec<Vec<ValidatorIndex>>, GroupRotationInfo<BlockNumber>) {
            parachains_runtime_api_impl::validator_groups::<Runtime>()
        }
        fn availability_cores() -> Vec<CoreState<Hash, BlockNumber>> {
            parachains_runtime_api_impl::availability_cores::<Runtime>()
        }
        fn persisted_validation_data(para_id: ParaId, assumption: OccupiedCoreAssumption)
            -> Option<PersistedValidationData<Hash, BlockNumber>> {
            parachains_runtime_api_impl::persisted_validation_data::<Runtime>(para_id, assumption)
        }
        fn assumed_validation_data(
            para_id: ParaId,
            expected_persisted_validation_data_hash: Hash,
        ) -> Option<(PersistedValidationData<Hash, BlockNumber>, ValidationCodeHash)> {
            parachains_runtime_api_impl::assumed_validation_data::<Runtime>(
                para_id,
                expected_persisted_validation_data_hash,
            )
        }
        fn check_validation_outputs(
            para_id: ParaId,
            outputs: primitives::CandidateCommitments,
        ) -> bool {
            parachains_runtime_api_impl::check_validation_outputs::<Runtime>(para_id, outputs)
        }
        fn session_index_for_child() -> SessionIndex {
            parachains_runtime_api_impl::session_index_for_child::<Runtime>()
        }
        fn validation_code(para_id: ParaId, assumption: OccupiedCoreAssumption)
            -> Option<ValidationCode> {
            parachains_runtime_api_impl::validation_code::<Runtime>(para_id, assumption)
        }
        fn candidate_pending_availability(para_id: ParaId) -> Option<CommittedCandidateReceipt<Hash>> {
            #[allow(deprecated)]
            parachains_runtime_api_impl::candidate_pending_availability::<Runtime>(para_id)
        }
        fn candidate_events() -> Vec<CandidateEvent<Hash>> {
            parachains_runtime_api_impl::candidate_events::<Runtime, _>(|ev| {
                match ev {
                    RuntimeEvent::ParaInclusion(ev) => {
                        Some(ev)
                    }
                    _ => None,
                }
            })
        }
        fn session_info(index: SessionIndex) -> Option<SessionInfo> {
            parachains_runtime_api_impl::session_info::<Runtime>(index)
        }
        fn session_executor_params(session_index: SessionIndex) -> Option<ExecutorParams> {
            parachains_runtime_api_impl::session_executor_params::<Runtime>(session_index)
        }
        fn dmq_contents(recipient: ParaId) -> Vec<InboundDownwardMessage<BlockNumber>> {
            parachains_runtime_api_impl::dmq_contents::<Runtime>(recipient)
        }
        fn inbound_hrmp_channels_contents(
            recipient: ParaId
        ) -> BTreeMap<ParaId, Vec<InboundHrmpMessage<BlockNumber>>> {
            parachains_runtime_api_impl::inbound_hrmp_channels_contents::<Runtime>(recipient)
        }
        fn validation_code_by_hash(hash: ValidationCodeHash) -> Option<ValidationCode> {
            parachains_runtime_api_impl::validation_code_by_hash::<Runtime>(hash)
        }
        fn on_chain_votes() -> Option<ScrapedOnChainVotes<Hash>> {
            parachains_runtime_api_impl::on_chain_votes::<Runtime>()
        }
        fn submit_pvf_check_statement(
            stmt: primitives::PvfCheckStatement,
            signature: primitives::ValidatorSignature
        ) {
            parachains_runtime_api_impl::submit_pvf_check_statement::<Runtime>(stmt, signature)
        }
        fn pvfs_require_precheck() -> Vec<ValidationCodeHash> {
            parachains_runtime_api_impl::pvfs_require_precheck::<Runtime>()
        }
        fn validation_code_hash(para_id: ParaId, assumption: OccupiedCoreAssumption)
            -> Option<ValidationCodeHash>
        {
            parachains_runtime_api_impl::validation_code_hash::<Runtime>(para_id, assumption)
        }
        fn disputes() -> Vec<(SessionIndex, CandidateHash, DisputeState<BlockNumber>)> {
            parachains_runtime_api_impl::get_session_disputes::<Runtime>()
        }
        fn unapplied_slashes(
        ) -> Vec<(SessionIndex, CandidateHash, slashing::PendingSlashes)> {
            parachains_runtime_api_impl::unapplied_slashes::<Runtime>()
        }
        fn key_ownership_proof(
            validator_id: ValidatorId,
        ) -> Option<slashing::OpaqueKeyOwnershipProof> {
            use parity_scale_codec::Encode;
            Historical::prove((PARACHAIN_KEY_TYPE_ID, validator_id))
                .map(|p| p.encode())
                .map(slashing::OpaqueKeyOwnershipProof::new)
        }
        fn submit_report_dispute_lost(
            dispute_proof: slashing::DisputeProof,
            key_ownership_proof: slashing::OpaqueKeyOwnershipProof,
        ) -> Option<()> {
            parachains_runtime_api_impl::submit_unsigned_slashing_report::<Runtime>(
                dispute_proof,
                key_ownership_proof,
            )
        }
        fn minimum_backing_votes() -> u32 {
            parachains_runtime_api_impl::minimum_backing_votes::<Runtime>()
        }
        fn para_backing_state(para_id: ParaId) -> Option<primitives::async_backing::BackingState> {
            parachains_runtime_api_impl::backing_state::<Runtime>(para_id)
        }
        fn async_backing_params() -> primitives::AsyncBackingParams {
            parachains_runtime_api_impl::async_backing_params::<Runtime>()
        }
        fn approval_voting_params() -> ApprovalVotingParams {
            parachains_runtime_api_impl::approval_voting_params::<Runtime>()
        }
        fn disabled_validators() -> Vec<ValidatorIndex> {
            parachains_runtime_api_impl::disabled_validators::<Runtime>()
        }
        fn node_features() -> NodeFeatures {
            parachains_runtime_api_impl::node_features::<Runtime>()
        }
        fn claim_queue() -> BTreeMap<CoreIndex, VecDeque<ParaId>> {
            vstaging_parachains_runtime_api_impl::claim_queue::<Runtime>()
        }
        fn candidates_pending_availability(para_id: ParaId) -> Vec<CommittedCandidateReceipt<Hash>> {
            vstaging_parachains_runtime_api_impl::candidates_pending_availability::<Runtime>(para_id)
        }
    }
    #[api_version(3)]
    impl beefy_primitives::BeefyApi<Block, BeefyId> for Runtime {
        fn beefy_genesis() -> Option<BlockNumber> {
            pallet_beefy::GenesisBlock::<Runtime>::get()
        }
        fn validator_set() -> Option<beefy_primitives::ValidatorSet<BeefyId>> {
            Beefy::validator_set()
        }
        fn submit_report_equivocation_unsigned_extrinsic(
            equivocation_proof: beefy_primitives::EquivocationProof<
                BlockNumber,
                BeefyId,
                BeefySignature,
            >,
            key_owner_proof: beefy_primitives::OpaqueKeyOwnershipProof,
        ) -> Option<()> {
            let key_owner_proof = key_owner_proof.decode()?;
            Beefy::submit_unsigned_equivocation_report(
                equivocation_proof,
                key_owner_proof,
            )
        }
        fn generate_key_ownership_proof(
            _set_id: beefy_primitives::ValidatorSetId,
            authority_id: BeefyId,
        ) -> Option<beefy_primitives::OpaqueKeyOwnershipProof> {
            use parity_scale_codec::Encode;
            Historical::prove((beefy_primitives::KEY_TYPE, authority_id))
                .map(|p| p.encode())
                .map(beefy_primitives::OpaqueKeyOwnershipProof::new)
        }
    }
    #[api_version(2)]
    impl mmr::MmrApi<Block, mmr::Hash, BlockNumber> for Runtime {
        fn mmr_root() -> Result<mmr::Hash, mmr::Error> {
            Ok(pallet_mmr::RootHash::<Runtime>::get())
        }
        fn mmr_leaf_count() -> Result<mmr::LeafIndex, mmr::Error> {
            Ok(pallet_mmr::NumberOfLeaves::<Runtime>::get())
        }
        fn generate_proof(
            block_numbers: Vec<BlockNumber>,
            best_known_block_number: Option<BlockNumber>,
        ) -> Result<(Vec<mmr::EncodableOpaqueLeaf>, mmr::Proof<mmr::Hash>), mmr::Error> {
            Mmr::generate_proof(block_numbers, best_known_block_number).map(
                |(leaves, proof)| {
                    (
                        leaves
                            .into_iter()
                            .map(|leaf| mmr::EncodableOpaqueLeaf::from_leaf(&leaf))
                            .collect(),
                        proof,
                    )
                },
            )
        }
        fn verify_proof(leaves: Vec<mmr::EncodableOpaqueLeaf>, proof: mmr::Proof<mmr::Hash>)
            -> Result<(), mmr::Error>
        {
            let leaves = leaves.into_iter().map(|leaf|
                leaf.into_opaque_leaf()
                .try_decode()
                .ok_or(mmr::Error::Verify)).collect::<Result<Vec<mmr::Leaf>, mmr::Error>>()?;
            Mmr::verify_leaves(leaves, proof)
        }
        fn verify_proof_stateless(
            root: mmr::Hash,
            leaves: Vec<mmr::EncodableOpaqueLeaf>,
            proof: mmr::Proof<mmr::Hash>
        ) -> Result<(), mmr::Error> {
            let nodes = leaves.into_iter().map(|leaf|mmr::DataOrHash::Data(leaf.into_opaque_leaf())).collect();
            pallet_mmr::verify_leaves_proof::<mmr::Hashing, _>(root, nodes, proof)
        }
    }
    impl fg_primitives::GrandpaApi<Block> for Runtime {
        fn grandpa_authorities() -> Vec<(GrandpaId, u64)> {
            Grandpa::grandpa_authorities()
        }
        fn current_set_id() -> fg_primitives::SetId {
            Grandpa::current_set_id()
        }
        fn submit_report_equivocation_unsigned_extrinsic(
            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()?;
            Grandpa::submit_unsigned_equivocation_report(
                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 parity_scale_codec::Encode;
            Historical::prove((fg_primitives::KEY_TYPE, authority_id))
                .map(|p| p.encode())
                .map(fg_primitives::OpaqueKeyOwnershipProof::new)
        }
    }
    impl babe_primitives::BabeApi<Block> for Runtime {
        fn configuration() -> babe_primitives::BabeConfiguration {
            let epoch_config = Babe::epoch_config().unwrap_or(BABE_GENESIS_EPOCH_CONFIG);
            babe_primitives::BabeConfiguration {
                slot_duration: Babe::slot_duration(),
                epoch_length: EpochDurationInBlocks::get().into(),
                c: epoch_config.c,
                authorities: Babe::authorities().to_vec(),
                randomness: Babe::randomness(),
                allowed_slots: epoch_config.allowed_slots,
            }
        }
        fn current_epoch_start() -> babe_primitives::Slot {
            Babe::current_epoch_start()
        }
        fn current_epoch() -> babe_primitives::Epoch {
            Babe::current_epoch()
        }
        fn next_epoch() -> babe_primitives::Epoch {
            Babe::next_epoch()
        }
        fn generate_key_ownership_proof(
            _slot: babe_primitives::Slot,
            authority_id: babe_primitives::AuthorityId,
        ) -> Option<babe_primitives::OpaqueKeyOwnershipProof> {
            use parity_scale_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,
            )
        }
    }
    impl authority_discovery_primitives::AuthorityDiscoveryApi<Block> for Runtime {
        fn authorities() -> Vec<AuthorityDiscoveryId> {
            parachains_runtime_api_impl::relevant_authority_ids::<Runtime>()
        }
    }
    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)
        }
    }
    impl frame_system_rpc_runtime_api::AccountNonceApi<Block, AccountId, Nonce> for Runtime {
        fn account_nonce(account: AccountId) -> Nonce {
            System::account_nonce(account)
        }
    }
    impl pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi<
        Block,
        Balance,
    > for Runtime {
        fn query_info(uxt: <Block as BlockT>::Extrinsic, len: u32) -> RuntimeDispatchInfo<Balance> {
            TransactionPayment::query_info(uxt, len)
        }
        fn query_fee_details(uxt: <Block as BlockT>::Extrinsic, len: u32) -> FeeDetails<Balance> {
            TransactionPayment::query_fee_details(uxt, len)
        }
        fn query_weight_to_fee(weight: Weight) -> Balance {
            TransactionPayment::weight_to_fee(weight)
        }
        fn query_length_to_fee(length: u32) -> Balance {
            TransactionPayment::length_to_fee(length)
        }
    }
    impl pallet_beefy_mmr::BeefyMmrApi<Block, Hash> for RuntimeApi {
        fn authority_set_proof() -> beefy_primitives::mmr::BeefyAuthoritySet<Hash> {
            MmrLeaf::authority_set_proof()
        }
        fn next_authority_set_proof() -> beefy_primitives::mmr::BeefyNextAuthoritySet<Hash> {
            MmrLeaf::next_authority_set_proof()
        }
    }
    #[cfg(feature = "try-runtime")]
    impl frame_try_runtime::TryRuntime<Block> for Runtime {
        fn on_runtime_upgrade(checks: frame_try_runtime::UpgradeCheckSelect) -> (Weight, Weight) {
            log::info!("try-runtime::on_runtime_upgrade starlight.");
            let weight = Executive::try_runtime_upgrade(checks).unwrap();
            (weight, BlockWeights::get().max_block)
        }
        fn execute_block(
            block: Block,
            state_root_check: bool,
            signature_check: bool,
            select: frame_try_runtime::TryStateSelect,
        ) -> Weight {
            // NOTE: intentional unwrap: we don't want to propagate the error backwards, and want to
            // have a backtrace here.
            Executive::try_execute_block(block, state_root_check, signature_check, select).unwrap()
        }
    }
    impl pallet_registrar_runtime_api::RegistrarApi<Block, ParaId, MaxLengthTokenSymbol> for Runtime {
        /// Return the registered para ids
35
        fn registered_paras() -> Vec<ParaId> {
35
            // We should return the container-chains for the session in which we are kicking in
35
            let parent_number = System::block_number();
35
            let should_end_session = <Runtime as pallet_session::Config>::ShouldEndSession::should_end_session(parent_number + 1);
35
            let session_index = if should_end_session {
                Session::current_index() +1
            }
            else {
35
                Session::current_index()
            };
35
            let container_chains = ContainerRegistrar::session_container_chains(session_index);
35
            let mut para_ids = vec![];
35
            para_ids.extend(container_chains.parachains);
35
            para_ids.extend(container_chains.parathreads.into_iter().map(|(para_id, _)| para_id));
35

            
35
            para_ids
35
        }
        /// Fetch genesis data for this para id
49
        fn genesis_data(para_id: ParaId) -> Option<ContainerChainGenesisData<MaxLengthTokenSymbol>> {
49
            ContainerRegistrar::para_genesis_data(para_id)
49
        }
        /// Fetch boot_nodes for this para id
        fn boot_nodes(_para_id: ParaId) -> Vec<Vec<u8>> {
            // TODO: uncomment when DataPreservers pallet exists
            /*DataPreservers::assignments_profiles(para_id)
                .filter(|profile| profile.mode == pallet_data_preservers::ProfileMode::Bootnode)
                .map(|profile| profile.url.into())
                .collect()*/
            vec![]
        }
    }
    impl pallet_registrar_runtime_api::OnDemandBlockProductionApi<Block, ParaId, Slot> for Runtime {
        /// Returns slot frequency for particular para thread. Slot frequency specifies amount of slot
        /// need to be passed between two parathread blocks. It is expressed as `(min, max)` pair where `min`
        /// indicates amount of slot must pass before we produce another block and `max` indicates amount of
        /// blocks before this parathread must produce the block.
        ///
        /// Simply put, parathread must produce a block after `min`  but before `(min+max)` slots.
        ///
        /// # Returns
        ///
        /// * `Some(slot_frequency)`.
        /// * `None` if the `para_id` is not a parathread.
        fn parathread_slot_frequency(para_id: ParaId) -> Option<SlotFrequency> {
            ContainerRegistrar::parathread_params(para_id).map(|params| {
                params.slot_frequency
            })
        }
    }
    #[cfg(feature = "runtime-benchmarks")]
    impl frame_benchmarking::Benchmark<Block> for Runtime {
        fn benchmark_metadata(extra: bool) -> (
            Vec<frame_benchmarking::BenchmarkList>,
            Vec<frame_support::traits::StorageInfo>,
        ) {
            use frame_benchmarking::{Benchmarking, BenchmarkList};
            use frame_support::traits::StorageInfoTrait;
            use frame_system_benchmarking::Pallet as SystemBench;
            use frame_benchmarking::baseline::Pallet as Baseline;
            use pallet_xcm::benchmarking::Pallet as PalletXcmExtrinsicsBenchmark;
            let mut list = Vec::<BenchmarkList>::new();
            list_benchmarks!(list, extra);
            let storage_info = AllPalletsWithSystem::storage_info();
            (list, storage_info)
        }
        fn dispatch_benchmark(
            config: frame_benchmarking::BenchmarkConfig,
        ) -> Result<
            Vec<frame_benchmarking::BenchmarkBatch>,
            sp_runtime::RuntimeString,
        > {
            use frame_support::traits::WhitelistedStorageKeys;
            use frame_benchmarking::{Benchmarking, BenchmarkBatch, BenchmarkError};
            use frame_system_benchmarking::Pallet as SystemBench;
            use frame_benchmarking::baseline::Pallet as Baseline;
            use pallet_xcm::benchmarking::Pallet as PalletXcmExtrinsicsBenchmark;
            use sp_storage::TrackedStorageKey;
            use xcm::latest::prelude::*;
            use xcm_config::{
                AssetHub, LocalCheckAccount, LocationConverter, TokenLocation, XcmConfig,
            };
            parameter_types! {
                pub ExistentialDepositAsset: Option<Asset> = Some((
                    TokenLocation::get(),
                    ExistentialDeposit::get()
                ).into());
                pub AssetHubParaId: ParaId = starlight_runtime_constants::system_parachain::ASSET_HUB_ID.into();
                pub const RandomParaId: ParaId = ParaId::new(43211234);
            }
            impl frame_system_benchmarking::Config for Runtime {}
            impl frame_benchmarking::baseline::Config for Runtime {}
            impl pallet_xcm::benchmarking::Config for Runtime {
                type DeliveryHelper = (
                    runtime_common::xcm_sender::ToParachainDeliveryHelper<
                        XcmConfig,
                        ExistentialDepositAsset,
                        xcm_config::PriceForChildParachainDelivery,
                        AssetHubParaId,
                        (),
                    >,
                    runtime_common::xcm_sender::ToParachainDeliveryHelper<
                        XcmConfig,
                        ExistentialDepositAsset,
                        xcm_config::PriceForChildParachainDelivery,
                        RandomParaId,
                        (),
                    >
                );
                fn reachable_dest() -> Option<Location> {
                    Some(crate::xcm_config::AssetHub::get())
                }
                fn teleportable_asset_and_dest() -> Option<(Asset, Location)> {
                    // Relay/native token can be teleported to/from AH.
                    Some((
                        Asset {
                            fun: Fungible(ExistentialDeposit::get()),
                            id: AssetId(Here.into())
                        },
                        crate::xcm_config::AssetHub::get(),
                    ))
                }
                fn reserve_transferable_asset_and_dest() -> Option<(Asset, Location)> {
                    // Relay can reserve transfer native token to some random parachain.
                    Some((
                        Asset {
                            fun: Fungible(ExistentialDeposit::get()),
                            id: AssetId(Here.into())
                        },
                        Parachain(RandomParaId::get().into()).into(),
                    ))
                }
                fn set_up_complex_asset_transfer(
                ) -> Option<(Assets, u32, Location, Box<dyn FnOnce()>)> {
                    // Relay supports only native token, either reserve transfer it to non-system parachains,
                    // or teleport it to system parachain. Use the teleport case for benchmarking as it's
                    // slightly heavier.
                    // Relay/native token can be teleported to/from AH.
                    let native_location = Here.into();
                    let dest = crate::xcm_config::AssetHub::get();
                    pallet_xcm::benchmarking::helpers::native_teleport_as_asset_transfer::<Runtime>(
                        native_location,
                        dest
                    )
                }
                fn get_asset() -> Asset {
                    Asset {
                        id: AssetId(Location::here()),
                        fun: Fungible(ExistentialDeposit::get()),
                    }
                }
            }
            impl pallet_xcm_benchmarks::Config for Runtime {
                type XcmConfig = XcmConfig;
                type AccountIdConverter = LocationConverter;
                type DeliveryHelper = runtime_common::xcm_sender::ToParachainDeliveryHelper<
                    XcmConfig,
                    ExistentialDepositAsset,
                    xcm_config::PriceForChildParachainDelivery,
                    AssetHubParaId,
                    (),
                >;
                fn valid_destination() -> Result<Location, BenchmarkError> {
                    Ok(AssetHub::get())
                }
                fn worst_case_holding(_depositable_count: u32) -> Assets {
                    // Starlight only knows about STAR
                    vec![Asset{
                        id: AssetId(TokenLocation::get()),
                        fun: Fungible(1_000_000 * UNITS),
                    }].into()
                }
            }
            parameter_types! {
                pub TrustedTeleporter: Option<(Location, Asset)> = Some((
                    AssetHub::get(),
                    Asset { fun: Fungible(1 * UNITS), id: AssetId(TokenLocation::get()) },
                ));
                pub TrustedReserve: Option<(Location, Asset)> = None;
            }
            impl pallet_xcm_benchmarks::fungible::Config for Runtime {
                type TransactAsset = Balances;
                type CheckedAccount = LocalCheckAccount;
                type TrustedTeleporter = TrustedTeleporter;
                type TrustedReserve = TrustedReserve;
                fn get_asset() -> Asset {
                    Asset {
                        id: AssetId(TokenLocation::get()),
                        fun: Fungible(1 * UNITS),
                    }
                }
            }
            impl pallet_xcm_benchmarks::generic::Config for Runtime {
                type TransactAsset = Balances;
                type RuntimeCall = RuntimeCall;
                fn worst_case_response() -> (u64, Response) {
                    (0u64, Response::Version(Default::default()))
                }
                fn worst_case_asset_exchange() -> Result<(Assets, Assets), BenchmarkError> {
                    // Starlight doesn't support asset exchanges
                    Err(BenchmarkError::Skip)
                }
                fn universal_alias() -> Result<(Location, Junction), BenchmarkError> {
                    // The XCM executor of Starlight doesn't have a configured `UniversalAliases`
                    Err(BenchmarkError::Skip)
                }
                fn transact_origin_and_runtime_call() -> Result<(Location, RuntimeCall), BenchmarkError> {
                    Ok((AssetHub::get(), frame_system::Call::remark_with_event { remark: vec![] }.into()))
                }
                fn subscribe_origin() -> Result<Location, BenchmarkError> {
                    Ok(AssetHub::get())
                }
                fn claimable_asset() -> Result<(Location, Location, Assets), BenchmarkError> {
                    let origin = AssetHub::get();
                    let assets: Assets = (AssetId(TokenLocation::get()), 1_000 * UNITS).into();
                    let ticket = Location { parents: 0, interior: Here };
                    Ok((origin, ticket, assets))
                }
                fn fee_asset() -> Result<Asset, BenchmarkError> {
                    Ok(Asset {
                        id: AssetId(TokenLocation::get()),
                        fun: Fungible(1_000_000 * UNITS),
                    })
                }
                fn unlockable_asset() -> Result<(Location, Location, Asset), BenchmarkError> {
                    // Starlight doesn't support asset locking
                    Err(BenchmarkError::Skip)
                }
                fn export_message_origin_and_destination(
                ) -> Result<(Location, NetworkId, InteriorLocation), BenchmarkError> {
                    // Starlight doesn't support exporting messages
                    Err(BenchmarkError::Skip)
                }
                fn alias_origin() -> Result<(Location, Location), BenchmarkError> {
                    // The XCM executor of Starlight doesn't have a configured `Aliasers`
                    Err(BenchmarkError::Skip)
                }
            }
            let mut whitelist: Vec<TrackedStorageKey> = AllPalletsWithSystem::whitelisted_storage_keys();
            let treasury_key = frame_system::Account::<Runtime>::hashed_key_for(Treasury::account_id());
            whitelist.push(treasury_key.to_vec().into());
            let mut batches = Vec::<BenchmarkBatch>::new();
            let params = (&config, &whitelist);
            add_benchmarks!(params, batches);
            Ok(batches)
        }
    }
    impl sp_genesis_builder::GenesisBuilder<Block> for Runtime {
        fn build_state(config: Vec<u8>) -> sp_genesis_builder::Result {
            build_state::<RuntimeGenesisConfig>(config)
        }
        fn get_preset(id: &Option<PresetId>) -> Option<Vec<u8>> {
            get_preset::<RuntimeGenesisConfig>(id, &genesis_config_presets::get_preset)
        }
        fn preset_names() -> Vec<PresetId> {
            vec![
                PresetId::from("local_testnet"),
                PresetId::from("development"),
                PresetId::from("staging_testnet"),
                PresetId::from("wococo_local_testnet"),
                PresetId::from("versi_local_testnet"),
            ]
        }
    }
}
pub struct OwnApplySession;
impl tanssi_initializer::ApplyNewSession<Runtime> for OwnApplySession {
113
    fn apply_new_session(
113
        changed: bool,
113
        session_index: u32,
113
        all_validators: Vec<(AccountId, ValidatorId)>,
113
        queued: Vec<(AccountId, ValidatorId)>,
113
    ) {
113
        use frame_support::traits::OneSessionHandler;
113
        let all_validators_initializer: Vec<(&AccountId, ValidatorId)> = all_validators
113
            .iter()
225
            .map(|(validator, key)| (validator, key.clone()))
113
            .collect();
113
        let queued_initializer: Vec<(&AccountId, ValidatorId)> = queued
113
            .iter()
225
            .map(|(validator, key)| (validator, key.clone()))
113
            .collect();
113

            
113
        Initializer::on_new_session(
113
            changed,
113
            all_validators_initializer.into_iter(),
113
            queued_initializer.into_iter(),
113
        );
113
        // We first initialize Configuration
113
        CollatorConfiguration::initializer_on_new_session(&session_index);
113
        // Next: Registrar
113
        ContainerRegistrar::initializer_on_new_session(&session_index);
113
        // // Next: AuthorityMapping
113
        // AuthorityMapping::initializer_on_new_session(&session_index, &all_validators);
113

            
113
        // let next_collators = queued.iter().map(|(k, _)| k.clone()).collect();
113

            
113
        // // Next: CollatorAssignment
113
        // let assignments =
113
        //     CollatorAssignment::initializer_on_new_session(&session_index, next_collators);
113

            
113
        // let queued_id_to_validator_map = queued.iter().cloned().collect();
113
        // AuthorityAssignment::initializer_on_new_session(
113
        //     &session_index,
113
        //     &queued_id_to_validator_map,
113
        //     &assignments.next_assignment,
113
        // );
113
    }
}
impl tanssi_initializer::Config for Runtime {
    type SessionIndex = u32;
    /// The identifier type for an authority.
    type AuthorityId = ValidatorId;
    type SessionHandler = OwnApplySession;
}
#[cfg(all(test, feature = "try-runtime"))]
mod remote_tests {
    use {
        super::*,
        frame_try_runtime::{runtime_decl_for_try_runtime::TryRuntime, UpgradeCheckSelect},
        remote_externalities::{
            Builder, Mode, OfflineConfig, OnlineConfig, SnapshotConfig, Transport,
        },
        std::env::var,
    };
    #[tokio::test]
    async fn run_migrations() {
        if var("RUN_MIGRATION_TESTS").is_err() {
            return;
        }
        sp_tracing::try_init_simple();
        let transport: Transport = var("WS")
            .unwrap_or("wss://starlight-rpc.polkadot.io:443".to_string())
            .into();
        let maybe_state_snapshot: Option<SnapshotConfig> = var("SNAP").map(|s| s.into()).ok();
        let mut ext = Builder::<Block>::default()
            .mode(if let Some(state_snapshot) = maybe_state_snapshot {
                Mode::OfflineOrElseOnline(
                    OfflineConfig {
                        state_snapshot: state_snapshot.clone(),
                    },
                    OnlineConfig {
                        transport,
                        state_snapshot: Some(state_snapshot),
                        ..Default::default()
                    },
                )
            } else {
                Mode::Online(OnlineConfig {
                    transport,
                    ..Default::default()
                })
            })
            .build()
            .await
            .unwrap();
        ext.execute_with(|| Runtime::on_runtime_upgrade(UpgradeCheckSelect::PreAndPost));
    }
}