// 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 Dancelight 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 frame_support::storage::{with_storage_layer, with_transaction};

// Fix compile error in impl_runtime_weights! macro

use {

    authority_discovery_primitives::AuthorityId as AuthorityDiscoveryId,

    beefy_primitives::{

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

        mmr::{BeefyDataProvider, MmrLeafVersion},

    },

    cumulus_primitives_core::relay_chain::{HeadData, ValidationCode},

    dp_container_chain_genesis_data::ContainerChainGenesisDataItem,

    frame_support::{

        dispatch::{DispatchErrorWithPostInfo, DispatchResult},

        dynamic_params::{dynamic_pallet_params, dynamic_params},

        traits::{

            fungible::Inspect,

            tokens::{PayFromAccount, UnityAssetBalanceConversion},

            ConstBool, Contains, EverythingBut,

        },

    },

    frame_system::{pallet_prelude::BlockNumberFor, EnsureNever},

    nimbus_primitives::NimbusId,

    pallet_collator_assignment::{GetRandomnessForNextBlock, RotateCollatorsEveryNSessions},

    pallet_initializer as tanssi_initializer,

    pallet_invulnerables::InvulnerableRewardDistribution,

    pallet_registrar::Error as ContainerRegistrarError,

    pallet_registrar_runtime_api::ContainerChainGenesisData,

    pallet_services_payment::{ProvideBlockProductionCost, ProvideCollatorAssignmentCost},

    parachains_scheduler::common::Assignment,

    parity_scale_codec::{Decode, Encode, MaxEncodedLen},

    primitives::{

        slashing, ApprovalVotingParams, BlockNumber, CandidateEvent, CandidateHash,

        CommittedCandidateReceipt, CoreIndex, CoreState, DisputeState, ExecutorParams,

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

        NodeFeatures, Nonce, OccupiedCoreAssumption, PersistedValidationData, ScrapedOnChainVotes,

        SessionInfo, Signature, ValidationCodeHash, ValidatorId, ValidatorIndex,

        PARACHAIN_KEY_TYPE_ID,

    },

    runtime_common::{

        self as polkadot_runtime_common, impl_runtime_weights, impls::ToAuthor, paras_registrar,

        paras_sudo_wrapper, traits::Registrar as RegistrarInterface, BlockHashCount, BlockLength,

        SlowAdjustingFeeUpdate,

    },

    runtime_parachains::{

        configuration as parachains_configuration,

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

        dmp as parachains_dmp, hrmp as parachains_hrmp,

        inclusion::{self as parachains_inclusion, UmpQueueId},

        initializer as parachains_initializer, on_demand as parachains_assigner_on_demand,

        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,

    serde::{Deserialize, Serialize},

    snowbridge_core::{

        outbound::{Command, Fee},

        ChannelId, PricingParameters,

    },

    snowbridge_pallet_outbound_queue::MerkleProof,

    sp_core::{storage::well_known_keys as StorageWellKnownKeys, Get},

    sp_genesis_builder::PresetId,

    sp_runtime::{

        traits::{BlockNumberProvider, ConvertInto},

        AccountId32,

    },

    sp_std::{

        cmp::Ordering,

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

        marker::PhantomData,

        prelude::*,

    },

    tp_bridge::ConvertLocation,

    tp_traits::{

        apply, derive_storage_traits, EraIndex, GetHostConfiguration, GetSessionContainerChains,

        ParaIdAssignmentHooks, RegistrarHandler, 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::{Balanced, Credit, HoldConsideration},

            EitherOf, EitherOfDiverse, EnsureOriginWithArg, 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::{OpaqueMetadata, H256},

    sp_runtime::{

        create_runtime_str, generic, impl_opaque_keys,

        traits::{

            AccountIdConversion, BlakeTwo256, Block as BlockT, ConstU32, Convert,

            Extrinsic as ExtrinsicT, Hash as HashT, 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,

    },

};

pub use {

    frame_system::Call as SystemCall,

    pallet_balances::Call as BalancesCall,

    primitives::{AccountId, Balance},

};

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

use snowbridge_core::{AgentId, TokenId};

/// Constant values used within the runtime.

use dancelight_runtime_constants::{currency::*, fee::*, snowbridge::EthereumLocation, time::*};

// XCM configurations.

pub mod xcm_config;

pub mod bridge_to_ethereum_config;

// Weights

mod weights;

// Governance and configurations.

pub mod governance;

use {

    governance::{

        pallet_custom_origins, AuctionAdmin, Fellows, GeneralAdmin, Treasurer, TreasurySpender,

    },

    pallet_collator_assignment::CoreAllocationConfiguration,

    xcm_runtime_apis::fees::Error as XcmPaymentApiError,

};

#[cfg(test)]

mod tests;

pub mod genesis_config_presets;

impl_runtime_weights!(dancelight_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 (Dancelight).

#[sp_version::runtime_version]

pub const VERSION: RuntimeVersion = RuntimeVersion {

    spec_name: create_runtime_str!("dancelight"),

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

    authoring_version: 0,

    spec_version: 1200,

    impl_version: 0,

    apis: RUNTIME_API_VERSIONS,

    transaction_version: 26,

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

/// Aggregate message origin for the `MessageQueue` pallet.

///

/// Can be extended to serve further use-cases besides just UMP. Is stored in storage, so any change

/// to existing values will require a migration.

pub enum AggregateMessageOrigin {

    #[codec(index = 0)]

    Ump(UmpQueueId),

    #[codec(index = 1)]

    Snowbridge(ChannelId),

    /// This will be processed by `CustomProcessSnowbridgeMessage`.

    #[codec(index = 2)]

    SnowbridgeTanssi(ChannelId),

}

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

impl From<u32> for AggregateMessageOrigin {

    fn from(n: u32) -> Self {

        // Some dummy for the benchmarks.

        Self::Ump(UmpQueueId::Para(n.into()))

    }

}

pub struct GetAggregateMessageOrigin;

impl Convert<ChannelId, AggregateMessageOrigin> for GetAggregateMessageOrigin {

}

impl Convert<UmpQueueId, AggregateMessageOrigin> for GetAggregateMessageOrigin {

}

pub struct GetAggregateMessageOriginTanssi;

impl Convert<ChannelId, AggregateMessageOrigin> for GetAggregateMessageOriginTanssi {

}

/// This is used by [parachains_inclusion::Pallet::on_queue_changed]

pub struct GetParaFromAggregateMessageOrigin;

impl Convert<AggregateMessageOrigin, ParaId> for GetParaFromAggregateMessageOrigin {

                // Read para id from EthereumSystem::channels storage map

                    None => {

                        // This should be unreachable, but return para id 0 if channel does not exist

                            channel_id

                        );

                    }

                }

            }

        }

}

/// The relay register and deregister calls should no longer be necessary

/// Everything is handled by the containerRegistrar

pub struct IsRelayRegister;

impl Contains<RuntimeCall> for IsRelayRegister {

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

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

        )

}

