fn new_notify_query(

        _responder: impl Into<Location>,

        _notify: impl Into<<T as Config>::RuntimeCall>,

        _timeout: BlockNumberFor<T>,

        _match_querier: impl Into<Location>,

    ) -> u64 {

        0

    }

#[derive(RuntimeDebug, PartialEq, Eq, Encode, Decode, Clone, TypeInfo)]

    fn on_container_author_noted(

        _author: &T::AccountId,

        _block_number: BlockNumber,

        para_id: ParaId,

    ) -> Weight {

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

        T::DbWeight::get().writes(1)

    }

#[frame_support::pallet]

    #[pallet::pallet]

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

        /// An XCM message to buy a core for this parathread has been sent to the relay chain.

        /// We received response for xcm

        /// We cleaned up expired pending blocks entries.

        /// We cleaned up expired in flight orders entries.

    #[pallet::error]

        fn from(value: BuyingError<BlockNumberFor<T>>) -> Self {

            match value {

                BuyingError::OrderAlreadyExists { .. } => Error::<T>::OrderAlreadyExists,

                BuyingError::BlockProductionPending { .. } => Error::<T>::BlockProductionPending,

                BuyingError::NotAParathread => Error::<T>::NotAParathread,

                    Error::<T>::NotAllowedToProduceBlockRightNow

        }

    #[pallet::storage]

    #[pallet::storage]

    #[pallet::storage]

    #[pallet::storage]

    #[pallet::storage]

    #[derive(Encode, Decode, CloneNoBound, PartialEq, Eq, DebugNoBound, TypeInfo)]

    #[pallet::storage]

    #[pallet::call]

        ) -> DispatchResult {

            ensure_none(origin)?;

            let current_nonce = CollatorSignatureNonce::<T>::get(para_id);

            CollatorSignatureNonce::<T>::set(para_id, current_nonce + 1);

            Self::on_collator_instantaneous_core_requested(para_id)

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

            ensure_root(origin)?;

            Self::on_collator_instantaneous_core_requested(para_id)

        ) -> DispatchResult {

            ensure_root(origin)?;

            if let Some(xcm_weights) = xcm_weights {

                RelayXcmWeightConfig::<T>::put(xcm_weights);

            } else {

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

            }

            Ok(())

        ) -> DispatchResult {

            ensure_root(origin)?;

            if let Some(relay_chain) = relay_chain {

                RelayChain::<T>::put(relay_chain);

            } else {

            Ok(())

        ) -> DispatchResult {

            let _responder = ensure_response(<T as Config>::RuntimeOrigin::from(origin))?;

            let maybe_para_id = QueryIdToParaId::<T>::get(query_id);

            let para_id = if let Some(para_id) = maybe_para_id {

                para_id

            QueryIdToParaId::<T>::remove(query_id);

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

            match response {

                Response::DispatchResult(MaybeErrorCode::Success) => {

                    // Success. Add para id to pending block

                    let now = <frame_system::Pallet<T>>::block_number();

                    let ttl = T::PendingBlocksTtl::get();

                    PendingBlocks::<T>::insert(para_id, now + ttl);

                }

                Response::DispatchResult(_) => {

                    // We do not add paraid to pending block on failure

                }

            Self::deposit_event(Event::ReceivedBuyCoreXCMResult { para_id, response });

            Ok(())

        ) -> DispatchResult {

            let _ = ensure_signed(origin)?;

            let now = frame_system::Pallet::<T>::block_number();

            let mut cleaned_up_para_ids = vec![];

            for para_id in expired_pending_blocks_para_id {

                let maybe_pending_block_ttl = PendingBlocks::<T>::get(para_id);

                if let Some(pending_block_ttl) = maybe_pending_block_ttl {

                    if pending_block_ttl < now {

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

                        cleaned_up_para_ids.push(para_id);

                    } else {

                        // Ignore if not expired

                    }

            Self::deposit_event(Event::CleanedUpExpiredPendingBlocksEntries {

                para_ids: cleaned_up_para_ids,

            });

            Ok(())

        ) -> DispatchResult {

            let _ = ensure_signed(origin)?;

            let now = frame_system::Pallet::<T>::block_number();

            let mut cleaned_up_para_ids = vec![];

            for para_id in expired_in_flight_orders {

                let maybe_in_flight_order = InFlightOrders::<T>::get(para_id);

                if let Some(in_flight_order) = maybe_in_flight_order {

                    if in_flight_order.ttl < now {

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

                        QueryIdToParaId::<T>::remove(in_flight_order.query_id);

                        cleaned_up_para_ids.push(para_id);

                    } else {

                        // Ignore if not expired

                    }

            Self::deposit_event(Event::CleanedUpExpiredInFlightOrderEntries {

                para_ids: cleaned_up_para_ids,

            });

            Ok(())

        pub fn interior_multilocation(para_id: ParaId) -> InteriorLocation {

            let container_chain_account = T::GetParathreadAccountId::convert(para_id);

            let account_junction = Junction::AccountId32 {

                id: container_chain_account,

                network: None,

            };

            [account_junction].into()

        }

        pub fn relay_relative_multilocation(

            interior_multilocation: InteriorLocation,

        ) -> Result<Location, Error<T>> {

            let relay_chain = Location::parent();

            let context: InteriorLocation = [Parachain(T::SelfParaId::get().into())].into();

            let mut reanchored: Location = interior_multilocation.into();

            reanchored

                .reanchor(&relay_chain, &context)

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

            Ok(reanchored)

        }

        pub fn is_core_buying_allowed(

            para_id: ParaId,

        ) -> Result<(), BuyingError<BlockNumberFor<T>>> {

            // If an in flight order is pending (i.e we did not receive the notification yet) and our

            // record is not expired yet, we should not allow the collator to buy another core.

            let maybe_in_flight_order = InFlightOrders::<T>::get(para_id);

            if let Some(in_flight_order) = maybe_in_flight_order {

                if in_flight_order.ttl < <frame_system::Pallet<T>>::block_number() {

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

                } else {

                    return Err(BuyingError::OrderAlreadyExists {

                        ttl: in_flight_order.ttl,

                        current_block_number: <frame_system::Pallet<T>>::block_number(),

                    });

            }

            let maybe_pending_blocks_ttl = PendingBlocks::<T>::get(para_id);

            if let Some(pending_blocks_ttl) = maybe_pending_blocks_ttl {

                if pending_blocks_ttl < <frame_system::Pallet<T>>::block_number() {

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

                } else {

                    return Err(BuyingError::BlockProductionPending {

                        ttl: pending_blocks_ttl,

                        current_block_number: <frame_system::Pallet<T>>::block_number(),

                    });

            }

            let parathread_params = T::GetParathreadParams::get_parathread_params(para_id)

                .ok_or(BuyingError::NotAParathread)?;

            let maybe_latest_author_info =

                T::LatestAuthorInfoFetcher::get_latest_author_info(para_id);

            if let Some(latest_author_info) = maybe_latest_author_info {

                let current_slot = T::SlotBeacon::slot();

                if !parathread_params.slot_frequency.should_parathread_buy_core(

                    Slot::from(current_slot as u64),

                    Slot::from(2u64),

                    latest_author_info.latest_slot_number,

                ) {

                    return Err(BuyingError::NotAllowedToProduceBlockRightNow {

                        slot_frequency: parathread_params.slot_frequency,

                        max_slot_earlier_core_buying_permitted: Slot::from(2u64),

                        last_block_production_slot: latest_author_info.latest_slot_number,

                    });

                }

            }

            Ok(())

        }

        fn on_collator_instantaneous_core_requested(para_id: ParaId) -> DispatchResult {

            Self::is_core_buying_allowed(para_id).map_err(Into::<Error<T>>::into)?;

            let xcm_weights_storage =

                RelayXcmWeightConfig::<T>::get().ok_or(Error::<T>::XcmWeightStorageNotSet)?;

            let withdraw_amount = xcm_weights_storage.buy_execution_cost;

            // Use the account derived from the multilocation composed with DescendOrigin

            // Buy on-demand cores

            // Any failure should return everything to the derivative account

            // Don't use utility::as_derivative because that will make the tanssi sovereign account

            // pay for fees, instead use `DescendOrigin` to make the parathread tank account

            // pay for fees.

            // TODO: when coretime is implemented, use coretime instantaneous credits instead of

            // buying on-demand cores at the price defined by the relay

            let origin = OriginKind::SovereignAccount;

            // TODO: max_amount is the max price of a core that this parathread is willing to pay

            // It should be defined in a storage item somewhere, controllable by the container chain

            // manager.

            let max_amount =

                T::GetParathreadMaxCorePrice::get_max_core_price(para_id).unwrap_or(u128::MAX);

            let call =

                T::GetPurchaseCoreCall::get_encoded(RelayChain::<T>::get(), max_amount, para_id);

            let weight_at_most = xcm_weights_storage.weight_at_most;

            // Assumption: derived account already has DOT

            // The balance should be enough to cover the `Withdraw` needed to `BuyExecution`, plus

            // the price of the core, which can change based on demand.

            let relay_asset_total: Asset = (Here, withdraw_amount).into();

            let refund_asset_filter: AssetFilter = AssetFilter::Wild(WildAsset::AllCounted(1));

            let interior_multilocation = Self::interior_multilocation(para_id);

            let derived_account =

                Self::relay_relative_multilocation(interior_multilocation.clone())?;

            let notify_call = <T as Config>::RuntimeCall::from(Call::<T>::query_response {

                query_id: 0,

                response: Default::default(),

            });

            let notify_call_weight = notify_call.get_dispatch_info().weight;

            let notify_query_ttl =

                <frame_system::Pallet<T>>::block_number() + T::CoreBuyingXCMQueryTtl::get();

            // Send XCM to relay chain

            let relay_chain = Location::parent();

            let query_id = T::XCMNotifier::new_notify_query(

                relay_chain.clone(),

                notify_call,

                notify_query_ttl,

                interior_multilocation.clone(),

            );

            let message: Xcm<()> = Xcm::builder_unsafe()

                .descend_origin(interior_multilocation.clone())

                .withdraw_asset(Assets::from(vec![relay_asset_total.clone()]))

                .buy_execution(relay_asset_total, Unlimited)

                // Both in case of error and in case of success, we want to refund the unused weight

                .set_appendix(

                    Xcm::builder_unsafe()

                        .report_transact_status(QueryResponseInfo {

                            destination: T::UniversalLocation::get()

                                .invert_target(&relay_chain)

                                .map_err(|_| Error::<T>::LocationInversionFailed)?, // This location from the point of view of destination

                            query_id,

                            max_weight: notify_call_weight,

                        })

                        .refund_surplus()

                        .deposit_asset(refund_asset_filter, derived_account)

                        .build(),

                )

                .transact(origin, weight_at_most, call)

                .build();

            let (ticket, _price) =

                T::XcmSender::validate(&mut Some(relay_chain), &mut Some(message))

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

            T::XcmSender::deliver(ticket).map_err(|_| Error::<T>::ErrorDeliveringXCM)?;

            Self::deposit_event(Event::BuyCoreXcmSent {

                para_id,

                transaction_status_query_id: query_id,

            });

            let in_flight_order_ttl = notify_query_ttl + T::AdditionalTtlForInflightOrders::get();

            InFlightOrders::<T>::insert(

                para_id,

                InFlightCoreBuyingOrder {

                    para_id,

                    query_id,

                    ttl: in_flight_order_ttl,

                },

            );

            QueryIdToParaId::<T>::insert(query_id, para_id);

            Ok(())

        }

        pub fn para_deregistered(para_id: ParaId) {

            if let Some(in_flight_order) = InFlightOrders::<T>::take(para_id) {

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

                QueryIdToParaId::<T>::remove(in_flight_order.query_id);

            }

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

        }

        fn validate_unsigned(_source: TransactionSource, call: &Self::Call) -> TransactionValidity {

                para_id,

                collator_account_id,

                proof,

            } = call

                let block_number = <frame_system::Pallet<T>>::block_number();

                let current_nonce = CollatorSignatureNonce::<T>::get(para_id);

                if proof.nonce != current_nonce {

                    return InvalidTransaction::Call.into();

                }

                let is_valid_collator = T::CheckCollatorValidity::is_valid_collator(

                    *para_id,

                    collator_account_id.clone(),

                    proof.public_key.clone(),

                );

                if !is_valid_collator {

                    return InvalidTransaction::Call.into();

                }

                if !proof.verify_signature(*para_id) {

                    return InvalidTransaction::Call.into();

                }

                ValidTransaction::with_tag_prefix("XcmCoreBuyer")

                    .priority(T::UnsignedPriority::get())

                    // TODO: tags

                    .and_provides((block_number, para_id))

                    //.and_provides((current_session, authority_id))

                    //.longevity(

                    //    TryInto::<u64>::try_into(

                    //       T::NextSessionRotation::average_session_length() / 2u32.into(),

                    //    )

                    //        .unwrap_or(64_u64),

                    //)

                    .longevity(64)

                    .propagate(true)

                    .build()

        }

    fn get_max_core_price(_para_id: ParaId) -> Option<u128> {

        None

    }

    fn convert(para_id: ParaId) -> [u8; 32] {

        // Derive a 32 byte account id for a parathread. Note that this is not the address of

        // the relay chain parathread tank, but that address is derived from this.

        let account: dp_core::AccountId = para_id.into_account_truncating();

        account.into()

    }