XCM: PayOverXcm config

runtime/test-runtime/src/lib.rs

@@ -549,6 +549,7 @@ pub mod pallet_test_notifier {
 	use pallet_xcm::ensure_response;
 	use sp_runtime::DispatchResult;
 	use xcm::latest::prelude::*;
+	use xcm_executor::traits::XcmQueryHandler;
 
 	#[pallet::pallet]
 	pub struct Pallet<T>(_);
@@ -584,7 +585,7 @@ pub mod pallet_test_notifier {
 			let id = who
 				.using_encoded(|mut d| <[u8; 32]>::decode(&mut d))
 				.map_err(|_| Error::<T>::BadAccountFormat)?;
-			let qid = pallet_xcm::Pallet::<T>::new_query(
+			let qid = <pallet_xcm::Pallet<T> as XcmQueryHandler>::new_query(
 				Junction::AccountId32 { network: None, id },
 				100u32.into(),
 				Here,

xcm/pallet-xcm/src/lib.rs

@@ -52,8 +52,8 @@ use frame_system::pallet_prelude::*;
 pub use pallet::*;
 use xcm_executor::{
 	traits::{
-		CheckSuspension, ClaimAssets, DropAssets, MatchesFungible, OnResponse,
-		VersionChangeNotifier, WeightBounds,
+		CheckSuspension, ClaimAssets, DropAssets, FinishedQuery, MatchesFungible, OnResponse, QueryResponseStatus,
+		VersionChangeNotifier, WeightBounds, XcmQueryHandler,
 	},
 	Assets,
 };
@@ -1120,6 +1120,77 @@ pub mod pallet {
 /// The maximum number of distinct assets allowed to be transferred in a single helper extrinsic.
 const MAX_ASSETS_FOR_TRANSFER: usize = 2;
 
+impl<T: Config> XcmQueryHandler for Pallet<T> {
+	type QueryId = u64;
+	type BlockNumber = T::BlockNumber;
+	type Error = XcmError;
+	type UniversalLocation = T::UniversalLocation;
+
+	/// Attempt to create a new query ID and register it as a query that is yet to respond.
+	fn new_query(
+		responder: impl Into<MultiLocation>,
+		timeout: T::BlockNumber,
+		match_querier: impl Into<MultiLocation>,
+	) -> Self::QueryId {
+		Self::do_new_query(responder, None, timeout, match_querier).into()
+	}
+
+	/// To check the status of the query, use `fn query()` passing the resultant `QueryId`
+	/// value.
+	fn report_outcome(
+		message: &mut Xcm<()>,
+		responder: impl Into<MultiLocation>,
+		timeout: Self::BlockNumber,
+	) -> Result<Self::QueryId, Self::Error> {
+		let responder = responder.into();
+		let destination = Self::UniversalLocation::get()
+			.invert_target(&responder)
+			.map_err(|()| XcmError::LocationNotInvertible)?;
+		let query_id = Self::new_query(responder, timeout, Here);
+		let response_info = QueryResponseInfo { destination, query_id, max_weight: Weight::zero() };
+		let report_error = Xcm(vec![ReportError(response_info)]);
+		message.0.insert(0, SetAppendix(report_error));
+		Ok(query_id)
+	}
+
+	fn take_response(query_id: Self::QueryId) -> QueryResponseStatus<Self::BlockNumber> {
+		match Queries::<T>::get(query_id) {
+			Some(QueryStatus::Ready { response, at }) => {
+				let response = response.try_into();
+				match response {
+					Ok(response) => {
+						Queries::<T>::remove(query_id);
+						Self::deposit_event(Event::ResponseTaken(query_id));
+						QueryResponseStatus::Finished(FinishedQuery::Response { response, at })
+					},
+					Err(_) => QueryResponseStatus::UnexpectedVersion,
+				}
+			},
+			Some(QueryStatus::VersionNotifier { origin, is_active }) => {
+				let origin = origin.try_into();
+				match origin {
+					Ok(origin) =>
+						QueryResponseStatus::Finished(FinishedQuery::VersionNotification {
+							origin,
+							is_active,
+						}),
+					Err(_) => QueryResponseStatus::UnexpectedVersion,
+				}
+			},
+			Some(QueryStatus::Pending { .. }) => QueryResponseStatus::Pending,
+			None => QueryResponseStatus::NotFound,
+		}
+	}
+
+	fn expect_response(id: Self::QueryId) {
+		let query_status = QueryStatus::Ready {
+			response: VersionedResponse::V3(Response::Null),
+			at: Self::BlockNumber::default(),
+		};
+		Queries::<T>::insert(id, query_status);
+	}
+}
+
 impl<T: Config> Pallet<T> {
 	fn do_reserve_transfer_assets(
 		origin: OriginFor<T>,
@@ -1470,36 +1541,6 @@ impl<T: Config> Pallet<T> {
 		})
 	}
 
-	/// Consume `message` and return another which is equivalent to it except that it reports
-	/// back the outcome.
-	///
-	/// - `message`: The message whose outcome should be reported.
-	/// - `responder`: The origin from which a response should be expected.
-	/// - `timeout`: The block number after which it is permissible for `notify` not to be
-	///   called even if a response is received.
-	///
-	/// `report_outcome` may return an error if the `responder` is not invertible.
-	///
-	/// It is assumed that the querier of the response will be `Here`.
-	///
-	/// To check the status of the query, use `fn query()` passing the resultant `QueryId`
-	/// value.
-	pub fn report_outcome(
-		message: &mut Xcm<()>,
-		responder: impl Into<MultiLocation>,
-		timeout: T::BlockNumber,
-	) -> Result<QueryId, XcmError> {
-		let responder = responder.into();
-		let destination = T::UniversalLocation::get()
-			.invert_target(&responder)
-			.map_err(|()| XcmError::LocationNotInvertible)?;
-		let query_id = Self::new_query(responder, timeout, Here);
-		let response_info = QueryResponseInfo { destination, query_id, max_weight: Weight::zero() };
-		let report_error = Xcm(vec![ReportError(response_info)]);
-		message.0.insert(0, SetAppendix(report_error));
-		Ok(query_id)
-	}
-
 	/// Consume `message` and return another which is equivalent to it except that it reports
 	/// back the outcome and dispatches `notify` on this chain.
 	///
@@ -1541,15 +1582,6 @@ impl<T: Config> Pallet<T> {
 		Ok(())
 	}
 
-	/// Attempt to create a new query ID and register it as a query that is yet to respond.
-	pub fn new_query(
-		responder: impl Into<MultiLocation>,
-		timeout: T::BlockNumber,
-		match_querier: impl Into<MultiLocation>,
-	) -> u64 {
-		Self::do_new_query(responder, None, timeout, match_querier)
-	}
-
 	/// Attempt to create a new query ID and register it as a query that is yet to respond, and
 	/// which will call a dispatchable when a response happens.
 	pub fn new_notify_query(
@@ -1564,20 +1596,6 @@ impl<T: Config> Pallet<T> {
 		Self::do_new_query(responder, Some(notify), timeout, match_querier)
 	}
 
-	/// Attempt to remove and return the response of query with ID `query_id`.
-	///
-	/// Returns `None` if the response is not (yet) available.
-	pub fn take_response(query_id: QueryId) -> Option<(Response, T::BlockNumber)> {
-		if let Some(QueryStatus::Ready { response, at }) = Queries::<T>::get(query_id) {
-			let response = response.try_into().ok()?;
-			Queries::<T>::remove(query_id);
-			Self::deposit_event(Event::ResponseTaken(query_id));
-			Some((response, at))
-		} else {
-			None
-		}
-	}
-
 	/// Note that a particular destination to whom we would like to send a message is unknown
 	/// and queue it for version discovery.
 	fn note_unknown_version(dest: &MultiLocation) {

xcm/pallet-xcm/src/mock.rs

@@ -85,7 +85,7 @@ pub mod pallet_test_notifier {
 			let id = who
 				.using_encoded(|mut d| <[u8; 32]>::decode(&mut d))
 				.map_err(|_| Error::<T>::BadAccountFormat)?;
-			let qid = crate::Pallet::<T>::new_query(
+			let qid = <crate::Pallet<T> as XcmQueryHandler>::new_query(
 				Junction::AccountId32 { network: None, id },
 				100u32.into(),
 				querier,

xcm/pallet-xcm/src/tests.rs

@@ -27,7 +27,10 @@ use polkadot_parachain::primitives::Id as ParaId;
 use sp_runtime::traits::{AccountIdConversion, BlakeTwo256, Hash};
 use xcm::{latest::QueryResponseInfo, prelude::*};
 use xcm_builder::AllowKnownQueryResponses;
-use xcm_executor::{traits::ShouldExecute, XcmExecutor};
+use xcm_executor::{
+	traits::{FinishedQuery, QueryResponseStatus, ShouldExecute, XcmQueryHandler},
+	XcmExecutor,
+};
 
 const ALICE: AccountId = AccountId::new([0u8; 32]);
 const BOB: AccountId = AccountId::new([1u8; 32]);
@@ -163,7 +166,10 @@ fn report_outcome_works() {
 			))
 		);
 
-		let response = Some((Response::ExecutionResult(None), 1));
+		let response = QueryResponseStatus::Finished(FinishedQuery::Response {
+			response: Response::ExecutionResult(None),
+			at: 1,
+		});
 		assert_eq!(XcmPallet::take_response(0), response);
 	});
 }
@@ -263,7 +269,10 @@ fn custom_querier_works() {
 			))
 		);
 
-		let response = Some((Response::ExecutionResult(None), 1));
+		let response = QueryResponseStatus::Finished(FinishedQuery::Response {
+			response: Response::ExecutionResult(None),
+			at: 1,
+		});
 		assert_eq!(XcmPallet::take_response(0), response);
 	});
 }

