// Copyright (C) Parity Technologies (UK) Ltd.

// This file is part of Cumulus.

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

// Cumulus 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 Cumulus.  If not, see <http://www.gnu.org/licenses/>.

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

//! `cumulus-pallet-parachain-system` is a base pallet for Cumulus-based parachains.

//!

//! This pallet handles low-level details of being a parachain. Its responsibilities include:

//!

//! - ingestion of the parachain validation data;

//! - ingestion and dispatch of incoming downward and lateral messages;

//! - coordinating upgrades with the Relay Chain; and

//! - communication of parachain outputs, such as sent messages, signaling an upgrade, etc.

//!

//! Users must ensure that they register this pallet as an inherent provider.

extern crate alloc;

use alloc::{collections::btree_map::BTreeMap, vec, vec::Vec};

use codec::{Decode, Encode};

use core::cmp;

use cumulus_primitives_core::{

	relay_chain, AbridgedHostConfiguration, ChannelInfo, ChannelStatus, CollationInfo,

	GetChannelInfo, InboundDownwardMessage, InboundHrmpMessage, ListChannelInfos, MessageSendError,

	OutboundHrmpMessage, ParaId, PersistedValidationData, UpwardMessage, UpwardMessageSender,

	XcmpMessageHandler, XcmpMessageSource,

};

use cumulus_primitives_parachain_inherent::{MessageQueueChain, ParachainInherentData};

use frame_support::{

	defensive,

	dispatch::{DispatchResult, Pays, PostDispatchInfo},

	ensure,

	inherent::{InherentData, InherentIdentifier, ProvideInherent},

	traits::{Get, HandleMessage},

	weights::Weight,

};

use frame_system::{ensure_none, ensure_root, pallet_prelude::HeaderFor};

use polkadot_parachain_primitives::primitives::RelayChainBlockNumber;

use polkadot_runtime_parachains::FeeTracker;

use scale_info::TypeInfo;

use sp_runtime::{

	traits::{Block as BlockT, BlockNumberProvider, Hash},

	transaction_validity::{

		InvalidTransaction, TransactionSource, TransactionValidity, ValidTransaction,

	},

	BoundedSlice, FixedU128, RuntimeDebug, Saturating,

};

use xcm::{latest::XcmHash, VersionedLocation, VersionedXcm};

use xcm_builder::InspectMessageQueues;

mod benchmarking;

pub mod migration;

mod mock;

#[cfg(test)]

mod tests;

pub mod weights;

pub use weights::WeightInfo;

mod unincluded_segment;

pub mod consensus_hook;

pub mod relay_state_snapshot;

#[macro_use]

pub mod validate_block;

use unincluded_segment::{

	Ancestor, HrmpChannelUpdate, HrmpWatermarkUpdate, OutboundBandwidthLimits, SegmentTracker,

	UsedBandwidth,

};

pub use consensus_hook::{ConsensusHook, ExpectParentIncluded};

/// Register the `validate_block` function that is used by parachains to validate blocks on a

/// validator.

///

/// Does *nothing* when `std` feature is enabled.

///

/// Expects as parameters the runtime, a block executor and an inherent checker.

///

/// # Example

///

/// ```

///     struct BlockExecutor;

///     struct Runtime;

///     struct CheckInherents;

///

///     cumulus_pallet_parachain_system::register_validate_block! {

///         Runtime = Runtime,

///         BlockExecutor = Executive,

///         CheckInherents = CheckInherents,

///     }

///

/// # fn main() {}

/// ```

pub use cumulus_pallet_parachain_system_proc_macro::register_validate_block;

pub use relay_state_snapshot::{MessagingStateSnapshot, RelayChainStateProof};

pub use pallet::*;

/// Something that can check the associated relay block number.

///

/// Each Parachain block is built in the context of a relay chain block, this trait allows us

/// to validate the given relay chain block number. With async backing it is legal to build

/// multiple Parachain blocks per relay chain parent. With this trait it is possible for the

/// Parachain to ensure that still only one Parachain block is build per relay chain parent.

///

/// By default [`RelayNumberStrictlyIncreases`] and [`AnyRelayNumber`] are provided.

pub trait CheckAssociatedRelayNumber {

	/// Check the current relay number versus the previous relay number.

	///

	/// The implementation should panic when there is something wrong.

