// 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::{ConstBool, FromContains},

    },

    frame_system::EnsureNever,

    pallet_initializer as tanssi_initializer,

    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::{

        impl_runtime_weights,

        impls::{

            ContainsParts, LocatableAssetConverter, ToAuthor, VersionedLocatableAsset,

            VersionedLocationConverter,

        },

        paras_registrar, paras_sudo_wrapper, 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, EnsureOriginWithArg, EverythingBut, InstanceFilter,

            KeyOwnerProofSystem, LinearStoragePrice, PrivilegeCmp, ProcessMessage,

            ProcessMessageError,

        },

        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::{ConstU8, OpaqueMetadata, H256},

    sp_runtime::{

        create_runtime_str, generic, impl_opaque_keys,

        traits::{

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

            Keccak256, OpaqueKeys, SaturatedConversion, Verify, Zero,

        },

        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, 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 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 = ();

    #[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: Initializer,

        pub para_assignment: ParaSessionInfo,

        pub authority_discovery: AuthorityDiscovery,

        pub beefy: Beefy,

        pub nimbus: TanssiInitializer,

    }

}

/// 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 = ();

    type MaxApprovals = MaxApprovals;

    type WeightInfo = ();

    type SpendFunds = ();

    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;

}

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! {

    // 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! {

    // 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::ConvictionVoting(..) |

				RuntimeCall::Referenda(..) |

				RuntimeCall::FellowshipCollective(..) |

				RuntimeCall::FellowshipReferenda(..) |

				RuntimeCall::Whitelist(..) |

				RuntimeCall::Utility(..) |

				RuntimeCall::Identity(..) |

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

				RuntimeCall::Scheduler(..) |

				RuntimeCall::Proxy(..) |

				RuntimeCall::Multisig(..) |

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

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

				// Specifically omitting Registrar `swap`

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

            ),

                RuntimeCall::Utility(..) |

					// 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 { .. })

                )

            }

            ProxyType::Auction => {

            }

        }

        }

}

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 = ();

    type ParaDeposit = ParaDeposit;

    type DataDepositPerByte = DataDepositPerByte;

    type WeightInfo = paras_registrar::TestWeightInfo;

}

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;

    pub const TemporarySlotLeasePeriodLength: u32 = 5;

    pub const MaxTemporarySlotPerLeasePeriod: u32 = 5;

}

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;

}

parameter_types! {

    pub const MaxInvulnerables: u32 = 100;

}

impl pallet_invulnerables::Config for Runtime {

    type RuntimeEvent = RuntimeEvent;

    type UpdateOrigin = EnsureRoot<AccountId>;

    type MaxInvulnerables = MaxInvulnerables;

    type CollatorId = <Self as frame_system::Config>::AccountId;

    type CollatorIdOf = pallet_invulnerables::IdentityCollator;

    type CollatorRegistration = Session;

    type WeightInfo = ();

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

    type Currency = Balances;

}

pub struct CurrentSessionIndexGetter;

impl tp_traits::GetSessionIndex<SessionIndex> for CurrentSessionIndexGetter {

    /// Returns current session index.

}

impl pallet_configuration::Config for Runtime {

    type SessionDelay = ConstU32<2>;

    type SessionIndex = SessionIndex;

    type CurrentSessionIndex = CurrentSessionIndexGetter;

    type ForceEmptyOrchestrator = ConstBool<true>;

    type WeightInfo = ();

}

/// 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};

    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>;