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::XcmAdapter,
  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 = XcmAdapter<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..) - 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 message is stored
+ (i32.load (i32.const 0)) ;; Size of the message
+ )
+ )
+ (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,42 @@
+;; 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
+
+ ;; 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) ;; Pointer to the where the query_id is stored
+ )
+ )
+ (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..) - 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 message is stored
+ (i32.sub ;; Size of the message
+ (i32.load (i32.const 0))
+ (i32.const 3) ;; Size of the XCM dest
+ )
+ )
+ )
+ (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,42 @@
+;; 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
+
+ ;; 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"))
+)
+
+
+
+