Transact from eth to sub

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

@@ -64,9 +64,8 @@ use snowbridge_core::{
 	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 @@ pub mod pallet {
 
 		/// To withdraw and deposit an asset.
 		type AssetTransactor: TransactAsset;
+
+		/// Returns the parachain ID we are running with.
+		type SelfParaId: Get<ParaId>;
 	}
 
 	#[pallet::hooks]
@@ -268,8 +270,8 @@ pub mod pallet {
 			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()) {
+			let (xcm, fee, message) =
+				match VersionedMessage::decode_all(&mut envelope.payload.as_ref()) {
 					Ok(message) => Self::do_convert(envelope.message_id, message)?,
 					Err(_) => return Err(Error::<T>::InvalidPayload.into()),
 				};
@@ -281,8 +283,13 @@ pub mod pallet {
 				fee
 			);
 
-			// Burning fees for teleport
-			Self::burn_fees(channel.para_id, fee)?;
+			let _ = match message {
+				// Transfer fees to BH for transact
+				VersionedMessage::V1(MessageV1 { command: Command::Transact { .. }, .. }) =>
+					Self::transfer_fees(channel.para_id, fee),
+				// 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,13 +321,13 @@ pub mod pallet {
 	impl<T: Config> Pallet<T> {
 		pub fn do_convert(
 			message_id: H256,
-			message: inbound::VersionedMessage,
-		) -> Result<(Xcm<()>, BalanceOf<T>), Error<T>> {
-			let (mut xcm, fee) =
-				T::MessageConverter::convert(message).map_err(|e| Error::<T>::ConvertMessage(e))?;
+			message: VersionedMessage,
+		) -> Result<(Xcm<()>, BalanceOf<T>, VersionedMessage), Error<T>> {
+			let (mut xcm, fee) = T::MessageConverter::convert(message.clone())
+				.map_err(|e| Error::<T>::ConvertMessage(e))?;
 			// Append the message id as an XCM topic
 			xcm.inner_mut().extend(vec![SetTopic(message_id.into())]);
-			Ok((xcm, fee))
+			Ok((xcm, fee, message))
 		}
 
 		pub fn send_xcm(xcm: Xcm<()>, dest: ParaId) -> Result<XcmHash, Error<T>> {
@@ -360,6 +367,24 @@ pub mod pallet {
 			})?;
 			Ok(())
 		}
+
+		pub fn transfer_fees(para_id: ParaId, fee: BalanceOf<T>) -> DispatchResult {
+			let dummy_context =
+				XcmContext { origin: None, message_id: Default::default(), topic: None };
+			let from = Location::new(1, [Parachain(para_id.into())]);
+			let to = Location::new(1, [Parachain(T::SelfParaId::get().into())]);
+			let fees = (Location::parent(), fee.saturated_into::<u128>()).into();
+			T::AssetTransactor::transfer_asset(&fees, &from, &to, &dummy_context).map_err(
+				|error| {
+					log::error!(
+						target: LOG_TARGET,
+						"XCM asset transfer failed with error {:?}", error
+					);
+					TokenError::FundsUnavailable
+				},
+			)?;
+			Ok(())
+		}
 	}
 
 	/// API for accessing the delivery cost of a message

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

@@ -88,7 +88,6 @@ impl pallet_balances::Config for Test {
 	type MaxFreezes = ();
 	type RuntimeHoldReason = ();
 	type RuntimeFreezeReason = ();
-	type MaxHolds = ();
 }
 
 parameter_types! {
@@ -258,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/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/pallets/system/src/mock.rs

@@ -136,7 +136,6 @@ impl pallet_balances::Config for Test {
 	type MaxFreezes = ();
 	type RuntimeHoldReason = ();
 	type RuntimeFreezeReason = ();
-	type MaxHolds = ();
 }
 
 impl pallet_xcm_origin::Config for Test {

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

@@ -56,6 +56,21 @@ pub enum Command {
 		/// 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 @@ impl<CreateAssetCall, CreateAssetDeposit, InboundQueuePalletInstance, AccountId,
 				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,39 @@ where
 			[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![
+			// Teleport required fees.
+			WithdrawAsset(xcm_fee.clone().into()),
+			// Pay for execution.
+			BuyExecution { fees: xcm_fee.clone(), weight_limit: Unlimited },
+			// Change origin to the bridge.
+			UniversalOrigin(GlobalConsensus(Ethereum { chain_id })),
+			// DescendOrigin to the sender.
+			DescendOrigin(AccountKey20 { network: None, key: sender.into() }.into()),
+			// 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),
+		]
+		.into();
+
+		(xcm, fee.into())
+	}
 }
 
 pub struct GlobalConsensusEthereumConvertsFor<AccountId>(PhantomData<AccountId>);

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

@@ -18,6 +18,7 @@ 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 }

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

@@ -27,7 +27,9 @@ use snowbridge_pallet_inbound_queue_fixtures::{
 	InboundQueueFixture,
 };
 use snowbridge_pallet_system;
-use snowbridge_router_primitives::inbound::GlobalConsensusEthereumConvertsFor;
+use snowbridge_router_primitives::inbound::{
+	Command, GlobalConsensusEthereumConvertsFor, MessageV1, VersionedMessage,
+};
 use sp_core::H256;
 use sp_runtime::{ArithmeticError::Underflow, DispatchError::Arithmetic};
 use testnet_parachains_constants::rococo::snowbridge::EthereumNetwork;
@@ -38,6 +40,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 {
@@ -320,6 +323,51 @@ fn send_token_from_ethereum_to_penpal() {
 	});
 }
 
+#[test]
+fn transact_from_ethereum_to_penpal() {
+	// Fund BridgeHub sovereign account on penpal so that it can pay execution fees.
+	PenpalA::fund_para_sovereign(BridgeHubRococo::para_id().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: hex!("ee9170abfbf9421ad6dd07f6bdec9d89f2b581e0").into(),
+				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 { .. }) => {},
+			]
+		);
+	});
+}
+
 /// Tests the registering of a token as an asset on AssetHub, and then subsequently sending
 /// a token from Ethereum to AssetHub.
 #[test]

cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/lib.rs

@@ -574,6 +574,7 @@ impl snowbridge_pallet_inbound_queue::Config for Runtime {
 	type WeightInfo = weights::snowbridge_pallet_inbound_queue::WeightInfo<Runtime>;
 	type PricingParameters = EthereumSystem;
 	type AssetTransactor = <xcm_config::XcmConfig as xcm_executor::Config>::AssetTransactor;
+	type SelfParaId = parachain_info::Pallet<Runtime>;
 }
 
 impl snowbridge_pallet_outbound_queue::Config for Runtime {

cumulus/parachains/runtimes/testing/penpal/Cargo.toml

@@ -46,6 +46,7 @@ sp-api = { path = "../../../../../substrate/primitives/api", default-features =
 sp-block-builder = { path = "../../../../../substrate/primitives/block-builder", default-features = false }
 sp-consensus-aura = { path = "../../../../../substrate/primitives/consensus/aura", default-features = false }
 sp-core = { path = "../../../../../substrate/primitives/core", default-features = false }
+sp-io = { path = "../../../../../substrate/primitives/io", default-features = false }
 sp-genesis-builder = { path = "../../../../../substrate/primitives/genesis-builder", default-features = false }
 sp-inherents = { path = "../../../../../substrate/primitives/inherents", default-features = false }
 sp-offchain = { path = "../../../../../substrate/primitives/offchain", default-features = false }
@@ -125,6 +126,7 @@ std = [
 	"sp-core/std",
 	"sp-genesis-builder/std",
 	"sp-inherents/std",
+	"sp-io/std",
 	"sp-offchain/std",
 	"sp-runtime/std",
 	"sp-session/std",