XCM revamp

runtime/common/src/paras_sudo_wrapper.rs

@@ -113,7 +113,7 @@ decl_module! {
 		/// The given parachain should exist and the payload should not exceed the preconfigured size
 		/// `config.max_downward_message_size`.
 		#[weight = (1_000, DispatchClass::Operational)]
-		pub fn sudo_queue_downward_xcm(origin, id: ParaId, xcm: xcm::VersionedXcm) -> DispatchResult {
+		pub fn sudo_queue_downward_xcm(origin, id: ParaId, xcm: xcm::opaque::VersionedXcm) -> DispatchResult {
 			ensure_root(origin)?;
 			ensure!(<paras::Module<T>>::is_valid_para(id), Error::<T>::ParaDoesntExist);
 			let config = <configuration::Module<T>>::config();

runtime/common/src/xcm_sender.rs

@@ -18,7 +18,7 @@
 
 use parity_scale_codec::Encode;
 use sp_std::marker::PhantomData;
-use xcm::{VersionedXcm, v0::{SendXcm, MultiLocation, Junction, Xcm, Result, Error}};
+use xcm::opaque::{VersionedXcm, v0::{SendXcm, MultiLocation, Junction, Xcm, Result, Error}};
 use runtime_parachains::{configuration, dmp};
 
 /// Xcm sender for relay chain. It only sends downward message.
@@ -36,7 +36,7 @@ impl<T: configuration::Config + dmp::Config> SendXcm for RelayChainXcmSender<T>
 			).map_err(Into::<Error>::into)?;
 			Ok(())
 		} else {
-			Err(Error::CannotReachDestination)
+			Err(Error::CannotReachDestination("UnsupportedDestination"))
 		}
 	}
 }

runtime/parachains/src/hrmp.rs

