mdBook generated from gitorial

Author: shawntabrizi

src/0/source/changes.diff

@@ -194,8 +194,6 @@ impl<Config: XcmConfig> ExecuteXcm for XcmExecutor<Config> {
 	/// Execute an XCM from a given `origin`.
 	fn execute(origin: impl Into<Location>, xcm: Xcm<()>) -> XcmResult {
 		log::trace!(target: "xcm::execute", "xcm: {:?}", xcm);
-		let origin: Location = origin.into();
-		let mut vm = Self::new(origin);
-		vm.process(xcm)
+		todo!("{:?}", origin.into())
 	}
 }

src/10/solution/README.md

@@ -1,14 +1,57 @@
 diff --git a/fundamentals/src/xcm_executor.rs b/fundamentals/src/xcm_executor.rs
-index f03d79b..f7e8d2e 100644
+index d50d85a..f03d79b 100644
 --- a/fundamentals/src/xcm_executor.rs
 +++ b/fundamentals/src/xcm_executor.rs
-@@ -194,6 +194,8 @@ impl<Config: XcmConfig> ExecuteXcm for XcmExecutor<Config> {
- 	/// Execute an XCM from a given `origin`.
- 	fn execute(origin: impl Into<Location>, xcm: Xcm<()>) -> XcmResult {
- 		log::trace!(target: "xcm::execute", "xcm: {:?}", xcm);
--		todo!("{:?}", origin.into())
-+		let origin: Location = origin.into();
-+		let mut vm = Self::new(origin);
-+		vm.process(xcm)
- 	}
- }
+@@ -132,14 +132,50 @@ impl<Config: XcmConfig> XcmExecutor<Config> {
+ 			// - `assets`: The asset(s) to remove from holding.
+ 			// - `beneficiary`: The new owner for the assets.
+ 			DepositAsset { assets, beneficiary } => {
+-				todo!("{:?} {:?}", assets, beneficiary)
++				let old_holding = self.holding.clone();
++				let result = Config::TransactionalProcessor::process(|| {
++					// Take assets from the holding registrar...
++					let deposited = self.holding.saturating_take(assets);
++					// ... and deposit them to the `beneficiary`.
++					for asset in deposited.into_assets_iter() {
++						Config::AssetTransactor::deposit_asset(
++							&asset,
++							&beneficiary,
++							Some(&self.context),
++						)?;
++					}
++					Ok(())
++				});
++				// If we were unable to execute `deposit_asset` in the `AssetTransactor`, we reset
++				// the XCM Executor holding registrar since no operations took place.
++				if Config::TransactionalProcessor::IS_TRANSACTIONAL && result.is_err() {
++					self.holding = old_holding;
++				}
++				result
+ 			},
+ 			// Asset(s) (`assets`) have been destroyed on the `origin` system and equivalent assets
+ 			// should be created and placed into the Holding Register.
+ 			//
+ 			// - `assets`: The asset(s) that are minted into the Holding Register.
+ 			ReceiveTeleportedAsset(assets) => {
+-				todo!("{:?}", assets)
++				Config::TransactionalProcessor::process(|| {
++					let origin = self.origin_ref().ok_or(XcmError::BadOrigin)?;
++					// check whether we trust origin to teleport this asset to us via config trait.
++					for asset in assets.inner() {
++						// We should check that the asset can actually be teleported in (for this to
++						// be in error, there would need to be an accounting violation by one of the
++						// trusted chains, so it's unlikely, but we don't want to punish a possibly
++						// innocent chain/user).
++						Config::AssetTransactor::can_check_in(origin, asset, &self.context)?;
++						Config::AssetTransactor::check_in(origin, asset, &self.context);
++					}
++					Ok(())
++				})
++				.and_then(|_| {
++					// ...and place into holding.
++					self.holding.subsume_assets(assets.into());
++					Ok(())
++				})
+ 			},
+ 			// In this workshop, we won't be implementing every instruction, just the ones above...
+ 			// Our executor will simply panic if you try to execute other instructions.

src/10/solution/fundamentals/src/xcm_executor.rs

@@ -132,50 +132,14 @@ impl<Config: XcmConfig> XcmExecutor<Config> {
 			// - `assets`: The asset(s) to remove from holding.
 			// - `beneficiary`: The new owner for the assets.
 			DepositAsset { assets, beneficiary } => {
-				let old_holding = self.holding.clone();
-				let result = Config::TransactionalProcessor::process(|| {
-					// Take assets from the holding registrar...
-					let deposited = self.holding.saturating_take(assets);
-					// ... and deposit them to the `beneficiary`.
-					for asset in deposited.into_assets_iter() {
-						Config::AssetTransactor::deposit_asset(
-							&asset,
-							&beneficiary,
-							Some(&self.context),
-						)?;
-					}
-					Ok(())
-				});
-				// If we were unable to execute `deposit_asset` in the `AssetTransactor`, we reset
-				// the XCM Executor holding registrar since no operations took place.
-				if Config::TransactionalProcessor::IS_TRANSACTIONAL && result.is_err() {
-					self.holding = old_holding;
-				}
-				result
+				todo!("{:?} {:?}", assets, beneficiary)
 			},
 			// Asset(s) (`assets`) have been destroyed on the `origin` system and equivalent assets
 			// should be created and placed into the Holding Register.
 			//
 			// - `assets`: The asset(s) that are minted into the Holding Register.
 			ReceiveTeleportedAsset(assets) => {
-				Config::TransactionalProcessor::process(|| {
-					let origin = self.origin_ref().ok_or(XcmError::BadOrigin)?;
-					// check whether we trust origin to teleport this asset to us via config trait.
-					for asset in assets.inner() {
-						// We should check that the asset can actually be teleported in (for this to
-						// be in error, there would need to be an accounting violation by one of the
-						// trusted chains, so it's unlikely, but we don't want to punish a possibly
-						// innocent chain/user).
-						Config::AssetTransactor::can_check_in(origin, asset, &self.context)?;
-						Config::AssetTransactor::check_in(origin, asset, &self.context);
-					}
-					Ok(())
-				})
-				.and_then(|_| {
-					// ...and place into holding.
-					self.holding.subsume_assets(assets.into());
-					Ok(())
-				})
+				todo!("{:?}", assets)
 			},
 			// In this workshop, we won't be implementing every instruction, just the ones above...
 			// Our executor will simply panic if you try to execute other instructions.

src/10/solution/solution.diff

@@ -0,0 +1,14 @@
+diff --git a/fundamentals/src/xcm_executor.rs b/fundamentals/src/xcm_executor.rs
+index f03d79b..f7e8d2e 100644
+--- a/fundamentals/src/xcm_executor.rs
++++ b/fundamentals/src/xcm_executor.rs
+@@ -194,6 +194,8 @@ impl<Config: XcmConfig> ExecuteXcm for XcmExecutor<Config> {
+ 	/// Execute an XCM from a given `origin`.
+ 	fn execute(origin: impl Into<Location>, xcm: Xcm<()>) -> XcmResult {
+ 		log::trace!(target: "xcm::execute", "xcm: {:?}", xcm);
+-		todo!("{:?}", origin.into())
++		let origin: Location = origin.into();
++		let mut vm = Self::new(origin);
++		vm.process(xcm)
+ 	}
+ }

src/10/template/README.md

@@ -79,37 +79,103 @@ impl<Config: XcmConfig> XcmExecutor<Config> {
 			// - `assets`: The asset(s) to be withdrawn.
 			// - `beneficiary`: The new owner for the assets.
 			TransferAsset { assets, beneficiary } => {
-				todo!("{:?} {:?}", assets, beneficiary)
+				Config::TransactionalProcessor::process(|| {
+					// Take `assets` from the origin account (on-chain) and place into dest account.
+					let origin = self.origin_ref().ok_or(XcmError::BadOrigin)?;
+					// Transfer each asset using the `AssetTransactor`.
+					for asset in assets.inner() {
+						Config::AssetTransactor::transfer_asset(
+							&asset,
+							origin,
+							&beneficiary,
+							&self.context,
+						)?;
+					}
+					Ok(())
+				})
 			},
 			// Withdraw asset(s) (`assets`) from the ownership of `origin` and place them into the
 			// Holding Register.
 			//
 			// - `assets`: The asset(s) to be withdrawn into holding.
 			WithdrawAsset(assets) => {
-				todo!("{:?}", assets)
+				Config::TransactionalProcessor::process(|| {
+					let origin = self.origin_ref().ok_or(XcmError::BadOrigin)?;
+					// Take `assets` from the origin account (on-chain)...
+					for asset in assets.inner() {
+						Config::AssetTransactor::withdraw_asset(
+							asset,
+							origin,
+							Some(&self.context),
+						)?;
+					}
+					Ok(())
+				})
+				.and_then(|_| {
+					// ...and place into holding.
+					self.holding.subsume_assets(assets.into());
+					Ok(())
+				})
 			},
 			// Reduce Holding by up to the given assets.
 			//
 			// Holding is reduced by as much as possible up to the assets in the parameter. It is
 			// not an error if the Holding does not contain the assets (to make this an error, use
 			// `ExpectAsset` prior).
 			BurnAsset(assets) => {
-				todo!("{:?}", assets)
+				self.holding.saturating_take(assets.into());
+				Ok(())
 			},
 			// Remove the asset(s) (`assets`) from the Holding Register and place equivalent assets
 			// under the ownership of `beneficiary` within this consensus system.
 			//
 			// - `assets`: The asset(s) to remove from holding.
 			// - `beneficiary`: The new owner for the assets.
 			DepositAsset { assets, beneficiary } => {
-				todo!("{:?} {:?}", assets, beneficiary)
+				let old_holding = self.holding.clone();
+				let result = Config::TransactionalProcessor::process(|| {
+					// Take assets from the holding registrar...
+					let deposited = self.holding.saturating_take(assets);
+					// ... and deposit them to the `beneficiary`.
+					for asset in deposited.into_assets_iter() {
+						Config::AssetTransactor::deposit_asset(
+							&asset,
+							&beneficiary,
+							Some(&self.context),
+						)?;
+					}
+					Ok(())
+				});
+				// If we were unable to execute `deposit_asset` in the `AssetTransactor`, we reset
+				// the XCM Executor holding registrar since no operations took place.
+				if Config::TransactionalProcessor::IS_TRANSACTIONAL && result.is_err() {
+					self.holding = old_holding;
+				}
+				result
 			},
 			// Asset(s) (`assets`) have been destroyed on the `origin` system and equivalent assets
 			// should be created and placed into the Holding Register.
 			//
 			// - `assets`: The asset(s) that are minted into the Holding Register.
 			ReceiveTeleportedAsset(assets) => {
-				todo!("{:?}", assets)
+				Config::TransactionalProcessor::process(|| {
+					let origin = self.origin_ref().ok_or(XcmError::BadOrigin)?;
+					// check whether we trust origin to teleport this asset to us via config trait.
+					for asset in assets.inner() {
+						// We should check that the asset can actually be teleported in (for this to
+						// be in error, there would need to be an accounting violation by one of the
+						// trusted chains, so it's unlikely, but we don't want to punish a possibly
+						// innocent chain/user).
+						Config::AssetTransactor::can_check_in(origin, asset, &self.context)?;
+						Config::AssetTransactor::check_in(origin, asset, &self.context);
+					}
+					Ok(())
+				})
+				.and_then(|_| {
+					// ...and place into holding.
+					self.holding.subsume_assets(assets.into());
+					Ok(())
+				})
 			},
 			// In this workshop, we won't be implementing every instruction, just the ones above...
 			// Our executor will simply panic if you try to execute other instructions.