Transact from eth to sub

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

@@ -8,6 +8,7 @@ use sp_core::RuntimeDebug;
 
 pub mod register_token;
 pub mod register_token_with_insufficient_fee;
+pub mod send_call_to_penpal;
 pub mod send_token;
 pub mod send_token_to_penpal;
 

bridges/snowbridge/pallets/inbound-queue/fixtures/src/send_call_to_penpal.rs

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2023 Snowfork <[email protected]>
+// Generated, do not edit!
+// See ethereum client README.md for instructions to generate
+
+use crate::InboundQueueFixture;
+use hex_literal::hex;
+use snowbridge_beacon_primitives::CompactExecutionHeader;
+use snowbridge_core::inbound::{Log, Message, Proof};
+use sp_std::vec;
+
+pub fn make_send_call_to_penpal_message() -> InboundQueueFixture {
+	InboundQueueFixture {
+        execution_header: CompactExecutionHeader{
+            parent_hash: hex!("e0fa68ceff08e6f024c84f408540372801b209ff8f11481a9dc6bc5db3ce92d3").into(),
+            block_number: 831,
+            state_root: hex!("ccc30635f32d558620d45ead60eabbe70dbf179b475fa9cec5a3791fd5be2b78").into(),
+            receipts_root: hex!("6bba8f0093461e22cd265bc0de44bf7a596db58ecbf44432e6de8b3490deb077").into(),
+        },
+        message: Message {
+            event_log: 	Log {
+                address: hex!("eda338e4dc46038493b885327842fd3e301cab39").into(),
+                topics: vec![
+                    hex!("7153f9357c8ea496bba60bf82e67143e27b64462b49041f8e689e1b05728f84f").into(),
+                    hex!("a69fbbae90bb6096d59b1930bbcfc8a3ef23959d226b1861deb7ad8fb06c6fa3").into(),
+                    hex!("c9ad11f6e2d2b770f52e7cbe22ba779eb8e5e000e0db4e5032488898bd3529ec").into(),
+                ],
+                data: hex!("00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000003e00a736aa00000000000290a987b944cb1dcce5564e5fdecd7a54d3de27fe0100902f5009000000000000000000000002688909017d2000071468656c6c6f0000").into(),
+            },
+            proof: Proof {
+                block_hash: hex!("be15f3cdf217baad8cc5c40d7e2dc1f173ab3bdaa58e5819905bb0c73f46cf78").into(),
+                tx_index: 0,
+                data: (vec![
+                    hex!("6bba8f0093461e22cd265bc0de44bf7a596db58ecbf44432e6de8b3490deb077").to_vec(),
+                ], vec![
+                    hex!("f90234822080b9022e02f9022a0183016e01b9010000000000000000000000000000000000000000000000014000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000200000000000000000020000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000010000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002004000000000000000000000200000000000000f9011ff9011c94eda338e4dc46038493b885327842fd3e301cab39f863a07153f9357c8ea496bba60bf82e67143e27b64462b49041f8e689e1b05728f84fa0a69fbbae90bb6096d59b1930bbcfc8a3ef23959d226b1861deb7ad8fb06c6fa3a0c9ad11f6e2d2b770f52e7cbe22ba779eb8e5e000e0db4e5032488898bd3529ecb8a000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000003e00a736aa00000000000290a987b944cb1dcce5564e5fdecd7a54d3de27fe0100902f5009000000000000000000000002688909017d2000071468656c6c6f0000").to_vec(),
+                ]),
+            },
+        },
+    }
+}

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

@@ -65,9 +65,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};
 