/// Dancelight shouold not permit parathread registration for now

/// TODO: remove once they are enabled

pub struct IsParathreadRegistrar;

impl Contains<RuntimeCall> for IsParathreadRegistrar {

            RuntimeCall::ContainerRegistrar(pallet_registrar::Call::register_parathread { .. })

        )

}

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

    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 = weights::frame_system::SubstrateWeight<Runtime>;

    type SS58Prefix = SS58Prefix;

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

    type MultiBlockMigrator = MultiBlockMigrations;

}

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

        use crate::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 = weights::pallet_scheduler::SubstrateWeight<Runtime>;

    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 = weights::pallet_preimage::SubstrateWeight<Runtime>;

    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;

    // Not benchmarked in Kusama

    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 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 = weights::pallet_balances::SubstrateWeight<Runtime>;

    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 = weights::pallet_timestamp::SubstrateWeight<Runtime>;

}

pub struct RewardPoints;

impl pallet_authorship::EventHandler<AccountId, BlockNumberFor<Runtime>> for RewardPoints {

}

impl pallet_authorship::Config for Runtime {

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

    type EventHandler = RewardPoints;

}

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

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

    type Keys = SessionKeys;

    // TODO: Current benchmarking code for pallet_session requires that the runtime

    // uses pallet_staking, which we don't use. We need to make a PR to Substrate to

    // allow decoupling the benchmark from other pallets.

    // See https://github.com/paritytech/polkadot-sdk/blob/0845044454c005b577eab7afaea18583bd7e3dd3/substrate/frame/session/benchmarking/src/inner.rs#L38

    type WeightInfo = ();

}

