Struct xcm::v3::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::v3::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<Self, (Self, Junction)>

pub fn pushed_front_with_interior( self, new: impl Into<Junction> ) -> Result<Self, (Self, 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<Self>) -> Result<(), Self>

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

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

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

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

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

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 Debug for MultiLocation

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

impl Decode for MultiLocation

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

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() -> Self

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

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

impl Encode for MultiLocation

fn size_hint(&self) -> usize

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

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]) -> Self

impl From<[Junction; 1]> for MultiLocation

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

impl From<[Junction; 2]> for MultiLocation

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

impl From<[Junction; 3]> for MultiLocation

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

impl From<[Junction; 4]> for MultiLocation

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

impl From<[Junction; 5]> for MultiLocation

fn from(j: [Junction; 5]) -> Self

impl From<[Junction; 6]> for MultiLocation

fn from(j: [Junction; 6]) -> Self

impl From<[Junction; 7]> for MultiLocation

fn from(j: [Junction; 7]) -> Self

impl From<[Junction; 8]> for MultiLocation

fn from(j: [Junction; 8]) -> Self

impl From<()> for MultiLocation

fn from((): ()) -> Self

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

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

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