// Copyright (C) Moondance Labs Ltd.

// This file is part of Tanssi.

// Tanssi is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

// Tanssi is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License

// along with Tanssi.  If not, see <http://www.gnu.org/licenses/>

//! The Starlight runtime for v1 parachains.

#![cfg_attr(not(feature = "std"), no_std)]

// `construct_runtime!` does a lot of recursion and requires us to increase the limit.

#![recursion_limit = "512"]

use {

    authority_discovery_primitives::AuthorityId as AuthorityDiscoveryId,

    beefy_primitives::{

        ecdsa_crypto::{AuthorityId as BeefyId, Signature as BeefySignature},

        mmr::{BeefyDataProvider, MmrLeafVersion},

    },

    frame_support::{

        dispatch::DispatchResult,

        dynamic_params::{dynamic_pallet_params, dynamic_params},

        traits::FromContains,

    },

    frame_system::EnsureNever,

    pallet_initializer as tanssi_initializer,

    pallet_nis::WithMaximumOf,

    pallet_registrar_runtime_api::ContainerChainGenesisData,

    pallet_session::ShouldEndSession,

    parity_scale_codec::{Decode, Encode, MaxEncodedLen},

    primitives::{

        slashing, AccountIndex, ApprovalVotingParams, BlockNumber, CandidateEvent, CandidateHash,

        CommittedCandidateReceipt, CoreIndex, CoreState, DisputeState, ExecutorParams,

        GroupRotationInfo, Hash, Id as ParaId, InboundDownwardMessage, InboundHrmpMessage, Moment,

        NodeFeatures, Nonce, OccupiedCoreAssumption, PersistedValidationData, ScrapedOnChainVotes,

        SessionInfo, Signature, ValidationCode, ValidationCodeHash, ValidatorId, ValidatorIndex,

        PARACHAIN_KEY_TYPE_ID,

    },

    runtime_common::{

        assigned_slots, auctions, claims, crowdloan, impl_runtime_weights,

        impls::{

            ContainsParts, LocatableAssetConverter, ToAuthor, VersionedLocatableAsset,

            VersionedLocationConverter,

        },

        paras_registrar, paras_sudo_wrapper, prod_or_fast, slots,

        traits::{Leaser, OnSwap},

        BlockHashCount, BlockLength, SlowAdjustingFeeUpdate,

    },

    runtime_parachains::{

        assigner_coretime as parachains_assigner_coretime,

        assigner_on_demand as parachains_assigner_on_demand,

        configuration as parachains_configuration, coretime,

        disputes::{self as parachains_disputes, slashing as parachains_slashing},

        dmp as parachains_dmp, hrmp as parachains_hrmp,

        inclusion::{self as parachains_inclusion, AggregateMessageOrigin, UmpQueueId},

        initializer as parachains_initializer, origin as parachains_origin,

        paras as parachains_paras, paras_inherent as parachains_paras_inherent,

        runtime_api_impl::{

            v10 as parachains_runtime_api_impl, vstaging as vstaging_parachains_runtime_api_impl,

        },

        scheduler as parachains_scheduler, session_info as parachains_session_info,

        shared as parachains_shared,

    },

    scale_info::TypeInfo,

    sp_genesis_builder::PresetId,

    sp_std::{

        cmp::Ordering,

        collections::{btree_map::BTreeMap, vec_deque::VecDeque},

        prelude::*,

    },

    starlight_runtime_constants::system_parachain::BROKER_ID,

    tp_traits::{GetSessionContainerChains, Slot, SlotFrequency},

};

#[cfg(any(feature = "std", test))]

use sp_version::NativeVersion;

