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

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

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

#![recursion_limit = "256"]

// Make the WASM binary available.

#[cfg(feature = "std")]

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

extern crate alloc;

pub mod xcm_config;

#[cfg(feature = "std")]

use sp_version::NativeVersion;

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

pub use sp_runtime::BuildStorage;

use sp_runtime::{DispatchError, TransactionOutcome};

pub mod weights;

use {

    alloc::{

        boxed::Box,

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

        vec,

        vec::Vec,

    },

    core::marker::PhantomData,

    cumulus_pallet_parachain_system::{

        RelayChainStateProof, RelayNumberMonotonicallyIncreases, RelaychainDataProvider,

        RelaychainStateProvider,

    },

    cumulus_primitives_core::{

        relay_chain::{self, SessionIndex},

        AggregateMessageOrigin, BodyId, ParaId,

    },

    frame_support::{

        construct_runtime,

        dispatch::DispatchClass,

        genesis_builder_helper::{build_state, get_preset},

        pallet_prelude::DispatchResult,

        parameter_types,

        traits::{

            fungible::{Balanced, Credit, Inspect},

            tokens::{ConversionToAssetBalance, PayFromAccount, UnityAssetBalanceConversion},

            ConstBool, ConstU128, ConstU32, ConstU64, ConstU8, Contains, EitherOfDiverse,

            InsideBoth, InstanceFilter, OnUnbalanced, ValidatorRegistration,

        },

        weights::{

            constants::{

                BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight,

                WEIGHT_REF_TIME_PER_SECOND,

            },

            ConstantMultiplier, Weight, WeightToFee as _, WeightToFeeCoefficient,

            WeightToFeeCoefficients, WeightToFeePolynomial,

        },

        PalletId,

    },

    frame_system::{

        limits::{BlockLength, BlockWeights},

        EnsureRoot, EnsureSigned,

    },

    nimbus_primitives::{NimbusId, SlotBeacon},

    pallet_collator_assignment::{GetRandomnessForNextBlock, RotateCollatorsEveryNSessions},

    pallet_invulnerables::InvulnerableRewardDistribution,

    pallet_pooled_staking::traits::IsCandidateEligible,

    pallet_registrar::RegistrarHooks,

    pallet_registrar_runtime_api::ContainerChainGenesisData,

    pallet_services_payment::{

        BalanceOf, ProvideBlockProductionCost, ProvideCollatorAssignmentCost,

    },

    pallet_session::{SessionManager, ShouldEndSession},

    pallet_stream_payment_runtime_api::{StreamPaymentApiError, StreamPaymentApiStatus},

    pallet_transaction_payment::FungibleAdapter,

    pallet_xcm_core_buyer::BuyingError,

    parity_scale_codec::DecodeWithMemTracking,

    polkadot_runtime_common::BlockHashCount,

    scale_info::prelude::format,

    smallvec::smallvec,

    sp_api::impl_runtime_apis,

    sp_consensus_aura::SlotDuration,

    sp_consensus_slots::Slot,

    sp_core::{crypto::KeyTypeId, Get, MaxEncodedLen, OpaqueMetadata, H256},

    sp_runtime::{

        generic, impl_opaque_keys,

        traits::{

            AccountIdConversion, AccountIdLookup, BlakeTwo256, Block as BlockT, ConvertInto,

            Hash as HashT, IdentityLookup, Verify,

        },

        transaction_validity::{TransactionSource, TransactionValidity},

        AccountId32, ApplyExtrinsicResult, Cow,

    },

    sp_version::RuntimeVersion,

    tanssi_runtime_common::SessionTimer,

    tp_stream_payment_common::StreamId,

    tp_traits::{

        apply, derive_storage_traits, GetContainerChainAuthor, GetHostConfiguration,

        GetSessionContainerChains, MaybeSelfChainBlockAuthor, NodeActivityTrackingHelper,

        ParaIdAssignmentHooks, RelayStorageRootProvider, RemoveInvulnerables, SlotFrequency,

    },

    tp_xcm_core_buyer::BuyCoreCollatorProof,

    xcm::Version as XcmVersion,

    xcm::{IntoVersion, VersionedAssetId, VersionedAssets, VersionedLocation, VersionedXcm},

    xcm_runtime_apis::{

        dry_run::{CallDryRunEffects, Error as XcmDryRunApiError, XcmDryRunEffects},

        fees::Error as XcmPaymentApiError,

    },

};

pub use {

    dp_core::{AccountId, Address, Balance, BlockNumber, Hash, Header, Index, Signature},

    sp_runtime::{MultiAddress, Perbill, Permill},

};

use {

    frame_support::{

        storage::{with_storage_layer, with_transaction},

        traits::{ExistenceRequirement, WithdrawReasons},

    },

    polkadot_runtime_common::SlowAdjustingFeeUpdate,

};

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

