Add XCM Precompile to pallet-xcm

polkadot/xcm/pallet-xcm/Cargo.toml

@@ -20,10 +20,12 @@ tracing = { workspace = true }
 
 frame-support = { workspace = true }
 frame-system = { workspace = true }
+pallet-revive = { workspace = true }
 sp-core = { workspace = true }
 sp-io = { workspace = true }
 sp-runtime = { workspace = true }
 
+pallet-timestamp = { workspace = true }
 xcm = { workspace = true }
 xcm-builder = { workspace = true }
 xcm-executor = { workspace = true }
@@ -49,6 +51,7 @@ std = [
 	"frame-support/std",
 	"frame-system/std",
 	"pallet-balances/std",
+	"pallet-revive/std",
 	"scale-info/std",
 	"serde",
 	"sp-core/std",
@@ -66,6 +69,7 @@ runtime-benchmarks = [
 	"frame-system/runtime-benchmarks",
 	"pallet-assets/runtime-benchmarks",
 	"pallet-balances/runtime-benchmarks",
+	"pallet-revive/runtime-benchmarks",
 	"polkadot-parachain-primitives/runtime-benchmarks",
 	"polkadot-runtime-parachains/runtime-benchmarks",
 	"sp-runtime/runtime-benchmarks",
@@ -80,6 +84,7 @@ try-runtime = [
 	"frame-system/try-runtime",
 	"pallet-assets/try-runtime",
 	"pallet-balances/try-runtime",
+	"pallet-revive/try-runtime",
 	"polkadot-runtime-parachains/try-runtime",
 	"sp-runtime/try-runtime",
 ]

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

@@ -22,6 +22,7 @@
 pub mod benchmarking;
 #[cfg(test)]
 mod mock;
+pub mod precompiles;
 #[cfg(test)]
 mod tests;
 

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

@@ -47,7 +47,8 @@ use xcm_executor::{
 };
 use xcm_simulator::helpers::derive_topic_id;
 
-use crate::{self as pallet_xcm, TestWeightInfo};
+use crate::{self as pallet_xcm, precompiles::XcmPrecompile, TestWeightInfo};
+use pallet_timestamp;
 
 pub type AccountId = AccountId32;
 pub type Balance = u128;
@@ -139,6 +140,17 @@ pub mod pallet_test_notifier {
 	}
 }
 
+parameter_types! {
+	pub const MinimumPeriod: u64 = 1;
+}
+
+impl pallet_timestamp::Config for Test {
+	type Moment = u64;
+	type OnTimestampSet = ();
+	type MinimumPeriod = MinimumPeriod;
+	type WeightInfo = ();
+}
+
 construct_runtime!(
 	pub enum Test
 	{
@@ -148,6 +160,8 @@ construct_runtime!(
 		ParasOrigin: origin,
 		XcmPallet: pallet_xcm,
 		TestNotifier: pallet_test_notifier,
+		Revive: pallet_revive,
+		Timestamp: pallet_timestamp,
 	}
 );
 
@@ -320,6 +334,14 @@ impl pallet_assets::Config for Test {
 	type BenchmarkHelper = XcmBenchmarkHelper;
 }
 
+#[derive_impl(pallet_revive::config_preludes::TestDefaultConfig)]
+impl pallet_revive::Config for Test {
+	type AddressMapper = pallet_revive::AccountId32Mapper<Self>;
+	type Currency = Balances;
+	type Precompiles = (XcmPrecompile<Self>,);
+	type Time = Timestamp;
+}
+
 // This child parachain is a system parachain trusted to teleport native token.
 pub const SOME_SYSTEM_PARA: u32 = 1001;
 

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

@@ -0,0 +1,135 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use crate::{Call, Config, VersionedLocation, VersionedXcm, Weight, WeightInfo};
+use alloc::vec::Vec;
+use alloy::sol_types::SolValue;
+use codec::{DecodeAll, Encode};
+use core::{marker::PhantomData, num::NonZero};
+use pallet_revive::{precompiles::*, Origin};
+use tracing::log::error;
+use xcm_executor::traits::WeightBounds;
+
+alloy::sol!("src/precompiles/IXcm.sol");
+use IXcm::*;
+
+pub struct XcmPrecompile<T>(PhantomData<T>);
+
+impl<Runtime> Precompile for XcmPrecompile<Runtime>
+where
+	Runtime: crate::Config + pallet_revive::Config,
+	Call<Runtime>: Into<<Runtime as pallet_revive::Config>::RuntimeCall>,
+{
+	type T = Runtime;
+	const MATCHER: AddressMatcher = AddressMatcher::Fixed(NonZero::new(10).unwrap());
+	const HAS_CONTRACT_INFO: bool = false;
+	type Interface = IXcm::IXcmCalls;
+
+	fn call(
+		_address: &[u8; 20],
+		input: &Self::Interface,
+		env: &mut impl Ext<T = Self::T>,
+	) -> Result<Vec<u8>, Error> {
+		let origin = env.caller();
+		let frame_origin = match origin {
+			Origin::Root => frame_system::RawOrigin::Root.into(),
+			Origin::Signed(account_id) =>
+				frame_system::RawOrigin::Signed(account_id.clone()).into(),
+		};
+
+		match input {
+			IXcmCalls::xcmSend(IXcm::xcmSendCall { destination, message }) => {
+				let _weight = <Runtime as Config>::WeightInfo::send();
+				// TODO: Charge gas for the weight
+
+				let final_destination = VersionedLocation::decode_all(&mut &destination[..])
+					.map_err(|e| {
+						error!("XCM send failed: Invalid destination format. Error: {e:?}");
+						Error::Revert("Invalid destination format".into())
+					})?;
+
+				let final_message =
+					VersionedXcm::<()>::decode_all(&mut &message[..]).map_err(|e| {
+						error!("XCM send failed: Invalid message format. Error: {e:?}");
+						Error::Revert("Invalid message format".into())
+					})?;
+
+				crate::Pallet::<Runtime>::send(
+					frame_origin,
+					final_destination.into(),
+					final_message.into(),
+				)
+				.map(|message_id| message_id.encode())
+				.map_err(|e| {
+					error!(
+						"XCM send failed: destination or message format may be incompatible. \
+						Error: {e:?}"
+					);
+					Error::Revert(
+						"XCM send failed: destination or message format may be incompatible".into(),
+					)
+				})
+			},
+			IXcmCalls::xcmExecute(IXcm::xcmExecuteCall { message, weight }) => {
+				let final_message = VersionedXcm::decode_all(&mut &message[..]).map_err(|e| {
+					error!("XCM execute failed: Invalid message format. Error: {e:?}");
+					Error::Revert("Invalid message format".into())
+				})?;
+
+				let weight = Weight::from_parts(weight.refTime, weight.proofSize);
+				// env.gas_meter_mut().charge(RuntimeCosts::CallXcmExecute(weight.clone()))?; //
+				// TODO: Charge gas
+
+				crate::Pallet::<Runtime>::execute(frame_origin, final_message.into(), weight)
+					.map(|results| results.encode())
+					.map_err(|e| {
+						error!(
+							"XCM execute failed: message may be invalid or execution \
+						constraints not satisfied. Error: {e:?}"
+						);
+						Error::Revert(
+							"XCM execute failed: message may be invalid or execution \
+						constraints not satisfied"
+								.into(),
+						)
+					})
+			},
+			IXcmCalls::weighMessage(IXcm::weighMessageCall { message }) => {
+				let converted_message =
+					VersionedXcm::decode_all(&mut &message[..]).map_err(|error| {
+						error!("XCM weightMessage: Invalid message format. Error: {error:?}");
+						Error::Revert("XCM weightMessage: Invalid message format".into())
+					})?;
+
+				let mut final_message = converted_message.try_into().map_err(|e| {
+					error!("XCM weightMessage: Conversion to Xcm failed with Error: {e:?}");
+					Error::Revert("XCM weightMessage: Conversion to Xcm failed".into())
+				})?;
+
+				let weight = <<Runtime>::Weigher>::weight(&mut final_message).map_err(|e| {
+					error!("XCM weightMessage: Failed to calculate weight. Error: {e:?}");
+					Error::Revert("XCM weightMessage: Failed to calculate weight".into())
+				})?;
+
+				let final_weight =
+					IXcm::Weight { proofSize: weight.proof_size(), refTime: weight.ref_time() };
+
+				Ok(final_weight.abi_encode())
+			},
+		}
+	}
+}

polkadot/xcm/pallet-xcm/src/precompiles/IXcm.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+/// @title Defines all functions that can be used to interact with XCM
+/// @author Tiago Bandeira
+/// @dev Parameters MUST use SCALE codec serialisation
+interface IXcm {
+    /// Weight v2
+    struct Weight {
+        /// The computational time used to execute some logic based on reference hardware
+        uint64 refTime;
+        /// The size of the proof needed to execute some logic
+        uint64 proofSize;
+    }
+
+    /// @notice Execute a Versioned XCM message locally with the caller's origin
+    /// @param message The Versioned XCM message to send
+    /// @param weight The maximum amount of weight to be used to execute the message
+    function xcmExecute(bytes calldata message, Weight calldata weight) external;
+
+    /// @notice Send an Versioned XCM message to a destination chain
+    /// @param destination The destination location, encoded according to the XCM format
+    /// @param message The Versioned XCM message to send
+    function xcmSend(bytes calldata destination, bytes calldata message) external;
+
+    /// @notice Given a message estimate the weight cost
+    /// @param message The XCM message to send
+    /// @returns weight estimated for sending the message
+    function weighMessage(bytes calldata message) external view returns (Weight weight);
+}