	fn check_associated_relay_number(

		current: RelayChainBlockNumber,

		previous: RelayChainBlockNumber,

	);

}

/// Provides an implementation of [`CheckAssociatedRelayNumber`].

///

/// It will ensure that the associated relay block number strictly increases between Parachain

/// blocks. This should be used by production Parachains when in doubt.

pub struct RelayNumberStrictlyIncreases;

impl CheckAssociatedRelayNumber for RelayNumberStrictlyIncreases {

	fn check_associated_relay_number(

		current: RelayChainBlockNumber,

		previous: RelayChainBlockNumber,

	) {

		if current <= previous {

			panic!("Relay chain block number needs to strictly increase between Parachain blocks!")

		}

	}

}

/// Provides an implementation of [`CheckAssociatedRelayNumber`].

///

/// This will accept any relay chain block number combination. This is mainly useful for

/// test parachains.

pub struct AnyRelayNumber;

impl CheckAssociatedRelayNumber for AnyRelayNumber {

	fn check_associated_relay_number(_: RelayChainBlockNumber, _: RelayChainBlockNumber) {}

}

/// Provides an implementation of [`CheckAssociatedRelayNumber`].

///

/// It will ensure that the associated relay block number monotonically increases between Parachain

/// blocks. This should be used when asynchronous backing is enabled.

pub struct RelayNumberMonotonicallyIncreases;

impl CheckAssociatedRelayNumber for RelayNumberMonotonicallyIncreases {

	fn check_associated_relay_number(

		current: RelayChainBlockNumber,

		previous: RelayChainBlockNumber,

	) {

		if current < previous {

			panic!("Relay chain block number needs to monotonically increase between Parachain blocks!")

		}

	}

}

/// The max length of a DMP message.

pub type MaxDmpMessageLenOf<T> = <<T as Config>::DmpQueue as HandleMessage>::MaxMessageLen;

pub mod ump_constants {

	use super::FixedU128;

	/// `host_config.max_upward_queue_size / THRESHOLD_FACTOR` is the threshold after which delivery

	/// starts getting exponentially more expensive.

	/// `2` means the price starts to increase when queue is half full.

	pub const THRESHOLD_FACTOR: u32 = 2;

	/// The base number the delivery fee factor gets multiplied by every time it is increased.

	/// Also the number it gets divided by when decreased.

	pub const EXPONENTIAL_FEE_BASE: FixedU128 = FixedU128::from_rational(105, 100); // 1.05

	/// The base number message size in KB is multiplied by before increasing the fee factor.

	pub const MESSAGE_SIZE_FEE_BASE: FixedU128 = FixedU128::from_rational(1, 1000); // 0.001

}

pub mod pallet {

	use super::*;

	use frame_support::pallet_prelude::*;

	use frame_system::{pallet_prelude::*, WeightInfo as SystemWeightInfo};

	#[pallet::storage_version(migration::STORAGE_VERSION)]

	#[pallet::without_storage_info]

	pub struct Pallet<T>(_);

	#[pallet::config]

	pub trait Config: frame_system::Config<OnSetCode = ParachainSetCode<Self>> {

		/// The overarching event type.

		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;

		/// Something which can be notified when the validation data is set.

		type OnSystemEvent: OnSystemEvent;

		/// Returns the parachain ID we are running with.

		#[pallet::constant]

		type SelfParaId: Get<ParaId>;

		/// The place where outbound XCMP messages come from. This is queried in `finalize_block`.

		type OutboundXcmpMessageSource: XcmpMessageSource;

		/// Queues inbound downward messages for delayed processing.

		///

		/// All inbound DMP messages from the relay are pushed into this. The handler is expected to

		/// eventually process all the messages that are pushed to it.

		type DmpQueue: HandleMessage;

		/// The weight we reserve at the beginning of the block for processing DMP messages.

		type ReservedDmpWeight: Get<Weight>;

		/// The message handler that will be invoked when messages are received via XCMP.

		///

		/// This should normally link to the XCMP Queue pallet.

		type XcmpMessageHandler: XcmpMessageHandler;

		/// The weight we reserve at the beginning of the block for processing XCMP messages.

		type ReservedXcmpWeight: Get<Weight>;

		/// Something that can check the associated relay parent block number.

		type CheckAssociatedRelayNumber: CheckAssociatedRelayNumber;