/// CollatorId type expected by this runtime.

pub type CollatorId = AccountId;

/// The `TxExtension` to the basic transaction logic.

pub type TxExtension = cumulus_pallet_weight_reclaim::StorageWeightReclaim<

    Runtime,

    (

        frame_system::CheckNonZeroSender<Runtime>,

        frame_system::CheckSpecVersion<Runtime>,

        frame_system::CheckTxVersion<Runtime>,

        frame_system::CheckGenesis<Runtime>,

        frame_system::CheckEra<Runtime>,

        frame_system::CheckNonce<Runtime>,

        frame_system::CheckWeight<Runtime>,

        pallet_transaction_payment::ChargeTransactionPayment<Runtime>,

        frame_metadata_hash_extension::CheckMetadataHash<Runtime>,

    ),

>;

/// Unchecked extrinsic type as expected by this runtime.

pub type UncheckedExtrinsic =

    generic::UncheckedExtrinsic<Address, RuntimeCall, Signature, TxExtension>;

/// Extrinsic type that has already been checked.

pub type CheckedExtrinsic = generic::CheckedExtrinsic<AccountId, RuntimeCall, TxExtension>;

/// Executive: handles dispatch to the various modules.

pub type Executive = frame_executive::Executive<

    Runtime,

    Block,

    frame_system::ChainContext<Runtime>,

    Runtime,

    AllPalletsWithSystem,

>;

/// DANCE, the native token, uses 12 decimals of precision.

pub mod currency {

    use super::Balance;

    // Provide a common factor between runtimes based on a supply of 10_000_000 tokens.

    pub const SUPPLY_FACTOR: Balance = 100;

    pub const MICRODANCE: Balance = 1_000_000;

    pub const MILLIDANCE: Balance = 1_000_000_000;

    pub const DANCE: Balance = 1_000_000_000_000;

    pub const KILODANCE: Balance = 1_000_000_000_000_000;

    pub const STORAGE_BYTE_FEE: Balance = 100 * MICRODANCE * SUPPLY_FACTOR;

    pub const STORAGE_ITEM_FEE: Balance = 100 * MILLIDANCE * SUPPLY_FACTOR;

}

/// Handles converting a weight scalar to a fee value, based on the scale and granularity of the

/// node's balance type.

///

/// This should typically create a mapping between the following ranges:

///   - `[0, MAXIMUM_BLOCK_WEIGHT]`

///   - `[Balance::min, Balance::max]`

///

/// Yet, it can be used for any other sort of change to weight-fee. Some examples being:

///   - Setting it to `0` will essentially disable the weight fee.

///   - Setting it to `1` will cause the literal `#[weight = x]` values to be charged.

pub struct WeightToFee;

impl WeightToFeePolynomial for WeightToFee {

    type Balance = Balance;

        // in Rococo, extrinsic base weight (smallest non-zero weight) is mapped to 1 MILLIUNIT:

        // in our template, we map to 1/10 of that, or 1/10 MILLIUNIT

}

/// Opaque types. These are used by the CLI to instantiate machinery that don't need to know

/// the specifics of the runtime. They can then be made to be agnostic over specific formats

/// of data like extrinsics, allowing for them to continue syncing the network through upgrades

/// to even the core data structures.

pub mod opaque {

    use {

        super::*,

        sp_runtime::{

            generic,

            traits::{BlakeTwo256, Hash as HashT},

        },

    };

    pub use sp_runtime::OpaqueExtrinsic as UncheckedExtrinsic;

    /// Opaque block header type.

    pub type Header = generic::Header<BlockNumber, BlakeTwo256>;

    /// Opaque block type.

    pub type Block = generic::Block<Header, UncheckedExtrinsic>;

    /// Opaque block identifier type.

    pub type BlockId = generic::BlockId<Block>;

    /// Opaque block hash type.

    pub type Hash = <BlakeTwo256 as HashT>::Output;

    /// Opaque signature type.

    pub use super::Signature;

}

impl_opaque_keys! {

    pub struct SessionKeys {

        pub nimbus: Initializer,

    }

}

#[sp_version::runtime_version]

pub const VERSION: RuntimeVersion = RuntimeVersion {

    spec_name: Cow::Borrowed("dancebox"),

    impl_name: Cow::Borrowed("dancebox"),

    authoring_version: 1,

    spec_version: 1700,

    impl_version: 0,

    apis: RUNTIME_API_VERSIONS,

    transaction_version: 1,

    system_version: 1,

};

/// This determines the average expected block time that we are targeting.

/// Blocks will be produced at a minimum duration defined by `SLOT_DURATION`.

/// `SLOT_DURATION` is picked up by `pallet_timestamp` which is in turn picked