pub struct FullIdentificationOf;

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

}

impl pallet_session::historical::Config for Runtime {

    type FullIdentification = ();

    type FullIdentificationOf = FullIdentificationOf;

}

parameter_types! {

    pub const BondingDuration: sp_staking::EraIndex = runtime_common::prod_or_fast!(28, 3);

}

parameter_types! {

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

    pub const ProposalBondMinimum: Balance = 2000 * CENTS;

    pub const ProposalBondMaximum: Balance = 1 * GRAND;

    // We allow it to be 1 minute in fast mode to be able to test it

    pub const SpendPeriod: BlockNumber = runtime_common::prod_or_fast!(6 * DAYS, 1 * MINUTES);

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

    pub TreasuryAccount: AccountId = Treasury::account_id();

}

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

pub struct TreasuryBenchmarkHelper<T>(PhantomData<T>);

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

use frame_support::traits::Currency;

use frame_support::traits::{

    ExistenceRequirement, OnUnbalanced, ValidatorRegistration, WithdrawReasons,

};

use pallet_services_payment::BalanceOf;

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

use pallet_treasury::ArgumentsFactory;

use runtime_parachains::configuration::HostConfiguration;

use sp_runtime::{DispatchError, TransactionOutcome};

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

impl<T> ArgumentsFactory<(), T::AccountId> for TreasuryBenchmarkHelper<T>

where

    T: pallet_treasury::Config,

    T::AccountId: From<[u8; 32]>,

{

    fn create_asset_kind(_seed: u32) {}

    fn create_beneficiary(seed: [u8; 32]) -> T::AccountId {

        let account: T::AccountId = seed.into();

        let balance = T::Currency::minimum_balance();

        let _ = T::Currency::make_free_balance_be(&account, balance);

        account

    }

}

impl pallet_treasury::Config for Runtime {

    type PalletId = TreasuryPalletId;

    type Currency = Balances;

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

    type RuntimeEvent = RuntimeEvent;

    type SpendPeriod = SpendPeriod;

    type Burn = Burn;

    type BurnDestination = ();

    type MaxApprovals = MaxApprovals;

    type WeightInfo = weights::pallet_treasury::SubstrateWeight<Runtime>;

    type SpendFunds = ();

    type SpendOrigin = TreasurySpender;

    type AssetKind = ();

    type Beneficiary = AccountId;

    type BeneficiaryLookup = IdentityLookup<Self::Beneficiary>;

    type Paymaster = PayFromAccount<Balances, TreasuryAccount>;

    type BalanceConverter = UnityAssetBalanceConversion;

    type PayoutPeriod = PayoutSpendPeriod;

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

    type BenchmarkHelper = TreasuryBenchmarkHelper<Runtime>;

}

impl pallet_offences::Config for Runtime {

    type RuntimeEvent = RuntimeEvent;

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

    type OnOffenceHandler = ExternalValidatorSlashes;

}

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;

    // Not benchmarked in Kusama, benchmarking code also don't match WeightInfo trait.

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

{

        use sp_runtime::traits::StaticLookup;

        // take the biggest period possible.

}

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 = weights::pallet_identity::SubstrateWeight<Runtime>;

}

impl pallet_utility::Config for Runtime {

    type RuntimeEvent = RuntimeEvent;

    type RuntimeCall = RuntimeCall;

    type PalletsOrigin = OriginCaller;

