Struct xcm_builder::test_utils::MultiLocation

source ·

pub struct MultiLocation {
    pub parents: u8,
    pub interior: Junctions,
}

Expand description

A relative path between state-bearing consensus systems.

A location in a consensus system is defined as an isolatable state machine held within global consensus. The location in question need not have a sophisticated consensus algorithm of its own; a single account within Ethereum, for example, could be considered a location.

A very-much non-exhaustive list of types of location include:

A (normal, layer-1) block chain, e.g. the Bitcoin mainnet or a parachain.
A layer-0 super-chain, e.g. the Polkadot Relay chain.
A layer-2 smart contract, e.g. an ERC-20 on Ethereum.
A logical functional component of a chain, e.g. a single instance of a pallet on a Frame-based Substrate chain.
An account.

A MultiLocation is a relative identifier, meaning that it can only be used to define the relative path between two locations, and cannot generally be used to refer to a location universally. It is comprised of an integer number of parents specifying the number of times to “escape” upwards into the containing consensus system and then a number of junctions, each diving down and specifying some interior portion of state (which may be considered a “sub-consensus” system).

This specific MultiLocation implementation uses a Junctions datatype which is a Rust enum in order to make pattern matching easier. There are occasions where it is important to ensure that a value is strictly an interior location, in those cases, Junctions may be used.

The MultiLocation value of Null simply refers to the interpreting consensus system.

Fields§

§parents: u8

The number of parent junctions at the beginning of this MultiLocation.

§interior: Junctions

The interior (i.e. non-parent) junctions that this MultiLocation contains.

Struct xcm_builder::test_utils::MultiLocation

Fields§

Implementations§

impl MultiLocation

pub fn new(parents: u8, interior: impl Into<Junctions>) -> MultiLocation

pub const fn into_versioned(self) -> VersionedMultiLocation

pub const fn here() -> MultiLocation

pub const fn parent() -> MultiLocation

pub const fn grandparent() -> MultiLocation

pub const fn ancestor(parents: u8) -> MultiLocation

pub const fn is_here(&self) -> bool

pub fn remove_network_id(&mut self)

pub fn interior(&self) -> &Junctions

pub fn interior_mut(&mut self) -> &mut Junctions

pub const fn parent_count(&self) -> u8

pub const fn contains_parents_only(&self, count: u8) -> bool

pub const fn len(&self) -> usize

pub fn first_interior(&self) -> Option<&Junction>

pub fn last(&self) -> Option<&Junction>

pub fn split_first_interior(self) -> (MultiLocation, Option<Junction>)

pub fn split_last_interior(self) -> (MultiLocation, Option<Junction>)

pub fn push_interior( &mut self, new: impl Into<Junction> ) -> Result<(), Junction>

pub fn push_front_interior( &mut self, new: impl Into<Junction> ) -> Result<(), Junction>

pub fn pushed_with_interior( self, new: impl Into<Junction> ) -> Result<MultiLocation, (MultiLocation, Junction)>

pub fn pushed_front_with_interior( self, new: impl Into<Junction> ) -> Result<MultiLocation, (MultiLocation, Junction)>

pub fn at(&self, i: usize) -> Option<&Junction>

pub fn at_mut(&mut self, i: usize) -> Option<&mut Junction>

pub fn dec_parent(&mut self)

pub fn take_first_interior(&mut self) -> Option<Junction>

pub fn take_last(&mut self) -> Option<Junction>

pub fn match_and_split(&self, prefix: &MultiLocation) -> Option<&Junction>

pub fn starts_with(&self, prefix: &MultiLocation) -> bool

pub fn append_with( &mut self, suffix: impl Into<MultiLocation> ) -> Result<(), MultiLocation>

pub fn appended_with( self, suffix: impl Into<MultiLocation> ) -> Result<MultiLocation, (MultiLocation, MultiLocation)>

pub fn prepend_with( &mut self, prefix: impl Into<MultiLocation> ) -> Result<(), MultiLocation>

pub fn prepended_with( self, prefix: impl Into<MultiLocation> ) -> Result<MultiLocation, (MultiLocation, MultiLocation)>

pub fn reanchor( &mut self, target: &MultiLocation, context: Junctions ) -> Result<(), ()>

pub fn reanchored( self, target: &MultiLocation, context: Junctions ) -> Result<MultiLocation, MultiLocation>

pub fn simplify(&mut self, context: &Junctions)

Trait Implementations§

impl Clone for MultiLocation

fn clone(&self) -> MultiLocation

fn clone_from(&mut self, source: &Self)

impl<ParaId: IsSystem + From<u32>> Contains<MultiLocation> for IsChildSystemParachain<ParaId>

fn contains(l: &MultiLocation) -> bool

impl<T: Get<(MultiAssetFilter, MultiLocation)>> ContainsPair<MultiAsset, MultiLocation> for Case<T>

fn contains(asset: &MultiAsset, origin: &MultiLocation) -> bool

impl ContainsPair<MultiAsset, MultiLocation> for NativeAsset

fn contains(asset: &MultiAsset, origin: &MultiLocation) -> bool

impl<Prefix: Contains<MultiLocation>> ContainsPair<MultiLocation, MultiLocation> for AliasForeignAccountId32<Prefix>

fn contains(origin: &MultiLocation, target: &MultiLocation) -> bool

impl<'a, Network: Get<Option<NetworkId>>, AccountId: Clone + Into<[u8; 32]>> Convert<&'a AccountId, MultiLocation> for AliasesIntoAccountId32<Network, AccountId>

fn convert(who: &AccountId) -> MultiLocation

impl Debug for MultiLocation

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Decode for MultiLocation

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<MultiLocation, Error>where __CodecInputEdqy: Input,

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self> ) -> Result<DecodeFinished, Error>where I: Input,

fn skip<I>(input: &mut I) -> Result<(), Error>where I: Input,

fn encoded_fixed_size() -> Option<usize>

impl Default for MultiLocation

fn default() -> MultiLocation

impl<'de> Deserialize<'de> for MultiLocation

fn deserialize<__D>( __deserializer: __D ) -> Result<MultiLocation, <__D as Deserializer<'de>>::Error>where __D: Deserializer<'de>,

impl Encode for MultiLocation

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy )where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8, Global> ⓘ

fn using_encoded<R, F>(&self, f: F) -> Rwhere F: FnOnce(&[u8]) -> R,

fn encoded_size(&self) -> usize

impl From<[Junction; 0]> for MultiLocation

fn from(j: [Junction; 0]) -> MultiLocation

impl From<[Junction; 1]> for MultiLocation

fn from(j: [Junction; 1]) -> MultiLocation

impl From<[Junction; 2]> for MultiLocation

fn from(j: [Junction; 2]) -> MultiLocation

impl From<[Junction; 3]> for MultiLocation

fn from(j: [Junction; 3]) -> MultiLocation

impl From<[Junction; 4]> for MultiLocation

fn from(j: [Junction; 4]) -> MultiLocation

fn decode<CodecInputEdqy>( codec_input_edqy: &mut CodecInputEdqy ) -> Result<MultiLocation, Error>where CodecInputEdqy: Input,

fn deserialize<D>( deserializer: D ) -> Result<MultiLocation, <D as Deserializer<'de>>::Error>where __D: Deserializer<'de>,

fn encode_to<CodecOutputEdqy>( &self, codec_dest_edqy: &mut CodecOutputEdqy )where CodecOutputEdqy: Output + ?Sized,