/// up by `pallet_aura` to implement `fn slot_duration()`.

///

/// Change this to adjust the block time.

pub const MILLISECS_PER_BLOCK: u64 = 6000;

// NOTE: Currently it is not possible to change the slot duration after the chain has started.

//       Attempting to do so will brick block production.

pub const SLOT_DURATION: u64 = MILLISECS_PER_BLOCK;

// Time is measured by number of blocks.

pub const MINUTES: BlockNumber = 60_000 / (MILLISECS_PER_BLOCK as BlockNumber);

pub const HOURS: BlockNumber = MINUTES * 60;

pub const DAYS: BlockNumber = HOURS * 24;

// Unit = the base number of indivisible units for balances

pub const UNIT: Balance = 1_000_000_000_000;

pub const CENTS: Balance = UNIT / 30_000;

pub const MILLIUNIT: Balance = 1_000_000_000;

pub const MICROUNIT: Balance = 1_000_000;

/// The existential deposit. Set to 1/10 of the Connected Relay Chain.

pub const EXISTENTIAL_DEPOSIT: Balance = MILLIUNIT;

/// We assume that ~5% of the block weight is consumed by `on_initialize` handlers. This is

/// used to limit the maximal weight of a single extrinsic.

const AVERAGE_ON_INITIALIZE_RATIO: Perbill = Perbill::from_percent(5);

/// We allow `Normal` extrinsics to fill up the block up to 75%, the rest can be used by

/// `Operational` extrinsics.

const NORMAL_DISPATCH_RATIO: Perbill = Perbill::from_percent(75);

/// We allow for 2 seconds of compute with a 6 second average block time

const MAXIMUM_BLOCK_WEIGHT: Weight = Weight::from_parts(

    WEIGHT_REF_TIME_PER_SECOND.saturating_mul(2),

    cumulus_primitives_core::relay_chain::MAX_POV_SIZE as u64,

);

/// The version information used to identify this runtime when compiled natively.

#[cfg(feature = "std")]

parameter_types! {

    pub const Version: RuntimeVersion = VERSION;

    // This part is copied from Substrate's `bin/node/runtime/src/lib.rs`.

    //  The `RuntimeBlockLength` and `RuntimeBlockWeights` exist here because the

    // `DeletionWeightLimit` and `DeletionQueueDepth` depend on those to parameterize

    // the lazy contract deletion.

    pub RuntimeBlockLength: BlockLength =

        BlockLength::max_with_normal_ratio(5 * 1024 * 1024, NORMAL_DISPATCH_RATIO);

    pub RuntimeBlockWeights: BlockWeights = BlockWeights::builder()

        .base_block(BlockExecutionWeight::get())

            // Operational transactions have some extra reserved space, so that they

            // are included even if block reached `MAXIMUM_BLOCK_WEIGHT`.

        .avg_block_initialization(AVERAGE_ON_INITIALIZE_RATIO)

        .build_or_panic();

    pub const SS58Prefix: u16 = 42;

}

// Configure FRAME pallets to include in runtime.

impl frame_system::Config for Runtime {

    /// The identifier used to distinguish between accounts.

    type AccountId = AccountId;

    /// The aggregated dispatch type that is available for extrinsics.

    type RuntimeCall = RuntimeCall;

    /// The lookup mechanism to get account ID from whatever is passed in dispatchers.

    type Lookup = AccountIdLookup<AccountId, ()>;

    /// The index type for storing how many extrinsics an account has signed.

    type Nonce = Index;

    /// The index type for blocks.

    type Block = Block;

    /// The type for hashing blocks and tries.

    type Hash = Hash;

    /// The hashing algorithm used.

    type Hashing = BlakeTwo256;

    /// The ubiquitous event type.

    type RuntimeEvent = RuntimeEvent;

    /// The ubiquitous origin type.

    type RuntimeOrigin = RuntimeOrigin;

    /// Maximum number of block number to block hash mappings to keep (oldest pruned first).

    type BlockHashCount = BlockHashCount;

    /// Runtime version.

    type Version = Version;

    /// Converts a module to an index of this module in the runtime.

    type PalletInfo = PalletInfo;

    /// The data to be stored in an account.

    type AccountData = pallet_balances::AccountData<Balance>;

    /// What to do if a new account is created.

    type OnNewAccount = ();

    /// What to do if an account is fully reaped from the system.

    type OnKilledAccount = ();

    /// The weight of database operations that the runtime can invoke.

    type DbWeight = RocksDbWeight;

    /// The basic call filter to use in dispatchable.

    type BaseCallFilter = InsideBoth<MaintenanceMode, TxPause>;

    /// Weight information for the extrinsics of this pallet.

    type SystemWeightInfo = weights::frame_system::SubstrateWeight<Runtime>;