    type WeightInfo = weights::pallet_utility::SubstrateWeight<Runtime>;

}

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 = weights::pallet_multisig::SubstrateWeight<Runtime>;

}

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(..) |

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

            }

                        &RuntimeCall::DataPreservers(..)

                            | &RuntimeCall::Registrar(..)

                            | &RuntimeCall::ContainerRegistrar(..)

                            | &RuntimeCall::Paras(..)

                            | &RuntimeCall::ParasSudoWrapper(..)

                    )

                }

            },

                        &RuntimeCall::ExternalValidators(..)

                            | &RuntimeCall::ExternalValidatorSlashes(..)

                    )

                }

            },

            ProxyType::SessionKeyManagement => {

            }

            ProxyType::Staking => {

            }

        }

        }

}

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 = weights::pallet_proxy::SubstrateWeight<Runtime>;

    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 = weights::runtime_parachains_configuration::SubstrateWeight<Runtime>;

}

impl parachains_shared::Config for Runtime {

    type DisabledValidators = Session;

}

impl parachains_session_info::Config for Runtime {

    type ValidatorSet = Historical;

}

pub type RewardValidators =

    pallet_external_validators_rewards::RewardValidatorsWithEraPoints<Runtime>;

impl parachains_inclusion::Config for Runtime {

    type RuntimeEvent = RuntimeEvent;

    type DisputesHandler = ParasDisputes;

    type RewardValidators = RewardValidators;

    type AggregateMessageOrigin = AggregateMessageOrigin;

    type GetAggregateMessageOrigin = GetAggregateMessageOrigin;

    type GetParaFromAggregateMessageOrigin = GetParaFromAggregateMessageOrigin;

    type MessageQueue = MessageQueue;

    type WeightInfo = weights::runtime_parachains_inclusion::SubstrateWeight<Runtime>;

}

parameter_types! {

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

}

impl parachains_paras::Config for Runtime {

    type RuntimeEvent = RuntimeEvent;

    type WeightInfo = weights::runtime_parachains_paras::SubstrateWeight<Runtime>;

    type UnsignedPriority = ParasUnsignedPriority;

    type QueueFootprinter = ParaInclusion;

    type NextSessionRotation = Babe;

    type OnNewHead = Registrar;

    type AssignCoretime = ();

}

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;

            }

            AggregateMessageOrigin::Snowbridge(_) => {

            }

            AggregateMessageOrigin::SnowbridgeTanssi(_) => {

            }

        }

}

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 = weights::pallet_message_queue::SubstrateWeight<Runtime>;

}

impl parachains_dmp::Config for Runtime {}

parameter_types! {

    pub const HrmpChannelSizeAndCapacityWithSystemRatio: Percent = Percent::from_percent(100);

}

impl parachains_hrmp::Config for Runtime {

    type RuntimeOrigin = RuntimeOrigin;

    type RuntimeEvent = RuntimeEvent;

    type ChannelManager = EnsureRoot<AccountId>;

    type Currency = Balances;

    type DefaultChannelSizeAndCapacityWithSystem =

        parachains_configuration::ActiveConfigHrmpChannelSizeAndCapacityRatio<

            Runtime,

            HrmpChannelSizeAndCapacityWithSystemRatio,

        >;

    type WeightInfo = weights::runtime_parachains_hrmp::SubstrateWeight<Runtime>;

    type VersionWrapper = XcmPallet;

}

impl parachains_paras_inherent::Config for Runtime {

    type WeightInfo = weights::runtime_parachains_paras_inherent::SubstrateWeight<Runtime>;

}

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

}

pub struct CollatorAssignmentProvider;

impl parachains_scheduler::common::AssignmentProvider<BlockNumberFor<Runtime>>

    for CollatorAssignmentProvider

