add other xcm_methods

polkadot/xcm/xcm-executor/src/traits/on_response.rs

@@ -20,7 +20,7 @@ use frame_support::{
  dispatch::fmt::Debug,
  pallet_prelude::{Get, TypeInfo},
 };
-use parity_scale_codec::{FullCodec, MaxEncodedLen};
+use parity_scale_codec::{Decode, Encode, FullCodec, MaxEncodedLen};
 use sp_arithmetic::traits::Zero;
 use xcm::latest::{
  Error as XcmError, InteriorMultiLocation, MultiLocation, QueryId, Response,
@@ -105,7 +105,7 @@ impl VersionChangeNotifier for () {
 }
 
 /// The possible state of an XCM query response.
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, PartialEq, Eq, Encode, Decode)]
 pub enum QueryResponseStatus<BlockNumber> {
  /// The response has arrived, and includes the inner Response and the block number it arrived
  /// at.

substrate/frame/contracts/src/exec.rs

@@ -49,7 +49,8 @@ use sp_core::{
 use sp_io::{crypto::secp256k1_ecdsa_recover_compressed, hashing::blake2_256};
 use sp_runtime::traits::{Convert, Hash, Zero};
 use sp_std::{marker::PhantomData, mem, prelude::*, vec::Vec};
-use xcm::{VersionedMultiLocation, VersionedXcm};
+use xcm::{v3::MultiLocation, VersionedMultiLocation, VersionedXcm};
+use xcm_executor::traits::{QueryHandler, QueryResponseStatus};
 
 pub type AccountIdOf<T> = <T as frame_system::Config>::AccountId;
 pub type MomentOf<T> = <<T as Config>::Time as Time>::Moment;
@@ -357,6 +358,17 @@ pub trait Ext: sealing::Sealed {
  ) -> DispatchResultWithPostInfo;
 
  fn xcm_send(&self, dest: VersionedMultiLocation, msg: VersionedXcm<()>) -> DispatchResult;
+
+ fn xcm_query(
+ &self,
+ timeout: BlockNumberFor<Self::T>,
+ match_querier: VersionedMultiLocation,
+ ) -> Result<<pallet_xcm::Pallet<Self::T> as QueryHandler>::QueryId, DispatchError>;
+
+ fn xcm_take_response(
+ &self,
+ query_id: <pallet_xcm::Pallet<Self::T> as QueryHandler>::QueryId,
+ ) -> QueryResponseStatus<BlockNumberFor<Self::T>>;
 }
 
 /// Describes the different functions that can be exported by an [`Executable`].
@@ -1472,6 +1484,33 @@ where
  pallet_xcm::Pallet::<T>::send(origin, Box::new(dest), Box::new(msg))
  }
 
+ fn xcm_query(
+ &self,
+ timeout: BlockNumberFor<T>,
+ match_querier: VersionedMultiLocation,
+ ) -> Result<<pallet_xcm::Pallet<Self::T> as QueryHandler>::QueryId, DispatchError> {
+ use frame_support::traits::EnsureOrigin;
+
+ let origin = RawOrigin::Signed(self.address().clone()).into();
+ let responder = <T as pallet_xcm::Config>::ExecuteXcmOrigin::ensure_origin(origin)?;
+
+ let query_id = <pallet_xcm::Pallet<T> as QueryHandler>::new_query(
+ responder,
+ timeout.into(),
+ MultiLocation::try_from(match_querier)
+ .map_err(|_| Into::<DispatchError>::into(pallet_xcm::Error::<T>::BadVersion))?,
+ );
+
+ Ok(query_id)
+ }
+
+ fn xcm_take_response(
+ &self,
+ query_id: <pallet_xcm::Pallet<Self::T> as QueryHandler>::QueryId,
+ ) -> QueryResponseStatus<BlockNumberFor<Self::T>> {
+ <pallet_xcm::Pallet<T> as QueryHandler>::take_response(query_id)
+ }
+
  fn ecdsa_recover(&self, signature: &[u8; 65], message_hash: &[u8; 32]) -> Result<[u8; 33], ()> {
  secp256k1_ecdsa_recover_compressed(signature, message_hash).map_err(|_| ())
  }

substrate/frame/contracts/src/wasm/runtime.rs

@@ -2695,6 +2695,52 @@ pub mod env {
  }
  }
 
+ fn xcm_query(
+ ctx: _,
+ memory: _,
+ timeout_ptr: u32,
+ match_querier_ptr: u32,
+ output_ptr: u32,
+ ) -> Result<ReturnCode, TrapReason> {
+ use frame_system::pallet_prelude::BlockNumberFor;
+ use xcm::VersionedMultiLocation;
+
+ let timeout: BlockNumberFor<E::T> = ctx.read_sandbox_memory_as(memory, timeout_ptr)?;
+ let match_querier: VersionedMultiLocation =
+ ctx.read_sandbox_memory_as(memory, match_querier_ptr)?;
+ // TODO benchmark
+ match ctx.ext.xcm_query(timeout, match_querier) {
+ Ok(query_id) => {
+ ctx.write_sandbox_memory(memory, output_ptr, &query_id.encode())?;
+ Ok(ReturnCode::Success)
+ },
+ Err(e) => {
+ if ctx.ext.append_debug_buffer("") {
+ ctx.ext.append_debug_buffer("call failed with: ");
+ ctx.ext.append_debug_buffer(e.into());
+ };
+ Ok(ReturnCode::CallRuntimeFailed)
+ },
+ }
+ }
+
+ fn xcm_take_response(
+ ctx: _,
+ memory: _,
+ query_id_ptr: u32,
+ output_ptr: u32,
+ ) -> Result<ReturnCode, TrapReason> {
+ use xcm_executor::traits::QueryHandler;
+
+ let query_id: <pallet_xcm::Pallet<E::T> as QueryHandler>::QueryId =
+ ctx.read_sandbox_memory_as(memory, query_id_ptr)?;
+
+ // TODO benchmark
+ let response = ctx.ext.xcm_take_response(query_id);
+ ctx.write_sandbox_memory(memory, output_ptr, &response.encode())?;
+ Ok(ReturnCode::Success)
+ }
+
  /// Recovers the ECDSA public key from the given message hash and signature.
  ///
  /// Writes the public key into the given output buffer.