Transfer asset via bridge

Cargo.toml

@@ -36,6 +36,7 @@ members = [
 	"primitives/utility",
 	"polkadot-parachain",
 	"parachains/common",
+	"parachains/pallets/bridge-transfer",
 	"parachains/pallets/parachain-info",
 	"parachains/pallets/ping",
 	"parachains/runtimes/testing/rococo-parachain",

parachains/pallets/bridge-transfer/Cargo.toml

@@ -0,0 +1,58 @@
+[package]
+name = "pallet-bridge-transfer"
+version = "0.1.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://docs.substrate.io/"
+repository = "https://github.com/paritytech/cumulus/"
+description = "Pallet for message transfer through bridges"
+readme = "README.md"
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] }
+scale-info = { version = "2.3.0", default-features = false, features = ["derive"] }
+log = { version = "0.4.14", default-features = false }
+
+# Substrate
+sp-std = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "master" }
+sp-runtime = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "master" }
+frame-benchmarking = { git = "https://github.com/paritytech/substrate", optional = true, default-features = false, branch = "master" }
+frame-system-benchmarking = { git = "https://github.com/paritytech/substrate", optional = true, default-features = false, branch = "master" }
+frame-support = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "master" }
+frame-system = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "master" }
+
+# Polkadot
+xcm = { git = "https://github.com/paritytech/polkadot", default-features = false, branch = "master" }
+xcm-builder = { git = "https://github.com/paritytech/polkadot", default-features = false, branch = "master" }
+xcm-executor = { git = "https://github.com/paritytech/polkadot", default-features = false, branch = "master" }
+
+[dev-dependencies]
+sp-version = { git = "https://github.com/paritytech/substrate", branch = "master" }
+pallet-balances = { git = "https://github.com/paritytech/substrate", branch = "master" }
+polkadot-parachain = { git = "https://github.com/paritytech/polkadot", branch = "master" }
+cumulus-pallet-xcmp-queue = { path = "../../../pallets/xcmp-queue" }
+
+[features]
+default = ["std"]
+std = [
+	"codec/std",
+	"log/std",
+	"scale-info/std",
+	"sp-std/std",
+	"sp-runtime/std",
+	"frame-support/std",
+	"frame-system/std",
+	"xcm/std",
+	"xcm-builder/std",
+	"xcm-executor/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system-benchmarking/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+	"xcm-builder/runtime-benchmarks",
+]
+try-runtime = ["frame-support/try-runtime"]

parachains/pallets/bridge-transfer/src/benchmarking.rs