@@ -276,12 +275,12 @@ pub mod pallet {
 				T::Token::transfer(&sovereign_account, &who, amount, 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,
@@ -290,8 +289,16 @@ pub mod pallet {
 				fee
 			);
 
-			// Burning fees for teleport
-			Self::burn_fees(channel.para_id, fee)?;
+			match message {
+				// For RegisterToken|SendToken burning fees for teleport
+				VersionedMessage::V1(MessageV1 {
+					command: Command::RegisterToken { .. }, ..
+				}) |
+				VersionedMessage::V1(MessageV1 { command: Command::SendToken { .. }, .. }) =>
+					Self::burn_fees(channel.para_id, fee)?,
+				// For transact do nothing here and leave it to dest chain to pay for fees by sender
+				VersionedMessage::V1(MessageV1 { command: Command::Transact { .. }, .. }) => (),
+			};
 
 			// Attempt to send XCM to a dest parachain
 			let message_id = Self::send_xcm(xcm, channel.para_id)?;
@@ -323,7 +330,7 @@ pub mod pallet {
 	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/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;
 use sp_std::convert::From;
+use xcm::prelude::{OriginKind, Transact};
 
 use crate::{Error, Event as InboundQueueEvent};
 
@@ -251,3 +252,34 @@ fn test_submit_no_funds_to_reward_relayers_and_ed_preserved() {
 		assert_eq!(amount, ExistentialDeposit::get());
 	});
 }
+
+#[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_at_most,
+				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(), 7);
+		assert_eq!(dest_fee, fee.into());
+		let transact = instructions.get(2).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

@@ -99,7 +99,7 @@ where
 }
 
 /// Hash the location to produce an agent id
-fn agent_id_of<T: Config>(location: &Location) -> Result<H256, DispatchError> {
+pub fn agent_id_of<T: Config>(location: &Location) -> Result<H256, DispatchError> {
 	T::AgentIdOf::convert_location(location).ok_or(Error::<T>::LocationConversionFailed.into())
 }
 

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

@@ -56,6 +56,19 @@ 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 weight required at most on dest chain
+		weight_at_most: Weight,
+		/// The payload of the transact
+		payload: Vec<u8>,
+	},
 }
 
 /// Destination for bridged tokens
@@ -146,6 +159,17 @@ 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_at_most, payload },
+			}) => Ok(Self::convert_transact(
+				chain_id,
+				sender,
+				origin_kind,
+				fee,
+				weight_at_most,
+				payload,
+			)),
 		}
 	}
 }
@@ -289,6 +313,33 @@ where
 			[GlobalConsensus(network), AccountKey20 { network: None, key: token.into() }],
 		)
 	}
+
+	fn convert_transact(
+		chain_id: u64,
+		sender: H160,
+		origin_kind: OriginKind,
+		fee: u128,
+		weight_at_most: Weight,
+		payload: Vec<u8>,
+	) -> (Xcm<()>, Balance) {
+		let xcm_fee: Asset = (Location::parent(), fee).into();
+
+		let message = vec![
+			UnpaidExecution { weight_limit: Unlimited, check_origin: None },
+			// Actually BurnAsset does nothing on dest chain, included here only for
+			// the dest chain to implement a custom Barrier which inspect the fee as
+			// expected(i.e. can cover the transact cost to avoid spamming)
+			BurnAsset(xcm_fee.clone().into()),
+			Transact { origin_kind, require_weight_at_most: weight_at_most, call: payload.into() },
+			// 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()),
+		];
+		(message.into(), fee.into())
+	}
 }
 
 pub struct GlobalConsensusEthereumConvertsFor<AccountId>(PhantomData<AccountId>);

