Add XCM Precompile to Pallet Revive

substrate/frame/revive/Cargo.toml

@@ -149,4 +149,4 @@ try-runtime = [
 	"pallet-transaction-payment/try-runtime",
 	"pallet-utility/try-runtime",
 	"sp-runtime/try-runtime",
-]
+]

substrate/frame/revive/mock-network/src/lib.rs

@@ -18,7 +18,8 @@ pub mod mocks;
 pub mod parachain;
 pub mod primitives;
 pub mod relay_chain;
-
+pub mod weight_info;
+pub mod utils;
 #[cfg(test)]
 mod tests;
 

substrate/frame/revive/mock-network/src/parachain.rs

@@ -19,7 +19,7 @@
 mod contracts_config;
 use crate::{
 	mocks::msg_queue::pallet as mock_msg_queue,
-	primitives::{AccountId, AssetIdForAssets, Balance},
+	primitives::{AccountId, AssetIdForAssets, Balance}, weight_info::ReviveTestWeightInfo,
 };
 use core::marker::PhantomData;
 use frame_support::{
@@ -176,8 +176,8 @@ pub fn estimate_weight(number_of_instructions: u64) -> Weight {
 pub fn estimate_fee_for_weight(weight: Weight) -> u128 {
 	let (_, units_per_second, units_per_mb) = TokensPerSecondPerMegabyte::get();
 
-	units_per_second * (weight.ref_time() as u128) / (WEIGHT_REF_TIME_PER_SECOND as u128) +
-		units_per_mb * (weight.proof_size() as u128) / (WEIGHT_PROOF_SIZE_PER_MB as u128)
+	units_per_second * (weight.ref_time() as u128) / (WEIGHT_REF_TIME_PER_SECOND as u128)
+		+ units_per_mb * (weight.proof_size() as u128) / (WEIGHT_PROOF_SIZE_PER_MB as u128)
 }
 
 pub type LocalBalancesTransactor =
@@ -324,7 +324,7 @@ impl pallet_xcm::Config for Runtime {
 	type MaxLockers = ConstU32<8>;
 	type MaxRemoteLockConsumers = ConstU32<0>;
 	type RemoteLockConsumerIdentifier = ();
-	type WeightInfo = pallet_xcm::TestWeightInfo;
+	type WeightInfo = ReviveTestWeightInfo;
 	type AdminOrigin = EnsureRoot<AccountId>;
 	// Aliasing is disabled: xcm_executor::Config::Aliasers is set to `Nothing`.
 	type AuthorizedAliasConsideration = Disabled;

substrate/frame/revive/mock-network/src/parachain/contracts_config.rs

@@ -17,11 +17,13 @@
 use super::{Balances, Runtime, RuntimeCall, RuntimeEvent};
 use crate::parachain::RuntimeHoldReason;
 use frame_support::derive_impl;
+use pallet_revive::precompiles::custom::XcmPrecompile;
 
 #[derive_impl(pallet_revive::config_preludes::TestDefaultConfig)]
 impl pallet_revive::Config for Runtime {
 	type AddressMapper = pallet_revive::AccountId32Mapper<Self>;
 	type Currency = Balances;
 	type Time = super::Timestamp;
 	type Xcm = pallet_xcm::Pallet<Self>;
-}
+	type Precompiles = (XcmPrecompile<Self>,);
+}

substrate/frame/revive/mock-network/src/tests.rs

@@ -16,24 +16,27 @@
 // limitations under the License.
 
 use crate::{
-	parachain, parachain_account_sovereign_account_id, primitives::CENTS, relay_chain, MockNet,
-	ParaA, ParachainBalances, Relay, ALICE, BOB, INITIAL_BALANCE,
+	parachain, parachain_account_sovereign_account_id, primitives::CENTS, relay_chain,
+	utils::to_fixed_non_zero, MockNet, ParaA, ParachainBalances, Relay, ALICE, BOB,
+	INITIAL_BALANCE,
 };
 use codec::{Decode, Encode};
 use frame_support::traits::{fungibles::Mutate, Currency};
 use frame_system::RawOrigin;
+use pallet_revive::precompiles::custom::IXcm;
 use pallet_revive::{
+	precompiles::alloy::sol_types::SolInterface,
 	test_utils::{self, builder::*},
-	Code, DepositLimit,
+	Code, DepositLimit, ExecReturnValue,
 };
 use pallet_revive_fixtures::compile_module;
-use pallet_revive_uapi::ReturnErrorCode;
+use pallet_revive_uapi::{ReturnErrorCode, ReturnFlags};
 use sp_core::H160;
 use xcm::{v4::prelude::*, VersionedLocation, VersionedXcm};
 use xcm_simulator::TestExt;
 
 macro_rules! assert_return_code {
-	( $x:expr , $y:expr $(,)? ) => {{
+	($x:expr, $y:expr $(,)?) => {{
 		assert_eq!(u32::from_le_bytes($x.data[..].try_into().unwrap()), $y as u32);
 	}};
 }
@@ -148,7 +151,6 @@ fn test_xcm_execute_reentrant_call() {
 			value: 0u128,
 		});
 
-		// The XCM used to transfer funds to Bob.
 		let message: Xcm<parachain::RuntimeCall> = Xcm::builder_unsafe()
 			.transact(OriginKind::Native, 1_000_000_000, transact_call.encode())
 			.expect_transact_status(MaybeErrorCode::Success)
@@ -202,3 +204,226 @@ fn test_xcm_send() {
 		assert_eq!(INITIAL_BALANCE + amount - fee, relay_chain::Balances::free_balance(ALICE));
 	});
 }
+
+#[test]
+fn test_xcm_execute_reentrant_call_via_precompile() {
+	MockNet::reset();
+
+	ParaA::execute_with(|| {
+		let initial_bob_balance = ParachainBalances::free_balance(BOB);
+
+		let transact_call = parachain::RuntimeCall::Contracts(pallet_revive::Call::call {
+			dest: to_fixed_non_zero(10),
+			gas_limit: 1_000_000.into(),
+			storage_deposit_limit: test_utils::deposit_limit::<parachain::Runtime>(),
+			data: vec![],
+			value: 0u128,
+		});
+
+		let message: Xcm<parachain::RuntimeCall> = Xcm::builder_unsafe()
+			.transact(OriginKind::Native, 1_000_000_000, transact_call.encode())
+			.expect_transact_status(MaybeErrorCode::Success)
+			.build();
+
+		let xcm_execute_params =
+			IXcm::xcmExecuteCall { message: VersionedXcm::V4(message).encode().into() };
+
+		let call = IXcm::IXcmCalls::xcmExecute(xcm_execute_params);
+		let encoded_call = call.abi_encode();
+		let results = bare_call(to_fixed_non_zero(10)).data(encoded_call).build();
+		let result = match results.result {
+			Ok(value) => value,
+			Err(_) => ExecReturnValue { flags: ReturnFlags::REVERT, data: Vec::new() },
+		};
+
+		let final_bob_balance = ParachainBalances::free_balance(BOB);
+
+		assert_eq!(
+			result.flags,
+			ReturnFlags::REVERT,
+			"Expected transaction to revert due to reentrant call"
+		);
+		assert_eq!(final_bob_balance, initial_bob_balance, "Bob's balance should remain unchanged");
+	});
+}
+
+#[test]
+fn test_xcm_execute_incomplete_call_via_precompile() {
+	MockNet::reset();
+	let amount = 10 * CENTS;
+
+	ParaA::execute_with(|| {
+		let initial_bob_balance = ParachainBalances::free_balance(BOB);
+		let initial_alice_balance = ParachainBalances::free_balance(ALICE);
+
+		let assets: Asset = (Here, amount).into();
+		let beneficiary = AccountId32 { network: None, id: BOB.clone().into() };
+
+		let message: Xcm<()> = Xcm::builder_unsafe()
+			.withdraw_asset(assets.clone())
+			// This will fail as the contract does not have enough balance to complete both
+			// withdrawals.
+			.withdraw_asset((Here, INITIAL_BALANCE))
+			.buy_execution(assets.clone(), Unlimited)
+			.deposit_asset(assets, beneficiary)
+			.build();
+
+		let xcm_execute_params =
+			IXcm::xcmExecuteCall { message: VersionedXcm::V4(message).encode().into() };
+
+		let call = IXcm::IXcmCalls::xcmExecute(xcm_execute_params);
+		let encoded_call = call.abi_encode();
+		bare_call(to_fixed_non_zero(10)).data(encoded_call).build();
+
+		let final_bob_balance = ParachainBalances::free_balance(BOB);
+		let final_alice_balance = ParachainBalances::free_balance(ALICE);
+
+		assert_eq!(final_bob_balance, initial_bob_balance, "Bob's balance should remain unchanged");
+		assert_eq!(
+			final_alice_balance, initial_alice_balance,
+			"Alice's balance should remain unchanged"
+		);
+	});
+}
+
+#[test]
+fn test_xcm_execute_precompile() {
+	MockNet::reset();
+	let amount: u128 = 10 * CENTS;
+
+	ParaA::execute_with(|| {
+		let initial_alice_balance = ParachainBalances::free_balance(ALICE);
+		let initial_bob_balance = ParachainBalances::free_balance(BOB);
+
+		let assets: Asset = (Here, amount).into();
+		let beneficiary = AccountId32 { network: None, id: BOB.clone().into() };
+
+		let message: Xcm<()> = Xcm::builder_unsafe()
+			.withdraw_asset(assets.clone())
+			.deposit_asset(assets, beneficiary)
+			.build();
+
+		let xcm_execute_params =
+			IXcm::xcmExecuteCall { message: VersionedXcm::V4(message).encode().into() };
+
+		let call = IXcm::IXcmCalls::xcmExecute(xcm_execute_params);
+		let encoded_call = call.abi_encode();
+
+		bare_call(to_fixed_non_zero(10)).data(encoded_call).build();
+
+		let final_alice_balance = ParachainBalances::free_balance(ALICE);
+		let final_bob_balance = ParachainBalances::free_balance(BOB);
+
+		assert_eq!(
+			final_bob_balance,
+			initial_bob_balance + amount,
+			"Bob's balance should increase by the specified amount"
+		);
+		assert_eq!(
+			final_alice_balance,
+			initial_alice_balance - amount,
+			"Alice's balance should decrease by the specified amount"
+		);
+	});
+}
+
+#[test]
+fn test_xcm_send_precompile() {
+	MockNet::reset();
+	let amount = 1_000 * CENTS;
+	let fee: u128 = parachain::estimate_message_fee(4);
+
+	let sovereign_account_id = ParaA::execute_with(|| {
+		let sovereign_account_id = parachain_account_sovereign_account_id(1, ALICE.clone());
+		let initial_sovereign_balance =
+			Relay::execute_with(|| relay_chain::Balances::free_balance(&sovereign_account_id));
+
+		let initial_alice_relay_balance =
+			Relay::execute_with(|| relay_chain::Balances::free_balance(ALICE));
+
+		let dest = VersionedLocation::V4(Parent.into());
+		let assets: Asset = (Here, amount).into();
+		let beneficiary = AccountId32 { network: None, id: ALICE.clone().into() };
+
+		let message: Xcm<()> = Xcm::builder()
+			.withdraw_asset(assets.clone())
+			.buy_execution((Here, fee), Unlimited)
+			.deposit_asset(assets, beneficiary)
+			.build();
+
+		let xcm_send_params = IXcm::xcmSendCall {
+			destination: dest.encode().into(),
+			message: VersionedXcm::V4(message).encode().into(),
+		};
+
+		let call = IXcm::IXcmCalls::xcmSend(xcm_send_params);
+		let encoded_call = call.abi_encode();
+		let results = bare_call(to_fixed_non_zero(10)).data(encoded_call).build();
+		let result = results.result.expect("Transaction should succeed");
+		let mut data = &result.data[..];
+		XcmHash::decode(&mut data).expect("Failed to decode xcm_send message_id");
+		(sovereign_account_id, initial_sovereign_balance, initial_alice_relay_balance)
+	});
+
+	Relay::execute_with(|| {
+		let (sovereign_account_id, initial_sovereign_balance, initial_alice_relay_balance) =
+			sovereign_account_id;
+
+		let final_sovereign_balance = relay_chain::Balances::free_balance(&sovereign_account_id);
+		assert_eq!(
+			final_sovereign_balance,
+			initial_sovereign_balance - amount,
+			"Sovereign account balance should decrease by the amount sent"
+		);
+
+		let final_alice_balance = relay_chain::Balances::free_balance(ALICE);
+		assert_eq!(
+			final_alice_balance,
+			initial_alice_relay_balance + amount - fee,
+			"Alice's balance should increase by amount minus fee"
+		);
+	});
+}
+
+#[test]
+fn test_xcm_send_precompile_via_fixture() {
+	MockNet::reset();
+	let amount = 1_000 * CENTS;
+	let fee: u128 = parachain::estimate_message_fee(4);
+	let Contract { addr, .. } = instantiate_test_contract("call_and_return");
+
+	ParaA::execute_with(|| {
+		let dest = VersionedLocation::V4(Parent.into());
+		let assets: Asset = (Here, amount).into();
+		let beneficiary = AccountId32 { network: None, id: ALICE.clone().into() };
+
+		let message: Xcm<()> = Xcm::builder()
+			.withdraw_asset(assets.clone())
+			.buy_execution((Here, fee), Unlimited)
+			.deposit_asset(assets, beneficiary)
+			.build();
+
+		let xcm_send_params = IXcm::xcmSendCall {
+			destination: dest.encode().into(),
+			message: VersionedXcm::V4(message).encode().into(),
+		};
+
+		let call = IXcm::IXcmCalls::xcmSend(xcm_send_params);
+		let encoded_call = call.abi_encode();
+		let result = bare_call(addr)
+			.data(
+				(to_fixed_non_zero(10), 5000u64)
+					.encode()
+					.into_iter()
+					.chain(encoded_call)
+					.collect::<Vec<_>>(),
+			)
+			.build_and_unwrap_result();
+		let mut data = &result.data[..];
+		XcmHash::decode(&mut data).expect("Failed to decode xcm_send message_id");
+	});
+
+	Relay::execute_with(|| {
+		assert_eq!(INITIAL_BALANCE + amount - fee, relay_chain::Balances::free_balance(ALICE));
+	});
+}

substrate/frame/revive/mock-network/src/utils.rs

@@ -0,0 +1,25 @@
+// 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 sp_core::H160;
+
+pub fn to_fixed_non_zero(precompile_id: u16) -> H160 {
+	let mut address = [0u8; 20];
+	address[16] = (precompile_id >> 8) as u8;
+	address[17] = (precompile_id & 0xFF) as u8;
+
+	H160::from(address)
+}