use {

    frame_support::{

        construct_runtime, derive_impl,

        genesis_builder_helper::{build_state, get_preset},

        parameter_types,

        traits::{

            fungible::HoldConsideration, tokens::UnityOrOuterConversion, Contains, EitherOf,

            EitherOfDiverse, EnsureOrigin, EnsureOriginWithArg, EverythingBut, InstanceFilter,

            KeyOwnerProofSystem, LinearStoragePrice, PrivilegeCmp, ProcessMessage,

            ProcessMessageError, StorageMapShim, WithdrawReasons,

        },

        weights::{ConstantMultiplier, WeightMeter, WeightToFee as _},

        PalletId,

    },

    frame_system::EnsureRoot,

    pallet_grandpa::{fg_primitives, AuthorityId as GrandpaId},

    pallet_identity::legacy::IdentityInfo,

    pallet_session::historical as session_historical,

    pallet_transaction_payment::{FeeDetails, FungibleAdapter, RuntimeDispatchInfo},

    sp_core::{ConstU128, ConstU8, OpaqueMetadata, H256},

    sp_runtime::{

        create_runtime_str, generic, impl_opaque_keys,

        traits::{

            BlakeTwo256, Block as BlockT, ConstU32, ConvertInto, Extrinsic as ExtrinsicT,

            IdentityLookup, Keccak256, OpaqueKeys, SaturatedConversion, Verify,

        },

        transaction_validity::{TransactionPriority, TransactionSource, TransactionValidity},

        ApplyExtrinsicResult, FixedU128, KeyTypeId, Perbill, Percent, Permill, RuntimeDebug,

    },

    sp_staking::SessionIndex,

    sp_version::RuntimeVersion,

    xcm::{

        latest::prelude::*, IntoVersion, VersionedAssetId, VersionedAssets, VersionedLocation,

        VersionedXcm,

    },

    xcm_builder::PayOverXcm,

};

pub use {

    frame_system::Call as SystemCall,

    pallet_balances::Call as BalancesCall,

    primitives::{AccountId, Balance},

};

/// Constant values used within the runtime.

use starlight_runtime_constants::{currency::*, fee::*, time::*};

// XCM configurations.

pub mod xcm_config;

// Governance and configurations.

pub mod governance;

use {

    governance::{

        pallet_custom_origins, AuctionAdmin, Fellows, GeneralAdmin, LeaseAdmin, Treasurer,

        TreasurySpender,

    },

    xcm_fee_payment_runtime_api::Error as XcmPaymentApiError,

};

#[cfg(test)]

mod tests;

pub mod genesis_config_presets;

mod validator_manager;

impl_runtime_weights!(starlight_runtime_constants);

// Make the WASM binary available.

#[cfg(feature = "std")]

include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));

/// Provides the `WASM_BINARY` build with `fast-runtime` feature enabled.

///

/// This is for example useful for local test chains.

#[cfg(feature = "std")]

pub mod fast_runtime_binary {

    include!(concat!(env!("OUT_DIR"), "/fast_runtime_binary.rs"));

}

/// Runtime version (Starlight).

#[sp_version::runtime_version]

pub const VERSION: RuntimeVersion = RuntimeVersion {

    spec_name: create_runtime_str!("starlight"),

    impl_name: create_runtime_str!("tanssi-starlight-v2.0"),

    authoring_version: 0,

    spec_version: 1_011_000,

    impl_version: 0,

    apis: RUNTIME_API_VERSIONS,

    transaction_version: 25,

    state_version: 1,

};

/// The BABE epoch configuration at genesis.

pub const BABE_GENESIS_EPOCH_CONFIG: babe_primitives::BabeEpochConfiguration =

    babe_primitives::BabeEpochConfiguration {

        c: PRIMARY_PROBABILITY,

        allowed_slots: babe_primitives::AllowedSlots::PrimaryAndSecondaryVRFSlots,

    };

/// Native version.

#[cfg(any(feature = "std", test))]

/// A type to identify calls to the Identity pallet. These will be filtered to prevent invocation,

/// locking the state of the pallet and preventing further updates to identities and sub-identities.

/// The locked state will be the genesis state of a new system chain and then removed from the Relay

/// Chain.

pub struct IsIdentityCall;

impl Contains<RuntimeCall> for IsIdentityCall {

}

parameter_types! {

    pub const Version: RuntimeVersion = VERSION;

    pub const SS58Prefix: u8 = 42;

}

#[derive_impl(frame_system::config_preludes::RelayChainDefaultConfig)]

impl frame_system::Config for Runtime {

    type BaseCallFilter = EverythingBut<IsIdentityCall>;

    type BlockWeights = BlockWeights;

    type BlockLength = BlockLength;

    type DbWeight = RocksDbWeight;

    type Nonce = Nonce;

    type Hash = Hash;

    type AccountId = AccountId;

    type Block = Block;

    type BlockHashCount = BlockHashCount;

    type Version = Version;

    type AccountData = pallet_balances::AccountData<Balance>;

    type SystemWeightInfo = ();

    type SS58Prefix = SS58Prefix;

    type MaxConsumers = frame_support::traits::ConstU32<16>;

}