		/// Weight info for functions and calls.

		type WeightInfo: WeightInfo;

		/// An entry-point for higher-level logic to manage the backlog of unincluded parachain

		/// blocks and authorship rights for those blocks.

		///

		/// Typically, this should be a hook tailored to the collator-selection/consensus mechanism

		/// that is used for this chain.

		///

		/// However, to maintain the same behavior as prior to asynchronous backing, provide the

		/// [`consensus_hook::ExpectParentIncluded`] here. This is only necessary in the case

		/// that collators aren't expected to have node versions that supply the included block

		/// in the relay-chain state proof.

		type ConsensusHook: ConsensusHook;

	}

	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {

		/// Handles actually sending upward messages by moving them from `PendingUpwardMessages` to

		/// `UpwardMessages`. Decreases the delivery fee factor if after sending messages, the queue

		/// total size is less than the threshold (see [`ump_constants::THRESHOLD_FACTOR`]).

		/// Also does the sending for HRMP messages it takes from `OutboundXcmpMessageSource`.

				None => {

					);

				},

			};

			// Before updating the relevant messaging state, we need to extract

			// the total bandwidth limits for the purpose of updating the unincluded

			// segment.

				None => {

					);

				},

			};

			// After this point, the `RelevantMessagingState` in storage reflects the

			// unincluded segment.

				{

					None => {

						);

					},

				};

						{

							Some(_) => {

							},

						}

						// Some ancestor within the segment already processed this signal --

						// validated during inherent creation.

					} else {

					};

				// The bandwidth constructed was ensured to satisfy relay chain constraints.

			// The parent hash was unknown during block finalization. Update it here.

	}

	impl<T: Config> Pallet<T> {

		/// Set the current validation data.

		///

		/// This should be invoked exactly once per block. It will panic at the finalization

		/// phase if the call was not invoked.

		///

		/// The dispatch origin for this call must be `Inherent`

		///

		/// As a side effect, this function upgrades the current validation function

		/// if the appropriate time has come.

		#[pallet::call_index(0)]

		#[pallet::weight((0, DispatchClass::Mandatory))]

		// TODO: This weight should be corrected.

		pub fn set_validation_data(

			origin: OriginFor<T>,

			data: ParachainInherentData,

			);

			// TODO: This is more than zero, but will need benchmarking to figure out what.

				// Unincluded ancestor consuming upgrade signal is still within the segment,

				// sanity check that it matches with the signal from relay chain.

				Some(relay_chain::UpgradeGoAhead::GoAhead) => {

					);

				},

			}

		}

		#[pallet::call_index(1)]

		#[pallet::weight((1_000, DispatchClass::Operational))]

		pub fn sudo_send_upward_message(

			origin: OriginFor<T>,

			message: UpwardMessage,

		}

		/// Authorize an upgrade to a given `code_hash` for the runtime. The runtime can be supplied

		/// later.

		///

		/// The `check_version` parameter sets a boolean flag for whether or not the runtime's spec

		/// version and name should be verified on upgrade. Since the authorization only has a hash,

		/// it cannot actually perform the verification.

		///

		/// This call requires Root origin.

		#[pallet::call_index(2)]

		#[pallet::weight(<T as frame_system::Config>::SystemWeightInfo::authorize_upgrade())]

		#[allow(deprecated)]

		#[deprecated(

			note = "To be removed after June 2024. Migrate to `frame_system::authorize_upgrade`."

		)]

		pub fn authorize_upgrade(

			origin: OriginFor<T>,

			code_hash: T::Hash,

			check_version: bool,

		}

		/// Provide the preimage (runtime binary) `code` for an upgrade that has been authorized.

		///

		/// If the authorization required a version check, this call will ensure the spec name

		/// remains unchanged and that the spec version has increased.

		///

		/// Note that this function will not apply the new `code`, but only attempt to schedule the

		/// upgrade with the Relay Chain.

		///

		/// All origins are allowed.

		#[pallet::call_index(3)]

		#[pallet::weight(<T as frame_system::Config>::SystemWeightInfo::apply_authorized_upgrade())]

		#[allow(deprecated)]

		#[deprecated(

			note = "To be removed after June 2024. Migrate to `frame_system::apply_authorized_upgrade`."

		)]

		pub fn enact_authorized_upgrade(

			_: OriginFor<T>,

			code: Vec<u8>,

		}

	}

	#[pallet::event]

	pub enum Event<T: Config> {

	}

	pub enum Error<T> {

	}

	/// Latest included block descendants the runtime accepted. In other words, these are

	/// ancestors of the currently executing block which have not been included in the observed

	/// relay-chain state.

	///

	/// The segment length is limited by the capacity returned from the [`ConsensusHook`] configured

	/// in the pallet.

	pub type UnincludedSegment<T: Config> = StorageValue<_, Vec<Ancestor<T::Hash>>, ValueQuery>;

	/// Storage field that keeps track of bandwidth used by the unincluded segment along with the

	/// latest HRMP watermark. Used for limiting the acceptance of new blocks with

	/// respect to relay chain constraints.

	pub type AggregatedUnincludedSegment<T: Config> =

		StorageValue<_, SegmentTracker<T::Hash>, OptionQuery>;

	/// In case of a scheduled upgrade, this storage field contains the validation code to be

	/// applied.

	///

	/// As soon as the relay chain gives us the go-ahead signal, we will overwrite the

	/// [`:code`][sp_core::storage::well_known_keys::CODE] which will result the next block process

	/// with the new validation code. This concludes the upgrade process.

	pub type PendingValidationCode<T: Config> = StorageValue<_, Vec<u8>, ValueQuery>;

	/// Validation code that is set by the parachain and is to be communicated to collator and

	/// consequently the relay-chain.

	///

	/// This will be cleared in `on_initialize` of each new block if no other pallet already set

	/// the value.

	pub type NewValidationCode<T: Config> = StorageValue<_, Vec<u8>, OptionQuery>;

	/// The [`PersistedValidationData`] set for this block.

	/// This value is expected to be set only once per block and it's never stored

	/// in the trie.

	pub type ValidationData<T: Config> = StorageValue<_, PersistedValidationData>;

	/// Were the validation data set to notify the relay chain?

	pub type DidSetValidationCode<T: Config> = StorageValue<_, bool, ValueQuery>;

	/// The relay chain block number associated with the last parachain block.

	///

	/// This is updated in `on_finalize`.

	pub type LastRelayChainBlockNumber<T: Config> =

		StorageValue<_, RelayChainBlockNumber, ValueQuery>;

	/// An option which indicates if the relay-chain restricts signalling a validation code upgrade.

	/// In other words, if this is `Some` and [`NewValidationCode`] is `Some` then the produced

	/// candidate will be invalid.

	///

	/// This storage item is a mirror of the corresponding value for the current parachain from the

	/// relay-chain. This value is ephemeral which means it doesn't hit the storage. This value is

	/// set after the inherent.

	pub type UpgradeRestrictionSignal<T: Config> =

		StorageValue<_, Option<relay_chain::UpgradeRestriction>, ValueQuery>;

	/// Optional upgrade go-ahead signal from the relay-chain.

	///

	/// This storage item is a mirror of the corresponding value for the current parachain from the

	/// relay-chain. This value is ephemeral which means it doesn't hit the storage. This value is

	/// set after the inherent.

	pub type UpgradeGoAhead<T: Config> =

		StorageValue<_, Option<relay_chain::UpgradeGoAhead>, ValueQuery>;

	/// The state proof for the last relay parent block.

	///

	/// This field is meant to be updated each block with the validation data inherent. Therefore,

	/// before processing of the inherent, e.g. in `on_initialize` this data may be stale.

	///

	/// This data is also absent from the genesis.

	pub type RelayStateProof<T: Config> = StorageValue<_, sp_trie::StorageProof>;

	/// The snapshot of some state related to messaging relevant to the current parachain as per

	/// the relay parent.

	///

	/// This field is meant to be updated each block with the validation data inherent. Therefore,

	/// before processing of the inherent, e.g. in `on_initialize` this data may be stale.

	///

	/// This data is also absent from the genesis.

	pub type RelevantMessagingState<T: Config> = StorageValue<_, MessagingStateSnapshot>;

	/// The parachain host configuration that was obtained from the relay parent.

	///

	/// This field is meant to be updated each block with the validation data inherent. Therefore,

	/// before processing of the inherent, e.g. in `on_initialize` this data may be stale.

	///

	/// This data is also absent from the genesis.

	#[pallet::disable_try_decode_storage]

	pub type HostConfiguration<T: Config> = StorageValue<_, AbridgedHostConfiguration>;

	/// The last downward message queue chain head we have observed.

	///

	/// This value is loaded before and saved after processing inbound downward messages carried

	/// by the system inherent.

	pub type LastDmqMqcHead<T: Config> = StorageValue<_, MessageQueueChain, ValueQuery>;

	/// The message queue chain heads we have observed per each channel incoming channel.

	///

	/// This value is loaded before and saved after processing inbound downward messages carried

	/// by the system inherent.

	pub type LastHrmpMqcHeads<T: Config> =

		StorageValue<_, BTreeMap<ParaId, MessageQueueChain>, ValueQuery>;

	/// Number of downward messages processed in a block.

	///

	/// This will be cleared in `on_initialize` of each new block.

	pub type ProcessedDownwardMessages<T: Config> = StorageValue<_, u32, ValueQuery>;

	/// HRMP watermark that was set in a block.

	///

	/// This will be cleared in `on_initialize` of each new block.

	pub type HrmpWatermark<T: Config> = StorageValue<_, relay_chain::BlockNumber, ValueQuery>;

	/// HRMP messages that were sent in a block.

	///

	/// This will be cleared in `on_initialize` of each new block.

	pub type HrmpOutboundMessages<T: Config> =

		StorageValue<_, Vec<OutboundHrmpMessage>, ValueQuery>;

	/// Upward messages that were sent in a block.

	///

	/// This will be cleared in `on_initialize` of each new block.

	pub type UpwardMessages<T: Config> = StorageValue<_, Vec<UpwardMessage>, ValueQuery>;

	/// Upward messages that are still pending and not yet send to the relay chain.

	pub type PendingUpwardMessages<T: Config> = StorageValue<_, Vec<UpwardMessage>, ValueQuery>;

	/// Initialization value for the delivery fee factor for UMP.

	/// The factor to multiply the base delivery fee by for UMP.

	pub type UpwardDeliveryFeeFactor<T: Config> =

		StorageValue<_, FixedU128, ValueQuery, UpwardInitialDeliveryFeeFactor>;

	/// The number of HRMP messages we observed in `on_initialize` and thus used that number for

	/// announcing the weight of `on_initialize` and `on_finalize`.

	pub type AnnouncedHrmpMessagesPerCandidate<T: Config> = StorageValue<_, u32, ValueQuery>;

	/// The weight we reserve at the beginning of the block for processing XCMP messages. This

	/// overrides the amount set in the Config trait.

	pub type ReservedXcmpWeightOverride<T: Config> = StorageValue<_, Weight>;

	/// The weight we reserve at the beginning of the block for processing DMP messages. This

	/// overrides the amount set in the Config trait.

	pub type ReservedDmpWeightOverride<T: Config> = StorageValue<_, Weight>;

	/// A custom head data that should be returned as result of `validate_block`.

	///

	/// See `Pallet::set_custom_validation_head_data` for more information.

	pub type CustomValidationHeadData<T: Config> = StorageValue<_, Vec<u8>, OptionQuery>;

	#[pallet::inherent]

	impl<T: Config> ProvideInherent for Pallet<T> {

		type Call = Call<T>;

		type Error = sp_inherents::MakeFatalError<()>;

		const INHERENT_IDENTIFIER: InherentIdentifier =

			cumulus_primitives_parachain_inherent::INHERENT_IDENTIFIER;

	}

	#[pallet::genesis_config]

	#[derive(frame_support::DefaultNoBound)]

	pub struct GenesisConfig<T: Config> {

		#[serde(skip)]

		pub _config: core::marker::PhantomData<T>,

	}

	#[pallet::genesis_build]

	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {

	}

	#[pallet::validate_unsigned]

	impl<T: Config> sp_runtime::traits::ValidateUnsigned for Pallet<T> {

		type Call = Call<T>;

				{

	}

}