@@ -959,7 +959,7 @@ impl<T: Config> Module<T> {
 		<Self as Store>::HrmpOpenChannelRequestsList::append(channel_id);
 
 		let notification_bytes = {
-			use xcm::{v0::Xcm, VersionedXcm};
+			use xcm::opaque::{v0::Xcm, VersionedXcm};
 			use parity_scale_codec::Encode as _;
 
 			VersionedXcm::from(Xcm::HrmpNewChannelOpenRequest {
@@ -1025,7 +1025,7 @@ impl<T: Config> Module<T> {
 
 		let notification_bytes = {
 			use parity_scale_codec::Encode as _;
-			use xcm::{v0::Xcm, VersionedXcm};
+			use xcm::opaque::{v0::Xcm, VersionedXcm};
 
 			VersionedXcm::from(Xcm::HrmpChannelAccepted {
 				recipient: u32::from(origin),
@@ -1068,7 +1068,7 @@ impl<T: Config> Module<T> {
 		let config = <configuration::Module<T>>::config();
 		let notification_bytes = {
 			use parity_scale_codec::Encode as _;
-			use xcm::{v0::Xcm, VersionedXcm};
+			use xcm::opaque::{v0::Xcm, VersionedXcm};
 
 			VersionedXcm::from(Xcm::HrmpChannelClosing {
 				initiator: u32::from(origin),

runtime/parachains/src/ump.rs

@@ -20,6 +20,7 @@ use crate::{
 };
 use sp_std::{fmt, prelude::*};
 use sp_std::collections::{btree_map::BTreeMap, vec_deque::VecDeque};
+use sp_runtime::traits::Zero;
 use frame_support::{decl_module, decl_storage, StorageMap, StorageValue, weights::Weight, traits::Get};
 use primitives::v1::{Id as ParaId, UpwardMessage};
 
@@ -65,27 +66,28 @@ impl<Config: xcm_executor::Config> UmpSink for XcmSink<Config> {
 		use xcm::v0::{Junction, MultiLocation, ExecuteXcm};
 		use xcm_executor::XcmExecutor;
 
-		let weight: Weight = 0;
-
-		if let Ok(versioned_xcm_message) = VersionedXcm::decode(&mut &msg[..]) {
+		// TODO: #2841 #UMPQUEUE Get a proper weight limit here. Probably from Relay Chain Config
+		let weight_limit = Weight::max_value();
+		let weight = if let Ok(versioned_xcm_message) = VersionedXcm::decode(&mut &msg[..]) {
 			match versioned_xcm_message {
 				VersionedXcm::V0(xcm_message) => {
 					let xcm_junction: Junction = Junction::Parachain { id: origin.into() };
 					let xcm_location: MultiLocation = xcm_junction.into();
-					// TODO: Do something with result.
-					let _result = XcmExecutor::<Config>::execute_xcm(xcm_location, xcm_message);
+					let result = XcmExecutor::<Config>::execute_xcm(xcm_location, xcm_message, weight_limit);
+					result.weight_used()
 				}
 			}
 		} else {
 			log::error!(
 				target: LOG_TARGET,
 				"Failed to decode versioned XCM from upward message.",
 			);
-		}
+			Weight::zero()
+		};
 
-		// TODO: to be sound, this implementation must ensure that returned (and thus consumed)
-		// weight is limited to some small portion of the total block weight (as a ballpark, 1/4, 1/8
-		// or lower).
+		// TODO: #2841 #UMPQUEUE to be sound, this implementation must ensure that returned (and thus consumed)
+		//  weight is limited to some small portion of the total block weight (as a ballpark, 1/4, 1/8
+		//  or lower).
 		weight
 	}
 }

runtime/rococo/src/lib.rs

@@ -81,11 +81,11 @@ pub use pallet_balances::Call as BalancesCall;
 
 use polkadot_parachain::primitives::Id as ParaId;
 use xcm::v0::{MultiLocation, NetworkId};
-use xcm_executor::traits::IsConcrete;
 use xcm_builder::{
 	AccountId32Aliases, ChildParachainConvertsVia, SovereignSignedViaLocation,
 	CurrencyAdapter as XcmCurrencyAdapter, ChildParachainAsNative,
 	SignedAccountId32AsNative, ChildSystemParachainAsSuperuser, LocationInverter,
+	IsConcrete, FixedWeightBounds, FixedRateOfConcreteFungible,
 };
 use constants::{time::*, currency::*, fee::*};
 use frame_support::traits::InstanceFilter;
@@ -616,6 +616,11 @@ type LocalOriginConverter = (
 	ChildSystemParachainAsSuperuser<ParaId, Origin>,
 );
 
+parameter_types! {
+	pub const BaseXcmWeight: Weight = 100_000;
+	pub const RocFee: (MultiLocation, u128) = (RocLocation::get(), 1 * CENTS);
+}
+
 pub struct XcmConfig;
 impl xcm_executor::Config for XcmConfig {
 	type Call = Call;
@@ -625,6 +630,10 @@ impl xcm_executor::Config for XcmConfig {
 	type IsReserve = ();
 	type IsTeleporter = ();
 	type LocationInverter = LocationInverter<Ancestry>;
+	type Barrier = ();
+	type Weigher = FixedWeightBounds<BaseXcmWeight, Call>;
+	type Trader = FixedRateOfConcreteFungible<RocFee>;
+	type ResponseHandler = ();
 }
 
 impl parachains_session_info::Config for Runtime {}

xcm/Cargo.toml

@@ -7,6 +7,7 @@ edition = "2018"
 
 [dependencies]
 parity-scale-codec = { version = "2.0.0", default-features = false, features = [ "derive" ] }
+derivative = {version = "2.2.0", default-features = false, features = [ "use_core" ] }
 
 [features]
 default = ["std"]

xcm/src/double_encoded.rs

@@ -0,0 +1,74 @@
+// Copyright 2020 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 <http://www.gnu.org/licenses/>.
+
+use alloc::vec::Vec;
+use parity_scale_codec::{Encode, Decode};
+
+#[derive(Encode, Decode)]
+#[codec(encode_bound())]
+#[codec(decode_bound())]
+pub struct DoubleEncoded<T> {
+	encoded: Vec<u8>,
+	#[codec(skip)]
+	decoded: Option<T>,
+}
+
+impl<T> Clone for DoubleEncoded<T> {
+	fn clone(&self) -> Self { Self { encoded: self.encoded.clone(), decoded: None } }
+}
+impl<T> Eq for DoubleEncoded<T> {
+}
+impl<T> PartialEq for DoubleEncoded<T> {
+	fn eq(&self, other: &Self) -> bool { self.encoded.eq(&other.encoded) }
+}
+impl<T> core::fmt::Debug for DoubleEncoded<T> {
+	fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { self.encoded.fmt(f) }
+}
+
+impl<T> From<Vec<u8>> for DoubleEncoded<T> {
+	fn from(encoded: Vec<u8>) -> Self {
+		Self { encoded, decoded: None }
+	}
+}
+
+impl<T> DoubleEncoded<T> {
+	pub fn into<S>(self) -> DoubleEncoded<S> { DoubleEncoded::from(self) }
+	pub fn from<S>(e: DoubleEncoded<S>) -> Self {
+		Self {
+			encoded: e.encoded,
+			decoded: None,
+		}
+	}
+	pub fn as_ref(&self) -> Option<&T> {
+		self.decoded.as_ref()
+	}
+}
+
+impl<T: Decode> DoubleEncoded<T> {
+	pub fn ensure_decoded(&mut self) -> Result<&T, ()> {
+		if self.decoded.is_none() {
+			self.decoded = T::decode(&mut &self.encoded[..]).ok();
+		}
+		self.decoded.as_ref().ok_or(())
+	}
+	pub fn take_decoded(&mut self) -> Result<T, ()> {
+		self.decoded.take().or_else(|| T::decode(&mut &self.encoded[..]).ok()).ok_or(())
+	}
+	pub fn try_into(mut self) -> Result<T, ()> {
+		self.ensure_decoded()?;
+		self.decoded.ok_or(())
+	}
+}

xcm/src/lib.rs

@@ -24,13 +24,32 @@
 extern crate alloc;
 
 use parity_scale_codec::{Encode, Decode};
+use derivative::Derivative;
 
 pub mod v0;
 
+mod double_encoded;
+pub use double_encoded::DoubleEncoded;
+
 /// A single XCM message, together with its version code.
-#[derive(Clone, Eq, PartialEq, Encode, Decode, Debug)]
-pub enum VersionedXcm {
-	V0(v0::Xcm),
+#[derive(Derivative, Encode, Decode)]
+#[derivative(Clone(bound=""), Eq(bound=""), PartialEq(bound=""), Debug(bound=""))]
+#[codec(encode_bound())]
+#[codec(decode_bound())]
+pub enum VersionedXcm<Call> {
+	V0(v0::Xcm<Call>),
+}
+
+pub mod opaque {
+	pub mod v0 {
+		// Everything from v0
+		pub use crate::v0::*;
+		// Then override with the opaque types in v0
+		pub use crate::v0::opaque::{Xcm, Order};
+	}
+
+	/// The basic VersionedXcm type which just uses the `Vec<u8>` as an encoded call.
+	pub type VersionedXcm = super::VersionedXcm<()>;
 }
 
 /// A versioned multi-location, a relative location of a cross-consensus system identifier.

xcm/src/v0/junction.rs

@@ -45,6 +45,10 @@ pub enum Junction {
 	/// An indexed parachain belonging to and operated by the context.
 	///
 	/// Generally used when the context is a Polkadot Relay-chain.
+	///
+	/// There is also `Parachain` which can be used in tests to avoid the faffy `{ id: ... }` syntax. Production
+	/// code should use this.
+	// TODO: parity-scale-codec#262: Change to be `Parachain(#[codec(compact)] u32)`
 	Parachain { #[codec(compact)] id: u32 },
 	/// A 32-byte identifier for an account of a specific network that is respected as a sovereign endpoint within
 	/// the context.
@@ -64,7 +68,7 @@ pub enum Junction {
 	/// An instanced, indexed pallet that forms a constituent part of the context.
 	///
 	/// Generally used when the context is a Frame-based chain.
-	PalletInstance { id: u8 },
+	PalletInstance(u8),
 	/// A non-descript index within the context location.
 	///
 	/// Usage will vary widely owing to its generality.