    /// Block & extrinsics weights: base values and limits.

    type BlockWeights = RuntimeBlockWeights;

    /// The maximum length of a block (in bytes).

    type BlockLength = RuntimeBlockLength;

    /// This is used as an identifier of the chain. 42 is the generic substrate prefix.

    type SS58Prefix = SS58Prefix;

    /// The action to take on a Runtime Upgrade

    type OnSetCode = cumulus_pallet_parachain_system::ParachainSetCode<Self>;

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

    type RuntimeTask = RuntimeTask;

    type SingleBlockMigrations = ();

    type MultiBlockMigrator = MultiBlockMigrations;

    type PreInherents = ();

    type PostInherents = ();

    type PostTransactions = ();

    type ExtensionsWeightInfo = weights::frame_system_extensions::SubstrateWeight<Runtime>;

}

impl cumulus_pallet_weight_reclaim::Config for Runtime {

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

}

impl pallet_timestamp::Config for Runtime {

    /// A timestamp: milliseconds since the unix epoch.

    type Moment = u64;

    type OnTimestampSet = dp_consensus::OnTimestampSet<

        <Self as pallet_author_inherent::Config>::SlotBeacon,

        ConstU64<{ SLOT_DURATION }>,

    >;

    type MinimumPeriod = ConstU64<{ SLOT_DURATION / 2 }>;

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

}

pub struct CanAuthor;

impl nimbus_primitives::CanAuthor<NimbusId> for CanAuthor {

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

    fn get_authors(_slot: &u32) -> Vec<NimbusId> {

        AuthorityAssignment::collator_container_chain(Session::current_index())

            .expect("authorities should be set")

            .orchestrator_chain

    }

}

impl pallet_author_inherent::Config for Runtime {

    type AuthorId = NimbusId;

    type AccountLookup = dp_consensus::NimbusLookUp;

    type CanAuthor = CanAuthor;

    type SlotBeacon = dp_consensus::AuraDigestSlotBeacon<Runtime>;

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

}

parameter_types! {

    pub const ExistentialDeposit: Balance = EXISTENTIAL_DEPOSIT;

}

impl pallet_balances::Config for Runtime {

    type MaxLocks = ConstU32<50>;

    /// The type for recording an account's balance.

    type Balance = Balance;

    /// The ubiquitous event type.

    type RuntimeEvent = RuntimeEvent;

    type DustRemoval = ();

    type ExistentialDeposit = ExistentialDeposit;

    type AccountStore = System;

    type MaxReserves = ConstU32<50>;

    type ReserveIdentifier = [u8; 8];

    type FreezeIdentifier = RuntimeFreezeReason;

    type MaxFreezes = ConstU32<10>;

    type RuntimeHoldReason = RuntimeHoldReason;

    type RuntimeFreezeReason = RuntimeFreezeReason;

    type DoneSlashHandler = ();

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

}

parameter_types! {

    pub const TransactionByteFee: Balance = 1;

}

impl pallet_transaction_payment::Config for Runtime {

    type RuntimeEvent = RuntimeEvent;

    type OnChargeTransaction =

        FungibleAdapter<Balances, tanssi_runtime_common::DealWithFees<Runtime>>;

    type OperationalFeeMultiplier = ConstU8<5>;

    type WeightToFee = WeightToFee;

    type LengthToFee = ConstantMultiplier<Balance, TransactionByteFee>;

    type FeeMultiplierUpdate = SlowAdjustingFeeUpdate<Self>;

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

}

parameter_types! {

    pub ReservedXcmpWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 4;

    pub ReservedDmpWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 4;

    pub const RelayOrigin: AggregateMessageOrigin = AggregateMessageOrigin::Parent;

}

pub const RELAY_CHAIN_SLOT_DURATION_MILLIS: u32 = 6000;

pub const UNINCLUDED_SEGMENT_CAPACITY: u32 = 3;

pub const BLOCK_PROCESSING_VELOCITY: u32 = 1;

type ConsensusHook = pallet_async_backing::consensus_hook::FixedVelocityConsensusHook<

    Runtime,

    BLOCK_PROCESSING_VELOCITY,

    UNINCLUDED_SEGMENT_CAPACITY,

>;

impl cumulus_pallet_parachain_system::Config for Runtime {

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

    type RuntimeEvent = RuntimeEvent;

    type OnSystemEvent = ();

    type SelfParaId = parachain_info::Pallet<Runtime>;

    type OutboundXcmpMessageSource = XcmpQueue;

    type DmpQueue = frame_support::traits::EnqueueWithOrigin<MessageQueue, RelayOrigin>;

    type ReservedDmpWeight = ReservedDmpWeight;

    type XcmpMessageHandler = XcmpQueue;

    type ReservedXcmpWeight = ReservedXcmpWeight;