{

                } else {

                }

        } else {

            // We dont want to assign affinity to a parathread that has not collators assigned

            // Even if we did they would need their own collators to produce blocks, but for now

            // I prefer to forbid.

            // In this case the parathread would have bought the core for nothing

            // Let's check that we have collators before allowing an assignment

            {

            } else {

            }

        }

            Assignment::Pool {

        }

    /// Push an assignment back to the front of the queue.

    ///

    /// The assignment has not been processed yet. Typically used on session boundaries.

    /// Parameters:

    /// - `assignment`: The on demand assignment.

            Assignment::Pool {

        }

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

    fn get_mock_assignment(_: CoreIndex, para_id: primitives::Id) -> Assignment {

        // Given that we are not tracking anything in `Bulk` assignments, it is safe to always

        // return a bulk assignment.

        Assignment::Bulk(para_id)

    }

            config.scheduler_params.num_cores

        );

}

parameter_types! {

    pub const OnDemandTrafficDefaultValue: FixedU128 = FixedU128::from_u32(1);

    // Keep 2 blocks worth of revenue information.

    // We don't need this because it is only used by coretime and we don't have coretime,

    // but the pallet implicitly assumes that this bound is at least 1, so we use a low value

    // that won't cause problems.

    pub const MaxHistoricalRevenue: BlockNumber = 2;

    pub const OnDemandPalletId: PalletId = PalletId(*b"py/ondmd");

}

impl parachains_assigner_on_demand::Config for Runtime {

    type RuntimeEvent = RuntimeEvent;

    type Currency = Balances;

    type TrafficDefaultValue = OnDemandTrafficDefaultValue;

    type WeightInfo = weights::runtime_parachains_assigner_on_demand::SubstrateWeight<Runtime>;

    type MaxHistoricalRevenue = MaxHistoricalRevenue;

    type PalletId = OnDemandPalletId;

}

impl parachains_initializer::Config for Runtime {

    type Randomness = pallet_babe::RandomnessFromOneEpochAgo<Runtime>;

    type ForceOrigin = EnsureRoot<AccountId>;

    type WeightInfo = weights::runtime_parachains_initializer::SubstrateWeight<Runtime>;

    type CoretimeOnNewSession = ();

}

impl parachains_disputes::Config for Runtime {

    type RuntimeEvent = RuntimeEvent;

    type RewardValidators = RewardValidators;

    type SlashingHandler = parachains_slashing::SlashValidatorsForDisputes<ParasSlashing>;

    type WeightInfo = weights::runtime_parachains_disputes::SubstrateWeight<Runtime>;

}

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 = weights::runtime_common_paras_registrar::SubstrateWeight<Runtime>;

}

impl pallet_parameters::Config for Runtime {

    type RuntimeEvent = RuntimeEvent;

    type RuntimeParameters = RuntimeParameters;

    type AdminOrigin = DynamicParameterOrigin;

    type WeightInfo = weights::pallet_parameters::SubstrateWeight<Runtime>;

}

parameter_types! {

    // TODO: BondingDuration is set to 28 days on Polkadot,

    // check which value to use in Starlight.

    pub BeefySetIdSessionEntries: u32 = BondingDuration::get() * SessionsPerEra::get();

}

impl pallet_beefy::Config for Runtime {

    type BeefyId = BeefyId;

    type MaxAuthorities = MaxAuthorities;

    // MaxNominators is used in case we need to slash validators and check how many

    // nominators do they have as maximum.

    // This value is part of the parameters that are then used for extrinsics

    // weight computation.

    type MaxNominators = ConstU32<0>;

    type MaxSetIdSessionEntries = BeefySetIdSessionEntries;

    type OnNewValidatorSet = BeefyMmrLeaf;

    // There are currently no benchmarks for pallet_beefy.

    // https://github.com/paritytech/polkadot-sdk/tree/master/substrate/frame/beefy/src

    type WeightInfo = ();

    type KeyOwnerProof = <Historical as KeyOwnerProofSystem<(KeyTypeId, BeefyId)>>::Proof;

    type EquivocationReportSystem =

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

    type AncestryHelper = BeefyMmrLeaf;

}

/// 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 = weights::pallet_mmr::SubstrateWeight<Runtime>;

    type LeafData = pallet_beefy_mmr::Pallet<Runtime>;

    type BlockHashProvider = pallet_mmr::DefaultBlockHashProvider<Runtime>;

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

    type BenchmarkHelper = ();

}