impl<T: Config> Pallet<T> {

	/// Get the unincluded segment size after the given hash.

	///

	/// If the unincluded segment doesn't contain the given hash, this returns the

	/// length of the entire unincluded segment.

	///

	/// This is intended to be used for determining how long the unincluded segment _would be_

	/// in runtime APIs related to authoring.

}

impl<T: Config> FeeTracker for Pallet<T> {

	type Id = ();

}

impl<T: Config> ListChannelInfos for Pallet<T> {

	fn outgoing_channels() -> Vec<ParaId> {

		let Some(state) = RelevantMessagingState::<T>::get() else { return Vec::new() };

		state.egress_channels.into_iter().map(|(id, _)| id).collect()

	}

}

impl<T: Config> GetChannelInfo for Pallet<T> {

		// Note, that we are using `relevant_messaging_state` which may be from the previous

		// block, in case this is called from `on_initialize`, i.e. before the inherent with

		// fresh data is submitted.

		//

		// That shouldn't be a problem though because this is anticipated and already can

		// happen. This is because sending implies that a message is buffered until there is

		// space to send a message in the candidate. After a while waiting in a buffer, it may

		// be discovered that the channel to which a message were addressed is now closed.

		// Another possibility, is that the maximum message size was decreased so that a

		// message in the buffer doesn't fit. Should any of that happen the sender should be

