Transact from eth to sub

bridges/snowbridge/pallets/inbound-queue/src/lib.rs

@@ -64,9 +64,8 @@
 	sibling_sovereign_account, BasicOperatingMode, Channel, ChannelId, ParaId, PricingParameters,
 	StaticLookup,
 };
-use snowbridge_router_primitives::{
-	inbound,
-	inbound::{ConvertMessage, ConvertMessageError},
+use snowbridge_router_primitives::inbound::{
+	Command, ConvertMessage, ConvertMessageError, MessageV1, VersionedMessage,
 };
 use sp_runtime::{traits::Saturating, SaturatedConversion, TokenError};
 
@@ -139,6 +138,9 @@
 
 		/// To withdraw and deposit an asset.
 		type AssetTransactor: TransactAsset;
+
+		/// Returns the parachain ID we are running with.
+		type SelfParaId: Get<ParaId>;
 	}
 
 	#[pallet::hooks]
@@ -267,12 +269,12 @@
 			let delivery_cost = Self::calculate_delivery_cost(message.encode().len() as u32);
 			T::Token::transfer(&sovereign_account, &who, delivery_cost, Preservation::Preserve)?;
 
-			// Decode message into XCM
-			let (xcm, fee) =
-				match inbound::VersionedMessage::decode_all(&mut envelope.payload.as_ref()) {
-					Ok(message) => Self::do_convert(envelope.message_id, message)?,
-					Err(_) => return Err(Error::<T>::InvalidPayload.into()),
-				};
+			// Decode payload into VersionMessage
+			let message = VersionedMessage::decode_all(&mut envelope.payload.as_ref())
+				.map_err(|_| Error::<T>::InvalidPayload)?;
+
+			// Convert VersionMessage to XCM
+			let (xcm, fee) = Self::do_convert(envelope.message_id, message.clone())?;
 
 			log::info!(
 				target: LOG_TARGET,
@@ -281,8 +283,12 @@
 				fee
 			);
 
-			// Burning fees for teleport
-			Self::burn_fees(channel.para_id, fee)?;
+			let _ = match message {
+				// For transact do nothing here and leave it to dest chain to pay for fees by sender
+				VersionedMessage::V1(MessageV1 { command: Command::Transact { .. }, .. }) => Ok(()),
+				// For others burning fees for teleport
+				_ => Self::burn_fees(channel.para_id, fee),
+			}?;
 
 			// Attempt to send XCM to a dest parachain
 			let message_id = Self::send_xcm(xcm, channel.para_id)?;
@@ -314,7 +320,7 @@
 	impl<T: Config> Pallet<T> {
 		pub fn do_convert(
 			message_id: H256,
-			message: inbound::VersionedMessage,
+			message: VersionedMessage,
 		) -> Result<(Xcm<()>, BalanceOf<T>), Error<T>> {
 			let (mut xcm, fee) =
 				T::MessageConverter::convert(message).map_err(|e| Error::<T>::ConvertMessage(e))?;

bridges/snowbridge/pallets/inbound-queue/src/mock.rs

@@ -257,6 +257,7 @@ impl inbound_queue::Config for Test {
 	type LengthToFee = IdentityFee<u128>;
 	type MaxMessageSize = ConstU32<1024>;
 	type AssetTransactor = SuccessfulTransactor;
+	type SelfParaId = OwnParaId;
 }
 
 pub fn last_events(n: usize) -> Vec<RuntimeEvent> {

bridges/snowbridge/pallets/inbound-queue/src/test.rs

@@ -2,12 +2,13 @@
 // SPDX-FileCopyrightText: 2023 Snowfork <[email protected]>
 use super::*;
 
-use frame_support::{assert_noop, assert_ok};
+use frame_support::{assert_noop, assert_ok, weights::Weight};
 use hex_literal::hex;
 use snowbridge_core::{inbound::Proof, ChannelId};
 use sp_keyring::AccountKeyring as Keyring;
 use sp_runtime::{DispatchError, TokenError};
 use sp_std::convert::From;
+use xcm::prelude::{OriginKind, Transact};
 
 use crate::{Error, Event as InboundQueueEvent};
 
@@ -210,3 +211,35 @@ fn test_set_operating_mode_root_only() {
 		);
 	});
 }
