XCM v3: Bridge infrastructure

xcm/src/v3/mod.rs

@@ -45,6 +45,7 @@ pub use multilocation::{
 };
 pub use traits::{
 	Error, ExecuteXcm, Outcome, Result, SendError, SendResult, SendXcm, Weight, XcmWeightInfo,
+	PreparedMessage,
 };
 // These parts of XCM v2 are unchanged in XCM v3, and are re-imported here.
 pub use super::v2::{BodyId, BodyPart, OriginKind, WeightLimit};
@@ -78,6 +79,24 @@ impl<Call> Xcm<Call> {
 		self.0.len()
 	}
 
+	/// Return a reference to the inner value.
+	pub fn inner(&self) -> &Vec<Instruction<Call>> { &self.0 }
+
+	/// Return a mutable reference to the inner value.
+	pub fn inner_mut(&mut self) -> &mut Vec<Instruction<Call>> { &mut self.0 }
+
+	/// Consume and return the inner value.
+	pub fn into_inner(self) -> Vec<Instruction<Call>> { self.0 }
+
+	/// Return an iterator over references to the items.
+	pub fn iter(&self) -> impl Iterator<Item=&Instruction<Call>> { self.0.iter() }
+
+	/// Return an iterator over mutable references to the items.
+	pub fn iter_mut(&mut self) -> impl Iterator<Item=&mut Instruction<Call>> { self.0.iter_mut() }
+
+	/// Consume and return an iterator over the items.
+	pub fn into_iter(self) -> impl Iterator<Item=Instruction<Call>> { self.0.into_iter() }
+
 	/// Consume and either return `self` if it contains some instructions, or if it's empty, then
 	/// instead return the result of `f`.
 	pub fn or_else(self, f: impl FnOnce() -> Self) -> Self {
@@ -118,6 +137,18 @@ impl<Call> Xcm<Call> {
 	}
 }
 