    type CheckAssociatedRelayNumber = RelayNumberMonotonicallyIncreases;

    type ConsensusHook = ConsensusHook;

    type SelectCore = cumulus_pallet_parachain_system::DefaultCoreSelector<Runtime>;

    type RelayParentOffset = ConstU32<0>;

}

pub struct ParaSlotProvider;

impl Get<(Slot, SlotDuration)> for ParaSlotProvider {

}

parameter_types! {

    pub const ExpectedBlockTime: u64 = MILLISECS_PER_BLOCK;

}

impl pallet_async_backing::Config for Runtime {

    type AllowMultipleBlocksPerSlot = ConstBool<true>;

    type GetAndVerifySlot =

        pallet_async_backing::ParaSlot<RELAY_CHAIN_SLOT_DURATION_MILLIS, ParaSlotProvider>;

    type ExpectedBlockTime = ExpectedBlockTime;

}

/// Only callable after `set_validation_data` is called which forms this proof the same way

pub struct BabeCurrentBlockRandomnessGetter;

impl BabeCurrentBlockRandomnessGetter {

            // storage reads as per actual reads

            )

    /// Return the block randomness from the relay mixed with the provided subject.

    /// This ensures that the randomness will be different on different pallets, as long as the subject is different.

}

/// Combines the vrf output of the previous relay block with the provided subject.

/// This ensures that the randomness will be different on different pallets, as long as the subject is different.

// Randomness trait

impl frame_support::traits::Randomness<Hash, BlockNumber> for BabeCurrentBlockRandomnessGetter {

}

pub struct OwnApplySession;

impl pallet_initializer::ApplyNewSession<Runtime> for OwnApplySession {

        // We first initialize Configuration

        // Next: Registrar

        // Next: AuthorityMapping

        // Next: CollatorAssignment

        );

        // Next: InactivityTracking

}

impl pallet_initializer::Config for Runtime {

    type SessionIndex = u32;

    /// The identifier type for an authority.

    type AuthorityId = NimbusId;

    type SessionHandler = OwnApplySession;

}

impl parachain_info::Config for Runtime {}

/// Returns a list of collators by combining pallet_invulnerables and pallet_pooled_staking.

pub struct CollatorsFromInvulnerablesAndThenFromStaking;

/// Play the role of the session manager.

impl SessionManager<CollatorId> for CollatorsFromInvulnerablesAndThenFromStaking {

            // Do not show this log in genesis

                index,

            );

        } else {

                index,

            );

        }

        // Max number of collators is set in pallet_configuration

                    // If a candidate is both in pallet_invulnerables and pallet_staking, do not count it twice

                } else {

                }

        // TODO: weight?

        /*

        frame_system::Pallet::<T>::register_extra_weight_unchecked(

            T::WeightInfo::new_session(invulnerables.len() as u32),

            DispatchClass::Mandatory,

        );

        */

        // we don't care.

        // we don't care.

}

parameter_types! {

    pub const Period: u32 = prod_or_fast!(1 * HOURS, 1 * MINUTES);

    pub const Offset: u32 = 0;

}

impl pallet_session::Config for Runtime {

    type RuntimeEvent = RuntimeEvent;

    type ValidatorId = CollatorId;

    // we don't have stash and controller, thus we don't need the convert as well.

    type ValidatorIdOf = ConvertInto;

    type ShouldEndSession = pallet_session::PeriodicSessions<Period, Offset>;

    type NextSessionRotation = pallet_session::PeriodicSessions<Period, Offset>;

    type SessionManager = CollatorsFromInvulnerablesAndThenFromStaking;

    // Essentially just Aura, but let's be pedantic.

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

    type Keys = SessionKeys;

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

    type DisablingStrategy = ();

}

/// Read full_rotation_period from pallet_configuration

pub struct ConfigurationCollatorRotationSessionPeriod;

impl Get<u32> for ConfigurationCollatorRotationSessionPeriod {

}

pub struct BabeGetRandomnessForNextBlock;

impl GetRandomnessForNextBlock<u32> for BabeGetRandomnessForNextBlock {

            {

                // Return random_hash as a [u8; 32] instead of a Hash

            } else {

                // If there is no randomness (e.g when running in dev mode), return [0; 32]

            }

        } else {

            // In block 0 (genesis) there is no randomness

        };

}

pub struct RemoveInvulnerablesImpl;

impl RemoveInvulnerables<CollatorId> for RemoveInvulnerablesImpl {

        // TODO: use binary_search when invulnerables are sorted

            } else {

            }

}

pub struct ParaIdAssignmentHooksImpl;

impl ParaIdAssignmentHooksImpl {

        use frame_support::traits::Currency;

        type ServicePaymentCurrency = <Runtime as pallet_services_payment::Config>::Currency;