parameter_types! {

    pub MaximumSchedulerWeight: Weight = Perbill::from_percent(80) *

        BlockWeights::get().max_block;

    pub const MaxScheduledPerBlock: u32 = 50;

    pub const NoPreimagePostponement: Option<u32> = Some(10);

}

/// Used the compare the privilege of an origin inside the scheduler.

pub struct OriginPrivilegeCmp;

impl PrivilegeCmp<OriginCaller> for OriginPrivilegeCmp {

            // Root is greater than anything.

            // For every other origin we don't care, as they are not used for `ScheduleOrigin`.

        }

}

/// Dynamic params that can be adjusted at runtime.

pub mod dynamic_params {

    use super::*;

    pub mod nis {

        use super::*;

        pub static Target: Perquintill = Perquintill::zero();

        pub static MinBid: Balance = 100 * UNITS;

    }

    pub mod preimage {

        use super::*;

        pub static BaseDeposit: Balance = deposit(2, 64);

        pub static ByteDeposit: Balance = deposit(0, 1);

    }

}

#[cfg(feature = "runtime-benchmarks")]

impl Default for RuntimeParameters {

    fn default() -> Self {

        RuntimeParameters::Preimage(dynamic_params::preimage::Parameters::BaseDeposit(

            dynamic_params::preimage::BaseDeposit,

            Some(1u32.into()),

        ))

    }

}

/// Defines what origin can modify which dynamic parameters.

pub struct DynamicParameterOrigin;

impl EnsureOriginWithArg<RuntimeOrigin, RuntimeParametersKey> for DynamicParameterOrigin {

    type Success = ();

        use crate::{dynamic_params::*, governance::*, RuntimeParametersKey::*};

        }

    #[cfg(feature = "runtime-benchmarks")]

    fn try_successful_origin(_key: &RuntimeParametersKey) -> Result<RuntimeOrigin, ()> {

        // Provide the origin for the parameter returned by `Default`:

        Ok(RuntimeOrigin::root())

    }

}

impl pallet_scheduler::Config for Runtime {

    type RuntimeOrigin = RuntimeOrigin;

    type RuntimeEvent = RuntimeEvent;

    type PalletsOrigin = OriginCaller;

    type RuntimeCall = RuntimeCall;

    type MaximumWeight = MaximumSchedulerWeight;

    // The goal of having ScheduleOrigin include AuctionAdmin is to allow the auctions track of

    // OpenGov to schedule periodic auctions.

    type ScheduleOrigin = EitherOf<EnsureRoot<AccountId>, AuctionAdmin>;

    type MaxScheduledPerBlock = MaxScheduledPerBlock;

    type WeightInfo = ();

    type OriginPrivilegeCmp = OriginPrivilegeCmp;

    type Preimages = Preimage;

}

parameter_types! {

    pub const PreimageHoldReason: RuntimeHoldReason = RuntimeHoldReason::Preimage(pallet_preimage::HoldReason::Preimage);

}

impl pallet_preimage::Config for Runtime {

    type WeightInfo = ();

    type RuntimeEvent = RuntimeEvent;

    type Currency = Balances;

    type ManagerOrigin = EnsureRoot<AccountId>;

    type Consideration = HoldConsideration<

        AccountId,

        Balances,

        PreimageHoldReason,

        LinearStoragePrice<

            dynamic_params::preimage::BaseDeposit,

            dynamic_params::preimage::ByteDeposit,

            Balance,

        >,

    >;

}

parameter_types! {

    pub const ExpectedBlockTime: Moment = MILLISECS_PER_BLOCK;

    pub ReportLongevity: u64 = u64::from(EpochDurationInBlocks::get()) * 10;

}

impl pallet_babe::Config for Runtime {

    type EpochDuration = EpochDurationInBlocks;

    type ExpectedBlockTime = ExpectedBlockTime;

    // session module is the trigger

    type EpochChangeTrigger = pallet_babe::ExternalTrigger;

    type DisabledValidators = Session;

    type WeightInfo = ();

    type MaxAuthorities = MaxAuthorities;

    type MaxNominators = ConstU32<0>;

    type KeyOwnerProof = sp_session::MembershipProof;

    type EquivocationReportSystem =

        pallet_babe::EquivocationReportSystem<Self, Offences, Historical, ReportLongevity>;

}

parameter_types! {

    pub const IndexDeposit: Balance = 100 * CENTS;

}

impl pallet_indices::Config for Runtime {

    type AccountIndex = AccountIndex;

    type Currency = Balances;

    type Deposit = IndexDeposit;

