More work

xcm/xcm-builder/Cargo.toml

@@ -6,6 +6,7 @@ description = "Tools & types for building with XCM and its executor."
 version = "0.9.13"
 
 [dependencies]
+impl-trait-for-tuples = "0.2.1"
 parity-scale-codec = { version = "2.3.1", default-features = false, features = ["derive"] }
 scale-info = { version = "1.0", default-features = false, features = ["derive"] }
 xcm = { path = "..", default-features = false }

xcm/xcm-builder/src/lib.rs

@@ -121,17 +121,33 @@ mod universal_exports {
 		assert_eq!(x, Err((Parent, Polkadot, Parachain(1000)).into()));
 	}
 
+	/// Implementation of `SendXcm` which uses the given `ExportXcm` impl in order to forward the
+	/// message over a bridge.
+	///
+	/// The actual message forwarded over the bridge is prepended with `UniversalOrigin` and
+	/// `DescendOrigin` in order to ensure that the message is executed with this Origin.
+	///
+	/// No effort is made to charge for any bridge fees, so this can only be used when it is known
+	/// that the message sending cannot be abused in any way.
 	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) {
+		fn send_xcm(dest: impl Into<MultiLocation>, xcm: Xcm<()>) -> SendResult {
+			let devolved = match ensure_is_remote(Ancestry::get(), dest) {
 				Ok(x) => x,
-				Err(dest) => return Err(SendError::CannotReachDestination(dest, message)),
+				Err(dest) => return Err(SendError::CannotReachDestination(dest, xcm)),
 			};
+			let (network, destination, local_network, local_location) = devolved;
+			let mut message: Xcm<()> = vec![
+				UniversalOrigin(GlobalConsensus(local_network)),
+				DescendOrigin(local_location),
+			].into();
+			message.inner_mut().extend(xcm.into_iter());
 			Exporter::export_xcm(network, 0, destination, message)
 		}
 	}
 
+	/// Alternative implentation of `LocalUnpaidExporter` which uses the `ExportMessage`
+	/// instruction executing locally.
 	pub struct LocalUnpaidExecutingExporter<
 		Executer,
 		Ancestry,
@@ -144,6 +160,135 @@ mod universal_exports {
 		WeightLimit: Get<u64>,
 		Call,
 	> SendXcm for LocalUnpaidExecutingExporter<Executer, Ancestry, WeightLimit, Call> {
+		fn send_xcm(dest: impl Into<MultiLocation>, 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) {
+				Ok(x) => x,
+				Err(_) => 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![ ExportMessage {
+				network: remote_network,
+				destination: remote_location,
+				xcm: inner_xcm,
+			} ]);
+			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`, but local, origins.
+
+	pub trait ExporterFor {
+		fn exporter_for(network: &NetworkId, remote_location: &InteriorMultiLocation) -> Option<MultiLocation>;
+	}
+
+	#[impl_trait_for_tuples::impl_for_tuples(30)]
+	impl ExporterFor for Tuple {
+		fn exporter_for(network: &NetworkId, remote_location: &InteriorMultiLocation) -> Option<MultiLocation> {
+			for_tuples!( #(
+				if let Some(r) = Tuple::exporter_for(network, remote_location) {
+					return Some(r);
+				}
+			)* );
+			None
+		}
+	}
+
+	pub struct NetworkExportTable<T>(sp_std::marker::PhantomData<T>);
+	impl<T: Get<&'static [(NetworkId, MultiLocation)]>> ExporterFor for NetworkExportTable<T> {
+		fn exporter_for(network: &NetworkId, _: &InteriorMultiLocation) -> Option<MultiLocation> {
+			T::get().iter().find(|(ref j, _)| j == network).map(|(_, l)| l.clone())
+		}
+	}
+
+	/// Implementation of `SendXcm` which wraps the message inside an `ExportMessage` instruction
+	/// and sends it to a destination known to be able to handle it.
+	///
+	/// No effort is made to make payment to the bridge for its services, so the bridge location
+	/// must have been configured with a barrier rule allowing unpaid execution for this message
+	/// coming from our origin.
+	///
+	/// The actual message send to the bridge for forwarding is prepended with `UniversalOrigin`
+	/// and `DescendOrigin` in order to ensure that the message is executed with our Origin.
+	pub struct UnpaidRemoteExporter<
+		Bridges,
+		Router,
+		Ancestry,
+	>(PhantomData<(Bridges, Router, Ancestry)>);
+	impl<
+		Bridges: ExporterFor,
+		Router: SendXcm,
+		Ancestry: Get<InteriorMultiLocation>,
+	> SendXcm for UnpaidRemoteExporter<Bridges, Router, Ancestry> {
+		fn send_xcm(dest: impl Into<MultiLocation>, 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 = SendError::CannotReachDestination(dest.clone(), xcm.clone());
+
+			let devolved = ensure_is_remote(Ancestry::get(), dest).map_err(|_| err.clone())?;
+			let (remote_network, remote_location, local_network, local_location) = devolved;
+
+			let bridge = Bridges::exporter_for(&remote_network, &remote_location).ok_or(err)?;
+
+			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![
+				ExportMessage {
+					network: remote_network,
+					destination: remote_location,
+					xcm: inner_xcm,
+				},
+			]);
+			Router::send_xcm(bridge, message)
+		}
+	}
+/*
+	/// Implementation of `SendXcm` which wraps the message inside an `ExportMessage` instruction
+	/// and sends it to a destination known to be able to handle it.
+	///
+	/// No effort is made to make payment to the bridge for its services, so the bridge location
+	/// must have been configured with a barrier rule allowing this message unpaid execution.
+	///
+	/// The actual message send to the bridge for forwarding is prepended with `UniversalOrigin`
+	/// and `DescendOrigin` in order to ensure that the message is executed with this Origin.
+	pub struct PaidRemoteExporter<
+		Executer,
+		Ancestry,
+		WeightLimit,
+		Call,
+	>(PhantomData<(Executer, Ancestry, WeightLimit, Call)>);
+	impl<
+		Executer: ExecuteXcm<Call>,
+		Ancestry: Get<InteriorMultiLocation>,
+		WeightLimit: Get<u64>,
+		Call,
+	> SendXcm for LocalPaidExecutingExporter<Executer, Ancestry, WeightLimit, Call> {
 		fn send_xcm(dest: impl Into<MultiLocation>, xcm: Xcm<()>) -> SendResult {
 			let dest = dest.into();
 
@@ -164,10 +309,10 @@ mod universal_exports {
 			inner_xcm.inner_mut().extend(xcm.into_iter());
 
 			let message = Xcm(vec![
-/*				WithdrawAsset((Here, )),
+				WithdrawAsset((Here, ).into()),
 				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 },
+				ExportMessage { network: remote_network, destination: remote_location, xcm: inner_xcm },
 			]);
 			let pre = match Executer::prepare(message) {
 				Ok(x) => x,
@@ -181,7 +326,5 @@ mod universal_exports {
 			}
 		}
 	}
-
-	// TODO: LocalPaidExecutingExporter able to accept from non-Here origins.
-	// TODO: RemotePaidExecutingExporter which uses `SendXcm`.
+*/
 }