+
+#[test]
+fn test_convert_transact() {
+	new_tester().execute_with(|| {
+		let message_id: H256 = [1; 32].into();
+		let sender: H160 = hex!("ee9170abfbf9421ad6dd07f6bdec9d89f2b581e0").into();
+		let fee: u128 = 40_000_000_000;
+		let weight_at_most = Weight::from_parts(40_000_000, 8_000);
+		let origin_kind = OriginKind::SovereignAccount;
+		let payload = hex!("00071468656c6c6f").to_vec();
+		let message = VersionedMessage::V1(MessageV1 {
+			chain_id: 11155111,
+			command: Command::Transact {
+				sender,
+				fee,
+				weight_ref_time: weight_at_most.ref_time(),
+				weight_proof_size: weight_at_most.proof_size(),
+				origin_kind,
+				payload: payload.clone(),
+			},
+		});
+		// Convert the message to XCM
+		let (xcm, dest_fee) = InboundQueue::do_convert(message_id, message).unwrap();
+		let instructions = xcm.into_inner();
+		assert_eq!(instructions.len(), 10);
+		assert_eq!(dest_fee, fee.into());
+		let transact = instructions.get(5).unwrap().clone();
+		let expected =
+			Transact { origin_kind, require_weight_at_most: weight_at_most, call: payload.into() };
+		assert_eq!(transact, expected);
+	});
+}

bridges/snowbridge/pallets/system/src/lib.rs

@@ -79,8 +79,6 @@ use xcm_executor::traits::ConvertLocation;
 #[cfg(feature = "runtime-benchmarks")]
 use frame_support::traits::OriginTrait;
 
-pub use pallet::*;
-
 pub type BalanceOf<T> =
 	<<T as pallet::Config>::Token as Inspect<<T as frame_system::Config>::AccountId>>::Balance;
 pub type AccountIdOf<T> = <T as frame_system::Config>::AccountId;

bridges/snowbridge/primitives/router/src/inbound/mod.rs

@@ -56,6 +56,21 @@
 		/// XCM execution fee on AssetHub
 		fee: u128,
 	},
+	/// call arbitrary transact on dest chain
+	Transact {
+		/// The address of the sender
+		sender: H160,
+		/// OriginKind
+		origin_kind: OriginKind,
+		/// XCM execution fee on dest chain
+		fee: u128,
+		/// The ref_time part of weight_at_most
+		weight_ref_time: u64,
+		/// The proof_size part of weight_at_most
+		weight_proof_size: u64,
+		/// The payload of the transact
+		payload: Vec<u8>,
+	},
 }
 
 /// Destination for bridged tokens
@@ -146,6 +161,19 @@
 				Ok(Self::convert_register_token(chain_id, token, fee)),
 			V1(MessageV1 { chain_id, command: SendToken { token, destination, amount, fee } }) =>
 				Ok(Self::convert_send_token(chain_id, token, destination, amount, fee)),
+			V1(MessageV1 {
+				chain_id,
+				command:
+					Transact { sender, origin_kind, fee, weight_ref_time, weight_proof_size, payload },
+			}) => Ok(Self::convert_transact(
+				chain_id,
+				sender,
+				origin_kind,
+				fee,
+				weight_ref_time,
+				weight_proof_size,
+				payload,
+			)),
 		}
 	}
 }
@@ -289,6 +317,53 @@
 			[GlobalConsensus(network), AccountKey20 { network: None, key: token.into() }],
 		)
 	}