@@ -0,0 +1,199 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2022 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.
+
+//! `BridgeTransfer` pallet benchmarks.
+
+use crate::{
+	AllowedExporters, AllowedReserveLocations, AllowedUniversalAliases, BenchmarkHelper, Call,
+	Config, Event, Pallet, PingMessageBuilder,
+};
+
+use frame_benchmarking::{benchmarks, BenchmarkError};
+use frame_support::{
+	ensure,
+	traits::{EnsureOrigin, Get},
+};
+use sp_std::prelude::*;
+use xcm::prelude::*;
+
+#[cfg(feature = "runtime-benchmarks")]
+impl<T: Config> Pallet<T> {
+	#[cfg(feature = "runtime-benchmarks")]
+	pub fn insert_universal_alias_for_benchmarks((location, junction): (MultiLocation, Junction)) {
+		assert!(matches!(
+			AllowedUniversalAliases::<T>::try_mutate(location, |junctions| junctions
+				.try_insert(junction)),
+			Ok(true)
+		));
+	}
+}
+
+benchmarks! {
+	transfer_asset_via_bridge {
+		let _ = T::TransferAssetOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+		// every asset has its own configuration and ledger, so there's a performance dependency
+		// (be sure to use "worst" of assets)
+		let max_assets_limit = T::MaxAssetsLimit::get();
+		ensure!(max_assets_limit > 0, "MaxAssetsLimit not set up correctly.");
+		let (bridged_network, bridge_config) = T::BenchmarkHelper::bridge_config()
+			.ok_or(BenchmarkError::Stop("missing `bridge_config` data"))?;
+		let (origin, assets, destination) = T::BenchmarkHelper::prepare_asset_transfer()
+			.ok_or(BenchmarkError::Stop("missing `prepare_asset_transfer` data"))?;
+		let assets_count = match &assets {
+			VersionedMultiAssets::V2(assets) => assets.len(),
+			VersionedMultiAssets::V3(assets) => assets.len(),
+		};
+		ensure!(assets_count == max_assets_limit as usize, "`assets` not set up correctly for worst case.");
+		AllowedExporters::<T>::insert(bridged_network, bridge_config);
+	}: _<T::RuntimeOrigin>(origin, Box::new(assets), Box::new(destination))
+	verify {
+		// we don't care about message hash or sender cost here, just check that the transfer has been initiated
+		let actual_event = frame_system::Pallet::<T>::events().pop().map(|r| r.event);
+		let expected_event: <T as Config>::RuntimeEvent = Event::TransferInitiated {
+			message_hash: Default::default(),
+			sender_cost: Default::default(),
+		}.into();
+		assert!(matches!(actual_event, Some(expected_event)));
+	}
+
+	ping_via_bridge {
+		let _ = T::TransferPingOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+
+		let (bridged_network, bridge_config) = T::BenchmarkHelper::bridge_config()
+			.ok_or(BenchmarkError::Stop("missing `bridge_config` data"))?;
+		AllowedExporters::<T>::insert(bridged_network, bridge_config);
+
+		let (origin, destination) = T::BenchmarkHelper::prepare_ping_transfer()
+			.ok_or(BenchmarkError::Stop("missing `prepare_ping_transfer` data"))?;
+
+		let origin_location = T::TransferPingOrigin::ensure_origin(origin.clone()).map_err(|_| BenchmarkError::Stop("invalid `origin`"),
+		)?;
+		let (_, _, destination_location) = Pallet::<T>::ensure_remote_destination(destination.clone()).map_err(|_|
+			BenchmarkError::Stop("invalid `destination_location`"),
+		)?;
+		let _ = T::PingMessageBuilder::try_build(&origin_location, &bridged_network, &destination_location).ok_or(
+			BenchmarkError::Stop("invalid `PingMessageBuilder`"),
+		)?;
+	}: _<T::RuntimeOrigin>(origin, Box::new(destination))
+	verify {
+		// we don't care about message hash or sender cost here, just check that the transfer has been initiated
+		let actual_event = frame_system::Pallet::<T>::events().pop().map(|r| r.event);
+		let expected_event: <T as Config>::RuntimeEvent = Event::TransferInitiated {
+			message_hash: Default::default(),
+			sender_cost: Default::default(),
+		}.into();
+		assert!(matches!(actual_event, Some(expected_event)));
+	}
+
+	add_exporter_config {
+		let origin = T::AdminOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+		let (bridged_network, bridge_config) = T::BenchmarkHelper::bridge_config()
+			.ok_or(BenchmarkError::Stop("missing `bridge_config` data"))?;
+	}: _<T::RuntimeOrigin>(origin, bridged_network, Box::new(bridge_config.clone()))
+	verify {
+		assert_eq!(AllowedExporters::<T>::get(bridged_network), Some(bridge_config));
+	}
+
+	remove_exporter_config {
+		let origin = T::AdminOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+		let (bridged_network, bridge_config) = T::BenchmarkHelper::bridge_config()
+			.ok_or(BenchmarkError::Stop("missing `bridge_config` data"))?;
+		AllowedExporters::<T>::insert(bridged_network, bridge_config);
+	}: _<T::RuntimeOrigin>(origin, bridged_network)
+	verify {
+		assert_eq!(AllowedExporters::<T>::get(bridged_network), None);
+	}
+
+	update_exporter_config {
+		let origin = T::AdminOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+		let (bridged_network, bridge_config) = T::BenchmarkHelper::bridge_config()
+			.ok_or(BenchmarkError::Stop("missing `bridge_config` data"))?;
+		AllowedExporters::<T>::insert(bridged_network, bridge_config);
+
+		let bridge_location_fee = None;
+		let target_location_fee = Some(xcm::VersionedMultiAsset::V3(MultiAsset {
+			id: Concrete(MultiLocation::parent()),
+			fun: Fungible(1_000_0000),
+		}));
+	}: _<T::RuntimeOrigin>(origin, bridged_network, bridge_location_fee.clone().map(Box::new), target_location_fee.clone().map(Box::new))
+	verify {
+		let exporter = AllowedExporters::<T>::get(bridged_network).unwrap();
+		assert_eq!(exporter.bridge_location_fee, bridge_location_fee.map(|fee| MultiAsset::try_from(fee).unwrap()));
+		assert_eq!(exporter.max_target_location_fee, target_location_fee.map(|fee| MultiAsset::try_from(fee).unwrap()));
+	}
+
+	add_universal_alias {
+		let origin = T::AdminOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+		let (location, junction) = match T::BenchmarkHelper::universal_alias() {
+			Some(alias) => alias,
+			None => match T::UniversalAliasesLimit::get() > 0_u32 {
+				true => return Err(BenchmarkError::Stop("missing `universal_alias` data")),
+				false => return Err(BenchmarkError::Weightless),
+			}
+		};
+	}: _<T::RuntimeOrigin>(origin, Box::new(location.clone()), junction)
+	verify {
+		assert!(AllowedUniversalAliases::<T>::get(&location.try_as().unwrap()).contains(&junction));
+	}
+
+	remove_universal_alias {
+		let origin = T::AdminOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+		let (location, junction) = match T::BenchmarkHelper::universal_alias() {
+			Some(alias) => alias,
+			None => match T::UniversalAliasesLimit::get() > 0_u32 {
+				true => return Err(BenchmarkError::Stop("missing `universal_alias` data")),
+				false => return Err(BenchmarkError::Weightless),
+			}
+		};
+		Pallet::<T>::insert_universal_alias_for_benchmarks((location.clone().try_into().unwrap(), junction));
+	}: _<T::RuntimeOrigin>(origin, Box::new(location.clone()), vec![junction.clone()])
+	verify {
+		assert!(!AllowedUniversalAliases::<T>::get(&location.try_as().unwrap()).contains(&junction));
+	}
+
+	add_reserve_location {
+		let origin = T::AdminOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+		let location = match T::BenchmarkHelper::reserve_location() {
+			Some(location) => location,
+			None => match T::ReserveLocationsLimit::get() > 0_u32 {
+				true => return Err(BenchmarkError::Stop("missing `reserve_location` data")),
+				false => return Err(BenchmarkError::Weightless),
+			}
+		};
+	}: _<T::RuntimeOrigin>(origin, Box::new(location.clone()))
+	verify {
+		assert!(AllowedReserveLocations::<T>::get().contains(&location.try_as().unwrap()));
+	}
+
+	remove_reserve_location {
+		let origin = T::AdminOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+		let location = match T::BenchmarkHelper::reserve_location() {
+			Some(location) => location,
+			None => match T::ReserveLocationsLimit::get() > 0_u32 {
+				true => return Err(BenchmarkError::Stop("missing `reserve_location` data")),
+				false => return Err(BenchmarkError::Weightless),
+			}
+		};
+		let multilocation: MultiLocation = location.clone().try_into().unwrap();
+		assert!(AllowedReserveLocations::<T>::try_mutate(|locations| locations.try_insert(multilocation)).unwrap());
+	}: _<T::RuntimeOrigin>(origin, vec![location.clone()])
+	verify {
+		assert!(!AllowedReserveLocations::<T>::get().contains(&location.try_as().unwrap()));
+	}
+
+	impl_benchmark_test_suite!(Pallet, crate::tests::new_test_ext(), crate::tests::TestRuntime);
+}