bridges/snowbridge/templates/send_call_to_penpal.mustache

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2023 Snowfork <[email protected]>
+// Generated, do not edit!
+// See ethereum client README.md for instructions to generate
+
+use crate::InboundQueueFixture;
+use hex_literal::hex;
+use snowbridge_beacon_primitives::CompactExecutionHeader;
+use snowbridge_core::inbound::{Log, Message, Proof};
+use sp_std::vec;
+
+pub fn make_send_call_to_penpal_message() -> InboundQueueFixture {
+    InboundQueueFixture {
+        execution_header: CompactExecutionHeader{
+            parent_hash: hex!("{{InboundMessageTest.ExecutionHeader.ParentHash}}").into(),
+            block_number: {{InboundMessageTest.ExecutionHeader.BlockNumber}},
+            state_root: hex!("{{InboundMessageTest.ExecutionHeader.StateRoot}}").into(),
+            receipts_root: hex!("{{InboundMessageTest.ExecutionHeader.ReceiptsRoot}}").into(),
+        },
+        message: Message {
+            event_log: 	Log {
+                address: hex!("{{InboundMessageTest.Message.EventLog.Address}}").into(),
+                topics: vec![
+                {{#InboundMessageTest.Message.EventLog.Topics}}
+                    hex!("{{.}}").into(),
+                {{/InboundMessageTest.Message.EventLog.Topics}}
+                ],
+                data: hex!("{{InboundMessageTest.Message.EventLog.Data}}").into(),
+            },
+            proof: Proof {
+                block_hash: hex!("{{InboundMessageTest.Message.Proof.BlockHash}}").into(),
+                tx_index: {{InboundMessageTest.Message.Proof.TxIndex}},
+                data: (vec![
+                {{#InboundMessageTest.Message.Proof.Data.Keys}}
+                    hex!("{{.}}").to_vec(),
+                {{/InboundMessageTest.Message.Proof.Data.Keys}}
+                ], vec![
+                {{#InboundMessageTest.Message.Proof.Data.Values}}
+                    hex!("{{.}}").to_vec(),
+                {{/InboundMessageTest.Message.Proof.Data.Values}}
+                ]),
+            },
+        },
+    }
+}

bridges/snowbridge/templates/send_token_to_penpal.mustache

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2023 Snowfork <[email protected]>
+// Generated, do not edit!
+// See ethereum client README.md for instructions to generate
+
+use crate::InboundQueueFixture;
+use hex_literal::hex;
+use snowbridge_beacon_primitives::CompactExecutionHeader;
+use snowbridge_core::inbound::{Log, Message, Proof};
+use sp_std::vec;
+
+pub fn make_send_token_to_penpal_message() -> InboundQueueFixture {
+    InboundQueueFixture {
+        execution_header: CompactExecutionHeader{
+            parent_hash: hex!("{{InboundMessageTest.ExecutionHeader.ParentHash}}").into(),
+            block_number: {{InboundMessageTest.ExecutionHeader.BlockNumber}},
+            state_root: hex!("{{InboundMessageTest.ExecutionHeader.StateRoot}}").into(),
+            receipts_root: hex!("{{InboundMessageTest.ExecutionHeader.ReceiptsRoot}}").into(),
+        },
+        message: Message {
+            event_log: 	Log {
+                address: hex!("{{InboundMessageTest.Message.EventLog.Address}}").into(),
+                topics: vec![
+                {{#InboundMessageTest.Message.EventLog.Topics}}
+                    hex!("{{.}}").into(),
+                {{/InboundMessageTest.Message.EventLog.Topics}}
+                ],
+                data: hex!("{{InboundMessageTest.Message.EventLog.Data}}").into(),
+            },
+            proof: Proof {
+                block_hash: hex!("{{InboundMessageTest.Message.Proof.BlockHash}}").into(),
+                tx_index: {{InboundMessageTest.Message.Proof.TxIndex}},
+                data: (vec![
+                {{#InboundMessageTest.Message.Proof.Data.Keys}}
+                    hex!("{{.}}").to_vec(),
+                {{/InboundMessageTest.Message.Proof.Data.Keys}}
+                ], vec![
+                {{#InboundMessageTest.Message.Proof.Data.Values}}
+                    hex!("{{.}}").to_vec(),
+                {{/InboundMessageTest.Message.Proof.Data.Values}}
+                ]),
+            },
+        },
+    }
+}

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

@@ -14,15 +14,18 @@ workspace = true
 codec = { package = "parity-scale-codec", version = "3.4.0", default-features = false }
 scale-info = { version = "2.10.0", default-features = false, features = ["derive"] }
 hex-literal = "0.4.1"
+hex = "0.4.3"
 
 # 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 }