+
+	fn convert_transact(
+		chain_id: u64,
+		sender: H160,
+		origin_kind: OriginKind,
+		fee: u128,
+		weight_ref_time: u64,
+		weight_proof_size: u64,
+		payload: Vec<u8>,
+	) -> (Xcm<()>, Balance) {
+		let xcm_fee: Asset = (Location::parent(), fee).into();
+
+		let xcm: Xcm<()> = vec![
+			// Only our inbound-queue pallet is allowed to invoke `UniversalOrigin`
+			DescendOrigin(PalletInstance(InboundQueuePalletInstance::get()).into()),
+			// Change origin to the bridge.
+			UniversalOrigin(GlobalConsensus(Ethereum { chain_id })),
+			// DescendOrigin to the sender.
+			DescendOrigin(AccountKey20 { network: None, key: sender.into() }.into()),
+			// Withdraw fees from sender to pay the xcm execution
+			WithdrawAsset(xcm_fee.clone().into()),
+			// Pay for execution.
+			BuyExecution { fees: xcm_fee.clone(), weight_limit: Unlimited },
+			// Transact on dest chain.
+			Transact {
+				origin_kind,
+				require_weight_at_most: Weight::from_parts(weight_ref_time, weight_proof_size),
+				call: payload.into(),
+			},
+			ExpectTransactStatus(MaybeErrorCode::Success),
+			RefundSurplus,
+			// Deposit surplus back to sender.
+			DepositAsset {
+				assets: Wild(AllCounted(1u32)),
+				beneficiary: Location {
+					parents: 1,
+					interior: Junctions::from([
+						GlobalConsensus(Ethereum { chain_id }),
+						AccountKey20 { network: None, key: sender.into() },
+					]),
+				},
+			},
+		]
+		.into();
+
+		(xcm, fee.into())
+	}
 }
 
 pub struct GlobalConsensusEthereumConvertsFor<AccountId>(PhantomData<AccountId>);

cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/Cargo.toml

@@ -18,11 +18,13 @@ hex-literal = "0.4.1"
 # Substrate
 sp-core = { path = "../../../../../../../substrate/primitives/core", default-features = false }
 frame-support = { path = "../../../../../../../substrate/frame/support", default-features = false }
+frame-system = { path = "../../../../../../../substrate/frame/system", default-features = false }
 pallet-assets = { path = "../../../../../../../substrate/frame/assets", default-features = false }
 pallet-asset-conversion = { path = "../../../../../../../substrate/frame/asset-conversion", default-features = false }
 pallet-balances = { path = "../../../../../../../substrate/frame/balances", default-features = false }
 pallet-message-queue = { path = "../../../../../../../substrate/frame/message-queue" }
 sp-runtime = { path = "../../../../../../../substrate/primitives/runtime", default-features = false }
+sp-io = { path = "../../../../../../../substrate/primitives/io", default-features = false }
 
 # Polkadot
 xcm = { package = "staging-xcm", path = "../../../../../../../polkadot/xcm", default-features = false }

cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/tests/snowbridge.rs

@@ -27,8 +27,11 @@ use snowbridge_pallet_inbound_queue_fixtures::{
 	InboundQueueFixture,
 };
 use snowbridge_pallet_system;
-use snowbridge_router_primitives::inbound::GlobalConsensusEthereumConvertsFor;
-use sp_core::H256;
+use snowbridge_router_primitives::inbound::{
+	Command, GlobalConsensusEthereumConvertsFor, MessageV1, VersionedMessage,
+};
+use sp_core::{H160, H256};
+use sp_io::hashing::blake2_256;
 use sp_runtime::{ArithmeticError::Underflow, DispatchError::Arithmetic};
 use testnet_parachains_constants::rococo::snowbridge::EthereumNetwork;
 
@@ -38,6 +41,7 @@ const TREASURY_ACCOUNT: [u8; 32] =
 	hex!("6d6f646c70792f74727372790000000000000000000000000000000000000000");
 const WETH: [u8; 20] = hex!("87d1f7fdfEe7f651FaBc8bFCB6E086C278b77A7d");
 const ETHEREUM_DESTINATION_ADDRESS: [u8; 20] = hex!("44a57ee2f2FCcb85FDa2B0B18EBD0D8D2333700e");
