#[frame_support::pallet]

    #[pallet::error]

    #[pallet::pallet]

    #[pallet::hooks]

        fn on_initialize(_n: BlockNumberFor<T>) -> Weight {

            let mut weight = Weight::zero();

            // We clear this storage item to make sure its always included

            DidSetContainerAuthorData::<T>::kill();

            weight += T::DbWeight::get().writes(1);

            // The read onfinalizes

            weight += T::DbWeight::get().reads(1);

            weight

        }

        fn on_finalize(_: BlockNumberFor<T>) {

            assert!(

                <DidSetContainerAuthorData<T>>::exists(),

                "Container chain author data needs to be present in every block!"

        }

    #[pallet::call]

        ) -> DispatchResultWithPostInfo {

            ensure_none(origin)?;

            assert!(

                !<DidSetContainerAuthorData<T>>::exists(),

                "DidSetContainerAuthorData must be updated only once in a block",

            let registered_para_ids = T::ContainerChains::current_container_chains();

            let mut total_weight =

                T::WeightInfo::set_latest_author_data(registered_para_ids.len() as u32);

            // We do this first to make sure we don't do 2 reads (parachains and relay state)

            // when we have no containers registered

            // Essentially one can pass an empty proof if no container-chains are registered

            if !registered_para_ids.is_empty() {

                    relay_storage_proof,

                } = data;

                let relay_chain_state = T::RelayChainStateProvider::current_relay_chain_state();

                let relay_storage_root = relay_chain_state.state_root;

                let relay_storage_rooted_proof =

                    GenericStateProof::new(relay_storage_root, relay_storage_proof)

                        .expect("Invalid relay chain state proof");

                let parent_tanssi_slot = u64::from(T::SlotBeacon::slot()).into();

                for para_id in registered_para_ids {

                    match Self::fetch_block_info_from_proof(

                        &relay_storage_rooted_proof,

                        para_id,

                        parent_tanssi_slot,

                    ) {

                        Ok(block_info) => {

                            LatestAuthor::<T>::mutate(

                                para_id,

                                |maybe_old_block_info: &mut Option<

                                >| {

                                    if let Some(ref mut old_block_info) = maybe_old_block_info {

                                        if block_info.block_number > old_block_info.block_number {

                                            // We only reward author if the block increases

                                            total_weight = total_weight.saturating_add(

                                                T::AuthorNotingHook::on_container_author_noted(

                                                    &block_info.author,

                                                    block_info.block_number,

                                                    para_id,

                                                ),

                                            );

                                            let _ = core::mem::replace(old_block_info, block_info);

                                        }

                                    } else {

                                        // If there is no previous block, we should reward the author of the first block

                                        total_weight = total_weight.saturating_add(

                                            T::AuthorNotingHook::on_container_author_noted(

                                                &block_info.author,

                                                block_info.block_number,

                                                para_id,

                                            ),

                                        );

                                        let _ = core::mem::replace(

                                            maybe_old_block_info,

                                            Some(block_info),

                                        );

                                    }

                                },

                            );

                        }

                        Err(e) => log::warn!(

                            "Author-noting error {:?} found in para {:?}",

                            e,

                            u32::from(para_id)

            }

            DidSetContainerAuthorData::<T>::put(true);

            Ok(PostDispatchInfo {

                actual_weight: Some(total_weight),

                pays_fee: Pays::No,

            })

        ) -> DispatchResult {

            ensure_root(origin)?;

            LatestAuthor::<T>::insert(

                para_id,

                ContainerChainBlockInfo {

                    block_number,

                    author: author.clone(),

                    latest_slot_number,

                },

            );

            Self::deposit_event(Event::LatestAuthorChanged {

                para_id,

                block_number,

                new_author: author,

                latest_slot_number,

            });

            Ok(())

        pub fn kill_author_data(origin: OriginFor<T>, para_id: ParaId) -> DispatchResult {

            ensure_root(origin)?;

            LatestAuthor::<T>::remove(para_id);

            Self::deposit_event(Event::RemovedAuthorData { para_id });

            Ok(())

    #[pallet::generate_deposit(pub(super) fn deposit_event)]

        /// Latest author changed

        /// Removed author data

    #[pallet::storage]

    #[pallet::storage]

        fn create_inherent(data: &InherentData) -> Option<Self::Call> {

            let data: tp_author_noting_inherent::OwnParachainInherentData = data

                .get_data(&INHERENT_IDENTIFIER)

                .ok()

                .flatten()

                .expect("there is not data to be posted; qed");

            Some(Call::set_latest_author_data { data })

        }

        fn is_inherent(call: &Self::Call) -> bool {

            matches!(call, Call::set_latest_author_data { .. })

        }

    fn fetch_block_info_from_proof(

        relay_state_proof: &GenericStateProof<cumulus_primitives_core::relay_chain::Block>,

        para_id: ParaId,

        tanssi_slot: Slot,

    ) -> Result<ContainerChainBlockInfo<T::AccountId>, Error<T>> {

        let bytes = para_id.twox_64_concat();

        // CONCAT

        let key = [PARAS_HEADS_INDEX, bytes.as_slice()].concat();

        let head_data = relay_state_proof

            .read_entry::<HeadData>(key.as_slice(), None)

            .map_err(|e| match e {

                ReadEntryErr::Proof => panic!("Invalid proof provided for para head key"),

                _ => Error::<T>::FailedReading,

            })?;

        let author_header = sp_runtime::generic::Header::<BlockNumber, BlakeTwo256>::decode(

            &mut head_data.0.as_slice(),

        )

        .map_err(|_| Error::<T>::FailedDecodingHeader)?;

        let mut first_error = None;

        for aura_digest in author_header.digest().logs() {

            match Self::author_from_log(aura_digest, para_id, &author_header, tanssi_slot) {

                Ok(x) => return Ok(x),

                Err(e) => {

                    if first_error.is_none() {

                        first_error = Some(e);

                    }

        Err(first_error.unwrap_or(Error::<T>::AuraDigestFirstItem))

    }

    fn author_from_log(

        aura_digest: &DigestItem,

        para_id: ParaId,

        author_header: &sp_runtime::generic::Header<BlockNumber, BlakeTwo256>,

        tanssi_slot: Slot,

    ) -> Result<ContainerChainBlockInfo<T::AccountId>, Error<T>> {

        let (id, mut data) = aura_digest

            .as_pre_runtime()

            .ok_or(Error::<T>::AsPreRuntimeError)?;

        if id == AURA_ENGINE_ID {

            let slot = InherentType::decode(&mut data).map_err(|_| Error::<T>::NonDecodableSlot)?;

            let author = T::ContainerChainAuthor::author_for_slot(slot, para_id)

                .ok_or(Error::<T>::AuthorNotFound)?;

            Ok(ContainerChainBlockInfo {

                block_number: author_header.number,

                author,

                // We store the slot number of the current tanssi block to have a time-based notion

                // of when the last block of a container chain was included.

                // Note that this is not the slot of the container chain block, and it does not

                // indicate when that block was created, but when it was included in tanssi.

                latest_slot_number: tanssi_slot,

            })

            Err(Error::<T>::NonAuraDigest)

    }

    fn get_latest_author_info(para_id: ParaId) -> Option<ContainerChainBlockInfo<T::AccountId>> {

        LatestAuthor::<T>::get(para_id)

    }