    type RuntimeEvent = RuntimeEvent;

    type WeightInfo = ();

}

parameter_types! {

    pub const ExistentialDeposit: Balance = EXISTENTIAL_DEPOSIT;

    pub const MaxLocks: u32 = 50;

    pub const MaxReserves: u32 = 50;

}

impl pallet_balances::Config for Runtime {

    type Balance = Balance;

    type DustRemoval = ();

    type RuntimeEvent = RuntimeEvent;

    type ExistentialDeposit = ExistentialDeposit;

    type AccountStore = System;

    type MaxLocks = MaxLocks;

    type MaxReserves = MaxReserves;

    type ReserveIdentifier = [u8; 8];

    type WeightInfo = ();

    type FreezeIdentifier = ();

    type RuntimeHoldReason = RuntimeHoldReason;

    type RuntimeFreezeReason = RuntimeFreezeReason;

    type MaxFreezes = ConstU32<1>;

}

parameter_types! {

    pub const TransactionByteFee: Balance = 10 * MILLICENTS;

    /// This value increases the priority of `Operational` transactions by adding

    /// a "virtual tip" that's equal to the `OperationalFeeMultiplier * final_fee`.

    pub const OperationalFeeMultiplier: u8 = 5;

}

impl pallet_transaction_payment::Config for Runtime {

    type RuntimeEvent = RuntimeEvent;

    type OnChargeTransaction = FungibleAdapter<Balances, ToAuthor<Runtime>>;

    type OperationalFeeMultiplier = OperationalFeeMultiplier;

    type WeightToFee = WeightToFee;

    type LengthToFee = ConstantMultiplier<Balance, TransactionByteFee>;

    type FeeMultiplierUpdate = SlowAdjustingFeeUpdate<Self>;

}

parameter_types! {

    pub const MinimumPeriod: u64 = SLOT_DURATION / 2;

}

impl pallet_timestamp::Config for Runtime {

    type Moment = u64;

    type OnTimestampSet = Babe;

    type MinimumPeriod = MinimumPeriod;

    type WeightInfo = ();

}

impl pallet_authorship::Config for Runtime {

    type FindAuthor = pallet_session::FindAccountFromAuthorIndex<Self, Babe>;

    type EventHandler = ();

}

impl_opaque_keys! {

    pub struct SessionKeys {

        pub grandpa: Grandpa,

        pub babe: Babe,

        pub para_validator: TanssiInitializer,

        pub para_assignment: ParaSessionInfo,

        pub authority_discovery: AuthorityDiscovery,

        pub beefy: Beefy,

    }

}

/// Special `ValidatorIdOf` implementation that is just returning the input as result.

pub struct ValidatorIdOf;

impl sp_runtime::traits::Convert<AccountId, Option<AccountId>> for ValidatorIdOf {

}

impl pallet_session::Config for Runtime {

    type RuntimeEvent = RuntimeEvent;

    type ValidatorId = AccountId;

    type ValidatorIdOf = ValidatorIdOf;

    type ShouldEndSession = Babe;

    type NextSessionRotation = Babe;

    type SessionManager = pallet_session::historical::NoteHistoricalRoot<Self, ValidatorManager>;

    type SessionHandler = <SessionKeys as OpaqueKeys>::KeyTypeIdProviders;

    type Keys = SessionKeys;

    type WeightInfo = ();

}

pub struct FullIdentificationOf;

impl sp_runtime::traits::Convert<AccountId, Option<()>> for FullIdentificationOf {

}

impl pallet_session::historical::Config for Runtime {

    type FullIdentification = ();

    type FullIdentificationOf = FullIdentificationOf;

}

parameter_types! {

    pub const SessionsPerEra: SessionIndex = 6;

    pub const BondingDuration: sp_staking::EraIndex = 28;

}

parameter_types! {

    pub const ProposalBond: Permill = Permill::from_percent(5);

    pub const ProposalBondMinimum: Balance = 2000 * CENTS;

    pub const ProposalBondMaximum: Balance = 1 * GRAND;

    pub const SpendPeriod: BlockNumber = 6 * DAYS;

    pub const Burn: Permill = Permill::from_perthousand(2);

    pub const TreasuryPalletId: PalletId = PalletId(*b"py/trsry");

    pub const PayoutSpendPeriod: BlockNumber = 30 * DAYS;

    // The asset's interior location for the paying account. This is the Treasury

    // pallet instance (which sits at index 18).

    pub TreasuryInteriorLocation: InteriorLocation = PalletInstance(18).into();

    pub const TipCountdown: BlockNumber = 1 * DAYS;

    pub const TipFindersFee: Percent = Percent::from_percent(20);

    pub const TipReportDepositBase: Balance = 100 * CENTS;

    pub const DataDepositPerByte: Balance = 1 * CENTS;

    pub const MaxApprovals: u32 = 100;

    pub const MaxAuthorities: u32 = 100_000;

    pub const MaxKeys: u32 = 10_000;

    pub const MaxPeerInHeartbeats: u32 = 10_000;

    pub const MaxBalance: Balance = Balance::max_value();

}

