Initial draft and make pallet-xcm build

xcm/pallet-xcm/src/lib.rs

@@ -196,14 +196,11 @@ pub mod pallet {
 		/// - `dest_weight`: Equal to the total weight on `dest` of the XCM message
 		///   `Teleport { assets, effects: [ BuyExecution{..}, DepositAsset{..} ] }`.
 		#[pallet::weight({
-			let mut message = Xcm::WithdrawAsset {
-				assets: assets.clone(),
-				effects: sp_std::vec![ InitiateTeleport {
-					assets: Wild(All),
-					dest: *dest.clone(),
-					effects: sp_std::vec![],
-				} ]
-			};
+			use sp_std::vec;
+			let mut message = Xcm(vec![
+				WithdrawAsset { assets: assets.clone() },
+				InitiateTeleport { assets: Wild(All), dest: *dest.clone(), xcm: Xcm(vec![]) },
+			]);
 			T::Weigher::weight(&mut message).map_or(Weight::max_value(), |w| 100_000_000 + w)
 		})]
 		pub fn teleport_assets(
@@ -228,24 +225,17 @@ pub mod pallet {
 				.map_err(|_| Error::<T>::CannotReanchor)?;
 			let max_assets = assets.len() as u32;
 			let assets = assets.into();
-			let mut message = Xcm::WithdrawAsset {
-				assets,
-				effects: vec![InitiateTeleport {
+			let mut message = Xcm(vec![
+				WithdrawAsset { assets },
+				InitiateTeleport {
 					assets: Wild(All),
 					dest: *dest,
-					effects: vec![
-						BuyExecution {
-							fees,
-							// Zero weight for additional XCM (since there are none to execute)
-							weight: 0,
-							debt: dest_weight,
-							halt_on_error: false,
-							instructions: vec![],
-						},
+					xcm: Xcm(vec![
+						BuyExecution { fees, weight: dest_weight },
 						DepositAsset { assets: Wild(All), max_assets, beneficiary: *beneficiary },
-					],
-				}],
-			};
+					]),
+				},
+			]);
 			let weight =
 				T::Weigher::weight(&mut message).map_err(|()| Error::<T>::UnweighableMessage)?;
 			let outcome =
@@ -269,11 +259,10 @@ pub mod pallet {
 		/// - `dest_weight`: Equal to the total weight on `dest` of the XCM message
 		///   `ReserveAssetDeposited { assets, effects: [ BuyExecution{..}, DepositAsset{..} ] }`.
 		#[pallet::weight({
-			let mut message = Xcm::TransferReserveAsset {
-				assets: assets.clone(),
-				dest: *dest.clone(),
-				effects: sp_std::vec![],
-			};
+			use sp_std::vec;
+			let mut message = Xcm(vec![
+				TransferReserveAsset { assets: assets.clone(), dest: *dest.clone(), xcm: Xcm(vec![]) }
+			]);
 			T::Weigher::weight(&mut message).map_or(Weight::max_value(), |w| 100_000_000 + w)
 		})]
 		pub fn reserve_transfer_assets(
@@ -298,21 +287,14 @@ pub mod pallet {
 				.map_err(|_| Error::<T>::CannotReanchor)?;
 			let max_assets = assets.len() as u32;
 			let assets = assets.into();
-			let mut message = Xcm::TransferReserveAsset {
+			let mut message = Xcm(vec![TransferReserveAsset {
 				assets,
 				dest: *dest,
-				effects: vec![
-					BuyExecution {
-						fees,
-						// Zero weight for additional instructions/orders (since there are none to execute)
-						weight: 0,
-						debt: dest_weight, // covers this, `TransferReserveAsset` xcm, and `DepositAsset` order.
-						halt_on_error: false,
-						instructions: vec![],
-					},
+				xcm: Xcm(vec![
+					BuyExecution { fees, weight: dest_weight },
 					DepositAsset { assets: Wild(All), max_assets, beneficiary: *beneficiary },
-				],
-			};
+				]),
+			}]);
 			let weight =
 				T::Weigher::weight(&mut message).map_err(|()| Error::<T>::UnweighableMessage)?;
 			let outcome =
@@ -354,12 +336,10 @@ pub mod pallet {
 		pub fn send_xcm(
 			interior: Junctions,
 			dest: MultiLocation,
-			message: Xcm<()>,
+			mut message: Xcm<()>,
 		) -> Result<(), SendError> {
-			let message = if let Junctions::Here = interior {
-				message
-			} else {
-				Xcm::<()>::RelayedFrom { who: interior, message: Box::new(message) }
+			if interior != Junctions::Here {
+				message.0.insert(0, DescendOrigin(interior))
 			};
 			log::trace!(target: "xcm::send_xcm", "dest: {:?}, message: {:?}", &dest, &message);
 			T::XcmRouter::send_xcm(dest, message)
@@ -406,16 +386,16 @@ pub mod pallet {
 		/// then reporting the outcome will fail. Futhermore if the estimate is too high, then it
 		/// may be put in the overweight queue and need to be manually executed.
 		pub fn on_report(
-			message: Xcm<()>,
+			message: &mut Xcm<()>,
 			responder: MultiLocation,
 			notify: impl Into<<T as Config>::Call>,
 			timeout: T::BlockNumber,
-		) -> Xcm<()> {
+		) {
 			let dest = T::LocationInverter::invert_location(&responder);
 			let notify: <T as Config>::Call = notify.into();
 			let max_response_weight = notify.get_dispatch_info().weight;
 			let query_id = Self::new_notify_query(responder, notify, timeout);
-			Xcm::ReportOutcome { dest, query_id, message: Box::new(message), max_response_weight }
+			message.0.insert(0, ReportOutcome { dest, query_id, max_response_weight });
 		}
 
 		/// Attempt to create a new query ID and register it as a query that is yet to respond.
@@ -459,7 +439,7 @@ pub mod pallet {
 							if let Ok(call) = bare.using_encoded(|mut bytes| <T as Config>::Call::decode(&mut bytes)) {
 								let weight = call.get_dispatch_info().weight;
 								if weight > max_weight { return 0 }
-								let dispatch_origin = Origin::Response(origin).into();
+								let dispatch_origin = Origin::Response(origin.clone()).into();
 								match call.dispatch(dispatch_origin) {
 									Ok(post_info) => post_info.actual_weight,
 									Err(error_and_info) => {

xcm/src/v1/order.rs

@@ -21,7 +21,7 @@ use crate::v0::Order as OldOrder;
 use super::{
 	MultiAsset, MultiAssetFilter, MultiAssets, MultiLocation, Xcm,
 };
-use alloc::vec::Vec;
+use alloc::{vec, vec::Vec};
 use core::{
 	convert::{TryFrom, TryInto},
 	result,
@@ -280,20 +280,11 @@ impl<Call> TryFrom<Instruction<Call>> for Order<Call> {
 				}
 				QueryHolding { query_id, dest, assets }
 			},
-			Instruction::OldBuyExecution { fees, weight, debt, xcm } => {
-				let orders = xcm.0
-					.into_iter()
-					.map(Order::<Call>::try_from)
-					.collect::<result::Result<_, _>>()?;
-				let halt_on_error = true;
-				BuyExecution { fees, weight, debt, halt_on_error, orders, instructions: vec![] }
-			},
 			Instruction::BuyExecution { fees, weight: debt } => {
 				let instructions = vec![];
-				let orders = vec![];
 				let halt_on_error = true;
 				let weight = 0;
-				BuyExecution { fees, weight, debt, halt_on_error, orders, instructions }
+				BuyExecution { fees, weight, debt, halt_on_error, instructions }
 			},
 			_ => return Err(()),
 		})

xcm/src/v2/mod.rs

@@ -66,6 +66,7 @@ pub mod prelude {
 		SendXcm, SendResult, SendError,
 		OriginKind, Response,
 		Instruction::{self, *},
+		Xcm,
 	};
 }
 
@@ -396,26 +397,6 @@ pub enum Instruction<Call> {
 		#[codec(compact)]
 		weight: u64,
 	},
-
-	/// Pay for the execution of some XCM `xcm` and `orders` with up to `weight`
-	/// picoseconds of execution time, paying for this with up to `fees` from the Holding Register.
-	///
-	/// - `fees`: The asset(s) to remove from the Holding Register to pay for fees.
-	/// - `weight`: The amount of weight to purchase; generally this will need to be at least the
-	///   expected weight of any following instructions.
-	/// - `debt`: The amount of weight-debt already incurred to be paid off; this should be equal
-	///   to the unpaid weight of any previous operations/orders.
-	/// 
-	/// Errors:
-//	#[deprecated = "Use `BuyExecution` instead"]
-	OldBuyExecution {
-		fees: MultiAsset,
-		#[codec(compact)]
-		weight: u64,
-		#[codec(compact)]
-		debt: u64,
-		xcm: Xcm<Call>,
-	},
 }
 
 impl<Call> Xcm<Call> {
@@ -470,8 +451,6 @@ impl<Call> Instruction<Call> {
 			=> QueryHolding { query_id, dest, assets, max_response_weight },
 			BuyExecution { fees, weight }
 			=> BuyExecution { fees, weight },
-			OldBuyExecution { fees, weight, debt, xcm }
-			=> OldBuyExecution { fees, weight, debt, xcm: xcm.into() },
     		ClearOrigin
 			=> ClearOrigin,
 			DescendOrigin(who)
@@ -592,29 +571,13 @@ impl<Call> TryFrom<OldOrder<Call>> for Instruction<Call> {
 				QueryHolding { query_id, dest, assets, max_response_weight: 0 },
 			OldOrder::BuyExecution {
 				fees,
-				weight,
 				debt,
-				halt_on_error,
-				orders,
 				instructions,
+				..
 			} => {
 				// We don't handle nested XCM.
 				if !instructions.is_empty() { return Err(()) }
-				// We also don't handle ignoring errors any more.
-				if !halt_on_error { return Err(()) }
-				if weight == 0 && orders.is_empty() {
-					BuyExecution { fees, weight: debt }
-				} else {
-					OldBuyExecution {
-						fees,
-						weight,
-						debt,
-						xcm: Xcm(orders
-							.into_iter()
-							.map(Instruction::<Call>::try_from)
-							.collect::<result::Result<_, _>>()?),
-					}
-				}
+				BuyExecution { fees, weight: debt }
 			}
 		})
 	}

xcm/xcm-builder/src/barriers.rs

@@ -22,36 +22,36 @@ use sp_std::{marker::PhantomData, result::Result};
 use xcm::latest::{Instruction::*, Junction, Junctions, MultiLocation, Xcm};
 use xcm_executor::traits::{OnResponse, ShouldExecute};
 
-/// Execution barrier that just takes `shallow_weight` from `weight_credit`.
+/// Execution barrier that just takes `max_weight` from `weight_credit`.
 pub struct TakeWeightCredit;
 impl ShouldExecute for TakeWeightCredit {
 	fn should_execute<Call>(
 		_origin: &Option<MultiLocation>,
 		_top_level: bool,
 		_message: &Xcm<Call>,
-		shallow_weight: Weight,
+		max_weight: Weight,
 		weight_credit: &mut Weight,
 	) -> Result<(), ()> {
-		*weight_credit = weight_credit.checked_sub(shallow_weight).ok_or(())?;
+		*weight_credit = weight_credit.checked_sub(max_weight).ok_or(())?;
 		Ok(())
 	}
 }
 
-/// Allows execution from `origin` if it is contained in `T` (i.e. `T::Contains(origin)`) taking payments into
-/// account.
+/// Allows execution from `origin` if it is contained in `T` (i.e. `T::Contains(origin)`) taking
+/// payments into account.
 pub struct AllowTopLevelPaidExecutionFrom<T>(PhantomData<T>);
 impl<T: Contains<MultiLocation>> ShouldExecute for AllowTopLevelPaidExecutionFrom<T> {
 	fn should_execute<Call>(
 		origin: &Option<MultiLocation>,
 		top_level: bool,
 		message: &Xcm<Call>,
-		shallow_weight: Weight,
+		max_weight: Weight,
 		_weight_credit: &mut Weight,
 	) -> Result<(), ()> {
 		let origin = origin.as_ref().ok_or(())?;
 		ensure!(T::contains(origin), ());
 		ensure!(top_level, ());
-		let iter = message.0.iter();
+		let mut iter = message.0.iter();
 		let i = iter.next().ok_or(())?;
 		match i {
 			ReceiveTeleportedAsset{..} | WithdrawAsset{..} | ReserveAssetDeposited{..} => (),
@@ -62,8 +62,7 @@ impl<T: Contains<MultiLocation>> ShouldExecute for AllowTopLevelPaidExecutionFro
 			i = iter.next().ok_or(())?;
 		}
 		match i {
-			BuyExecution { weight , .. } if *weight >= shallow_weight => Ok(()),
-			OldBuyExecution { debt , .. } if *debt >= shallow_weight => Ok(()),
+			BuyExecution { weight , .. } if *weight >= max_weight => Ok(()),
 			_ => Err(()),
 		}
 	}
@@ -77,7 +76,7 @@ impl<T: Contains<MultiLocation>> ShouldExecute for AllowUnpaidExecutionFrom<T> {
 		origin: &Option<MultiLocation>,
 		_top_level: bool,
 		_message: &Xcm<Call>,
-		_shallow_weight: Weight,
+		_max_weight: Weight,
 		_weight_credit: &mut Weight,
 	) -> Result<(), ()> {
 		let origin = origin.as_ref().ok_or(())?;
@@ -105,7 +104,7 @@ impl<ResponseHandler: OnResponse> ShouldExecute for AllowKnownQueryResponses<Res
 		origin: &Option<MultiLocation>,
 		_top_level: bool,
 		message: &Xcm<Call>,
-		_shallow_weight: Weight,
+		_max_weight: Weight,
 		_weight_credit: &mut Weight,
 	) -> Result<(), ()> {
 		let origin = origin.as_ref().ok_or(())?;

xcm/xcm-builder/src/tests.rs

@@ -57,7 +57,7 @@ fn weigher_should_work() {
 		],
 	}
 	.into();
-	assert_eq!(<TestConfig as Config>::Weigher::shallow(&mut message), Ok(30));
+	assert_eq!(<TestConfig as Config>::Weigher::weight(&mut message), Ok(30));
 }
 
 #[test]