diff --git a/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/tests/snowbridge.rs b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/tests/snowbridge.rs
new file mode 100644
index 000000000000..6dce66c6d256
--- /dev/null
+++ b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/tests/snowbridge.rs
@@ -0,0 +1,403 @@
+// 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::*;
+use hex_literal::hex;
+use integration_tests_common::{AssetHubRococoPallet, BridgeHubRococoPallet};
+use snowbridge_control;
+use snowbridge_router_primitives::inbound::{Command, Destination, MessageV1, VersionedMessage};
+use sp_core::H256;
+
+const INITIAL_FUND: u128 = 5_000_000_000 * ROCOCO_ED;
+const CHAIN_ID: u64 = 15;
+const DEST_PARA_ID: u32 = 1000;
+const TREASURY_ACCOUNT: [u8; 32] =
+	hex!("6d6f646c70792f74727372790000000000000000000000000000000000000000");
+const WETH: [u8; 20] = hex!("87d1f7fdfEe7f651FaBc8bFCB6E086C278b77A7d");
+const ASSETHUB_SOVEREIGN: [u8; 32] =
+	hex!("7369626ce8030000000000000000000000000000000000000000000000000000");
+const ETHEREUM_DESTINATION_ADDRESS: [u8; 20] = hex!("44a57ee2f2FCcb85FDa2B0B18EBD0D8D2333700e");
+
+#[test]
+fn create_agent() {
+	BridgeHubRococo::fund_accounts(vec![(
+		BridgeHubRococo::sovereign_account_id_of(MultiLocation {
+			parents: 1,
+			interior: X1(Parachain(DEST_PARA_ID)),
+		}),
+		INITIAL_FUND,
+	)]);
+
+	let sudo_origin = <Rococo as Chain>::RuntimeOrigin::root();
+	let destination = Rococo::child_location_of(BridgeHubRococo::para_id()).into();
+
+	let remote_xcm = VersionedXcm::from(Xcm(vec![
+		UnpaidExecution { weight_limit: Unlimited, check_origin: None },
+		DescendOrigin(X1(Parachain(DEST_PARA_ID))),
+		Transact {
+			require_weight_at_most: 3000000000.into(),
+			origin_kind: OriginKind::Xcm,
+			call: vec![51, 1].into(),
+		},
+	]));
+
+	//Rococo Global Consensus
+	// Send XCM message from Relay Chain to Bridge Hub source Parachain
+	Rococo::execute_with(|| {
+		assert_ok!(<Rococo as RococoPallet>::XcmPallet::send(
+			sudo_origin,
+			bx!(destination),
+			bx!(remote_xcm),
+		));
+
+		type RuntimeEvent = <Rococo as Chain>::RuntimeEvent;
+
+		assert_expected_events!(
+			Rococo,
+			vec![
+				RuntimeEvent::XcmPallet(pallet_xcm::Event::Sent { .. }) => {},
+			]
+		);
+	});
+
+	BridgeHubRococo::execute_with(|| {
+		type RuntimeEvent = <BridgeHubRococo as Chain>::RuntimeEvent;
+
+		assert_expected_events!(
+			BridgeHubRococo,
+			vec![
+				RuntimeEvent::DmpQueue(cumulus_pallet_dmp_queue::Event::ExecutedDownward {
+					outcome: Outcome::Complete(_),
+					..
+				}) => {},
+				RuntimeEvent::EthereumControl(snowbridge_control::Event::CreateAgent {
+					..
+				}) => {},
+			]
+		);
+	});
+}
+
+#[test]
+fn create_channel() {
+	let source_location = MultiLocation { parents: 1, interior: X1(Parachain(DEST_PARA_ID)) };
+
+	BridgeHubRococo::fund_accounts(vec![(
+		BridgeHubRococo::sovereign_account_id_of(source_location),
+		INITIAL_FUND,
+	)]);
+
+	let sudo_origin = <Rococo as Chain>::RuntimeOrigin::root();
+	let destination: VersionedMultiLocation =
+		Rococo::child_location_of(BridgeHubRococo::para_id()).into();
+
+	let create_agent_xcm = VersionedXcm::from(Xcm(vec![
+		UnpaidExecution { weight_limit: Unlimited, check_origin: None },
+		DescendOrigin(X1(Parachain(DEST_PARA_ID))),
+		Transact {
+			require_weight_at_most: 3000000000.into(),
+			origin_kind: OriginKind::Xcm,
+			call: vec![51, 1].into(),
+		},
+	]));
+
+	let create_channel_xcm = VersionedXcm::from(Xcm(vec![
+		UnpaidExecution { weight_limit: Unlimited, check_origin: None },
+		DescendOrigin(X1(Parachain(DEST_PARA_ID))),
+		Transact {
+			require_weight_at_most: 3000000000.into(),
+			origin_kind: OriginKind::Xcm,
+			call: vec![51, 2].into(),
+		},
+	]));
+
+	//Rococo Global Consensus
+	// Send XCM message from Relay Chain to Bridge Hub source Parachain
+	Rococo::execute_with(|| {
+		assert_ok!(<Rococo as RococoPallet>::XcmPallet::send(
+			sudo_origin.clone(),
+			bx!(destination.clone()),
+			bx!(create_agent_xcm),
+		));
+
+		assert_ok!(<Rococo as RococoPallet>::XcmPallet::send(
+			sudo_origin,
+			bx!(destination),
+			bx!(create_channel_xcm),
+		));
+
+		type RuntimeEvent = <Rococo as Chain>::RuntimeEvent;
+
+		assert_expected_events!(
+			Rococo,
+			vec![
+				RuntimeEvent::XcmPallet(pallet_xcm::Event::Sent { .. }) => {},
+			]
+		);
+	});
+
+	BridgeHubRococo::execute_with(|| {
+		type RuntimeEvent = <BridgeHubRococo as Chain>::RuntimeEvent;
+
+		assert_expected_events!(
+			BridgeHubRococo,
+			vec![
+				RuntimeEvent::DmpQueue(cumulus_pallet_dmp_queue::Event::ExecutedDownward {
+					outcome: Outcome::Complete(_),
+					..
+				}) => {},
+				RuntimeEvent::EthereumControl(snowbridge_control::Event::CreateChannel {
+					..
+				}) => {},
+			]
+		);
+	});
+}
+
+#[test]
+fn register_token() {
+	BridgeHubRococo::fund_accounts(vec![(
+		BridgeHubRococo::sovereign_account_id_of(MultiLocation {
+			parents: 1,
+			interior: X1(Parachain(DEST_PARA_ID)),
+		}),
+		INITIAL_FUND,
+	)]);
+
+	let message_id_: H256 = [1; 32].into();
+
+	BridgeHubRococo::execute_with(|| {
+		type RuntimeEvent = <BridgeHubRococo as Chain>::RuntimeEvent;
+		type EthereumInboundQueue =
+			<BridgeHubRococo as BridgeHubRococoPallet>::EthereumInboundQueue;
+		let message = VersionedMessage::V1(MessageV1 {
+			chain_id: CHAIN_ID,
+			command: Command::RegisterToken { token: WETH.into() },
+		});
+		let (xcm, _) = EthereumInboundQueue::do_convert(message_id_, message).unwrap();
+		let _ = EthereumInboundQueue::send_xcm(xcm, DEST_PARA_ID.into()).unwrap();
+
+		assert_expected_events!(
+			BridgeHubRococo,
+			vec![
+				RuntimeEvent::XcmpQueue(cumulus_pallet_xcmp_queue::Event::XcmpMessageSent { .. }) => {},
+			]
+		);
+	});
+
+	AssetHubRococo::execute_with(|| {
+		type RuntimeEvent = <AssetHubRococo as Chain>::RuntimeEvent;
+
+		assert_expected_events!(
+			AssetHubRococo,
+			vec![
+				RuntimeEvent::ForeignAssets(pallet_assets::Event::Created { .. }) => {},
+				RuntimeEvent::XcmpQueue(cumulus_pallet_xcmp_queue::Event::Success { message_id, .. }) => {
+					message_id: H256::from(*message_id) == message_id_,
+				},
+			]
+		);
+	});
+}
+
+#[test]
+fn send_token() {
+	BridgeHubRococo::fund_accounts(vec![(
+		BridgeHubRococo::sovereign_account_id_of(MultiLocation {
+			parents: 1,
+			interior: X1(Parachain(DEST_PARA_ID)),
+		}),
+		INITIAL_FUND,
+	)]);
+
+	// Fund ethereum sovereign in asset hub
+	AssetHubRococo::fund_accounts(vec![
+		(ASSETHUB_SOVEREIGN.into(), INITIAL_FUND),
+		(AssetHubRococoReceiver::get(), INITIAL_FUND),
+	]);
+
+	let message_id_: H256 = [1; 32].into();
+
+	BridgeHubRococo::execute_with(|| {
+		type RuntimeEvent = <BridgeHubRococo as Chain>::RuntimeEvent;
+		type EthereumInboundQueue =
+			<BridgeHubRococo as BridgeHubRococoPallet>::EthereumInboundQueue;
+		let message = VersionedMessage::V1(MessageV1 {
+			chain_id: CHAIN_ID,
+			command: Command::RegisterToken { token: WETH.into() },
+		});
+		let (xcm, _) = EthereumInboundQueue::do_convert(message_id_, message).unwrap();
+		let _ = EthereumInboundQueue::send_xcm(xcm, DEST_PARA_ID.into()).unwrap();
+		let message = VersionedMessage::V1(MessageV1 {
+			chain_id: CHAIN_ID,
+			command: Command::SendToken {
+				token: WETH.into(),
+				destination: Destination::AccountId32 { id: AssetHubRococoReceiver::get().into() },
+				amount: 1_000_000_000,
+			},
+		});
+		let (xcm, _) = EthereumInboundQueue::do_convert(message_id_, message).unwrap();
+		let _ = EthereumInboundQueue::send_xcm(xcm, DEST_PARA_ID.into()).unwrap();
+
+		assert_expected_events!(
+			BridgeHubRococo,
+			vec![
+				RuntimeEvent::XcmpQueue(cumulus_pallet_xcmp_queue::Event::XcmpMessageSent { .. }) => {},
+			]
+		);
+	});
+
+	AssetHubRococo::execute_with(|| {
+		type RuntimeEvent = <AssetHubRococo as Chain>::RuntimeEvent;
+
+		assert_expected_events!(
+			AssetHubRococo,
+			vec![
+				RuntimeEvent::ForeignAssets(pallet_assets::Event::Issued { .. }) => {},
+				RuntimeEvent::XcmpQueue(cumulus_pallet_xcmp_queue::Event::Success { message_id, .. }) => {
+					message_id: H256::from(*message_id) == message_id_,
+				},
+			]
+		);
+	});
+}
+
+#[test]
+fn reserve_transfer_token() {
+	BridgeHubRococo::fund_accounts(vec![(
+		BridgeHubRococo::sovereign_account_id_of(MultiLocation {
+			parents: 1,
+			interior: X1(Parachain(DEST_PARA_ID)),
+		}),
+		INITIAL_FUND,
+	)]);
+
+	// Fund ethereum sovereign in asset hub
+	AssetHubRococo::fund_accounts(vec![
+		(ASSETHUB_SOVEREIGN.into(), INITIAL_FUND),
+		(AssetHubRococoReceiver::get(), INITIAL_FUND),
+	]);
+
+	const WETH_AMOUNT: u128 = 1_000_000_000;
+	let message_id_: H256 = [1; 32].into();
+
+	BridgeHubRococo::execute_with(|| {
+		type RuntimeEvent = <BridgeHubRococo as Chain>::RuntimeEvent;
+		type EthereumInboundQueue =
+			<BridgeHubRococo as BridgeHubRococoPallet>::EthereumInboundQueue;
+		let message = VersionedMessage::V1(MessageV1 {
+			chain_id: CHAIN_ID,
+			command: Command::RegisterToken { token: WETH.into() },
+		});
+		let (xcm, _) = EthereumInboundQueue::do_convert(message_id_, message).unwrap();
+		let _ = EthereumInboundQueue::send_xcm(xcm, DEST_PARA_ID.into()).unwrap();
+		let message = VersionedMessage::V1(MessageV1 {
+			chain_id: CHAIN_ID,
+			command: Command::SendToken {
+				token: WETH.into(),
+				destination: Destination::AccountId32 { id: AssetHubRococoReceiver::get().into() },
+				amount: WETH_AMOUNT,
+			},
+		});
+		let (xcm, _) = EthereumInboundQueue::do_convert(message_id_, message).unwrap();
+		let _ = EthereumInboundQueue::send_xcm(xcm, DEST_PARA_ID.into()).unwrap();
+
+		assert_expected_events!(
+			BridgeHubRococo,
+			vec![
+				RuntimeEvent::XcmpQueue(cumulus_pallet_xcmp_queue::Event::XcmpMessageSent { .. }) => {},
+			]
+		);
+	});
+
+	AssetHubRococo::execute_with(|| {
+		type RuntimeEvent = <AssetHubRococo as Chain>::RuntimeEvent;
+		type RuntimeOrigin = <AssetHubRococo as Chain>::RuntimeOrigin;
+
+		assert_expected_events!(
+			AssetHubRococo,
+			vec![
+				RuntimeEvent::ForeignAssets(pallet_assets::Event::Issued { .. }) => {},
+				RuntimeEvent::XcmpQueue(cumulus_pallet_xcmp_queue::Event::Success { message_id, .. }) => {
+					message_id: H256::from(*message_id) == message_id_,
+				},
+			]
+		);
+		let assets = vec![MultiAsset {
+			id: Concrete(MultiLocation {
+				parents: 2,
+				interior: X2(
+					GlobalConsensus(Ethereum { chain_id: CHAIN_ID }),
+					AccountKey20 { network: None, key: WETH },
+				),
+			}),
+			fun: Fungible(WETH_AMOUNT),
+		}];
+		let multi_assets = VersionedMultiAssets::V3(MultiAssets::from(assets));
+
+		let destination = VersionedMultiLocation::V3(MultiLocation {
+			parents: 2,
+			interior: X1(GlobalConsensus(Ethereum { chain_id: CHAIN_ID })),
+		});
+
+		let beneficiary = VersionedMultiLocation::V3(MultiLocation {
+			parents: 0,
+			interior: X1(AccountKey20 { network: None, key: ETHEREUM_DESTINATION_ADDRESS.into() }),
+		});
+
+		<AssetHubRococo as AssetHubRococoPallet>::PolkadotXcm::reserve_transfer_assets(
+			RuntimeOrigin::signed(AssetHubRococoReceiver::get()),
+			Box::new(destination),
+			Box::new(beneficiary),
+			Box::new(multi_assets),
+			0,
+		)
+		.unwrap();
+	});
+
+	BridgeHubRococo::execute_with(|| {
+		type RuntimeEvent = <BridgeHubRococo as Chain>::RuntimeEvent;
+
+		assert_expected_events!(
+			BridgeHubRococo,
+			vec![
+				RuntimeEvent::EthereumOutboundQueue(snowbridge_outbound_queue::Event::MessageQueued {..}) => {},
+				RuntimeEvent::XcmpQueue(cumulus_pallet_xcmp_queue::Event::Success { .. }) => {},
+			]
+		);
+		let events = BridgeHubRococo::events();
+		assert!(
+			events
+				.iter()
+				.find(|&event| matches!(
+					event,
+					RuntimeEvent::Balances(pallet_balances::Event::Deposit{ who, amount })
+						if *who == TREASURY_ACCOUNT.into() && *amount == 16903333
+				))
+				.is_some(),
+			"Snowbridge sovereign takes local fee."
+		);
+		assert!(
+			events
+				.iter()
+				.find(|&event| matches!(
+					event,
+					RuntimeEvent::Balances(pallet_balances::Event::Deposit{ who, amount })
+						if *who == ASSETHUB_SOVEREIGN.into() && *amount == 2200000000000
+				))
+				.is_some(),
+			"Assethub sovereign takes remote fee."
+		);
+	});
+}
diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/lib.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/lib.rs
index 633a58c07893..308369aad454 100644
--- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/lib.rs
+++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/lib.rs
@@ -80,7 +80,7 @@ use pallet_xcm::EnsureXcm;
 pub use sp_consensus_aura::sr25519::AuthorityId as AuraId;
 pub use sp_runtime::{MultiAddress, Perbill, Permill};
 use xcm::VersionedMultiLocation;
-use xcm_config::{TreasuryAccount, XcmRouter, XcmOriginToTransactDispatchOrigin};
+use xcm_config::{TreasuryAccount, XcmOriginToTransactDispatchOrigin, XcmRouter};
 
 use bp_runtime::HeaderId;
 use bridge_hub_common::{
diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/xcm_config.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/xcm_config.rs
index 8e2ffbfeafa4..96cd20c90a2b 100644
--- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/xcm_config.rs
+++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/xcm_config.rs
@@ -322,7 +322,7 @@ impl xcm_executor::Config for XcmConfig {
 				bp_rococo::Balance,
 				AccountId,
 				TokenLocation,
-			 	EthereumNetwork,
+				EthereumNetwork,
 				Self::AssetTransactor,
 				crate::EthereumOutboundQueue,
 			>,