impl pallet_treasury::Config for Runtime {

    type PalletId = TreasuryPalletId;

    type Currency = Balances;

    type ApproveOrigin = EitherOfDiverse<EnsureRoot<AccountId>, Treasurer>;

    type RejectOrigin = EitherOfDiverse<EnsureRoot<AccountId>, Treasurer>;

    type RuntimeEvent = RuntimeEvent;

    type OnSlash = Treasury;

    type ProposalBond = ProposalBond;

    type ProposalBondMinimum = ProposalBondMinimum;

    type ProposalBondMaximum = ProposalBondMaximum;

    type SpendPeriod = SpendPeriod;

    type Burn = Burn;

    type BurnDestination = Society;

    type MaxApprovals = MaxApprovals;

    type WeightInfo = ();

    type SpendFunds = Bounties;

    type SpendOrigin = TreasurySpender;

    type AssetKind = VersionedLocatableAsset;

    type Beneficiary = VersionedLocation;

    type BeneficiaryLookup = IdentityLookup<Self::Beneficiary>;

    type Paymaster = PayOverXcm<

        TreasuryInteriorLocation,

        crate::xcm_config::XcmRouter,

        crate::XcmPallet,

        ConstU32<{ 6 * HOURS }>,

        Self::Beneficiary,

        Self::AssetKind,

        LocatableAssetConverter,

        VersionedLocationConverter,

    >;

    type BalanceConverter = UnityOrOuterConversion<

        ContainsParts<

            FromContains<

                xcm_builder::IsChildSystemParachain<ParaId>,

                xcm_builder::IsParentsOnly<ConstU8<1>>,

            >,

        >,

        AssetRate,

    >;

    type PayoutPeriod = PayoutSpendPeriod;

    #[cfg(feature = "runtime-benchmarks")]

    type BenchmarkHelper = runtime_common::impls::benchmarks::TreasuryArguments;

}

parameter_types! {

    pub const BountyDepositBase: Balance = 100 * CENTS;

    pub const BountyDepositPayoutDelay: BlockNumber = 4 * DAYS;

    pub const BountyUpdatePeriod: BlockNumber = 90 * DAYS;

    pub const MaximumReasonLength: u32 = 16384;

    pub const CuratorDepositMultiplier: Permill = Permill::from_percent(50);

    pub const CuratorDepositMin: Balance = 10 * CENTS;

    pub const CuratorDepositMax: Balance = 500 * CENTS;

    pub const BountyValueMinimum: Balance = 200 * CENTS;

}

impl pallet_bounties::Config for Runtime {

    type BountyDepositBase = BountyDepositBase;

    type BountyDepositPayoutDelay = BountyDepositPayoutDelay;

    type BountyUpdatePeriod = BountyUpdatePeriod;

    type CuratorDepositMultiplier = CuratorDepositMultiplier;

    type CuratorDepositMin = CuratorDepositMin;

    type CuratorDepositMax = CuratorDepositMax;

    type BountyValueMinimum = BountyValueMinimum;

    type ChildBountyManager = ChildBounties;

    type DataDepositPerByte = DataDepositPerByte;

    type RuntimeEvent = RuntimeEvent;

    type MaximumReasonLength = MaximumReasonLength;

    type WeightInfo = ();

}

parameter_types! {

    pub const MaxActiveChildBountyCount: u32 = 100;

    pub ChildBountyValueMinimum: Balance = BountyValueMinimum::get() / 10;

}

impl pallet_child_bounties::Config for Runtime {

    type RuntimeEvent = RuntimeEvent;

    type MaxActiveChildBountyCount = MaxActiveChildBountyCount;

    type ChildBountyValueMinimum = ChildBountyValueMinimum;

    type WeightInfo = ();

}

impl pallet_offences::Config for Runtime {

    type RuntimeEvent = RuntimeEvent;