xcm/xcm-builder/Cargo.toml

@@ -22,6 +22,7 @@ log = { version = "0.4.17", default-features = false }
 
 # Polkadot dependencies
 polkadot-parachain = { path = "../../parachain", default-features = false }
+polkadot-core-primitives = { path = "../../core-primitives", default-features = false }
 
 [dev-dependencies]
 primitive-types = "0.12.1"

xcm/xcm-builder/src/lib.rs

@@ -88,3 +88,6 @@ pub use universal_exports::{
 	HaulBlobError, HaulBlobExporter, NetworkExportTable, SovereignPaidRemoteExporter,
 	UnpaidLocalExporter, UnpaidRemoteExporter,
 };
+
+mod pay;
+pub use pay::PayOverXcm;

xcm/xcm-builder/src/pay.rs

@@ -0,0 +1,132 @@
+// Copyright 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/>.
+
+//! `PayOverXcm` struct for paying through XCM and getting the status back
+
+use frame_support::traits::{
+	tokens::{Pay, PaymentStatus},
+	Get,
+};
+use polkadot_core_primitives::AccountId;
+use sp_std::{marker::PhantomData, vec};
+use xcm::{opaque::lts::Weight, prelude::*};
+use xcm_executor::traits::{FinishedQuery, QueryResponseStatus, XcmQueryHandler};
+
+/// Implementation of the `frame_support_traits::tokens::Pay` trait, to allow
+/// for generic payments of a given `AssetKind` and `Balance` from an implied origin, to a
+/// beneficiary via XCM, relying on the XCM `TransferAsset` instruction.
+///
+/// `PayOverXcm::pay` is asynchronous, and returns a `QueryId` which can then be used in
+/// `check_payment` to check the status of the XCM transaction.
+///
+pub struct PayOverXcm<
+	DestinationChain,
+	SenderAccount,
+	Router,
+	Querier,
+	Timeout,
+	Beneficiary,
+	AssetKind,
+>(
+	PhantomData<(
+		DestinationChain,
+		SenderAccount,
+		Router,
+		Querier,
+		Timeout,
+		Beneficiary,
+		AssetKind,
+	)>,
+);
+impl<
+		DestinationChain: Get<MultiLocation>,
+		SenderAccount: Get<AccountId>,
+		Router: SendXcm,
+		Querier: XcmQueryHandler,
+		Timeout: Get<Querier::BlockNumber>,
+		Beneficiary: Into<[u8; 32]> + Clone,
+		AssetKind: Into<AssetId>,
+	> Pay
+	for PayOverXcm<DestinationChain, SenderAccount, Router, Querier, Timeout, Beneficiary, AssetKind>
+{
+	type Beneficiary = Beneficiary;
+	type AssetKind = AssetKind;
+	type Balance = u128;
+	type Id = Querier::QueryId;
+	type Error = xcm::latest::Error;
+
+	fn pay(
+		who: &Self::Beneficiary,
+		asset_kind: Self::AssetKind,
+		amount: Self::Balance,
+	) -> Result<Self::Id, Self::Error> {
+		let destination_chain = DestinationChain::get();
+		let sender_account = SenderAccount::get();
+		let sender_origin = Junction::AccountId32 { network: None, id: sender_account.into() };
+
+		let destination = Querier::UniversalLocation::get()
+			.invert_target(&destination_chain)
+			.map_err(|()| Self::Error::LocationNotInvertible)?;
+
+		let query_id = Querier::new_query(destination_chain, Timeout::get(), sender_origin);
+
+		let message = Xcm(vec![
+			UnpaidExecution { weight_limit: Unlimited, check_origin: None },
+			SetAppendix(Xcm(vec![ReportError(QueryResponseInfo {
+				destination,
+				query_id,
+				max_weight: Weight::zero(),
+			})])),
+			DescendOrigin(sender_origin.into()),
+			TransferAsset {
+				beneficiary: AccountId32 { network: None, id: who.clone().into() }.into(),
+				assets: vec![MultiAsset {
+					id: asset_kind.into(),
+					fun: Fungibility::Fungible(amount),
+				}]
+				.into(),
+			},
+		]);
+
+		let (ticket, _) = Router::validate(&mut Some(destination_chain), &mut Some(message))?;
+		Router::deliver(ticket)?;
+		Ok(query_id.into())
+	}
+
+	fn check_payment(id: Self::Id) -> PaymentStatus {
+		match Querier::take_response(id) {
+			QueryResponseStatus::Finished(FinishedQuery::Response { response, at: _ }) =>
+				match response {
+					Response::ExecutionResult(Some(_)) => PaymentStatus::Failure,
+					Response::ExecutionResult(None) => PaymentStatus::Success,
+					_ => PaymentStatus::Unknown,
+				},
+			QueryResponseStatus::Pending => PaymentStatus::InProgress,
+			QueryResponseStatus::NotFound |
+			QueryResponseStatus::UnexpectedVersion |
+			QueryResponseStatus::Finished(FinishedQuery::VersionNotification { .. }) =>
+				PaymentStatus::Unknown,
+		}
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn ensure_successful(_: &Self::Beneficiary, _: Self::Balance) {}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn ensure_concluded(id: Self::Id) {
+		Querier::expect_response(id);
+	}
+}

xcm/xcm-executor/src/traits/mod.rs

@@ -38,7 +38,9 @@ pub use token_matching::{
 	Error, MatchesFungible, MatchesFungibles, MatchesNonFungible, MatchesNonFungibles,
 };
 mod on_response;
-pub use on_response::{OnResponse, VersionChangeNotifier};
+pub use on_response::{
+	FinishedQuery, OnResponse, QueryResponseStatus, VersionChangeNotifier, XcmQueryHandler,
+};
 mod should_execute;
 pub use should_execute::{CheckSuspension, ShouldExecute};
 mod transact_asset;