Implement a blocking barrier for XCMv3

bridges/bin/rialto-parachain/runtime/src/lib.rs

@@ -69,7 +69,7 @@ use polkadot_parachain::primitives::Sibling;
 use xcm::latest::prelude::*;
 use xcm_builder::{
 	AccountId32Aliases, AllowTopLevelPaidExecutionFrom, AllowUnpaidExecutionFrom, CurrencyAdapter,
-	EnsureXcmOrigin, FixedWeightBounds, IsConcrete, LocationInverter, NativeAsset,
+	EnsureXcmOrigin, FixedWeightBounds, IsConcrete, NativeAsset,
 	ParentAsSuperuser, ParentIsPreset, RelayChainAsNative, SiblingParachainAsNative,
 	SiblingParachainConvertsVia, SignedAccountId32AsNative, SignedToAccountId32,
 	SovereignSignedViaLocation, TakeWeightCredit, UsingComponents,
@@ -289,7 +289,7 @@ parameter_types! {
 	pub const RelayLocation: MultiLocation = MultiLocation::parent();
 	pub const RelayNetwork: NetworkId = NetworkId::Polkadot;
 	pub RelayOrigin: Origin = cumulus_pallet_xcm::Origin::Relay.into();
-	pub Ancestry: MultiLocation = Parachain(ParachainInfo::parachain_id().into()).into();
+	pub UniversalLocation: InteriorMultiLocation = Parachain(ParachainInfo::parachain_id().into()).into();
 }
 
 /// Type for specifying how a `MultiLocation` can be converted into an `AccountId`. This is used
@@ -374,12 +374,14 @@ impl Config for XcmConfig {
 	type OriginConverter = XcmOriginToTransactDispatchOrigin;
 	type IsReserve = NativeAsset;
 	type IsTeleporter = NativeAsset; // <- should be enough to allow teleportation of UNIT
-	type LocationInverter = LocationInverter<Ancestry>;
+	type UniversalLocation = UniversalLocation;
 	type Barrier = Barrier;
 	type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;
 	type Trader = UsingComponents<IdentityFee<Balance>, RelayLocation, AccountId, Balances, ()>;
 	type ResponseHandler = PolkadotXcm;
 	type AssetTrap = PolkadotXcm;
+	type AssetLocker = ();
+	type AssetExchanger = ();
 	type AssetClaims = PolkadotXcm;
 	type SubscriptionService = PolkadotXcm;
 }
@@ -406,7 +408,7 @@ impl pallet_xcm::Config for Runtime {
 	type XcmTeleportFilter = Everything;
 	type XcmReserveTransferFilter = Everything;
 	type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;
-	type LocationInverter = LocationInverter<Ancestry>;
+	type UniversalLocation = UniversalLocation;
 	type Origin = Origin;
 	type Call = Call;
 	const VERSION_DISCOVERY_QUEUE_SIZE: u32 = 100;

bridges/primitives/chain-rococo/src/lib.rs

@@ -43,7 +43,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
 	spec_name: sp_version::create_runtime_str!("rococo"),
 	impl_name: sp_version::create_runtime_str!("parity-rococo-v2.0"),
 	authoring_version: 0,
-	spec_version: 9180,
+	spec_version: 9190,
 	impl_version: 0,
 	apis: sp_version::create_apis_vec![[]],
 	transaction_version: 0,

node/core/pvf/src/host.rs

@@ -328,7 +328,7 @@ async fn run(
 		futures::select_biased! {
 			() = cleanup_pulse.select_next_some() => {
 				// `select_next_some` because we don't expect this to fail, but if it does, we
-				// still don't fail. The tradeoff is that the compiled cache will start growing
+				// still don't fail. The trade-off is that the compiled cache will start growing
 				// in size. That is, however, rather a slow process and hopefully the operator
 				// will notice it.
 

node/network/protocol/src/request_response/mod.rs

@@ -104,7 +104,7 @@ const STATEMENTS_TIMEOUT: Duration = Duration::from_secs(1);
 
 /// We don't want a slow peer to slow down all the others, at the same time we want to get out the
 /// data quickly in full to at least some peers (as this will reduce load on us as they then can
-/// start serving the data). So this value is a tradeoff. 3 seems to be sensible. So we would need
+/// start serving the data). So this value is a trade-off. 3 seems to be sensible. So we would need
 /// to have 3 slow nodes connected, to delay transfer for others by `STATEMENTS_TIMEOUT`.
 pub const MAX_PARALLEL_STATEMENT_REQUESTS: u32 = 3;
 

runtime/common/src/xcm_sender.rs

@@ -16,34 +16,71 @@
 
 //! XCM sender for relay chain.
 
+use frame_support::traits::Get;
 use parity_scale_codec::Encode;
-use runtime_parachains::{configuration, dmp};
-use sp_std::marker::PhantomData;
-use xcm::latest::prelude::*;
+use primitives::v2::Id as ParaId;
+use runtime_parachains::{
+	configuration::{self, HostConfiguration},
+	dmp,
+};
+use sp_std::{marker::PhantomData, prelude::*};
+use xcm::prelude::*;
+use SendError::*;
+
+pub trait PriceForParachainDelivery {
+	fn price_for_parachain_delivery(para: ParaId, message: &Xcm<()>) -> MultiAssets;
+}
+impl PriceForParachainDelivery for () {
+	fn price_for_parachain_delivery(_: ParaId, _: &Xcm<()>) -> MultiAssets {
+		MultiAssets::new()
+	}
+}
+
+pub struct ConstantPrice<T>(sp_std::marker::PhantomData<T>);
+impl<T: Get<MultiAssets>> PriceForParachainDelivery for ConstantPrice<T> {
+	fn price_for_parachain_delivery(_: ParaId, _: &Xcm<()>) -> MultiAssets {
+		T::get()
+	}
+}
 
 /// XCM sender for relay chain. It only sends downward message.
-pub struct ChildParachainRouter<T, W>(PhantomData<(T, W)>);
+pub struct ChildParachainRouter<T, W, P>(PhantomData<(T, W, P)>);
 
-impl<T: configuration::Config + dmp::Config, W: xcm::WrapVersion> SendXcm
-	for ChildParachainRouter<T, W>
+impl<T: configuration::Config + dmp::Config, W: xcm::WrapVersion, P: PriceForParachainDelivery>
+	SendXcm for ChildParachainRouter<T, W, P>
 {
-	fn send_xcm(dest: impl Into<MultiLocation>, msg: Xcm<()>) -> SendResult {
-		let dest = dest.into();
-		match dest {
-			MultiLocation { parents: 0, interior: X1(Parachain(id)) } => {
-				// Downward message passing.
-				let versioned_xcm =
-					W::wrap_version(&dest, msg).map_err(|()| SendError::DestinationUnsupported)?;
-				let config = <configuration::Pallet<T>>::config();
-				<dmp::Pallet<T>>::queue_downward_message(
-					&config,
-					id.into(),
-					versioned_xcm.encode(),
-				)
-				.map_err(Into::<SendError>::into)?;
-				Ok(())
-			},
-			dest => Err(SendError::CannotReachDestination(dest, msg)),
-		}
+	type Ticket = (HostConfiguration<T::BlockNumber>, ParaId, Vec<u8>);
+
+	fn validate(
+		dest: &mut Option<MultiLocation>,
+		msg: &mut Option<Xcm<()>>,
+	) -> SendResult<(HostConfiguration<T::BlockNumber>, ParaId, Vec<u8>)> {
+		let d = dest.take().ok_or(MissingArgument)?;
+		let id = if let MultiLocation { parents: 0, interior: X1(Parachain(id)) } = &d {
+			*id
+		} else {
+			*dest = Some(d);
+			return Err(NotApplicable)
+		};
+
+		// Downward message passing.
+		let xcm = msg.take().ok_or(MissingArgument)?;
+		let config = <configuration::Pallet<T>>::config();
+		let para = id.into();
+		let price = P::price_for_parachain_delivery(para, &xcm);
+		let blob = W::wrap_version(&d, xcm).map_err(|()| DestinationUnsupported)?.encode();
+		<dmp::Pallet<T>>::can_queue_downward_message(&config, &para, &blob)
+			.map_err(Into::<SendError>::into)?;
+
+		Ok(((config, para, blob), price))
+	}
+
+	fn deliver(
+		(config, para, blob): (HostConfiguration<T::BlockNumber>, ParaId, Vec<u8>),
+	) -> Result<XcmHash, SendError> {
+		let hash = sp_io::hashing::blake2_256(&blob[..]);
+		<dmp::Pallet<T>>::queue_downward_message(&config, para, blob)
+			.map(|()| hash)
+			.map_err(|_| SendError::Transport(&"Error placing into DMP queue"))
 	}
 }

runtime/kusama/src/lib.rs

@@ -1988,7 +1988,7 @@ sp_api::impl_runtime_apis! {
 			use frame_system_benchmarking::Pallet as SystemBench;
 			use frame_benchmarking::baseline::Pallet as Baseline;
 			use xcm::latest::prelude::*;
-			use xcm_config::{CheckAccount, KsmLocation, SovereignAccountOf, Statemine, XcmConfig};
+			use xcm_config::{CheckAccount, SovereignAccountOf, Statemine, TokenLocation, XcmConfig};
 
 			impl pallet_session_benchmarking::Config for Runtime {}
 			impl pallet_offences_benchmarking::Config for Runtime {}
@@ -2002,10 +2002,10 @@ sp_api::impl_runtime_apis! {
 				fn valid_destination() -> Result<MultiLocation, BenchmarkError> {
 					Ok(Statemine::get())
 				}
-				fn worst_case_holding() -> MultiAssets {
+				fn worst_case_holding(_depositable_count: u32) -> MultiAssets {
 					// Kusama only knows about KSM.
 					vec![MultiAsset{
-						id: Concrete(KsmLocation::get()),
+						id: Concrete(TokenLocation::get()),
 						fun: Fungible(1_000_000 * UNITS),
 					}].into()
 				}
@@ -2014,11 +2014,7 @@ sp_api::impl_runtime_apis! {
 			parameter_types! {
 				pub const TrustedTeleporter: Option<(MultiLocation, MultiAsset)> = Some((
 					Statemine::get(),
-					MultiAsset { fun: Fungible(1 * UNITS), id: Concrete(KsmLocation::get()) },
-				));
-				pub const TrustedReserve: Option<(MultiLocation, MultiAsset)> = Some((
-					Statemine::get(),
-					MultiAsset { fun: Fungible(1 * UNITS), id: Concrete(KsmLocation::get()) },
+					MultiAsset { fun: Fungible(1 * UNITS), id: Concrete(TokenLocation::get()) },
 				));
 			}
 
@@ -2027,11 +2023,10 @@ sp_api::impl_runtime_apis! {
 
 				type CheckedAccount = CheckAccount;
 				type TrustedTeleporter = TrustedTeleporter;
-				type TrustedReserve = TrustedReserve;
 
 				fn get_multi_asset() -> MultiAsset {
 					MultiAsset {
-						id: Concrete(KsmLocation::get()),
+						id: Concrete(TokenLocation::get()),
 						fun: Fungible(1 * UNITS),
 					}
 				}
@@ -2044,6 +2039,16 @@ sp_api::impl_runtime_apis! {
 					(0u64, Response::Version(Default::default()))
 				}
 
+				fn worst_case_asset_exchange() -> Result<(MultiAssets, MultiAssets), BenchmarkError> {
+					// Kusama doesn't support asset exchanges
+					Err(BenchmarkError::Skip)
+				}
+
+				fn universal_alias() -> Result<Junction, BenchmarkError> {
+					// The XCM executor of Kusama doesn't have a configured `UniversalAliases`
+					Err(BenchmarkError::Skip)
+				}
+
 				fn transact_origin() -> Result<MultiLocation, BenchmarkError> {
 					Ok(Statemine::get())
 				}
@@ -2054,10 +2059,15 @@ sp_api::impl_runtime_apis! {
 
 				fn claimable_asset() -> Result<(MultiLocation, MultiLocation, MultiAssets), BenchmarkError> {
 					let origin = Statemine::get();
-					let assets: MultiAssets = (Concrete(KsmLocation::get()), 1_000 * UNITS).into();
+					let assets: MultiAssets = (Concrete(TokenLocation::get()), 1_000 * UNITS).into();
 					let ticket = MultiLocation { parents: 0, interior: Here };
 					Ok((origin, ticket, assets))
 				}
+
+				fn unlockable_asset() -> Result<(MultiLocation, MultiLocation, MultiAsset), BenchmarkError> {
+					// Kusama doesn't support asset locking
+					Err(BenchmarkError::Skip)
+				}
 			}
 
 			let whitelist: Vec<TrackedStorageKey> = vec![

runtime/kusama/src/weights/xcm/mod.rs

@@ -75,7 +75,12 @@ impl<Call> XcmWeightInfo<Call> for KusamaXcmWeight<Call> {
 	fn receive_teleported_asset(assets: &MultiAssets) -> Weight {
 		assets.weigh_multi_assets(XcmBalancesWeight::<Runtime>::receive_teleported_asset())
 	}
-	fn query_response(_query_id: &u64, _response: &Response, _max_weight: &u64) -> Weight {
+	fn query_response(
+		_query_id: &u64,
+		_response: &Response,
+		_max_weight: &u64,
+		_querier: &Option<MultiLocation>,
+	) -> Weight {
 		XcmGeneric::<Runtime>::query_response()
 	}
 	fn transfer_asset(assets: &MultiAssets, _dest: &MultiLocation) -> Weight {
@@ -117,31 +122,23 @@ impl<Call> XcmWeightInfo<Call> for KusamaXcmWeight<Call> {
 	fn descend_origin(_who: &InteriorMultiLocation) -> Weight {
 		XcmGeneric::<Runtime>::descend_origin()
 	}
-	fn report_error(
-		_query_id: &QueryId,
-		_dest: &MultiLocation,
-		_max_response_weight: &u64,
-	) -> Weight {
+	fn report_error(_query_response_info: &QueryResponseInfo) -> Weight {
 		XcmGeneric::<Runtime>::report_error()
 	}
 
-	fn deposit_asset(
-		assets: &MultiAssetFilter,
-		_max_assets: &u32, // TODO use max assets?
-		_dest: &MultiLocation,
-	) -> Weight {
+	fn deposit_asset(assets: &MultiAssetFilter, _dest: &MultiLocation) -> Weight {
 		assets.weigh_multi_assets(XcmBalancesWeight::<Runtime>::deposit_asset())
 	}
 	fn deposit_reserve_asset(
 		assets: &MultiAssetFilter,
-		_max_assets: &u32, // TODO use max assets?
 		_dest: &MultiLocation,
 		_xcm: &Xcm<()>,
 	) -> Weight {
 		assets.weigh_multi_assets(XcmBalancesWeight::<Runtime>::deposit_reserve_asset())
 	}
-	fn exchange_asset(_give: &MultiAssetFilter, _receive: &MultiAssets) -> Weight {
-		Weight::MAX // todo fix
+	fn exchange_asset(_give: &MultiAssetFilter, _receive: &MultiAssets, _maximal: &bool) -> Weight {
+		// Kusama does not currently support exchange asset operations
+		Weight::MAX
 	}
 	fn initiate_reserve_withdraw(
 		assets: &MultiAssetFilter,
@@ -157,13 +154,8 @@ impl<Call> XcmWeightInfo<Call> for KusamaXcmWeight<Call> {
 	) -> Weight {
 		assets.weigh_multi_assets(XcmBalancesWeight::<Runtime>::initiate_teleport())
 	}
-	fn query_holding(
-		_query_id: &u64,
-		_dest: &MultiLocation,
-		_assets: &MultiAssetFilter,
-		_max_response_weight: &u64,
-	) -> Weight {
-		XcmGeneric::<Runtime>::query_holding()
+	fn report_holding(_response_info: &QueryResponseInfo, _assets: &MultiAssetFilter) -> Weight {
+		XcmGeneric::<Runtime>::report_holding()
 	}
 	fn buy_execution(_fees: &MultiAsset, _weight_limit: &WeightLimit) -> Weight {
 		XcmGeneric::<Runtime>::buy_execution()
@@ -192,4 +184,70 @@ impl<Call> XcmWeightInfo<Call> for KusamaXcmWeight<Call> {
 	fn unsubscribe_version() -> Weight {
 		XcmGeneric::<Runtime>::unsubscribe_version()
 	}
+	fn burn_asset(assets: &MultiAssets) -> Weight {
+		assets.weigh_multi_assets(XcmGeneric::<Runtime>::burn_asset())
+	}
+	fn expect_asset(assets: &MultiAssets) -> Weight {
+		assets.weigh_multi_assets(XcmGeneric::<Runtime>::expect_asset())
+	}
+	fn expect_origin(_origin: &Option<MultiLocation>) -> Weight {
+		XcmGeneric::<Runtime>::expect_origin()
+	}
+	fn expect_error(_error: &Option<(u32, XcmError)>) -> Weight {
+		XcmGeneric::<Runtime>::expect_error()
+	}
+	fn query_pallet(_module_name: &Vec<u8>, _response_info: &QueryResponseInfo) -> Weight {
+		XcmGeneric::<Runtime>::query_pallet()
+	}
+	fn expect_pallet(
+		_index: &u32,
+		_name: &Vec<u8>,
+		_module_name: &Vec<u8>,
+		_crate_major: &u32,
+		_min_crate_minor: &u32,
+	) -> Weight {
+		XcmGeneric::<Runtime>::expect_pallet()
+	}
+	fn report_transact_status(_response_info: &QueryResponseInfo) -> Weight {
+		XcmGeneric::<Runtime>::report_transact_status()
+	}
+	fn clear_transact_status() -> Weight {
+		XcmGeneric::<Runtime>::clear_transact_status()
+	}
+	fn universal_origin(_: &Junction) -> Weight {
+		// Kusama does not currently support universal origin operations
+		Weight::MAX
+	}
+	fn export_message(_: &NetworkId, _: &Junctions, _: &Xcm<()>) -> Weight {
+		Weight::MAX // todo fix
+	}
+	fn lock_asset(_: &MultiAsset, _: &MultiLocation) -> Weight {
+		// Kusama does not currently support asset locking operations
+		Weight::MAX
+	}
+	fn unlock_asset(_: &MultiAsset, _: &MultiLocation) -> Weight {
+		// Kusama does not currently support asset locking operations
+		Weight::MAX
+	}
+	fn note_unlockable(_: &MultiAsset, _: &MultiLocation) -> Weight {
+		// Kusama does not currently support asset locking operations
+		Weight::MAX
+	}
+	fn request_unlock(_: &MultiAsset, _: &MultiLocation) -> Weight {
+		// Kusama does not currently support asset locking operations
+		Weight::MAX
+	}
+	fn set_fees_mode(_: &bool) -> Weight {
+		XcmGeneric::<Runtime>::set_fees_mode()
+	}
+	fn set_topic(_topic: &[u8; 32]) -> Weight {
+		XcmGeneric::<Runtime>::set_topic()
+	}
+	fn clear_topic() -> Weight {
+		XcmGeneric::<Runtime>::clear_topic()
+	}
+	fn alias_origin(_: &MultiLocation) -> Weight {
+		// XCM Executor does not currently support alias origin operations
+		Weight::MAX
+	}
 }