    type IdentificationTuple = pallet_session::historical::IdentificationTuple<Self>;

    type OnOffenceHandler = ();

}

impl pallet_authority_discovery::Config for Runtime {

    type MaxAuthorities = MaxAuthorities;

}

parameter_types! {

    pub const MaxSetIdSessionEntries: u32 = BondingDuration::get() * SessionsPerEra::get();

}

impl pallet_grandpa::Config for Runtime {

    type RuntimeEvent = RuntimeEvent;

    type WeightInfo = ();

    type MaxAuthorities = MaxAuthorities;

    type MaxNominators = ConstU32<0>;

    type MaxSetIdSessionEntries = MaxSetIdSessionEntries;

    type KeyOwnerProof = sp_session::MembershipProof;

    type EquivocationReportSystem =

        pallet_grandpa::EquivocationReportSystem<Self, Offences, Historical, ReportLongevity>;

}

/// Submits a transaction with the node's public and signature type. Adheres to the signed extension

/// format of the chain.

impl<LocalCall> frame_system::offchain::CreateSignedTransaction<LocalCall> for Runtime

where

    RuntimeCall: From<LocalCall>,

{

}

impl frame_system::offchain::SigningTypes for Runtime {

    type Public = <Signature as Verify>::Signer;

    type Signature = Signature;

}

impl<C> frame_system::offchain::SendTransactionTypes<C> for Runtime

where

    RuntimeCall: From<C>,

{

    type Extrinsic = UncheckedExtrinsic;

    type OverarchingCall = RuntimeCall;

}

parameter_types! {

    pub Prefix: &'static [u8] = b"Pay ROCs to the Starlight account:";

}

impl claims::Config for Runtime {

    type RuntimeEvent = RuntimeEvent;

    type VestingSchedule = Vesting;

    type Prefix = Prefix;

    type MoveClaimOrigin = EnsureRoot<AccountId>;

    type WeightInfo = claims::TestWeightInfo;

}

parameter_types! {

    // Minimum 100 bytes/STAR deposited (1 CENT/byte)

    pub const BasicDeposit: Balance = 1000 * CENTS;       // 258 bytes on-chain

    pub const ByteDeposit: Balance = deposit(0, 1);

    pub const SubAccountDeposit: Balance = 200 * CENTS;   // 53 bytes on-chain

    pub const MaxSubAccounts: u32 = 100;

    pub const MaxAdditionalFields: u32 = 100;

    pub const MaxRegistrars: u32 = 20;

}

impl pallet_identity::Config for Runtime {

    type RuntimeEvent = RuntimeEvent;

    type Currency = Balances;

    type BasicDeposit = BasicDeposit;

    type ByteDeposit = ByteDeposit;

    type SubAccountDeposit = SubAccountDeposit;

    type MaxSubAccounts = MaxSubAccounts;

    type IdentityInformation = IdentityInfo<MaxAdditionalFields>;

    type MaxRegistrars = MaxRegistrars;

    type Slashed = Treasury;

    type ForceOrigin = EitherOf<EnsureRoot<Self::AccountId>, GeneralAdmin>;

    type RegistrarOrigin = EitherOf<EnsureRoot<Self::AccountId>, GeneralAdmin>;

    type OffchainSignature = Signature;

    type SigningPublicKey = <Signature as Verify>::Signer;

    type UsernameAuthorityOrigin = EnsureRoot<Self::AccountId>;

    type PendingUsernameExpiration = ConstU32<{ 7 * DAYS }>;

    type MaxSuffixLength = ConstU32<7>;

    type MaxUsernameLength = ConstU32<32>;

    type WeightInfo = ();

}

impl pallet_utility::Config for Runtime {

    type RuntimeEvent = RuntimeEvent;

    type RuntimeCall = RuntimeCall;

    type PalletsOrigin = OriginCaller;

    type WeightInfo = ();

}

parameter_types! {

    // One storage item; key size is 32; value is size 4+4+16+32 bytes = 56 bytes.

    pub const DepositBase: Balance = deposit(1, 88);

    // Additional storage item size of 32 bytes.

    pub const DepositFactor: Balance = deposit(0, 32);

    pub const MaxSignatories: u32 = 100;

}

impl pallet_multisig::Config for Runtime {

    type RuntimeEvent = RuntimeEvent;

    type RuntimeCall = RuntimeCall;

    type Currency = Balances;

    type DepositBase = DepositBase;

    type DepositFactor = DepositFactor;