parachains/pallets/bridge-transfer/src/impls.rs

@@ -0,0 +1,56 @@
+// Copyright (C) 2023 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::{Config, Pallet};
+use frame_support::traits::{Contains, ContainsPair};
+use xcm::prelude::*;
+use xcm_builder::ExporterFor;
+
+/// `ExporterFor` implementation to check if we can transfer anything to `NetworkId`
+impl<T: Config> ExporterFor for Pallet<T> {
+	fn exporter_for(
+		network: &NetworkId,
+		_remote_location: &InteriorMultiLocation,
+		_message: &Xcm<()>,
+	) -> Option<(MultiLocation, Option<MultiAsset>)> {
+		Self::allowed_exporters(network)
+			.map(|bridge_config| (bridge_config.bridge_location, bridge_config.bridge_location_fee))
+	}
+}
+
+/// Verifies if we have `(MultiLocation, Junction)` in allowed universal aliases.
+pub struct AllowedUniversalAliasesOf<T>(sp_std::marker::PhantomData<T>);
+impl<T: Config> Contains<(MultiLocation, Junction)> for AllowedUniversalAliasesOf<T> {
+	fn contains((location, junction): &(MultiLocation, Junction)) -> bool {
+		log::trace!(target: "xcm::contains", "AllowedUniversalAliasesOf location: {:?}, junction: {:?}", location, junction);
+		Pallet::<T>::allowed_universal_aliases(location).contains(junction)
+	}
+}
+
+/// Verifies if we can allow `(MultiAsset, MultiLocation)` as trusted reserve.
+pub struct IsAllowedReserveOf<T, F>(sp_std::marker::PhantomData<(T, F)>);
+impl<T: Config, F: ContainsPair<MultiAsset, MultiLocation>> ContainsPair<MultiAsset, MultiLocation>
+	for IsAllowedReserveOf<T, F>
+{
+	fn contains(asset: &MultiAsset, origin: &MultiLocation) -> bool {
+		log::trace!(target: "xcm::contains", "IsAllowedReserveOf asset: {:?}, origin: {:?}", asset, origin);
+		// first check - if we have configured origin as trusted reserve location
+		if !Pallet::<T>::allowed_reserve_locations().contains(origin) {
+			return false
+		}
+		// second check - we need to pass additional `(asset, origin)` filter
+		F::contains(asset, origin)
+	}
+}