Initial effort at integrating xcm-executor into Rococo

runtime/common/src/parachains.rs

@@ -58,7 +58,7 @@ use system::{
 };
 use crate::attestations::{self, IncludedBlocks};
 use crate::registrar::Registrar;
-use xcm::{VersionedXcm, VersionedMultiLocation, v0::{Xcm, MultiOrigin, MultiAsset, MultiLocation, Junction, Ai}};
+use xcm::{VersionedXcm, VersionedMultiLocation, v0::{Xcm, SendXcm, ExecuteXcm, MultiOrigin, MultiAsset, MultiLocation, Junction, Ai}};
 
 // ranges for iteration of general block number don't work, so this
 // is a utility to get around that.
@@ -326,6 +326,9 @@ pub trait Trait: CreateSignedTransaction<Call<Self>> + attestations::Trait + ses
 
 	/// A type that converts the opaque hash type to exact one.
 	type BlockHashConversion: Convert<Self::Hash, primitives::v0::Hash>;
+
+	/// The XCM interpreter.
+	type XcmExecutive: ExecuteXcm;
 }
 
 /// Origin for the parachains module.
@@ -808,6 +811,21 @@ fn make_sorted_duties(duty: &[Chain]) -> Vec<(usize, ParaId)> {
 	sorted_duties
 }
 
