[Feature] Add XCM benchmark weights to Statemint and Statemine

parachains/runtimes/assets/statemine/Cargo.toml

@@ -71,6 +71,7 @@ cumulus-primitives-utility = { path = "../../../../primitives/utility", default-
 pallet-collator-selection = { path = "../../../../pallets/collator-selection", default-features = false }
 parachain-info = { path = "../../../pallets/parachain-info", default-features = false }
 parachains-common = { path = "../../../common", default-features = false }
+pallet-xcm-benchmarks = { git = "https://github.com/paritytech/polkadot", branch = "master", default-features = false, optional = true }
 
 
 [dev-dependencies]
@@ -101,6 +102,7 @@ runtime-benchmarks = [
 	"cumulus-pallet-session-benchmarking/runtime-benchmarks",
 	"pallet-collator-selection/runtime-benchmarks",
 	"cumulus-pallet-xcmp-queue/runtime-benchmarks",
+	"pallet-xcm-benchmarks",
 ]
 try-runtime = [
 	"frame-executive/try-runtime",

parachains/runtimes/assets/statemine/src/lib.rs

@@ -638,6 +638,10 @@ mod benches {
 		[pallet_timestamp, Timestamp]
 		[pallet_collator_selection, CollatorSelection]
 		[cumulus_pallet_xcmp_queue, XcmpQueue]
+		// XCM
+		// NOTE: Make sure you point to the individual modules below.
+		[pallet_xcm_benchmarks::fungible, XcmBalances]
+		[pallet_xcm_benchmarks::generic, XcmGeneric]
 	);
 }
 
@@ -789,6 +793,12 @@ impl_runtime_apis! {
 			use frame_system_benchmarking::Pallet as SystemBench;
 			use cumulus_pallet_session_benchmarking::Pallet as SessionBench;
 
+			// This is defined once again in dispatch_benchmark, because list_benchmarks!
+			// and add_benchmarks! are macros exported by define_benchmarks! macros and those types
+			// are referenced in that call.
+			type XcmBalances = pallet_xcm_benchmarks::fungible::Pallet::<Runtime>;
+			type XcmGeneric = pallet_xcm_benchmarks::generic::Pallet::<Runtime>;
+
 			let mut list = Vec::<BenchmarkList>::new();
 			list_benchmarks!(list, extra);
 
@@ -799,14 +809,104 @@ impl_runtime_apis! {
 		fn dispatch_benchmark(
 			config: frame_benchmarking::BenchmarkConfig
 		) -> Result<Vec<frame_benchmarking::BenchmarkBatch>, sp_runtime::RuntimeString> {
-			use frame_benchmarking::{Benchmarking, BenchmarkBatch, TrackedStorageKey};
+			use frame_benchmarking::{Benchmarking, BenchmarkBatch, BenchmarkError,
+				TrackedStorageKey};
 
 			use frame_system_benchmarking::Pallet as SystemBench;
 			impl frame_system_benchmarking::Config for Runtime {}
 
 			use cumulus_pallet_session_benchmarking::Pallet as SessionBench;
 			impl cumulus_pallet_session_benchmarking::Config for Runtime {}
 
+			use xcm::latest::prelude::*;
+			use xcm_config::KsmLocation;
+			use pallet_xcm_benchmarks::asset_instance_from;
+
+			impl pallet_xcm_benchmarks::Config for Runtime {
+				type XcmConfig = xcm_config::XcmConfig;
+				type AccountIdConverter = xcm_config::LocationToAccountId;
+				fn valid_destination() -> Result<MultiLocation, BenchmarkError> {
+					Ok(KsmLocation::get())
+				}
+				fn worst_case_holding() -> MultiAssets {
+					// A mix of fungible, non-fungible, and concrete assets.
+					const HOLDING_FUNGIBLES: u32 = 100;
+					const HOLDING_NON_FUNGIBLES: u32 = 100;
+					let fungibles_amount: u128 = 100;
+					let mut assets = (0..HOLDING_FUNGIBLES)
+						.map(|i| {
+							MultiAsset {
+								id: Concrete(GeneralIndex(i as u128).into()),
+								fun: Fungible(fungibles_amount * i as u128),
+							}
+							.into()
+						})
+						.chain(core::iter::once(MultiAsset { id: Concrete(Here.into()), fun: Fungible(u128::MAX) }))
+						.chain((0..HOLDING_NON_FUNGIBLES).map(|i| MultiAsset {
+							id: Concrete(GeneralIndex(i as u128).into()),
+							fun: NonFungible(asset_instance_from(i)),
+						}))
+						.collect::<Vec<_>>();
+
+						assets.push(MultiAsset{
+							id: Concrete(KsmLocation::get()),
+							fun: Fungible(1_000_000 * UNITS),
+						});
+						assets.into()
+				}
+			}
+
+			parameter_types! {
+				pub const TrustedTeleporter: Option<(MultiLocation, MultiAsset)> = Some((
+					KsmLocation::get(),
+					MultiAsset { fun: Fungible(1 * UNITS), id: Concrete(KsmLocation::get()) },
+				));
+				pub const TrustedReserve: Option<(MultiLocation, MultiAsset)> = None;
+				pub const CheckedAccount: Option<AccountId> = None;
+
+			}
+
+			impl pallet_xcm_benchmarks::fungible::Config for Runtime {
+				type TransactAsset = Balances;
+
+				type CheckedAccount = CheckedAccount;
+				type TrustedTeleporter = TrustedTeleporter;
+				type TrustedReserve = TrustedReserve;
+
+				fn get_multi_asset() -> MultiAsset {
+					MultiAsset {
+						id: Concrete(KsmLocation::get()),
+						fun: Fungible(1 * UNITS),
+					}
+				}
+			}
+
+			impl pallet_xcm_benchmarks::generic::Config for Runtime {
+				type Call = Call;
+
+				fn worst_case_response() -> (u64, Response) {
+					(0u64, Response::Version(Default::default()))
+				}
+
+				fn transact_origin() -> Result<MultiLocation, BenchmarkError> {
+					Ok(KsmLocation::get())
+				}
+
+				fn subscribe_origin() -> Result<MultiLocation, BenchmarkError> {
+					Ok(KsmLocation::get())
+				}
+
+				fn claimable_asset() -> Result<(MultiLocation, MultiLocation, MultiAssets), BenchmarkError> {
+					let origin = KsmLocation::get();
+					let assets: MultiAssets = (Concrete(KsmLocation::get()), 1_000 * UNITS).into();
+					let ticket = MultiLocation { parents: 0, interior: Here };
+					Ok((origin, ticket, assets))
+				}
+			}
+
+			type XcmBalances = pallet_xcm_benchmarks::fungible::Pallet::<Runtime>;
+			type XcmGeneric = pallet_xcm_benchmarks::generic::Pallet::<Runtime>;
+
 			let whitelist: Vec<TrackedStorageKey> = vec![
 				// Block Number
 				hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef702a5c1b19ab7a04f536c519aca4983ac").to_vec().into(),
@@ -818,13 +918,14 @@ impl_runtime_apis! {
 				hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef70a98fdbe9ce6c55837576c60c7af3850").to_vec().into(),
 				// System Events
 				hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef780d41e5e16056765bc8461851072c9d7").to_vec().into(),
+				//TODO: use from relay_well_known_keys::ACTIVE_CONFIG
+				hex_literal::hex!("06de3d8a54d27e44a9d5ce189618f22db4b49d95320d9021994c850f25b8e385").to_vec().into(),
 			];
 
 			let mut batches = Vec::<BenchmarkBatch>::new();
 			let params = (&config, &whitelist);
 			add_benchmarks!(params, batches);
 
-			if batches.is_empty() { return Err("Benchmark not found for this pallet.".into()) }
 			Ok(batches)
 		}
 	}

parachains/runtimes/assets/statemine/src/weights/mod.rs

@@ -13,6 +13,7 @@ pub mod pallet_uniques;
 pub mod pallet_utility;
 pub mod paritydb_weights;
 pub mod rocksdb_weights;
+pub mod xcm;
 
 pub use block_weights::constants::BlockExecutionWeight;
 pub use extrinsic_weights::constants::ExtrinsicBaseWeight;

parachains/runtimes/assets/statemine/src/weights/xcm/mod.rs

@@ -0,0 +1,182 @@
+// Copyright 2022 Parity Technologies (UK) Ltd.
+// This file is part of Cumulus.
+
+// Cumulus is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Cumulus is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Cumulus.  If not, see <http://www.gnu.org/licenses/>.
+
+mod pallet_xcm_benchmarks_fungible;
+mod pallet_xcm_benchmarks_generic;
+
+use crate::Runtime;
+use frame_support::weights::Weight;
+use pallet_xcm_benchmarks_fungible::WeightInfo as XcmFungibleWeight;
+use pallet_xcm_benchmarks_generic::WeightInfo as XcmGeneric;
+use sp_std::prelude::*;
+use xcm::{
+	latest::{prelude::*, Weight as XCMWeight},
+	DoubleEncoded,
+};
+
+trait WeighMultiAssets {
+	fn weigh_multi_assets(&self, weight: Weight) -> XCMWeight;
+}
+
+const MAX_ASSETS: u32 = 100;
+
+impl WeighMultiAssets for MultiAssetFilter {
+	fn weigh_multi_assets(&self, weight: Weight) -> XCMWeight {
+		let weight = match self {
+			Self::Definite(assets) =>
+				weight.scalar_saturating_mul(assets.inner().into_iter().count() as u64),
+			Self::Wild(_) => weight.scalar_saturating_mul(MAX_ASSETS as u64),
+		};
+		weight.ref_time()
+	}
+}
+
+impl WeighMultiAssets for MultiAssets {
+	fn weigh_multi_assets(&self, weight: Weight) -> XCMWeight {
+		weight.scalar_saturating_mul(self.inner().into_iter().count() as u64).ref_time()
+	}
+}
+
+pub struct StatemineXcmWeight<Call>(core::marker::PhantomData<Call>);
+impl<Call> XcmWeightInfo<Call> for StatemineXcmWeight<Call> {
+	fn withdraw_asset(assets: &MultiAssets) -> XCMWeight {
+		assets.weigh_multi_assets(XcmFungibleWeight::<Runtime>::withdraw_asset())
+	}
+	// Currently there is no trusted reserve
+	fn reserve_asset_deposited(_assets: &MultiAssets) -> XCMWeight {
+		unimplemented!()
+	}
+	fn receive_teleported_asset(assets: &MultiAssets) -> XCMWeight {
+		assets.weigh_multi_assets(XcmFungibleWeight::<Runtime>::receive_teleported_asset())
+	}
+	fn query_response(_query_id: &u64, _response: &Response, _max_weight: &u64) -> XCMWeight {
+		XcmGeneric::<Runtime>::query_response().ref_time()
+	}
+	fn transfer_asset(assets: &MultiAssets, _dest: &MultiLocation) -> XCMWeight {
+		assets.weigh_multi_assets(XcmFungibleWeight::<Runtime>::transfer_asset())
+	}
+	fn transfer_reserve_asset(
+		assets: &MultiAssets,
+		_dest: &MultiLocation,
+		_xcm: &Xcm<()>,
+	) -> XCMWeight {
+		assets.weigh_multi_assets(XcmFungibleWeight::<Runtime>::transfer_reserve_asset())
+	}
+	fn transact(
+		_origin_type: &OriginKind,
+		_require_weight_at_most: &u64,
+		_call: &DoubleEncoded<Call>,
+	) -> XCMWeight {
+		XcmGeneric::<Runtime>::transact().ref_time()
+	}
+	fn hrmp_new_channel_open_request(
+		_sender: &u32,
+		_max_message_size: &u32,
+		_max_capacity: &u32,
+	) -> XCMWeight {
+		// XCM Executor does not currently support HRMP channel operations
+		Weight::MAX.ref_time()
+	}
+	fn hrmp_channel_accepted(_recipient: &u32) -> XCMWeight {
+		// XCM Executor does not currently support HRMP channel operations
+		Weight::MAX.ref_time()
+	}
+	fn hrmp_channel_closing(_initiator: &u32, _sender: &u32, _recipient: &u32) -> XCMWeight {
+		// XCM Executor does not currently support HRMP channel operations
+		Weight::MAX.ref_time()
+	}
+	fn clear_origin() -> XCMWeight {
+		XcmGeneric::<Runtime>::clear_origin().ref_time()
+	}
+	fn descend_origin(_who: &InteriorMultiLocation) -> XCMWeight {
+		XcmGeneric::<Runtime>::descend_origin().ref_time()
+	}
+	fn report_error(
+		_query_id: &QueryId,
+		_dest: &MultiLocation,
+		_max_response_weight: &u64,
+	) -> XCMWeight {
+		XcmGeneric::<Runtime>::report_error().ref_time()
+	}
+
+	fn deposit_asset(
+		assets: &MultiAssetFilter,
+		_max_assets: &u32,
+		_dest: &MultiLocation,
+	) -> XCMWeight {
+		assets.weigh_multi_assets(XcmFungibleWeight::<Runtime>::deposit_asset())
+	}
+	fn deposit_reserve_asset(
+		assets: &MultiAssetFilter,
+		_max_assets: &u32,
+		_dest: &MultiLocation,
+		_xcm: &Xcm<()>,
+	) -> XCMWeight {
+		assets.weigh_multi_assets(XcmFungibleWeight::<Runtime>::deposit_reserve_asset())
+	}
+	fn exchange_asset(_give: &MultiAssetFilter, _receive: &MultiAssets) -> XCMWeight {
+		Weight::MAX.ref_time()
+	}
+	fn initiate_reserve_withdraw(
+		assets: &MultiAssetFilter,
+		_reserve: &MultiLocation,
+		_xcm: &Xcm<()>,
+	) -> XCMWeight {
+		assets.weigh_multi_assets(XcmGeneric::<Runtime>::initiate_reserve_withdraw())
+	}
+	fn initiate_teleport(
+		assets: &MultiAssetFilter,
+		_dest: &MultiLocation,
+		_xcm: &Xcm<()>,
+	) -> XCMWeight {
+		assets.weigh_multi_assets(XcmFungibleWeight::<Runtime>::initiate_teleport())
+	}
+	fn query_holding(
+		_query_id: &u64,
+		_dest: &MultiLocation,
+		_assets: &MultiAssetFilter,
+		_max_response_weight: &u64,
+	) -> XCMWeight {
+		XcmGeneric::<Runtime>::query_holding().ref_time()
+	}
+	fn buy_execution(_fees: &MultiAsset, _weight_limit: &WeightLimit) -> XCMWeight {
+		XcmGeneric::<Runtime>::buy_execution().ref_time()
+	}
+	fn refund_surplus() -> XCMWeight {
+		XcmGeneric::<Runtime>::refund_surplus().ref_time()
+	}
+	fn set_error_handler(_xcm: &Xcm<Call>) -> XCMWeight {
+		XcmGeneric::<Runtime>::set_error_handler().ref_time()
+	}
+	fn set_appendix(_xcm: &Xcm<Call>) -> XCMWeight {
+		XcmGeneric::<Runtime>::set_appendix().ref_time()
+	}
+	fn clear_error() -> XCMWeight {
+		XcmGeneric::<Runtime>::clear_error().ref_time()
+	}
+	fn claim_asset(_assets: &MultiAssets, _ticket: &MultiLocation) -> XCMWeight {
+		XcmGeneric::<Runtime>::claim_asset().ref_time()
+	}
+	fn trap(_code: &u64) -> XCMWeight {
+		XcmGeneric::<Runtime>::trap().ref_time()
+	}
+	fn subscribe_version(_query_id: &QueryId, _max_response_weight: &u64) -> XCMWeight {
+		XcmGeneric::<Runtime>::subscribe_version().ref_time()
+	}
+	fn unsubscribe_version() -> XCMWeight {
+		XcmGeneric::<Runtime>::unsubscribe_version().ref_time()
+	}
+}