+impl<Call> From<Vec<Instruction<Call>>> for Xcm<Call> {
+	fn from(c: Vec<Instruction<Call>>) -> Self {
+		Self(c)
+	}
+}
+
+impl<Call> From<Xcm<Call>> for Vec<Instruction<Call>> {
+	fn from(c: Xcm<Call>) -> Self {
+		c.0
+	}
+}
+
 /// A prelude for importing all types typically used when interacting with XCM messages.
 pub mod prelude {
 	mod contents {
@@ -135,8 +166,8 @@ pub mod prelude {
 			MultiAssetFilter::{self, *},
 			MultiAssets, MultiLocation,
 			NetworkId::{self, *},
-			OriginKind, Outcome, PalletInfo, Parent, ParentThen, QueryId, QueryResponseInfo,
-			Response, Result as XcmResult, SendError, SendResult, SendXcm,
+			OriginKind, Outcome, PalletInfo, Parent, ParentThen, PreparedMessage, QueryId,
+			QueryResponseInfo, Response, Result as XcmResult, SendError, SendResult, SendXcm,
 			WeightLimit::{self, *},
 			WildFungibility::{self, Fungible as WildFungible, NonFungible as WildNonFungible},
 			WildMultiAsset::{self, *},

xcm/src/v3/traits.rs

@@ -214,8 +214,20 @@ impl Outcome {
 	}
 }
 
+pub trait PreparedMessage {
+	fn weight_of(&self) -> Weight;
+}
+
 /// Type of XCM message executor.
 pub trait ExecuteXcm<Call> {
+	type Prepared: PreparedMessage;
+	fn prepare(message: Xcm<Call>) -> result::Result<Self::Prepared, Xcm<Call>>;
+	fn execute(
+		origin: impl Into<MultiLocation>,
+		pre: Self::Prepared,
+		weight_credit: Weight,
+	) -> Outcome;
+
 	/// Execute some XCM `message` from `origin` using no more than `weight_limit` weight. The weight limit is
 	/// a basic hard-limit and the implementation may place further restrictions or requirements on weight and
 	/// other aspects.
@@ -244,18 +256,32 @@ pub trait ExecuteXcm<Call> {
 		message: Xcm<Call>,
 		weight_limit: Weight,
 		weight_credit: Weight,
-	) -> Outcome;
+	) -> Outcome {
+		let pre = match Self::prepare(message) {
+			Ok(x) => x,
+			Err(_) => return Outcome::Error(Error::WeightNotComputable),
+		};
+		let xcm_weight = pre.weight_of();
+		if xcm_weight > weight_limit {
+			return Outcome::Error(Error::WeightLimitReached(xcm_weight))
+		}
+		Self::execute(origin, pre, weight_credit)
+	}
+}
+
+pub enum Weightless {}
+impl PreparedMessage for Weightless {
+	fn weight_of(&self) -> Weight { unreachable!() }
 }
 
 impl<C> ExecuteXcm<C> for () {
-	fn execute_xcm_in_credit(
-		_origin: impl Into<MultiLocation>,
-		_message: Xcm<C>,
-		_weight_limit: Weight,
-		_weight_credit: Weight,
-	) -> Outcome {
-		Outcome::Error(Error::Unimplemented)
-	}
+	type Prepared = Weightless;
+	fn prepare(message: Xcm<C>) -> result::Result<Self::Prepared, Xcm<C>> { Err(message) }
+	fn execute(
+		_: impl Into<MultiLocation>,
+		_: Self::Prepared,
+		_: Weight,
+	) -> Outcome { unreachable!() }
 }
 
 /// Error result value when attempting to send an XCM message.

xcm/xcm-builder/src/lib.rs

@@ -74,47 +74,36 @@ mod universal_exports {
 	use xcm_executor::traits::ExportXcm;
 
 	fn ensure_is_remote(
-		ancestry: impl Into<InteriorMultiLocation>,
+		universal_local: impl Into<InteriorMultiLocation>,
 		dest: impl Into<MultiLocation>,
-	) -> Result<(NetworkId, InteriorMultiLocation), MultiLocation> {
+	) -> Result<(NetworkId, InteriorMultiLocation, NetworkId, InteriorMultiLocation), MultiLocation> {
 		let dest = dest.into();
-		let ancestry = ancestry.into();
-		let local_network = match ancestry.first() {
-			Some(GlobalConsensus(network)) => network.clone(),
+		let universal_local = universal_local.into();
+		let (local_net, local_loc) = match universal_local.clone().split_first() {
+			(location, Some(GlobalConsensus(network))) => (network, location),
 			_ => return Err(dest),
 		};
-		let universal_destination: InteriorMultiLocation = ancestry
+		let universal_destination: InteriorMultiLocation = universal_local
 			.into_location()
 			.appended_with(dest.clone())
 			.map_err(|x| x.1)?
 			.try_into()?;
 		let (remote_dest, remote_net) = match universal_destination.split_first() {
-			(d, Some(GlobalConsensus(n))) if n != local_network => (d, n),
+			(d, Some(GlobalConsensus(n))) if n != local_net => (d, n),
 			_ => return Err(dest),
 		};
-		Ok((remote_net, remote_dest))
-	}
-
-	pub struct LocalExporter<Exporter, Ancestry>(PhantomData<(Exporter, Ancestry)>);
-	impl<Exporter: ExportXcm, Ancestry: Get<InteriorMultiLocation>> SendXcm for LocalExporter<Exporter, Ancestry> {
-		fn send_xcm(dest: impl Into<MultiLocation>, message: Xcm<()>) -> SendResult {
-			let (network, destination) = match ensure_is_remote(Ancestry::get(), dest) {
-				Ok(x) => x,
-				Err(dest) => return Err(SendError::CannotReachDestination(dest, message)),
-			};
-			Exporter::export_xcm(network, 0, destination, message)
-		}
+		Ok((remote_net, remote_dest, local_net, local_loc))
 	}
 
 	#[test]
-	fn local_exporter_works() {
+	fn ensure_is_remote_works() {
 		// A Kusama parachain is remote from the Polkadot Relay.
 		let x = ensure_is_remote(Polkadot, (Parent, Kusama, Parachain(1000)));
-		assert_eq!(x, Ok((Kusama, Parachain(1000).into())));
+		assert_eq!(x, Ok((Kusama, Parachain(1000).into(), Polkadot, Here)));
 
 		// Polkadot Relay is remote from a Kusama parachain.
 		let x = ensure_is_remote((Kusama, Parachain(1000)), (Parent, Parent, Polkadot));
-		assert_eq!(x, Ok((Polkadot, ().into())));
+		assert_eq!(x, Ok((Polkadot, Here, Kusama, Parachain(1000).into())));
 
 		// Our own parachain is local.
 		let x = ensure_is_remote(Polkadot, Parachain(1000));
@@ -128,4 +117,69 @@ mod universal_exports {
 		let x = ensure_is_remote((), (Parent, Polkadot, Parachain(1000)));
 		assert_eq!(x, Err((Parent, Polkadot, Parachain(1000)).into()));
 	}
+
+	pub struct LocalUnpaidExporter<Exporter, Ancestry>(PhantomData<(Exporter, Ancestry)>);
+	impl<Exporter: ExportXcm, Ancestry: Get<InteriorMultiLocation>> SendXcm for LocalUnpaidExporter<Exporter, Ancestry> {
+		fn send_xcm(dest: impl Into<MultiLocation>, message: Xcm<()>) -> SendResult {
+			let (network, destination, _, _) = match ensure_is_remote(Ancestry::get(), dest) {
+				Ok(x) => x,
+				Err(dest) => return Err(SendError::CannotReachDestination(dest, message)),
+			};
+			Exporter::export_xcm(network, 0, destination, message)
+		}
+	}
+
+	pub struct LocalUnpaidExecutingExporter<
+		Executer,
+		Ancestry,
+		WeightLimit,
+		Call,
+	>(PhantomData<(Executer, Ancestry, WeightLimit, Call)>);
+	impl<
+		Executer: ExecuteXcm<Call>,
+		Ancestry: Get<InteriorMultiLocation>,
+		WeightLimit: Get<u64>,
+		Call,
+	> SendXcm for LocalUnpaidExecutingExporter<Executer, Ancestry, WeightLimit, Call> {
+		fn send_xcm(dest: impl Into<MultiLocation>, mut xcm: Xcm<()>) -> SendResult {
+			let dest = dest.into();
+
+			// TODO: proper matching so we can be sure that it's the only viable send_xcm before we
+			// attempt and thus can acceptably consume dest & xcm.
+			let err = Err(SendError::CannotReachDestination(dest.clone(), xcm.clone()));
+
+			let devolved = match ensure_is_remote(Ancestry::get(), dest.clone()) {
+				Ok(x) => x,
+				Err(dest) => return err,
+			};
+			let (remote_network, remote_location, local_network, local_location) = devolved;
+
+			let mut inner_xcm: Xcm<()> = vec![
+				UniversalOrigin(GlobalConsensus(local_network)),
+				DescendOrigin(local_location),
+			].into();
+			inner_xcm.inner_mut().extend(xcm.into_iter());
+
+			let message = Xcm(vec![
+/*				WithdrawAsset((Here, )),
+				BuyExecution { fees: Wild(AllCounted(1)), weight_limit: Unlimited },
+				DepositAsset { assets: Wild(AllCounted(1)), beneficiary: Here.into() },
+*/				ExportMessage { network: remote_network, destination: remote_location, xcm: inner_xcm },
+			]);
+			let dest = dest.into();
+			let pre = match Executer::prepare(message) {
+				Ok(x) => x,
+				Err(_) => return err,
+			};
+			// We just swallow the weight - it should be constant.
+			let weight_credit = pre.weight_of();
+			match Executer::execute(Here, pre, weight_credit) {
+				Outcome::Complete(_) => Ok(()),
+				_ => return err,
+			}
+		}
+	}
+
+	// TODO: LocalPaidExecutingExporter able to accept from non-Here origins.
+	// TODO: RemotePaidExecutingExporter which uses `SendXcm`.
 }

xcm/xcm-executor/src/lib.rs

@@ -63,30 +63,36 @@ pub struct XcmExecutor<Config: config::Config> {
 	_config: PhantomData<Config>,
 }
 
+pub struct WeighedMessage<Call>(Weight, Xcm<Call>);
+impl<C> PreparedMessage for WeighedMessage<C> {
+	fn weight_of(&self) -> Weight {
+		self.0
+	}
+}
+
 impl<Config: config::Config> ExecuteXcm<Config::Call> for XcmExecutor<Config> {
-	fn execute_xcm_in_credit(
-		origin: impl Into<MultiLocation>,
+	type Prepared = WeighedMessage<Config::Call>;
+	fn prepare(
 		mut message: Xcm<Config::Call>,
-		weight_limit: Weight,
+	) -> Result<Self::Prepared, Xcm<Config::Call>> {
+		match Config::Weigher::weight(&mut message) {
+			Ok(weight) => Ok(WeighedMessage(weight, message)),
+			Err(_) => Err(message),
+		}
+	}
+	fn execute(
+		origin: impl Into<MultiLocation>,
+		WeighedMessage(xcm_weight, mut message): WeighedMessage<Config::Call>,
 		mut weight_credit: Weight,
 	) -> Outcome {
 		let origin = origin.into();
 		log::trace!(
 			target: "xcm::execute_xcm_in_credit",
-			"origin: {:?}, message: {:?}, weight_limit: {:?}, weight_credit: {:?}",
+			"origin: {:?}, message: {:?}, weight_credit: {:?}",
 			origin,
 			message,
-			weight_limit,
 			weight_credit,
 		);
-		let xcm_weight = match Config::Weigher::weight(&mut message) {
-			Ok(x) => x,
-			Err(()) => return Outcome::Error(XcmError::WeightNotComputable),
-		};
-		if xcm_weight > weight_limit {
-			return Outcome::Error(XcmError::WeightLimitReached(xcm_weight))
-		}
-
 		if let Err(_) =
 			Config::Barrier::should_execute(&origin, &mut message, xcm_weight, &mut weight_credit)
 		{