    type MaxSignatories = MaxSignatories;

    type WeightInfo = ();

}

parameter_types! {

    pub const ConfigDepositBase: Balance = 500 * CENTS;

    pub const FriendDepositFactor: Balance = 50 * CENTS;

    pub const MaxFriends: u16 = 9;

    pub const RecoveryDeposit: Balance = 500 * CENTS;

}

impl pallet_recovery::Config for Runtime {

    type RuntimeEvent = RuntimeEvent;

    type WeightInfo = ();

    type RuntimeCall = RuntimeCall;

    type Currency = Balances;

    type ConfigDepositBase = ConfigDepositBase;

    type FriendDepositFactor = FriendDepositFactor;

    type MaxFriends = MaxFriends;

    type RecoveryDeposit = RecoveryDeposit;

}

parameter_types! {

    pub const SocietyPalletId: PalletId = PalletId(*b"py/socie");

}

impl pallet_society::Config for Runtime {

    type RuntimeEvent = RuntimeEvent;

    type Currency = Balances;

    type Randomness = pallet_babe::RandomnessFromOneEpochAgo<Runtime>;

    type GraceStrikes = ConstU32<1>;

    type PeriodSpend = ConstU128<{ 50_000 * CENTS }>;

    type VotingPeriod = ConstU32<{ 5 * DAYS }>;

    type ClaimPeriod = ConstU32<{ 2 * DAYS }>;

    type MaxLockDuration = ConstU32<{ 36 * 30 * DAYS }>;

    type FounderSetOrigin = EnsureRoot<AccountId>;

    type ChallengePeriod = ConstU32<{ 7 * DAYS }>;

    type MaxPayouts = ConstU32<8>;

    type MaxBids = ConstU32<512>;

    type PalletId = SocietyPalletId;

    type WeightInfo = ();

}

parameter_types! {

    pub const MinVestedTransfer: Balance = 100 * CENTS;

    pub UnvestedFundsAllowedWithdrawReasons: WithdrawReasons =

        WithdrawReasons::except(WithdrawReasons::TRANSFER | WithdrawReasons::RESERVE);

}

impl pallet_vesting::Config for Runtime {

    type RuntimeEvent = RuntimeEvent;

    type Currency = Balances;

    type BlockNumberToBalance = ConvertInto;

    type MinVestedTransfer = MinVestedTransfer;

    type WeightInfo = ();

    type UnvestedFundsAllowedWithdrawReasons = UnvestedFundsAllowedWithdrawReasons;

    type BlockNumberProvider = System;

    const MAX_VESTING_SCHEDULES: u32 = 28;

}

parameter_types! {

    // One storage item; key size 32, value size 8; .

    pub const ProxyDepositBase: Balance = deposit(1, 8);

    // Additional storage item size of 33 bytes.

    pub const ProxyDepositFactor: Balance = deposit(0, 33);

    pub const MaxProxies: u16 = 32;

    pub const AnnouncementDepositBase: Balance = deposit(1, 8);

    pub const AnnouncementDepositFactor: Balance = deposit(0, 66);

    pub const MaxPending: u16 = 32;

}

/// The type used to represent the kinds of proxying allowed.

#[derive(

    Copy,

    Clone,

    Eq,

    PartialEq,

    Ord,

    PartialOrd,

    Encode,

)]

pub enum ProxyType {

}

impl Default for ProxyType {

}

impl InstanceFilter<RuntimeCall> for ProxyType {

                RuntimeCall::System(..) |

				RuntimeCall::Babe(..) |

				RuntimeCall::Timestamp(..) |

				RuntimeCall::Indices(pallet_indices::Call::claim {..}) |

				RuntimeCall::Indices(pallet_indices::Call::free {..}) |

				RuntimeCall::Indices(pallet_indices::Call::freeze {..}) |

				// Specifically omitting Indices `transfer`, `force_transfer`

				// Specifically omitting the entire Balances pallet

				RuntimeCall::Session(..) |

				RuntimeCall::Grandpa(..) |

				RuntimeCall::Treasury(..) |

				RuntimeCall::Bounties(..) |

				RuntimeCall::ChildBounties(..) |

				RuntimeCall::ConvictionVoting(..) |

				RuntimeCall::Referenda(..) |

				RuntimeCall::FellowshipCollective(..) |

				RuntimeCall::FellowshipReferenda(..) |

				RuntimeCall::Whitelist(..) |

				RuntimeCall::Claims(..) |

