Contracts expose pallet-xcm

cumulus/parachains/runtimes/contracts/contracts-rococo/src/contracts.rs

@@ -24,6 +24,7 @@ use frame_support::{
 use pallet_contracts::{
 	migration::{v12, v13, v14, v15},
 	weights::SubstrateWeight,
+	xcm::PalletXCMAdapter,
 	Config, DebugInfo, DefaultAddressGenerator, Frame, Schedule,
 };
 use sp_runtime::Perbill;
@@ -79,4 +80,5 @@ impl Config for Runtime {
 	type RuntimeHoldReason = RuntimeHoldReason;
 	type Debug = ();
 	type Environment = ();
+	type Xcm = PalletXCMAdapter<Self>;
 }

polkadot/xcm/pallet-xcm/src/benchmarking.rs

@@ -190,6 +190,33 @@ benchmarks! {
 		Pallet::<T>::check_xcm_version_change(VersionMigrationStage::MigrateAndNotifyOldTargets, Weight::zero());
 	}
 
+	new_query {
+		let responder = MultiLocation::from(Parent);
+		let timeout = 1u32.into();
+		let match_querier = MultiLocation::from(Here);
+	}: {
+		Pallet::<T>::new_query(responder, timeout, match_querier);
+	}
+
+	take_response {
+		let responder = MultiLocation::from(Parent);
+		let timeout = 1u32.into();
+		let match_querier = MultiLocation::from(Here);
+		let query_id = Pallet::<T>::new_query(responder, timeout, match_querier);
+		let infos = (0 .. xcm::v3::MaxPalletsInfo::get()).map(|_| PalletInfo::new(
+			u32::MAX,
+			(0..xcm::v3::MaxPalletNameLen::get()).map(|_| 97u8).collect::<Vec<_>>().try_into().unwrap(),
+			(0..xcm::v3::MaxPalletNameLen::get()).map(|_| 97u8).collect::<Vec<_>>().try_into().unwrap(),
+			u32::MAX,
+			u32::MAX,
+			u32::MAX,
+		).unwrap()).collect::<Vec<_>>();
+		Pallet::<T>::expect_response(query_id, Response::PalletsInfo(infos.try_into().unwrap()));
+
+	}: {
+		Pallet::<T>::take_response(query_id);
+	}
+
 	impl_benchmark_test_suite!(
 		Pallet,
 		crate::mock::new_test_ext_with_balances(Vec::new()),

polkadot/xcm/pallet-xcm/src/lib.rs

@@ -73,6 +73,13 @@ pub trait WeightInfo {
 	fn notify_target_migration_fail() -> Weight;
 	fn migrate_version_notify_targets() -> Weight;
 	fn migrate_and_notify_old_targets() -> Weight;
+	// TODO remove after benchmark are regenerated
+	fn new_query() -> Weight {
+		Weight::zero()
+	}
+	fn take_response() -> Weight {
+		Weight::zero()
+	}
 }
 
 /// fallback implementation
@@ -141,6 +148,14 @@ impl WeightInfo for TestWeightInfo {
 	fn migrate_and_notify_old_targets() -> Weight {
 		Weight::from_parts(100_000_000, 0)
 	}
+
+	fn new_query() -> Weight {
+		Weight::from_parts(100_000_000, 0)
+	}
+
+	fn take_response() -> Weight {
+		Weight::from_parts(100_000_000, 0)
+	}
 }
 
 #[frame_support::pallet]

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

@@ -17,7 +17,7 @@
 use crate::Xcm;
 use core::result;
 use frame_support::pallet_prelude::{Get, TypeInfo};
-use parity_scale_codec::{FullCodec, MaxEncodedLen};
+use parity_scale_codec::{Decode, Encode, FullCodec, MaxEncodedLen};
 use sp_arithmetic::traits::Zero;
 use sp_std::fmt::Debug;
 use xcm::latest::{
@@ -103,7 +103,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/bin/node/runtime/src/lib.rs

@@ -1327,6 +1327,7 @@ impl pallet_contracts::Config for Runtime {
 	type CodeHashLockupDepositPercent = CodeHashLockupDepositPercent;
 	type Debug = ();
 	type Environment = ();
+	type Xcm = ();
 }
 
 impl pallet_sudo::Config for Runtime {

substrate/frame/contracts/Cargo.toml

@@ -48,20 +48,34 @@ 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 = { package = "staging-xcm", path = "../../../polkadot/xcm", default-features = false}
+xcm-executor = { package = "staging-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"
 env_logger = "0.9"
 pretty_assertions = "1"
 wat = "1"
 
+# Polkadot Dependencies
+xcm-simulator = {path = "../../../polkadot/xcm/xcm-simulator"}
+xcm-builder = {package = "staging-xcm-builder", path = "../../../polkadot/xcm/xcm-builder"}
+polkadot-runtime-parachains = {path = "../../../polkadot/runtime/parachains"}
+polkadot-parachain-primitives = { path = "../../../polkadot/parachain"  }
+polkadot-primitives = { path = "../../../polkadot/primitives"  }
+
 # Substrate Dependencies
 pallet-balances = { path = "../balances" }
 pallet-timestamp = { path = "../timestamp" }
+pallet-message-queue = { path = "../message-queue" }
 pallet-insecure-randomness-collective-flip = { path = "../insecure-randomness-collective-flip" }
 pallet-utility = { path = "../utility" }
+pallet-assets = { path = "../assets" }
 pallet-proxy = { path = "../proxy" }
 sp-keystore = { path = "../../primitives/keystore" }
+sp-tracing = { path = "../../primitives/tracing" }
 
 [features]
 default = [ "std" ]
@@ -79,6 +93,7 @@ std = [
 	"pallet-proxy/std",
 	"pallet-timestamp/std",
 	"pallet-utility/std",
+	"pallet-xcm/std",
 	"rand/std",
 	"scale-info/std",
 	"serde",
@@ -90,27 +105,41 @@ std = [
 	"sp-std/std",
 	"wasm-instrument/std",
 	"wasmi/std",
+	"xcm-executor/std",
+	"xcm/std",
 ]
 runtime-benchmarks = [
 	"frame-benchmarking/runtime-benchmarks",
 	"frame-support/runtime-benchmarks",
 	"frame-system/runtime-benchmarks",
+	"pallet-assets/runtime-benchmarks",
 	"pallet-balances/runtime-benchmarks",
+	"pallet-message-queue/runtime-benchmarks",
 	"pallet-proxy/runtime-benchmarks",
 	"pallet-timestamp/runtime-benchmarks",
 	"pallet-utility/runtime-benchmarks",
+	"pallet-xcm/runtime-benchmarks",
+	"polkadot-parachain-primitives/runtime-benchmarks",
+	"polkadot-primitives/runtime-benchmarks",
+	"polkadot-runtime-parachains/runtime-benchmarks",
 	"rand",
 	"rand_pcg",
 	"sp-runtime/runtime-benchmarks",
 	"wasm-instrument",
+	"xcm-builder/runtime-benchmarks",
+	"xcm-executor/runtime-benchmarks",
 ]
 try-runtime = [
 	"frame-support/try-runtime",
 	"frame-system/try-runtime",
+	"pallet-assets/try-runtime",
 	"pallet-balances/try-runtime",
 	"pallet-insecure-randomness-collective-flip/try-runtime",
+	"pallet-message-queue/try-runtime",
 	"pallet-proxy/try-runtime",
 	"pallet-timestamp/try-runtime",
 	"pallet-utility/try-runtime",
+	"pallet-xcm/try-runtime",
+	"polkadot-runtime-parachains/try-runtime",
 	"sp-runtime/try-runtime",
 ]

substrate/frame/contracts/fixtures/xcm_execute.wat

@@ -0,0 +1,38 @@
+;; This passes its input to `seal_xcm_execute` and returns the return value to its caller.
+(module
+	(import "seal0" "xcm_execute" (func $xcm_execute (param i32 i32) (result i32)))
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; 0x1000 = 4k in little endian
+	;; Size of input buffer
+	(data (i32.const 0) "\00\10")
+
+	(func (export "call")
+		;; Receive the encoded call
+		(call $seal_input
+			(i32.const 4)	;; Pointer to the input buffer
+			(i32.const 0)	;; Size of the length buffer
+		)
+		;; Input data layout.
+		;; [0..4) - size of the call
+		;; [4..) - xcm message
+
+		;; Just use the call passed as input and store result to memory
+		(i32.store (i32.const 0)
+			(call $xcm_execute
+				(i32.const 4)		     ;; Pointer where the xcm msg is stored
+				(i32.load (i32.const 0)) ;; Size of the xcm msg
+			)
+		)
+		(call $seal_return
+			(i32.const 0)	;; flags
+			(i32.const 0)	;; returned value
+			(i32.const 4)	;; length of returned value
+		)
+	)
+
+	(func (export "deploy"))
+)
+

substrate/frame/contracts/fixtures/xcm_query.wat

@@ -0,0 +1,43 @@
+;; This passes its input to `seal_xcm_query` and returns the return value to its caller.
+(module
+	(import "seal0" "xcm_query" (func $xcm_query (param i32 i32 i32) (result i32)))
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; 0x1000 = 4k in little endian
+	;; size of input buffer
+	(data (i32.const 0) "\00\10")
+
+	(func (export "call")
+		;; Receive the encoded call
+		(call $seal_input
+			(i32.const 4)	;; Pointer to the input buffer
+			(i32.const 0)	;; Size of the length buffer
+		)
+		;; Input data layout.
+		;; [0..4) - size of the call
+		;; [4..12) - timeout
+		;; [12..49) - match_querier
+		;; [8..10)  response
+
+		;; Just use the call passed as input and store result to memory
+		(i32.store (i32.const 0)
+			(call $xcm_query
+				(i32.const 4)   ;; Pointer where the timeout is stored
+				(i32.const 12)	;; Pointer where the match_querier is stored
+				(i32.const 49)	;; ...
+			)
+		)
+		(call $seal_return
+			(i32.const 0)	;; flags
+			(i32.const 49)	;; returned value
+			(i32.const 8)	;; length of returned value
+		)
+	)
+
+	(func (export "deploy"))
+)
+
+
+

substrate/frame/contracts/fixtures/xcm_send.wat

@@ -0,0 +1,44 @@
+;; This passes its input to `seal_xcm_send` and returns the return value to its caller.
+(module
+	(import "seal0" "xcm_send" (func $xcm_send (param i32 i32 i32) (result i32)))
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; 0x1000 = 4k in little endian
+	;; size of input buffer
+	(data (i32.const 0) "\00\10")
+
+	(func (export "call")
+		;; Receive the encoded call
+		(call $seal_input
+			(i32.const 4)	;; Pointer to the input buffer
+			(i32.const 0)	;; Size of the length buffer
+		)
+		;; Input data layout.
+		;; [0..4) - size of the call
+		;; [4..7) - dest
+		;; [7..) - xcm message
+
+		;; Just use the call passed as input and store result to memory
+		(i32.store (i32.const 0)
+			(call $xcm_send
+				(i32.const 4)               ;; Pointer where the dest is stored
+				(i32.const 7)				;; Pointer where the xcm msg is stored
+				(i32.sub		            ;; Size of the xcm msg
+					(i32.load (i32.const 0))
+					(i32.const 3)
+				)
+			)
+		)
+		(call $seal_return
+			(i32.const 0)	;; flags
+			(i32.const 0)	;; returned value
+			(i32.const 4)	;; length of returned value
+		)
+	)
+
+	(func (export "deploy"))
+)
+
+

substrate/frame/contracts/fixtures/xcm_take_response.wat

@@ -0,0 +1,43 @@
+;; This passes its input to `seal_xcm_take_response` and returns the return value to its caller.
+(module
+	(import "seal0" "xcm_take_response" (func $xcm_take_response (param i32 i32) (result i32)))
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; 0x1000 = 4k in little endian
+	;; size of input buffer
+	(data (i32.const 0) "\00\10")
+
+	(func (export "call")
+		;; Receive the encoded call
+		(call $seal_input
+			(i32.const 4)	;; Pointer to the input buffer
+			(i32.const 0)	;; Size of the length buffer
+		)
+		;; Input data layout.
+		;; [0..4) - size of the call
+		;; [4..12) - query_id
+		;; [12..) - response
+
+		;; Just use the call passed as input and store result to memory
+		(i32.store (i32.const 0)
+			(call $xcm_take_response
+				(i32.const 4)   ;; Pointer where the query_id is stored
+				(i32.const 12)	;; Pointer where the response is stored
+			)
+		)
+
+		(call $seal_return
+			(i32.const 0)	;; flags
+			(i32.const 12)	;; returned value
+			(i32.const 112)	;; length of returned value
+		)
+	)
+
+	(func (export "deploy"))
+)
+
+
+
+