		// notified about the message was discarded.

		//

		// Here it a similar case, with the difference that the realization that the channel is

		// closed came the same block.

			None => {

			},

		};

		// ^^^ NOTE: This storage field should carry over from the previous block. So if it's

		// None then it must be that this is an edge-case where a message is attempted to be

		// sent at the first block. It should be safe to assume that there are no channels

		// opened at all so early. At least, relying on this assumption seems to be a better

		// trade-off, compared to introducing an error variant that the clients should be

		// prepared to handle.

			// The channel is at its capacity. Skip it for now.

}

impl<T: Config> Pallet<T> {

	/// Updates inherent data to only contain messages that weren't already processed

	/// by the runtime based on last relay chain block number.

	///

	/// This method doesn't check for mqc heads mismatch.

		// HRMP.

		// If MQC doesn't match after dropping messages, the runtime will panic when creating

		// inherent.

	/// Enqueue all inbound downward messages relayed by the collator into the MQ pallet.

	///

	/// Checks if the sequence of the messages is valid, dispatches them and communicates the

	/// number of processed messages to the collator via a storage update.

	///

	/// # Panics

	///

	/// If it turns out that after processing all messages the Message Queue Chain

	/// hash doesn't match the expected.

			// Eagerly update the MQC head hash:

					Err(_) => {

					},