+impl<T: Trait> SendXcm for Module<T> {
+	fn send_xcm(dest: MultiLocation, msg: xcm::v0::Xcm) -> xcm::v0::XcmResult {
+		if let MultiLocation::X1(Junction::Parachain{ id }) = dest {
+			let downward_queue_count = DownwardMessageQueue::decode_len(id).unwrap_or(0);
+			if downward_queue_count >= MAX_DOWNWARD_QUEUE_COUNT {
+				return Err(())	// Destination buffer overflow.
+			}
+			DownwardMessageQueue::append(id, msg.encode());
+			Ok(())
+		} else {
+			return Err(())	// Cannot reach destination.
+		}
+	}
+}
+
 impl<T: Trait> Module<T> {
 	/// Initialize the state of a new parachain/parathread.
 	pub fn initialize_para(
@@ -932,89 +950,12 @@ impl<T: Trait> Module<T> {
 	/// Dispatch some messages from a parachain.
 	fn dispatch_message(from: ParaId, data: &[u8]) {
 		use sp_std::convert::TryFrom;
+		let origin: MultiLocation = Junction::Parachain { id: from }.into();
 		match VersionedXcm::decode(&mut &data[..]).map(Xcm::try_from) {
-			Ok(Ok(Xcm::ForwardToParachain { id, inner })) => {
-				let id = ParaId::from(id);
-				let downward_queue_count = DownwardMessageQueue::decode_len(id).unwrap_or(0);
-				if downward_queue_count >= MAX_DOWNWARD_QUEUE_COUNT {
-					return
-				}
-				let msg = VersionedXcm::from(Xcm::ForwardedFromParachain{ id: from.into(), inner });
-				DownwardMessageQueue::append(id, msg.encode());
-			},
-			Ok(Ok(Xcm::Transact{ origin_type, call })) => {
-				if let Ok(message_call) = <T as Trait>::Call::decode(&mut &call[..]) {
-					let origin: <T as Trait>::Origin = match origin_type {
-						MultiOrigin::SovereignAccount => system::RawOrigin::Signed(from.into_account()).into(),
-						MultiOrigin::Native => Origin::Parachain(from).into(),
-						MultiOrigin::Superuser if from.is_system() => system::RawOrigin::Root.into(),
-						_ => return,
-					};
-					let _ok = message_call.dispatch(origin).is_ok();
-					// Not much to do with the result as it is. It's up to the parachain to ensure that the
-					// message makes sense.
-				}
-			},
-			Ok(Ok(Xcm::ReserveAssetTransfer { assets, dest, effects })) => {
-				if assets.is_empty() { return };
-				// TODO: Handle multiple assets. This is just a hack to make it work for 1 asset.
-				let asset = assets[0].clone();
-				let amount = match asset {
-					MultiAsset::ConcreteFungible { id: MultiLocation::Null, amount} => amount,
-					_ => return,	// Bail as we don't support being a reserve for this asset.
-				};
-				let (onward_asset, dest) = match dest {
-					// Only destination we support for reserve asset transfers is into a parachain.
-					MultiLocation::X1(Junction::Parachain { id }) => {
-						let destid = ParaId::from(id);
-						let destaccount = destid.into_account();
-						if T::ParachainCurrency::transfer_out(from, &destaccount, amount, AllowDeath).is_err() {
-							return
-						}
-						// The onward asset, since it's the Relay-chain's native currency, is identified as
-						// the chain itself (from our context, it's therefore `Null`). From the parachain's context,
-						// it is identified as `Parent`.
-						(MultiAsset::ConcreteFungible { id: Junction::Parent.into(), amount }, destid)
-					},
-					_ => return,
-				};
-				let msg = VersionedXcm::from(Xcm::ReserveAssetCredit { assets: vec![onward_asset], effects }).encode();
-				DownwardMessageQueue::append(dest, msg);
-			},
-			Ok(Ok(Xcm::WithdrawAsset { assets, effects })) => {
-				if assets.is_empty() || effects.is_empty() { return };
-				// TODO: Handle multiple assets. This is just a hack to make it work for 1 asset.
-				let asset = assets[0].clone();
-				let amount = match asset {
-					MultiAsset::ConcreteFungible { id: MultiLocation::Null, amount} => amount,
-					_ => return,	// Bail as we don't support being a reserve for this asset.
-				};
-				// TODO: Handle multiple effects. This is just a hack to make it work for 1 effect.
-				let effect = effects[0].clone();
-				match effect {
-					// Only effect we support for now is a straight wildcard deposit into an AccountId32.
-					// TODO: Consider caring about the `network`.
-					Ai::DepositAsset { assets, dest: MultiLocation::X1(Junction::AccountId32 { id, .. }) } => {
-						if assets.is_empty() { return };
-						// TODO: Handle multiple assets. This is just a hack to make it work for 1 asset.
-						let asset = assets[0].clone();
-						match asset {
-							MultiAsset::All => {
-								let dest = match T::AccountId::decode(&mut &id[..]) {
-									Ok(x) => x,
-									Err(_) => return,
-								};
-								if T::ParachainCurrency::transfer_out(from, &dest, amount, AllowDeath).is_err() {
-									return
-								}
-							},
-							_ => return,
-						}
-					}
-					_ => return,
-				}
+			Ok(Ok(xcm)) => {
+				// TODO: handle error.
+				let _ = T::XcmExecutive::execute_xcm(origin.clone(), xcm);
 			},
-			Ok(Ok(_)) => (),	// Unhandled XCM message type.
 			Ok(Err(_)) => (),	// Unsupported XCM version.
 			Err(_) => (),		// Bad format (can't decode).
 		}

runtime/rococo/Cargo.toml

@@ -76,6 +76,9 @@ runtime-common = { package = "polkadot-runtime-common", path = "../common", defa
 primitives = { package = "polkadot-primitives", path = "../../primitives", default-features = false }
 polkadot-parachain = { path = "../../parachain", default-features = false }
 
+xcm = { path = "../../xcm", default-features = false }
+xcm-executor = { path = "../../xcm/xcm-executor", default-features = false }
+
 [dev-dependencies]
 libsecp256k1 = "0.3.2"
 tiny-keccak = "1.5.0"
@@ -149,6 +152,8 @@ std = [
 	"sp-staking/std",
 	"randomness-collective-flip/std",
 	"runtime-common/std",
+	"xcm/std",
+	"xcm-executor/std",
 ]
 runtime-benchmarks = [
 	"runtime-common/runtime-benchmarks",

runtime/rococo/src/lib.rs

@@ -398,6 +398,67 @@ parameter_types! {
 	pub const SlashPeriod: BlockNumber = 7 * DAYS;
 }
 
+parameter_types! {
+	const RocLocation: MultiLocation = MultiLocation::X1(Junction::Parent);
+}
+
+pub type LocalAssetTransactor =
+	CurrencyAdapter<
+		// Use this currency:
+		balances::Module::<T, DefaultInstance>,
+		// Use this currency when it is a fungible asset matching the given location or name:
+		(IsConcrete<RocLocation>),
+		// Do a simple punn to convert an AccountId32 MultiLocation into a native chain account ID:
+		// TODO: This will need some ParaId::into_account() magic.
+		AccountId32Punner<T::AccountId>,
+		// Our chain's account ID type (we can't get away without mentioning it explicitly):
+		T::AccountId,
+	>;
+
+use polkadot_parachain::primitives::{AccountIdConversion, Id as ParaId};
+use xcm::v0::{MultiLocation, Junction};
+use sp_core::crypto::UncheckedInto;
+impl AccountIdConversion<AccountId> for MultiLocation {
+	fn into_account(&self) -> AccountId {
+		match self {
+			MultiLocation::X1(Junction::Parachain { id }) => ParaId::from(id).into_account(),
+			MultiLocation::X1(Junction::AccountId32 { id }) => id.unchecked_into(),
+			x => ("multilocation", x).using_encoded(sp_io::hashing::blake2_256).unchecked_into(),
+		}
+	}
+
+	fn try_from_account(a: AccountId) -> Option<Self> {
+		if let Some(id) = ParaId::try_from_account(a) {
+			return Some(Junction::Parachain { id: id.into() })
+		}
+		Some(Junction::AccountId32 { id: a.into() })
+	}
+}
+
+pub struct LocalOriginConverter;
+impl OriginConverter<Origin> for LocalOriginConverter {
+	fn convert_origin(origin: MultiLocation, kind: MultiOrigin) -> Result<Origin, xcm::v0::Error> {
+		Ok(match (kind, origin) {
+			(MultiOrigin::SovereignAccount, origin) => system::RawOrigin::Signed(origin.into_account()).into(),
+			(MultiOrigin::Native, MultiLocation::X1(Junction::Parachain { id })) => parachains::Origin::Parachain(id).into(),
+			(MultiOrigin::Native, MultiLocation::X1(Junction::AccountId32 { id })) => system::RawOrigin::Signed(id).into(),
+			(MultiOrigin::Superuser, MultiLocation::X1(Junction::Parachain { id })) if ParaId::from(id).is_system()
+				=> system::RawOrigin::Root.into(),
+			_ => Err(())?,
+		})
+	}
+}
+
+pub struct XcmExecutorConfig;
+impl xcm_executor::Config for XcmExecutorConfig {
+	type Call = Call;
+	type XcmSender = Parachains;
+	type AssetTransactor = LocalAssetTransactor;
+	type OriginConverter = LocalOriginConverter;
+	type IsReserve = ();
+	type IsTeleporter = ();
+}
+
 impl parachains::Trait for Runtime {
 	type AuthorityId = primitives::v0::fisherman::FishermanAppCrypto;
 	type Origin = Origin;
@@ -419,6 +480,8 @@ impl parachains::Trait for Runtime {
 	type IdentificationTuple = <Self::KeyOwnerProofSystem as KeyOwnerProofSystem<(KeyTypeId, Vec<u8>)>>::IdentificationTuple;
 	type ReportOffence = Offences;
 	type BlockHashConversion = sp_runtime::traits::Identity;
+
+	type XcmExecutive = XcmExecutor<XcmExecutorConfig>;
 }
 
 /// Submits a transaction with the node's public and signature type. Adheres to the signed extension

xcm/src/v0.rs

@@ -16,20 +16,25 @@
 
 //! Cross-Consensus Message format data structures.
 
-use sp_std::{boxed::Box, vec::Vec, convert::TryFrom};
+use sp_std::{result, boxed::Box, vec::Vec, convert::TryFrom};
 use sp_runtime::RuntimeDebug;
 use codec::{self, Encode, Decode};
 use super::{VersionedXcm, VersionedMultiLocation, VersionedMultiAsset};
 
-pub type XcmError = ();
-pub type XcmResult = Result<(), XcmError>;
+pub type Error = ();
+pub type Result = result::Result<(), Error>;
+
+#[deprecated]
+pub type XcmError = Error;
+#[deprecated]
+pub type XcmResult = Result;
 
 pub trait ExecuteXcm {
-	fn execute_xcm(origin: MultiLocation, msg: Xcm) -> XcmResult;
+	fn execute_xcm(origin: MultiLocation, msg: Xcm) -> Result;
 }
 
 pub trait SendXcm {
-	fn send_xcm(dest: MultiLocation, msg: Xcm) -> XcmResult;
+	fn send_xcm(dest: MultiLocation, msg: Xcm) -> Result;
 }
 
 /// Basically just the XCM (more general) version of `ParachainDispatchOrigin`.
@@ -95,6 +100,33 @@ impl MultiLocation {
 			s => Err(s)?,
 		})
 	}
+	pub fn into_iter(self) -> impl Iterator<Item=Junction> {
+		match self {
+			MultiLocation::Null => None,
+			MultiLocation::X1(a) => Some(a),
+			MultiLocation::X2(a, b) => Some(a).chain(Some(b)),
+			MultiLocation::X3(a, b, c) => Some(a).chain(Some(b)).chain(Some(c)),
+			MultiLocation::X4(a, b, c, d) => Some(a).chain(Some(b)).chain(Some(c)).chain(Some(d)),
+		}
+	}
+
+	pub fn push(&mut self, new: Junction) -> Result<(), ()> {
+		let mut n = MultiLocation::Null;
+		sp_std::mem::swap(&mut *self, &mut n);
+		match n.pushed_with(new) {
+			Ok(result) => { *self = result; Ok(()) }
+			Err(old) => { *self = old; Err(()) }
+		}
+	}
+
+	/// Returns partial result as error in case of failure (e.g. because out of space).
+	pub fn appended_with(self, new: MultiLocation) -> Result<Self, Self> {
+		let mut result= self;
+		for j in new.into_iter() {
+			result = result.pushed_with(j)?;
+		}
+		Ok(result)
+	}
 }
 
 #[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Encode, Decode, RuntimeDebug)]
@@ -119,6 +151,23 @@ impl From<Junction> for MultiLocation {
 	}
 }
 
+impl Junction {
+	fn is_sub_consensus(&self) -> bool {
+		match self {
+			Junction::Parent => false,
+
+			Junction::Parachain { .. } |
+			Junction::OpaqueRemark(..) |
+			Junction::AccountId32 { .. } |
+			Junction::AccountIndex64 { .. } |
+			Junction::AccountKey20 { .. } |
+			Junction::PalletInstance { .. } |
+			Junction::GeneralIndex { .. } |
+			Junction::GeneralKey(..) => true,
+		}
+	}
+}
+
 #[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Encode, Decode, RuntimeDebug)]
 pub enum AssetInstance {
 	Undefined,
@@ -176,8 +225,8 @@ pub enum Xcm {
 	Balances { #[codec(compact)] query_id: u64, assets: MultiAssets },
 	Transact { origin_type: MultiOrigin, call: Vec<u8> },
 	// these won't be staying here for long. only v0 parachains with HRMP.
-	ForwardToParachain { id: u32, inner: Box<VersionedXcm> },
-	ForwardedFromParachain { id: u32, inner: Box<VersionedXcm> },
+	RelayToParachain { id: u32, inner: Box<VersionedXcm> },
+	RelayedFrom { superorigin: MultiLocation, inner: Box<VersionedXcm> },
 }
 
 impl From<Xcm> for VersionedXcm {

xcm/xcm-executor/src/assets.rs

@@ -39,6 +39,12 @@ impl From<Vec<MultiAsset>> for Assets {
 	}
 }
 
+impl From<Assets> for Vec<MultiAsset> {
+	fn from(a: Assets) -> Self {
+		a.into_assets_iter().collect()
+	}
+}
+
 impl Assets {
 	pub fn into_assets_iter(self) -> impl Iterator<Item=MultiAsset> {
 		let fungible = self.fungible.into_iter()

xcm/xcm-executor/src/currency_adapter.rs

@@ -20,6 +20,9 @@ use frame_support::traits::{ExistenceRequirement::AllowDeath, WithdrawReason};
 use crate::traits::{MatchesFungible, PunnFromLocation, TransactAsset};
 use sp_std::{convert::TryInto, marker::PhantomData};
 
+// TODO: Will need some way of punning a `Junction::Parachain` into the sovereign parachain account.
+//   Right now it only works with `Junction::AccountId32`.
+
 pub struct CurrencyAdapter<Currency, Matcher, AccountIdConverter, AccountId>(
 	PhantomData<Currency>,
 	PhantomData<Matcher>,

xcm/xcm-executor/src/lib.rs

@@ -17,7 +17,7 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 
 use sp_std::{marker::PhantomData, convert::TryInto};
-use frame_support::dispatch::Dispatchable;
+use frame_support::{ensure, dispatch::Dispatchable};
 use codec::Decode;
 use xcm::v0::{Xcm, Ai, ExecuteXcm, SendXcm, XcmResult, MultiLocation, Junction};
 
@@ -37,8 +37,13 @@ pub struct XcmExecutor<Config>(PhantomData<Config>);
 impl<Config: config::Config> ExecuteXcm for XcmExecutor<Config> {
 	fn execute_xcm(origin: MultiLocation, msg: Xcm) -> XcmResult {
 		let (mut holding, effects) = match (origin.clone(), msg) {
-			(origin, Xcm::ForwardedFromParachain { id, inner }) => {
-				let new_origin = origin.pushed_with(Junction::Parachain { id }).map_err(|_| ())?;
+			(origin, Xcm::RelayedFrom { superorigin, inner }) => {
+				// We ensure that it doesn't contain any `Parent` Junctions which would imply a privilege escalation.
+				let mut new_origin = origin;
+				for j in superorigin.into_iter() {
+					ensure!(j.is_sub_consensus(), ());
+					new_origin.push(j).map_err(|_| ())?;
+				}
 				return Self::execute_xcm(new_origin, (*inner).try_into()?)
 			}
 			(origin, Xcm::WithdrawAsset { assets, effects }) => {
@@ -84,6 +89,17 @@ impl<Config: config::Config> ExecuteXcm for XcmExecutor<Config> {
 				// message makes sense.
 				return Ok(());
 			}
+			(origin, Xcm::RelayToParachain { id, inner }) => {
+				let msg = Xcm::RelayedFrom { superorigin: origin, inner }.into();
+				Config::XcmSender::send_xcm(Junction::Parachain { id }.into(), msg)
+			},
+			(origin, Xcm::ReserveAssetTransfer { mut assets, dest, effects }) => {
+				for asset in assets.iter_mut() {
+					*asset = Config::AssetTransactor::transfer_asset(asset, &origin, &dest)?;
+				}
+				let msg = Xcm::ReserveAssetCredit { assets, effects }.into();
+				Config::XcmSender::send_xcm(dest, msg)
+			},
 			_ => Err(())?,	// Unhandled XCM message.
 		};