// Copyright Parity Technologies (UK) Ltd. // This file is part of Polkadot. // Polkadot 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. // Polkadot 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 Polkadot. If not, see . //! Parachain runtime mock. use codec::{Decode, Encode}; use frame_support::weights::Weight; use polkadot_parachain_primitives::primitives::{ DmpMessageHandler, Id as ParaId, XcmpMessageFormat, XcmpMessageHandler, }; use polkadot_primitives::BlockNumber as RelayBlockNumber; use sp_runtime::traits::{Get, Hash}; use sp_std::prelude::*; use xcm::{latest::prelude::*, VersionedXcm}; #[frame_support::pallet] pub mod pallet { use super::*; use frame_support::pallet_prelude::*; #[pallet::config] pub trait Config: frame_system::Config { type RuntimeEvent: From> + IsType<::RuntimeEvent>; type XcmExecutor: ExecuteXcm; } #[pallet::call] impl Pallet {} #[pallet::pallet] #[pallet::without_storage_info] pub struct Pallet(_); #[pallet::storage] #[pallet::getter(fn parachain_id)] pub(super) type ParachainId = StorageValue<_, ParaId, ValueQuery>; #[pallet::storage] #[pallet::getter(fn received_dmp)] /// A queue of received DMP messages pub(super) type ReceivedDmp = StorageValue<_, Vec>, ValueQuery>; impl Get for Pallet { fn get() -> ParaId { Self::parachain_id() } } pub type MessageId = [u8; 32]; #[pallet::event] #[pallet::generate_deposit(pub(super) fn deposit_event)] pub enum Event { /// Some XCM was executed OK. Success(Option), /// Some XCM failed. Fail(Option, XcmError), /// Bad XCM version used. BadVersion(Option), /// Bad XCM format used. BadFormat(Option), // DMP /// Downward message is invalid XCM. InvalidFormat(MessageId), /// Downward message is unsupported version of XCM. UnsupportedVersion(MessageId), /// Downward message executed with the given outcome. ExecutedDownward(MessageId, Outcome), } impl Pallet { pub fn set_para_id(para_id: ParaId) { ParachainId::::put(para_id); } fn handle_xcmp_message( sender: ParaId, _sent_at: RelayBlockNumber, xcm: VersionedXcm, max_weight: Weight, ) -> Result { let hash = Encode::using_encoded(&xcm, T::Hashing::hash); let mut message_hash = Encode::using_encoded(&xcm, sp_io::hashing::blake2_256); let (result, event) = match Xcm::::try_from(xcm) { Ok(xcm) => { let location = (Parent, Parachain(sender.into())); match T::XcmExecutor::prepare_and_execute( location, xcm, &mut message_hash, max_weight, Weight::zero(), ) { Outcome::Error { error } => (Err(error), Event::Fail(Some(hash), error)), Outcome::Complete { used } => (Ok(used), Event::Success(Some(hash))), // As far as the caller is concerned, this was dispatched without error, so // we just report the weight used. Outcome::Incomplete { used, error } => (Ok(used), Event::Fail(Some(hash), error)), } }, Err(()) => (Err(XcmError::UnhandledXcmVersion), Event::BadVersion(Some(hash))), }; Self::deposit_event(event); result } } impl XcmpMessageHandler for Pallet { fn handle_xcmp_messages<'a, I: Iterator>( iter: I, max_weight: Weight, ) -> Weight { for (sender, sent_at, data) in iter { let mut data_ref = data; let _ = XcmpMessageFormat::decode(&mut data_ref) .expect("Simulator encodes with versioned xcm format; qed"); let mut remaining_fragments = data_ref; while !remaining_fragments.is_empty() { if let Ok(xcm) = VersionedXcm::::decode(&mut remaining_fragments) { let _ = Self::handle_xcmp_message(sender, sent_at, xcm, max_weight); } else { debug_assert!(false, "Invalid incoming XCMP message data"); } } } max_weight } } impl DmpMessageHandler for Pallet { fn handle_dmp_messages( iter: impl Iterator)>, limit: Weight, ) -> Weight { for (_i, (_sent_at, data)) in iter.enumerate() { let mut id = sp_io::hashing::blake2_256(&data[..]); let maybe_versioned = VersionedXcm::::decode(&mut &data[..]); match maybe_versioned { Err(_) => { Self::deposit_event(Event::InvalidFormat(id)); }, Ok(versioned) => match Xcm::try_from(versioned) { Err(()) => Self::deposit_event(Event::UnsupportedVersion(id)), Ok(x) => { let outcome = T::XcmExecutor::prepare_and_execute( Parent, x.clone(), &mut id, limit, Weight::zero(), ); >::append(x); Self::deposit_event(Event::ExecutedDownward(id, outcome)); }, }, } } limit } } }