• Understand the different XCM configurable parts of a chain
• Construct different XCM configurations for chains with different needs

🛠️ Configurables in XcmConfig

Notes:

The XCM Configuration has many configurable items

EXERCISE: ask the class to raise hands and postulate on what they think should be configurable.

---v

🛠️ Configurables in XcmConfig

#![allow(unused)]
fn main() {
// How we convert locations into account ids
type SovereignAccountOf = SovereignAccountOf;

pub struct XcmConfig;
impl Config for XcmConfig {
  // The absolute Location of the current system
  type UniversalLocation = UniversalLocation;
  // Pre-execution filters
  type Barrier = Barrier;
  // How we withdraw/deposit assets
  type AssetTransactor = LocalAssetTransactor;
  // How we convert a Location to a FRAME dispatch origin
  type OriginConverter = LocalOriginConverter;
  // How we route the XCM outside this chain
  type XcmSender = XcmRouter;
  // Who we trust as reserve chains
  type IsReserve = ?;
  // Who do we trust as teleporters
  type IsTeleporter = ?;
  // How we weigh a message
  type Weigher = ?;
  // How we charge for fees
  type Trader = ?;
  // How we handle responses
  type ResponseHandler = ?;
  // How we handle asset traps
  type AssetTrap = ?;
  // How we handle asset claims
  type AssetClaims = ?;
  // How we handle version subscriptions
  type SubscriptionService = ?;
}
}

Notes:

• SovereignAccountOf: Means of converting a Location into an account ID Used later for: OriginConverter , AssetTransactor

• xcm-pallet is a pallet that not only allows sending and executing XCM messages, but rather it also implements several of the configuration traits and thus can be used perform several XCM configuration actions.

---v

🛠️ xcm-builder

xcm-builder is a crate containing common configuration shims to facilitate XCM configuration.

Most pre-built configuration items can be found in xcm-builder.

It allows to use the XCM executor in FRAME.

🤔 Grab your chain's requirements before starting

Questions that you should have answers for:

• Is my chain going to transfer just the native token? Is my chain going to receive several other kinds of assets?

• Is my chain going to allow free execution? Maybe only limited to some parachains/relay chain?

• Is my chain a 20 byte account chain? a 32 byte account chain?

• How will my chain accept fee payment? In one asset? In several?

Notes:

• Some of the answers to these questions might imply you need to use your own custom primitives.

---v

Our starting example setup requirements

1. Parachain that does not charge for relay incoming messages.
2. Parachain that trusts the relay as the reserve chain for the relay chain tokens.
3. Parachain that mints in pallet-balances when it receives relay chain tokens.
4. Users can execute XCMs locally.

📁 SovereignAccountOf via xcm-builder

• Defines how we convert a Location into a local account ID.
• Useful when we want to withdraw/deposit tokens from a Location defined origin
• Useful when we want to dispatch as signed origins from a Location defined origin.

Notes:

• This will define how we convert a Location into a local account ID.
• This is useful when we want to withdraw/deposit tokens from a Location defined origin or when we want to dispatch as signed origins from a Location defined origin.

---v

📁 SovereignAccountOf via xcm-builder

• HashedDescription: Hashes the description of a Location and converts that into an AccountId.

#![allow(unused)]
fn main() {
pub struct HashedDescription<AccountId, Describe>(PhantomData<(AccountId, Describe)>);
impl<
  AccountId: From<[u8; 32]> + Clone,
  Describe: DescribeLocation
> ConvertLocation<AccountId> for HashedDescription<AccountId, Describe>
{
	fn convert_location(value: &Location) -> Option<AccountId> {
		Some(blake2_256(&Describe::describe_location(value)?).into())
	}
}
}

---v

📁 SovereignAccountOf via xcm-builder

• HashedDescription. An example of a converter definition:

#![allow(unused)]
fn main() {
pub type LocationToAccount =
  HashedDescription<AccountId, (
    LegacyDescribeForeignChainAccount, // Legacy conversion - MUST BE FIRST!
    DescribeTerminus,
    DescribePalletTerminal
  )>;
}

#![allow(unused)]
fn main() {
pub trait DescribeLocation {
	/// Create a description of the given `location` if possible. No two locations should have the
	/// same descriptor.
	fn describe_location(location: &Location) -> Option<Vec<u8>>;
}
}

#![allow(unused)]
fn main() {
fn describe_location(l: &Location) -> Option<Vec<u8>> {
	match (l.parents, &l.interior) {
		(0, X1(AccountId32 { id, .. })) => Some((b"AccountId32", id).encode()),
		_ => return None,
	}
}
}

#![allow(unused)]
fn main() {
fn describe_location(l: &Location) -> Option<Vec<u8>> {
	match (l.parents, &l.interior) {
		(0, Here) => Some(Vec::new()),
		_ => return None,
	}
}
}

#![allow(unused)]
fn main() {
fn describe_location(l: &Location) -> Option<Vec<u8>> {
	match (l.parents, &l.interior) {
		(0, X1(PalletInstance(i))) =>
			Some((b"Pallet", Compact::<u32>::from(*i as u32)).encode()),
		_ => return None,
	}
}
}

#![allow(unused)]
fn main() {
fn describe_location(l: &Location) -> Option<Vec<u8>> {
	match (l.parents, &l.interior) {
		(0, X1(AccountKey20 { key, .. })) => Some((b"AccountKey20", key).encode()),
		_ => return None,
	}
}
}

#![allow(unused)]
fn main() {
parameter_types! {
  pub const UniversalLocation: InteriorLocation = GlobalConsensus(NetworkId::Polkadot).into();
}
}

#![allow(unused)]
fn main() {
pub struct WithComputedOrigin<InnerBarrier, LocalUniversal, MaxPrefixes>;
}

#![allow(unused)]
fn main() {
fn withdraw_asset(
	what: &Asset,
	who: &Location,
	_maybe_context: Option<&XcmContext>,
) -> result::Result<xcm_executor::Assets, XcmError> {
	let (asset_id, amount) = Matcher::matches_fungibles(what)?;
	let who = AccountIdConverter::convert_location(who)
		.ok_or(MatchError::AccountIdConversionFailed)?;
	Assets::burn_from(asset_id, &who, amount, Exact, Polite)
		.map_err(|e| XcmError::FailedToTransactAsset(e.into()))?;
	Ok(what.clone().into())
}
}

#![allow(unused)]
fn main() {
fn deposit_asset(
  what: &Asset,
  who: &Location,
  _context: &XcmContext
) -> XcmResult {
	let (asset_id, amount) = Matcher::matches_fungibles(what)?;
	let who = AccountIdConverter::convert_location(who)
		.ok_or(MatchError::AccountIdConversionFailed)?;
	Assets::mint_into(asset_id, &who, amount)
		.map_err(|e| XcmError::FailedToTransactAsset(e.into()))?;
	Ok(())
}
}

#![allow(unused)]
fn main() {
pub type XcmRouter = (
	// Two routers - use UMP to communicate with the relay chain:
	cumulus_primitives_utility::ParentAsUmp<ParachainSystem, PolkadotXcm>,
	// ..and XCMP to communicate with the sibling chains.
	XcmpQueue,
);
}

#![allow(unused)]
fn main() {
pub trait SendXcm {
  type Ticket;

  fn validate(
    destination: &mut Option<Location>,
    message: &mut Option<Xcm<()>>,
  ) -> SendResult<Self::Ticket>;

  fn deliver(ticket: Self::Ticket) -> Result<XcmHash, SendError>;
}
}