				RuntimeCall::Utility(..) |

				RuntimeCall::Identity(..) |

				RuntimeCall::Society(..) |

				RuntimeCall::Recovery(pallet_recovery::Call::as_recovered {..}) |

				RuntimeCall::Recovery(pallet_recovery::Call::vouch_recovery {..}) |

				RuntimeCall::Recovery(pallet_recovery::Call::claim_recovery {..}) |

				RuntimeCall::Recovery(pallet_recovery::Call::close_recovery {..}) |

				RuntimeCall::Recovery(pallet_recovery::Call::remove_recovery {..}) |

				RuntimeCall::Recovery(pallet_recovery::Call::cancel_recovered {..}) |

				// Specifically omitting Recovery `create_recovery`, `initiate_recovery`

				RuntimeCall::Vesting(pallet_vesting::Call::vest {..}) |

				RuntimeCall::Vesting(pallet_vesting::Call::vest_other {..}) |

				// Specifically omitting Vesting `vested_transfer`, and `force_vested_transfer`

				RuntimeCall::Scheduler(..) |

				RuntimeCall::Proxy(..) |

				RuntimeCall::Multisig(..) |

				RuntimeCall::Nis(..) |

				RuntimeCall::Registrar(paras_registrar::Call::register {..}) |

				RuntimeCall::Registrar(paras_registrar::Call::deregister {..}) |

				// Specifically omitting Registrar `swap`

				RuntimeCall::Registrar(paras_registrar::Call::reserve {..}) |

				RuntimeCall::Crowdloan(..) |

				RuntimeCall::Slots(..) |

				RuntimeCall::Auctions(..) // Specifically omitting the entire XCM Pallet

            ),

                RuntimeCall::Bounties(..) |

					RuntimeCall::Utility(..) |

					RuntimeCall::ChildBounties(..) |

					// OpenGov calls

					RuntimeCall::ConvictionVoting(..) |

					RuntimeCall::Referenda(..) |

					RuntimeCall::FellowshipCollective(..) |

					RuntimeCall::FellowshipReferenda(..) |

					RuntimeCall::Whitelist(..)

            ),

                RuntimeCall::Identity(pallet_identity::Call::provide_judgement { .. })

                    | RuntimeCall::Utility(..)

            ),

            ProxyType::CancelProxy => {

                    RuntimeCall::Proxy(pallet_proxy::Call::reject_announcement { .. })

                )

            }

                RuntimeCall::Auctions { .. }

                    | RuntimeCall::Crowdloan { .. }

                    | RuntimeCall::Registrar { .. }

                    | RuntimeCall::Multisig(..)

                    | RuntimeCall::Slots { .. }

            ),

        }

        }

}

impl pallet_proxy::Config for Runtime {

    type RuntimeEvent = RuntimeEvent;

    type RuntimeCall = RuntimeCall;

    type Currency = Balances;

    type ProxyType = ProxyType;

    type ProxyDepositBase = ProxyDepositBase;

    type ProxyDepositFactor = ProxyDepositFactor;

    type MaxProxies = MaxProxies;

    type WeightInfo = ();

    type MaxPending = MaxPending;

    type CallHasher = BlakeTwo256;

    type AnnouncementDepositBase = AnnouncementDepositBase;

    type AnnouncementDepositFactor = AnnouncementDepositFactor;

}

impl parachains_origin::Config for Runtime {}

impl parachains_configuration::Config for Runtime {

    type WeightInfo = parachains_configuration::TestWeightInfo;

}

impl parachains_shared::Config for Runtime {

    type DisabledValidators = Session;

}

impl parachains_session_info::Config for Runtime {

    type ValidatorSet = Historical;

}

/// Special `RewardValidators` that does nothing ;)

pub struct RewardValidators;

impl runtime_parachains::inclusion::RewardValidators for RewardValidators {

}

impl parachains_inclusion::Config for Runtime {

    type RuntimeEvent = RuntimeEvent;

    type DisputesHandler = ParasDisputes;

    type RewardValidators = RewardValidators;

    type MessageQueue = MessageQueue;

    type WeightInfo = ();

}

parameter_types! {

    pub const ParasUnsignedPriority: TransactionPriority = TransactionPriority::max_value();

}

impl parachains_paras::Config for Runtime {

    type RuntimeEvent = RuntimeEvent;

    type WeightInfo = parachains_paras::TestWeightInfo;

    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;

}

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;

}

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 {

}

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;