        // Check if the container chain has enough credits for a session assignments

                    WithdrawReasons::FEE,

            } else {

            };

                // Return assignment imbalance to tank on error

        // If the para has been assigned collators for this session it must have enough block credits

        // for the current and the next session.

        } else {

        };

        // Check if the container chain has enough credits for producing blocks

        // Check if we can withdraw

        // This should take into account whether we tank goes below ED

        // The true refers to keepAlive

        )

        // TODO: Have proper weight

}

impl<AC> ParaIdAssignmentHooks<BalanceOf<Runtime>, AC> for ParaIdAssignmentHooksImpl {

            // Short-circuit in case collators are empty

                )

    /// Make those para ids valid by giving them enough credits, for benchmarking.

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

    fn make_valid_para_ids(para_ids: &[ParaId]) {

        use frame_support::assert_ok;

        let blocks_per_session = Period::get();

        // Enough credits to run any benchmark

        let block_credits = 20 * blocks_per_session;

        let session_credits = 20;

        for para_id in para_ids {

            assert_ok!(ServicesPayment::set_block_production_credits(

                RuntimeOrigin::root(),

                *para_id,

                block_credits,

            ));

            assert_ok!(ServicesPayment::set_collator_assignment_credits(

                RuntimeOrigin::root(),

                *para_id,

                session_credits,

            ));

        }

    }

}

impl pallet_collator_assignment::Config for Runtime {

    type HostConfiguration = Configuration;

    type ContainerChains = Registrar;

    type SessionIndex = u32;

    type SelfParaId = ParachainInfo;

    type ShouldRotateAllCollators =

        RotateCollatorsEveryNSessions<ConfigurationCollatorRotationSessionPeriod>;

    type Randomness =

        pallet_collator_assignment::ParachainRandomness<BabeGetRandomnessForNextBlock, Runtime>;

    type RemoveInvulnerables = RemoveInvulnerablesImpl;

    type ParaIdAssignmentHooks = ParaIdAssignmentHooksImpl;

    type CollatorAssignmentTip = ServicesPayment;

    type Currency = Balances;

    type ForceEmptyOrchestrator = ConstBool<false>;

    type CoreAllocationConfiguration = ();

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

}

impl pallet_authority_assignment::Config for Runtime {

    type SessionIndex = u32;

    type AuthorityId = NimbusId;

}

pub const FIXED_BLOCK_PRODUCTION_COST: u128 = 1 * currency::MICRODANCE;

pub const FIXED_COLLATOR_ASSIGNMENT_COST: u128 = 100 * currency::MICRODANCE;

pub struct BlockProductionCost<Runtime>(PhantomData<Runtime>);

impl ProvideBlockProductionCost<Runtime> for BlockProductionCost<Runtime> {

}

pub struct CollatorAssignmentCost<Runtime>(PhantomData<Runtime>);

impl ProvideCollatorAssignmentCost<Runtime> for CollatorAssignmentCost<Runtime> {

}

parameter_types! {

    // 60 days worth of blocks

    pub const FreeBlockProductionCredits: BlockNumber = 60 * DAYS;

    // 60 days worth of blocks

    pub const FreeCollatorAssignmentCredits: u32 = FreeBlockProductionCredits::get()/Period::get();

}

impl pallet_services_payment::Config for Runtime {

    /// Handler for fees

    type OnChargeForBlock = ();

    type OnChargeForCollatorAssignment = ();

    type OnChargeForCollatorAssignmentTip = ();

    /// Currency type for fee payment

    type Currency = Balances;

    /// Provider of a block cost which can adjust from block to block

    type ProvideBlockProductionCost = BlockProductionCost<Runtime>;

    /// Provider of a block cost which can adjust from block to block

    type ProvideCollatorAssignmentCost = CollatorAssignmentCost<Runtime>;

    /// The maximum number of block credits that can be accumulated

    type FreeBlockProductionCredits = FreeBlockProductionCredits;

    /// The maximum number of session credits that can be accumulated

    type FreeCollatorAssignmentCredits = FreeCollatorAssignmentCredits;

    type ManagerOrigin =

        EitherOfDiverse<pallet_registrar::EnsureSignedByManager<Runtime>, EnsureRoot<AccountId>>;

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

}

parameter_types! {

    pub const ProfileDepositBaseFee: Balance = currency::STORAGE_ITEM_FEE;

    pub const ProfileDepositByteFee: Balance = currency::STORAGE_BYTE_FEE;

    #[derive(Clone)]

    pub const MaxAssignmentsPerParaId: u32 = 10;

    #[derive(Clone)]

    pub const MaxNodeUrlCount: u32 = 4;

    #[derive(Clone)]

    pub const MaxStringLen: u32 = 200;

}

