Add pallet_xcm::execute

substrate/frame/contracts/Cargo.toml

@@ -48,6 +48,10 @@ sp-io = { path = "../../primitives/io", default-features = false}
 sp-runtime = { path = "../../primitives/runtime", default-features = false}
 sp-std = { path = "../../primitives/std", default-features = false}
 
+xcm = { path = "../../../polkadot/xcm", default-features = false}
+xcm-executor = { path = "../../../polkadot/xcm/xcm-executor", default-features = false}
+pallet-xcm = { path = "../../../polkadot/xcm/pallet-xcm", default-features = false}
+
 [dev-dependencies]
 array-bytes = "6.1"
 assert_matches = "1"
@@ -90,6 +94,9 @@ std = [
  "sp-std/std",
  "wasm-instrument/std",
  "wasmi/std",
+ "pallet-xcm/std",
+ "xcm/std",
+ "xcm-executor/std",
 ]
 runtime-benchmarks = [
  "frame-benchmarking/runtime-benchmarks",

substrate/frame/contracts/src/exec.rs

@@ -49,6 +49,7 @@ 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::VersionedXcm;
 
 pub type AccountIdOf<T> = <T as frame_system::Config>::AccountId;
 pub type MomentOf<T> = <<T as Config>::Time as Time>::Moment;
@@ -61,6 +62,8 @@ pub type TopicOf<T> = <T as frame_system::Config>::Hash;
 /// Type for variable sized storage key. Used for transparent hashing.
 type VarSizedKey<T> = BoundedVec<u8, <T as Config>::MaxStorageKeyLen>;
 
+pub type CallOf<T> = <T as frame_system::Config>::RuntimeCall;
+
 /// Combined key type for both fixed and variable sized storage keys.
 pub enum Key<T: Config> {
  /// Variant for fixed sized keys.
@@ -345,6 +348,13 @@ pub trait Ext: sealing::Sealed {
  &mut self,
  code_hash: &CodeHash<Self::T>,
  ) -> Result<(), DispatchError>;
+
+ /// Execute an XCM message locally, using the contract's address as the origin.
+ fn xcm_execute(
+ &mut self,
+ message: VersionedXcm<CallOf<Self::T>>,
+ max_weight: Weight,
+ ) -> DispatchResultWithPostInfo;
 }
 
 /// Describes the different functions that can be exported by an [`Executable`].
@@ -1446,6 +1456,15 @@ where
  call.dispatch(origin)
  }
 
+ fn xcm_execute(
+ &mut self,
+ message: VersionedXcm<CallOf<T>>,
+ max_weight: Weight,
+ ) -> DispatchResultWithPostInfo {
+ let origin = RawOrigin::Signed(self.address().clone()).into();
+ pallet_xcm::Pallet::<T>::execute(origin, Box::new(message), max_weight)
+ }
+
  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/lib.rs

@@ -233,7 +233,7 @@ pub mod pallet {
  pub struct Pallet<T>(_);
 
  #[pallet::config]
- pub trait Config: frame_system::Config {
+ pub trait Config: frame_system::Config + pallet_xcm::Config {
  /// The time implementation used to supply timestamps to contracts through `seal_now`.
  type Time: Time;
 

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

@@ -113,6 +113,8 @@ pub enum ReturnCode {
  EcdsaRecoverFailed = 11,
  /// sr25519 signature verification failed.
  Sr25519VerifyFailed = 12,
+ /// The `seal_xcm_execute` was executed but returned an error.
+ XcmExcuteFailed = 13,
 }
 
 impl From<ExecReturnValue> for ReturnCode {
@@ -260,6 +262,8 @@ pub enum RuntimeCosts {
  ChainExtension(Weight),
  /// Weight charged for calling into the runtime.
  CallRuntime(Weight),
+ /// Weight charged for Executing an XCM message.
+ XcmExecute(Weight),
  /// Weight of calling `seal_set_code_hash`
  SetCodeHash,
  /// Weight of calling `ecdsa_to_eth_address`
@@ -350,6 +354,7 @@ impl RuntimeCosts {
  .saturating_add(s.sr25519_verify_per_byte.saturating_mul(len.into())),
  ChainExtension(weight) => weight,
  CallRuntime(weight) => weight,
+ XcmExecute(weight) => weight,
  SetCodeHash => s.set_code_hash,
  EcdsaToEthAddress => s.ecdsa_to_eth_address,
  ReentrantCount => s.reentrance_count,
@@ -2626,6 +2631,43 @@ pub mod env {
  }
  }
 
+ fn xcm_execute(
+ ctx: _,
+ memory: _,
+ call_ptr: u32,
+ call_len: u32,
+ max_weight_ptr: u32,
+ ) -> Result<ReturnCode, TrapReason> {
+ use crate::exec::CallOf;
+ use frame_support::dispatch::{extract_actual_weight, DispatchInfo};
+ use pallet_xcm::WeightInfo;
+ use xcm::VersionedXcm;
+
+ ctx.charge_gas(RuntimeCosts::CopyFromContract(call_len))?;
+ let message: VersionedXcm<CallOf<E::T>> =
+ ctx.read_sandbox_memory_as_unbounded(memory, call_ptr, call_len)?;
+ let max_weight: Weight = ctx.read_sandbox_memory_as(memory, max_weight_ptr)?;
+
+ let weight = max_weight.saturating_add(<E::T as pallet_xcm::Config>::WeightInfo::execute());
+ let dispatch_info = DispatchInfo { weight, ..Default::default() };
+
+ let charged = ctx.charge_gas(RuntimeCosts::XcmExecute(weight))?;
+ let result = ctx.ext.xcm_execute(message, max_weight);
+
+ let actual_weight = extract_actual_weight(&result, &dispatch_info);
+ ctx.adjust_gas(charged, RuntimeCosts::XcmExecute(actual_weight));
+ match result {
+ Ok(_) => Ok(ReturnCode::Success),
+ Err(e) => {
+ if ctx.ext.append_debug_buffer("") {
+ ctx.ext.append_debug_buffer("seal0::xcm_execute failed with: ");
+ ctx.ext.append_debug_buffer(e.into());
+ };
+ Ok(ReturnCode::XcmExcuteFailed)
+ },
+ }
+ }
+
  /// Recovers the ECDSA public key from the given message hash and signature.
  ///
  /// Writes the public key into the given output buffer.