		// After hashing each message in the message queue chain submitted by the collator, we

		// should arrive to the MQC head provided by the relay chain.

		//

		// A mismatch means that at least some of the submitted messages were altered, omitted or

		// added improperly.

	/// Process all inbound horizontal messages relayed by the collator.

	///

	/// This is similar to [`enqueue_inbound_downward_messages`], but works with multiple inbound

	/// channels. It immediately dispatches signals and queues all other XCMs. Blob messages are

	/// ignored.

	///

	/// **Panics** if either any of horizontal messages submitted by the collator was sent from

	///            a para which has no open channel to this parachain or if after processing

	///            messages across all inbound channels MQCs were obtained which do not

	///            correspond to the ones found on the relay-chain.

		// First, check that all submitted messages are sent from channels that exist. The

		// channel exists if its MQC head is present in `vfp.hrmp_mqc_heads`.

			// A violation of the assertion below indicates that one of the messages submitted

			// by the collator was sent from a sender that doesn't have a channel opened to

			// this parachain, according to the relay-parent state.

		}

		// Second, prepare horizontal messages for a more convenient processing:

		//

		// instead of a mapping from a para to a list of inbound HRMP messages, we will have a

		// list of tuples `(sender, message)` first ordered by `sent_at` (the relay chain block

		// number in which the message hit the relay-chain) and second ordered by para id

		// ascending.

		//

		// The messages will be dispatched in this order.

			}

		{

		}

		// Check that the MQC heads for each channel provided by the relay chain match the MQC

		// heads we have after processing all incoming messages.

		//

		// Along the way we also carry over the relevant entries from the `last_mqc_heads` to

		// `running_mqc_heads`. Otherwise, in a block where no messages were sent in a channel

		// it won't get into next block's `last_mqc_heads` and thus will be all zeros, which

		// would corrupt the message queue chain.

		}

	/// Drop blocks from the unincluded segment with respect to the latest parachain head.

		// Clean up unincluded segment if nonempty.

				);

			},

			(None, true) => {

				// All this logic is essentially a workaround to support collators which

				// might still not provide the included block with the state proof.

			},

		};