pub type DataPreserversProfileId = u64;

impl pallet_data_preservers::Config for Runtime {

    type RuntimeHoldReason = RuntimeHoldReason;

    type Currency = Balances;

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

    type ProfileId = DataPreserversProfileId;

    type ProfileDeposit = tp_traits::BytesDeposit<ProfileDepositBaseFee, ProfileDepositByteFee>;

    type AssignmentProcessor = tp_data_preservers_common::AssignmentProcessor<Runtime>;

    type AssignmentOrigin = pallet_registrar::EnsureSignedByManager<Runtime>;

    type ForceSetProfileOrigin = EnsureRoot<AccountId>;

    type MaxAssignmentsPerParaId = MaxAssignmentsPerParaId;

    type MaxNodeUrlCount = MaxNodeUrlCount;

    type MaxStringLen = MaxStringLen;

    type MaxParaIdsVecLen = MaxLengthParaIds;

}

impl pallet_author_noting::Config for Runtime {

    type ContainerChains = CollatorAssignment;

    type SlotBeacon = dp_consensus::AuraDigestSlotBeacon<Runtime>;

    type ContainerChainAuthor = CollatorAssignment;

    type AuthorNotingHook = (

        XcmCoreBuyer,

        InflationRewards,

        ServicesPayment,

        InactivityTracking,

    );

    type RelayOrPara = pallet_author_noting::ParaMode<

        cumulus_pallet_parachain_system::RelaychainDataProvider<Self>,

    >;

    type MaxContainerChains = MaxLengthParaIds;

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

}

parameter_types! {

    pub const PotId: PalletId = PalletId(*b"PotStake");

    pub const MaxCandidates: u32 = 1000;

    pub const MinCandidates: u32 = 5;

    pub const SessionLength: BlockNumber = 5;

    pub const MaxInvulnerables: u32 = 100;

    pub const ExecutiveBody: BodyId = BodyId::Executive;

}

impl pallet_invulnerables::Config for Runtime {

    type UpdateOrigin = EnsureRoot<AccountId>;

    type MaxInvulnerables = MaxInvulnerables;

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

    type CollatorIdOf = ConvertInto;

    type CollatorRegistration = Session;

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

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

    type Currency = Balances;

}

parameter_types! {

    #[derive(Clone)]

    pub const MaxLengthParaIds: u32 = 100u32;

    pub const MaxEncodedGenesisDataSize: u32 = 5_000_000u32; // 5MB

}

pub struct CurrentSessionIndexGetter;

impl tp_traits::GetSessionIndex<u32> for CurrentSessionIndexGetter {

    /// Returns current session index.

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

    fn skip_to_session(session_index: SessionIndex) {

        while Session::current_index() < session_index {

            Session::rotate_session();

        }

    }

}

impl pallet_configuration::Config for Runtime {

    type SessionDelay = ConstU32<2>;

    type SessionIndex = u32;

    type CurrentSessionIndex = CurrentSessionIndexGetter;

    type ForceEmptyOrchestrator = ConstBool<false>;

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

}

pub struct DanceboxRegistrarHooks;

impl RegistrarHooks for DanceboxRegistrarHooks {

        // Give free credits but only once per para id

        // Clear pallet_author_noting storage

                e,

            );

        // Remove bootnodes from pallet_data_preservers

        // To be able to call mark_valid_for_collating, a container chain must have bootnodes

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

    fn benchmarks_ensure_valid_for_collating(para_id: ParaId) {

        use {

            frame_support::traits::EnsureOriginWithArg,

            pallet_data_preservers::{NodeType, ParaIdsFilter, Profile},

        };

        let profile = Profile {

            bootnode_url: Some(b"/ip4/127.0.0.1/tcp/33049/ws/p2p/12D3KooWHVMhQDHBpj9vQmssgyfspYecgV6e3hH1dQVDUkUbCYC9"

                    .to_vec()

                    .try_into()

                    .expect("to fit in BoundedVec")),

            direct_rpc_urls: Default::default(),

            proxy_rpc_urls: Default::default(),

            para_ids: ParaIdsFilter::AnyParaId,

            node_type: NodeType::Substrate,

            assignment_request: tp_data_preservers_common::ProviderRequest::Free,

            additional_info: Default::default(),

        };

        let profile_id = pallet_data_preservers::NextProfileId::<Runtime>::get();

        let profile_owner = AccountId::new([1u8; 32]);

        DataPreservers::force_create_profile(RuntimeOrigin::root(), profile, profile_owner)

            .expect("profile create to succeed");

        let para_manager =

            <Runtime as pallet_data_preservers::Config>::AssignmentOrigin::try_successful_origin(

                &para_id,

            )

            .expect("should be able to get para manager");

        DataPreservers::start_assignment(

            para_manager,

            profile_id,

            para_id,

            tp_data_preservers_common::AssignerExtra::Free,

        )

        .expect("assignement to work");

        assert!(

            pallet_data_preservers::Assignments::<Runtime>::get(para_id).contains(&profile_id),

            "profile should be correctly assigned"

        );

    }

}

