XCM v3 Companion

pallets/dmp-queue/src/lib.rs

@@ -239,7 +239,7 @@ pub mod pallet {
 					Ok(0)
 				},
 				Ok(Ok(x)) => {
-					let outcome = T::XcmExecutor::execute_xcm(Parent, x, limit);
+					let outcome = T::XcmExecutor::execute_xcm(Parent, x, message_id, limit);
 					match outcome {
 						Outcome::Error(XcmError::WeightLimitReached(required)) =>
 							Err((message_id, required)),
@@ -424,27 +424,32 @@ mod tests {
 		})
 	}
 
+	pub enum Weightless {}
+	impl PreparedMessage for Weightless {
+		fn weight_of(&self) -> Weight {
+			unreachable!()
+		}
+	}
+
 	pub struct MockExec;
 	impl ExecuteXcm<Call> for MockExec {
-		fn execute_xcm_in_credit(
+		type Prepared = Weightless;
+
+		fn prepare(message: Xcm) -> Result<Self::Prepared, Xcm> {
+			Err(message)
+		}
+
+		fn execute(
 			_origin: impl Into<MultiLocation>,
-			message: Xcm,
-			weight_limit: Weight,
-			_credit: Weight,
+			_: Weightless,
+			_hash: XcmHash,
+			_weight_limit: Weight,
 		) -> Outcome {
-			let o = match (message.0.len(), &message.0.first()) {
-				(1, Some(Transact { require_weight_at_most, .. })) => {
-					if *require_weight_at_most <= weight_limit {
-						Outcome::Complete(*require_weight_at_most)
-					} else {
-						Outcome::Error(XcmError::WeightLimitReached(*require_weight_at_most))
-					}
-				},
-				// use 1000 to decide that it's not supported.
-				_ => Outcome::Incomplete(1000.min(weight_limit), XcmError::Unimplemented),
-			};
-			TRACE.with(|q| q.borrow_mut().push((message, o.clone())));
-			o
+			unreachable!()
+		}
+
+		fn charge_fees(_location: impl Into<MultiLocation>, _fees: MultiAssets) -> XcmResult {
+			Err(XcmError::Unimplemented)
 		}
 	}
 
@@ -480,7 +485,7 @@ mod tests {
 
 	fn msg(weight: Weight) -> Xcm {
 		Xcm(vec![Transact {
-			origin_type: OriginKind::Native,
+			origin_kind: OriginKind::Native,
 			require_weight_at_most: weight,
 			call: Vec::new().into(),
 		}])

pallets/parachain-system/src/lib.rs

@@ -740,7 +740,7 @@ impl<T: Config> GetChannelInfo for Pallet<T> {
 		// 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
-		// tradeoff, compared to introducing an error variant that the clients should be
+		// trade-off, compared to introducing an error variant that the clients should be
 		// prepared to handle.
 		let index = match channels.binary_search_by_key(&id, |item| item.0) {
 			Err(_) => return ChannelStatus::Closed,

pallets/xcm/src/lib.rs

@@ -67,13 +67,13 @@ pub mod pallet {
 	pub enum Event<T: Config> {
 		/// Downward message is invalid XCM.
 		/// \[ id \]
-		InvalidFormat([u8; 8]),
+		InvalidFormat([u8; 32]),
 		/// Downward message is unsupported version of XCM.
 		/// \[ id \]
-		UnsupportedVersion([u8; 8]),
+		UnsupportedVersion([u8; 32]),
 		/// Downward message executed with the given outcome.
 		/// \[ id, outcome \]
-		ExecutedDownward([u8; 8], Outcome),
+		ExecutedDownward([u8; 32], Outcome),
 	}
 
 	/// Origin for the parachains module.
@@ -113,7 +113,7 @@ impl<T: Config> DmpMessageHandler for UnlimitedDmpExecution<T> {
 	) -> Weight {
 		let mut used = 0;
 		for (_sent_at, data) in iter {
-			let id = sp_io::hashing::twox_64(&data[..]);
+			let id = sp_io::hashing::blake2_256(&data[..]);
 			let msg = VersionedXcm::<T::Call>::decode_all_with_depth_limit(
 				MAX_XCM_DECODE_DEPTH,
 				&mut data.as_slice(),
@@ -123,7 +123,7 @@ impl<T: Config> DmpMessageHandler for UnlimitedDmpExecution<T> {
 				Err(_) => Pallet::<T>::deposit_event(Event::InvalidFormat(id)),
 				Ok(Err(())) => Pallet::<T>::deposit_event(Event::UnsupportedVersion(id)),
 				Ok(Ok(x)) => {
-					let outcome = T::XcmExecutor::execute_xcm(Parent, x, limit);
+					let outcome = T::XcmExecutor::execute_xcm(Parent, x, id, limit);
 					used += outcome.weight_used();
 					Pallet::<T>::deposit_event(Event::ExecutedDownward(id, outcome));
 				},
@@ -146,7 +146,7 @@ impl<T: Config> DmpMessageHandler for LimitAndDropDmpExecution<T> {
 	) -> Weight {
 		let mut used = 0;
 		for (_sent_at, data) in iter {
-			let id = sp_io::hashing::twox_64(&data[..]);
+			let id = sp_io::hashing::blake2_256(&data[..]);
 			let msg = VersionedXcm::<T::Call>::decode_all_with_depth_limit(
 				MAX_XCM_DECODE_DEPTH,
 				&mut data.as_slice(),
@@ -157,7 +157,7 @@ impl<T: Config> DmpMessageHandler for LimitAndDropDmpExecution<T> {
 				Ok(Err(())) => Pallet::<T>::deposit_event(Event::UnsupportedVersion(id)),
 				Ok(Ok(x)) => {
 					let weight_limit = limit.saturating_sub(used);
-					let outcome = T::XcmExecutor::execute_xcm(Parent, x, weight_limit);
+					let outcome = T::XcmExecutor::execute_xcm(Parent, x, id, weight_limit);
 					used += outcome.weight_used();
 					Pallet::<T>::deposit_event(Event::ExecutedDownward(id, outcome));
 				},

pallets/xcmp-queue/Cargo.toml

@@ -13,10 +13,12 @@ scale-info = { version = "2.1.1", default-features = false, features = ["derive"
 # Substrate
 frame-support = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "master" }
 frame-system = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "master" }
+sp-io = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "master" }
 sp-runtime = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "master" }
 sp-std = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "master" }
 
 # Polkadot
+polkadot-runtime-common = { git = "https://github.com/paritytech/polkadot", default-features = false, branch = "master" }
 xcm = { git = "https://github.com/paritytech/polkadot", default-features = false, branch = "master" }
 xcm-executor = { git = "https://github.com/paritytech/polkadot", default-features = false, branch = "master" }
 
@@ -30,7 +32,6 @@ frame-benchmarking = { default-features = false, optional = true, git = "https:/
 
 # Substrate
 sp-core = { git = "https://github.com/paritytech/substrate", branch = "master" }
-sp-io = { git = "https://github.com/paritytech/substrate", branch = "master" }
 pallet-balances = { git = "https://github.com/paritytech/substrate", branch = "master" }
 
 # Polkadot
@@ -48,6 +49,8 @@ std = [
 	"frame-support/std",
 	"frame-system/std",
 	"log/std",
+	"polkadot-runtime-common/std",
+	"sp-io/std",
 	"sp-runtime/std",
 	"sp-std/std",
 	"xcm-executor/std",

pallets/xcmp-queue/src/lib.rs

@@ -44,15 +44,16 @@ use cumulus_primitives_core::{
 	ParaId, XcmpMessageFormat, XcmpMessageHandler, XcmpMessageSource,
 };
 use frame_support::{
-	traits::EnsureOrigin,
+	traits::{EnsureOrigin, Get},
 	weights::{constants::WEIGHT_PER_MILLIS, Weight},
 };
+use polkadot_runtime_common::xcm_sender::ConstantPrice;
 use rand_chacha::{
 	rand_core::{RngCore, SeedableRng},
 	ChaChaRng,
 };
 use scale_info::TypeInfo;
-use sp_runtime::{traits::Hash, RuntimeDebug};
+use sp_runtime::RuntimeDebug;
 use sp_std::{convert::TryFrom, prelude::*};
 use xcm::{latest::prelude::*, VersionedXcm, WrapVersion, MAX_XCM_DECODE_DEPTH};
 use xcm_executor::traits::ConvertOrigin;
@@ -99,6 +100,9 @@ pub mod pallet {
 		/// superuser origin.
 		type ControllerOriginConverter: ConvertOrigin<Self::Origin>;
 
+		/// The price for delivering an XCM to a sibling parachain destination.
+		type PriceForSiblingDelivery: PriceForSiblingDelivery;
+
 		/// The weight information of this pallet.
 		type WeightInfo: WeightInfo;
 	}
@@ -263,17 +267,17 @@ pub mod pallet {
 	#[pallet::generate_deposit(pub(super) fn deposit_event)]
 	pub enum Event<T: Config> {
 		/// Some XCM was executed ok.
-		Success { message_hash: Option<T::Hash>, weight: Weight },
+		Success { message_hash: Option<XcmHash>, weight: Weight },
 		/// Some XCM failed.
-		Fail { message_hash: Option<T::Hash>, error: XcmError, weight: Weight },
+		Fail { message_hash: Option<XcmHash>, error: XcmError, weight: Weight },
 		/// Bad XCM version used.
-		BadVersion { message_hash: Option<T::Hash> },
+		BadVersion { message_hash: Option<XcmHash> },
 		/// Bad XCM format used.
-		BadFormat { message_hash: Option<T::Hash> },
+		BadFormat { message_hash: Option<XcmHash> },
 		/// An upward message was sent to the relay chain.
-		UpwardMessageSent { message_hash: Option<T::Hash> },
+		UpwardMessageSent { message_hash: Option<XcmHash> },
 		/// An HRMP message was sent to a sibling parachain.
-		XcmpMessageSent { message_hash: Option<T::Hash> },
+		XcmpMessageSent { message_hash: Option<XcmHash> },
 		/// An XCM exceeded the individual message weight budget.
 		OverweightEnqueued {
 			sender: ParaId,
@@ -599,13 +603,13 @@ impl<T: Config> Pallet<T> {
 		xcm: VersionedXcm<T::Call>,
 		max_weight: Weight,
 	) -> Result<Weight, XcmError> {
-		let hash = Encode::using_encoded(&xcm, T::Hashing::hash);
+		let hash = xcm.using_encoded(sp_io::hashing::blake2_256);
 		log::debug!("Processing XCMP-XCM: {:?}", &hash);
 		let (result, event) = match Xcm::<T::Call>::try_from(xcm) {
 			Ok(xcm) => {
-				let location = (1, Parachain(sender.into()));
+				let location = (Parent, Parachain(sender.into()));
 
-				match T::XcmExecutor::execute_xcm(location, xcm, max_weight) {
+				match T::XcmExecutor::execute_xcm(location, xcm, hash, max_weight) {
 					Outcome::Error(e) =>
 						(Err(e), Event::Fail { message_hash: Some(hash), error: e, weight: 0 }),
 					Outcome::Complete(w) =>
@@ -796,7 +800,7 @@ impl<T: Config> Pallet<T> {
 			let index = shuffled[shuffle_index];
 			let sender = status[index].sender;
 			let sender_origin = T::ControllerOriginConverter::convert_origin(
-				(1, Parachain(sender.into())),
+				(Parent, Parachain(sender.into())),
 				OriginKind::Superuser,
 			);
 			let is_controller = sender_origin
@@ -1092,28 +1096,59 @@ impl<T: Config> XcmpMessageSource for Pallet<T> {
 	}
 }
 
+pub trait PriceForSiblingDelivery {
+	fn price_for_sibling_delivery(id: ParaId, message: &Xcm<()>) -> MultiAssets;
+}
+
+impl PriceForSiblingDelivery for () {
+	fn price_for_sibling_delivery(_: ParaId, _: &Xcm<()>) -> MultiAssets {
+		MultiAssets::new()
+	}
+}
+
+impl<T: Get<MultiAssets>> PriceForSiblingDelivery for ConstantPrice<T> {
+	fn price_for_sibling_delivery(_: ParaId, _: &Xcm<()>) -> MultiAssets {
+		T::get()
+	}
+}
+
 /// Xcm sender for sending to a sibling parachain.
 impl<T: Config> SendXcm for Pallet<T> {
-	fn send_xcm(dest: impl Into<MultiLocation>, msg: Xcm<()>) -> Result<(), SendError> {
-		let dest = dest.into();
+	type Ticket = (ParaId, VersionedXcm<()>);
 
-		match &dest {
+	fn validate(
+		dest: &mut Option<MultiLocation>,
+		msg: &mut Option<Xcm<()>>,
+	) -> SendResult<(ParaId, VersionedXcm<()>)> {
+		let d = dest.take().ok_or(SendError::MissingArgument)?;
+		let xcm = msg.take().ok_or(SendError::MissingArgument)?;
+
+		match &d {
 			// An HRMP message for a sibling parachain.
 			MultiLocation { parents: 1, interior: X1(Parachain(id)) } => {
-				let versioned_xcm = T::VersionWrapper::wrap_version(&dest, msg)
+				let id = ParaId::from(*id);
+				let price = T::PriceForSiblingDelivery::price_for_sibling_delivery(id, &xcm);
+				let versioned_xcm = T::VersionWrapper::wrap_version(&d, xcm)
 					.map_err(|()| SendError::DestinationUnsupported)?;
-				let hash = T::Hashing::hash_of(&versioned_xcm);
-				Self::send_fragment(
-					(*id).into(),
-					XcmpMessageFormat::ConcatenatedVersionedXcm,
-					versioned_xcm,
-				)
-				.map_err(|e| SendError::Transport(<&'static str>::from(e)))?;
-				Self::deposit_event(Event::XcmpMessageSent { message_hash: Some(hash) });
-				Ok(())
+				Ok(((id, versioned_xcm), price))
 			},
 			// Anything else is unhandled. This includes a message this is meant for us.
-			_ => Err(SendError::CannotReachDestination(dest, msg)),
+			_ => {
+				*dest = Some(d);
+				Err(SendError::NotApplicable)
+			},
+		}
+	}
+
+	fn deliver((id, xcm): (ParaId, VersionedXcm<()>)) -> Result<XcmHash, SendError> {
+		let hash = xcm.using_encoded(sp_io::hashing::blake2_256);
+
+		match Self::send_fragment(id, XcmpMessageFormat::ConcatenatedVersionedXcm, xcm) {
+			Ok(_) => {
+				Self::deposit_event(Event::XcmpMessageSent { message_hash: Some(hash) });
+				Ok(hash)
+			},
+			Err(e) => Err(SendError::Transport(<&'static str>::from(e))),
 		}
 	}
 }

pallets/xcmp-queue/src/mock.rs

@@ -18,17 +18,18 @@ use crate as xcmp_queue;
 use core::marker::PhantomData;
 use cumulus_pallet_parachain_system::AnyRelayNumber;
 use cumulus_primitives_core::{IsSystem, ParaId};
-use frame_support::{parameter_types, traits::OriginTrait};
+use frame_support::{
+	parameter_types,
+	traits::{Nothing, OriginTrait},
+};
 use frame_system::EnsureRoot;
 use sp_core::H256;
 use sp_runtime::{
 	testing::Header,
 	traits::{BlakeTwo256, IdentityLookup},
 };
 use xcm::prelude::*;
-use xcm_builder::{
-	CurrencyAdapter, FixedWeightBounds, IsConcrete, LocationInverter, NativeAsset, ParentIsPreset,
-};
+use xcm_builder::{CurrencyAdapter, FixedWeightBounds, IsConcrete, NativeAsset, ParentIsPreset};
 use xcm_executor::traits::ConvertOrigin;
 
 type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic<Test>;
@@ -115,9 +116,10 @@ impl cumulus_pallet_parachain_system::Config for Test {
 
 parameter_types! {
 	pub const RelayChain: MultiLocation = MultiLocation::parent();
-	pub Ancestry: MultiLocation = X1(Parachain(1u32.into())).into();
+	pub UniversalLocation: InteriorMultiLocation = X1(Parachain(1u32.into())).into();
 	pub UnitWeightCost: Weight = 1_000_000;
 	pub const MaxInstructions: u32 = 100;
+	pub const MaxAssetsIntoHolding: u32 = 64;
 }
 
 /// Means for transacting assets on this chain.
@@ -145,14 +147,22 @@ impl xcm_executor::Config for XcmConfig {
 	type OriginConverter = ();
 	type IsReserve = NativeAsset;
 	type IsTeleporter = NativeAsset;
-	type LocationInverter = LocationInverter<Ancestry>;
+	type UniversalLocation = UniversalLocation;
 	type Barrier = ();
 	type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;
 	type Trader = ();
 	type ResponseHandler = ();
 	type AssetTrap = ();
 	type AssetClaims = ();
 	type SubscriptionService = ();
+	type PalletInstancesInfo = AllPalletsWithSystem;
+	type MaxAssetsIntoHolding = MaxAssetsIntoHolding;
+	type AssetLocker = ();
+	type AssetExchanger = ();
+	type FeeManager = ();
+	type MessageExporter = ();
+	type UniversalAliases = Nothing;
+	type CallDispatcher = Call;
 }
 
 pub type XcmRouter = (
@@ -191,6 +201,7 @@ impl Config for Test {
 	type ControllerOrigin = EnsureRoot<AccountId>;
 	type ControllerOriginConverter = SystemParachainAsSuperuser<Origin>;
 	type WeightInfo = ();
+	type PriceForSiblingDelivery = ();
 }
 
 pub fn new_test_ext() -> sp_io::TestExternalities {

parachain-template/runtime/src/lib.rs

@@ -392,6 +392,7 @@ impl cumulus_pallet_xcmp_queue::Config for Runtime {
 	type ControllerOrigin = EnsureRoot<AccountId>;
 	type ControllerOriginConverter = XcmOriginToTransactDispatchOrigin;
 	type WeightInfo = ();
+	type PriceForSiblingDelivery = ();
 }
 
 impl cumulus_pallet_dmp_queue::Config for Runtime {