+const XCM_FEE: u128 = 40_000_000_000;
 
 #[derive(Encode, Decode, Debug, PartialEq, Eq, Clone, TypeInfo)]
 pub enum ControlCall {
@@ -71,17 +75,16 @@ pub fn send_inbound_message(fixture: InboundQueueFixture) -> DispatchResult {
 /// Create an agent on Ethereum. An agent is a representation of an entity in the Polkadot
 /// ecosystem (like a parachain) on Ethereum.
 #[test]
-#[ignore]
 fn create_agent() {
-	let origin_para: u32 = 1001;
+	let origin_para: u32 = 2000;
 	// Fund the origin parachain sovereign account so that it can pay execution fees.
 	BridgeHubRococo::fund_para_sovereign(origin_para.into(), INITIAL_FUND);
 
 	let sudo_origin = <Rococo as Chain>::RuntimeOrigin::root();
 	let destination = Rococo::child_location_of(BridgeHubRococo::para_id()).into();
 
 	let create_agent_call = SnowbridgeControl::Control(ControlCall::CreateAgent {});
-	// Construct XCM to create an agent for para 1001
+	// Construct XCM to create an agent for para 2000
 	let remote_xcm = VersionedXcm::from(Xcm(vec![
 		UnpaidExecution { weight_limit: Unlimited, check_origin: None },
 		DescendOrigin(Parachain(origin_para).into()),
@@ -128,9 +131,8 @@ fn create_agent() {
 /// Create a channel for a consensus system. A channel is a bidirectional messaging channel
 /// between BridgeHub and Ethereum.
 #[test]
-#[ignore]
 fn create_channel() {
-	let origin_para: u32 = 1001;
+	let origin_para: u32 = 2000;
 	// Fund AssetHub sovereign account so that it can pay execution fees.
 	BridgeHubRococo::fund_para_sovereign(origin_para.into(), INITIAL_FUND);
 
@@ -139,7 +141,7 @@ fn create_channel() {
 		Rococo::child_location_of(BridgeHubRococo::para_id()).into();
 
 	let create_agent_call = SnowbridgeControl::Control(ControlCall::CreateAgent {});
-	// Construct XCM to create an agent for para 1001
+	// Construct XCM to create an agent for para 2000
 	let create_agent_xcm = VersionedXcm::from(Xcm(vec![
 		UnpaidExecution { weight_limit: Unlimited, check_origin: None },
 		DescendOrigin(Parachain(origin_para).into()),
@@ -152,7 +154,7 @@ fn create_channel() {
 
 	let create_channel_call =
 		SnowbridgeControl::Control(ControlCall::CreateChannel { mode: OperatingMode::Normal });
-	// Construct XCM to create a channel for para 1001
+	// Construct XCM to create a channel for para 2000
 	let create_channel_xcm = VersionedXcm::from(Xcm(vec![
 		UnpaidExecution { weight_limit: Unlimited, check_origin: None },
 		DescendOrigin(Parachain(origin_para).into()),
@@ -535,3 +537,52 @@ fn send_token_from_ethereum_to_asset_hub_fail_for_insufficient_fund() {
 		assert_err!(send_inbound_message(make_register_token_message()), Arithmetic(Underflow));
 	});
 }
+
+#[test]
+fn transact_from_ethereum_to_penpal() {
+	// Fund sender on penpal so that it can pay execution fees.
+	let sender: H160 = hex!("ee9170abfbf9421ad6dd07f6bdec9d89f2b581e0").into();
+	PenpalA::fund_accounts(vec![(
+		blake2_256(&(b"AccountKey20", sender).encode()).into(),
+		INITIAL_FUND,
+	)]);
+
+	BridgeHubRococo::execute_with(|| {
+		type RuntimeEvent = <BridgeHubRococo as Chain>::RuntimeEvent;
+
+		let message_id: H256 = [1; 32].into();
+		let message = VersionedMessage::V1(MessageV1 {
+			chain_id: CHAIN_ID,
+			command: Command::Transact {
+				sender,
+				fee: XCM_FEE,
+				weight_ref_time: 40_000_000,
+				weight_proof_size: 8_000,
+				origin_kind: OriginKind::SovereignAccount,
+				payload: hex!("00071468656c6c6f").to_vec(),
+			},
+		});
+		// Convert the message to XCM
+		let (xcm, _) = EthereumInboundQueue::do_convert(message_id, message).unwrap();
+		// Send the XCM
+		let _ = EthereumInboundQueue::send_xcm(xcm, PenpalA::para_id().into()).unwrap();
+
+		assert_expected_events!(
+			BridgeHubRococo,
+			vec![
+				RuntimeEvent::XcmpQueue(cumulus_pallet_xcmp_queue::Event::XcmpMessageSent { .. }) => {},
+			]
+		);
+	});
+
+	PenpalA::execute_with(|| {
+		type RuntimeEvent = <PenpalA as Chain>::RuntimeEvent;
+		// Check that system event remarked on PenPal
+		assert_expected_events!(
+			PenpalA,
+			vec![
+				RuntimeEvent::System(frame_system::Event::Remarked { .. }) => {},
+			]
+		);
+	});
+}