pub struct PalletRelayStorageRootProvider;

impl RelayStorageRootProvider for PalletRelayStorageRootProvider {

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

    fn set_relay_storage_root(relay_block_number: u32, storage_root: Option<H256>) {

        pallet_relay_storage_roots::pallet::RelayStorageRootKeys::<Runtime>::mutate(|x| {

            if storage_root.is_some() {

                if x.is_full() {

                    let key = x.remove(0);

                    pallet_relay_storage_roots::pallet::RelayStorageRoot::<Runtime>::remove(key);

                }

                let pos = x.iter().position(|x| *x >= relay_block_number);

                if let Some(pos) = pos {

                    if x[pos] != relay_block_number {

                        x.try_insert(pos, relay_block_number).unwrap();

                    }

                } else {

                    // Push at end

                    x.try_push(relay_block_number).unwrap();

                }

            } else {

                let pos = x.iter().position(|x| *x == relay_block_number);

                if let Some(pos) = pos {

                    x.remove(pos);

                }

            }

        });

        pallet_relay_storage_roots::pallet::RelayStorageRoot::<Runtime>::set(

            relay_block_number,

            storage_root,

        );

    }

}

impl pallet_registrar::Config for Runtime {

    type RegistrarOrigin =

        EitherOfDiverse<pallet_registrar::EnsureSignedByManager<Runtime>, EnsureRoot<AccountId>>;

    type MarkValidForCollatingOrigin = EnsureRoot<AccountId>;

    type MaxLengthParaIds = MaxLengthParaIds;

    type MaxGenesisDataSize = MaxEncodedGenesisDataSize;

    type RegisterWithRelayProofOrigin = EnsureSigned<AccountId>;

    type RelayStorageRootProvider = PalletRelayStorageRootProvider;

    type SessionDelay = ConstU32<2>;

    type SessionIndex = u32;

    type CurrentSessionIndex = CurrentSessionIndexGetter;

    type Currency = Balances;

    type RegistrarHooks = DanceboxRegistrarHooks;

    type RuntimeHoldReason = RuntimeHoldReason;

    type InnerRegistrar = ();

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

    type DataDepositPerByte = DataDepositPerByte;

}

impl pallet_authority_mapping::Config for Runtime {

    type SessionIndex = u32;

    type SessionRemovalBoundary = ConstU32<2>;

    type AuthorityId = NimbusId;

}

impl pallet_sudo::Config for Runtime {

    type RuntimeCall = RuntimeCall;

    type RuntimeEvent = RuntimeEvent;

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

}

impl pallet_utility::Config for Runtime {

    type RuntimeEvent = RuntimeEvent;

    type RuntimeCall = RuntimeCall;

    type PalletsOrigin = OriginCaller;

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

}

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

#[apply(derive_storage_traits)]

#[derive(Copy, Ord, PartialOrd, MaxEncodedLen, DecodeWithMemTracking)]

#[allow(clippy::unnecessary_cast)]

pub enum ProxyType {

    /// All calls can be proxied. This is the trivial/most permissive filter.

    Any = 0,

    /// Only extrinsics that do not transfer funds.

    NonTransfer = 1,

    /// Only extrinsics related to governance (democracy and collectives).

    Governance = 2,

    /// Only extrinsics related to staking.

    Staking = 3,

    /// Allow to veto an announced proxy call.

    CancelProxy = 4,

    /// Allow extrinsic related to Balances.

    Balances = 5,

    /// Allow extrinsics related to Registrar

    Registrar = 6,

    /// Allow extrinsics related to Registrar that needs to be called through Sudo

    SudoRegistrar = 7,

    /// Allow extrinsics from the Session pallet for key management.

    SessionKeyManagement = 8,

}

impl Default for ProxyType {

}

impl InstanceFilter<RuntimeCall> for ProxyType {

        // Since proxy filters are respected in all dispatches of the Utility

        // pallet, it should never need to be filtered by any proxy.

            ProxyType::NonTransfer => {

                    RuntimeCall::System(..)

                        | RuntimeCall::ParachainSystem(..)

                        | RuntimeCall::Timestamp(..)

                        | RuntimeCall::Proxy(..)

                        | RuntimeCall::Registrar(..)

                )

            }

            // We don't have governance yet

            ProxyType::Staking => {

            }

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

            ),

            ProxyType::Balances => {

            }

            ProxyType::Registrar => {

                    RuntimeCall::Registrar(..) | RuntimeCall::DataPreservers(..)