use super::{Junction, Location, NetworkId};
use alloc::sync::Arc;
use codec::{Decode, Encode, MaxEncodedLen};
use core::{mem, ops::Range, result};
use scale_info::TypeInfo;
pub(crate) const MAX_JUNCTIONS: usize = 8;
#[derive(
Clone,
Eq,
PartialEq,
Ord,
PartialOrd,
Encode,
Decode,
Debug,
TypeInfo,
MaxEncodedLen,
serde::Serialize,
serde::Deserialize,
)]
pub enum Junctions {
Here,
X1(Arc<[Junction; 1]>),
X2(Arc<[Junction; 2]>),
X3(Arc<[Junction; 3]>),
X4(Arc<[Junction; 4]>),
X5(Arc<[Junction; 5]>),
X6(Arc<[Junction; 6]>),
X7(Arc<[Junction; 7]>),
X8(Arc<[Junction; 8]>),
}
macro_rules! impl_junctions {
($count:expr, $variant:ident) => {
impl From<[Junction; $count]> for Junctions {
fn from(junctions: [Junction; $count]) -> Self {
Self::$variant(Arc::new(junctions))
}
}
impl PartialEq<[Junction; $count]> for Junctions {
fn eq(&self, rhs: &[Junction; $count]) -> bool {
self.as_slice() == rhs
}
}
};
}
impl_junctions!(1, X1);
impl_junctions!(2, X2);
impl_junctions!(3, X3);
impl_junctions!(4, X4);
impl_junctions!(5, X5);
impl_junctions!(6, X6);
impl_junctions!(7, X7);
impl_junctions!(8, X8);
pub struct JunctionsIterator {
junctions: Junctions,
range: Range<usize>,
}
impl Iterator for JunctionsIterator {
type Item = Junction;
fn next(&mut self) -> Option<Junction> {
self.junctions.at(self.range.next()?).cloned()
}
}
impl DoubleEndedIterator for JunctionsIterator {
fn next_back(&mut self) -> Option<Junction> {
self.junctions.at(self.range.next_back()?).cloned()
}
}
pub struct JunctionsRefIterator<'a> {
junctions: &'a Junctions,
range: Range<usize>,
}
impl<'a> Iterator for JunctionsRefIterator<'a> {
type Item = &'a Junction;
fn next(&mut self) -> Option<&'a Junction> {
self.junctions.at(self.range.next()?)
}
}
impl<'a> DoubleEndedIterator for JunctionsRefIterator<'a> {
fn next_back(&mut self) -> Option<&'a Junction> {
self.junctions.at(self.range.next_back()?)
}
}
impl<'a> IntoIterator for &'a Junctions {
type Item = &'a Junction;
type IntoIter = JunctionsRefIterator<'a>;
fn into_iter(self) -> Self::IntoIter {
JunctionsRefIterator { junctions: self, range: 0..self.len() }
}
}
impl IntoIterator for Junctions {
type Item = Junction;
type IntoIter = JunctionsIterator;
fn into_iter(self) -> Self::IntoIter {
JunctionsIterator { range: 0..self.len(), junctions: self }
}
}
impl Junctions {
pub const fn into_location(self) -> Location {
Location { parents: 0, interior: self }
}
pub const fn into_exterior(self, n: u8) -> Location {
Location { parents: n, interior: self }
}
pub fn as_slice(&self) -> &[Junction] {
match self {
Junctions::Here => &[],
Junctions::X1(ref a) => &a[..],
Junctions::X2(ref a) => &a[..],
Junctions::X3(ref a) => &a[..],
Junctions::X4(ref a) => &a[..],
Junctions::X5(ref a) => &a[..],
Junctions::X6(ref a) => &a[..],
Junctions::X7(ref a) => &a[..],
Junctions::X8(ref a) => &a[..],
}
}
pub fn as_slice_mut(&mut self) -> &mut [Junction] {
match self {
Junctions::Here => &mut [],
Junctions::X1(ref mut a) => &mut Arc::make_mut(a)[..],
Junctions::X2(ref mut a) => &mut Arc::make_mut(a)[..],
Junctions::X3(ref mut a) => &mut Arc::make_mut(a)[..],
Junctions::X4(ref mut a) => &mut Arc::make_mut(a)[..],
Junctions::X5(ref mut a) => &mut Arc::make_mut(a)[..],
Junctions::X6(ref mut a) => &mut Arc::make_mut(a)[..],
Junctions::X7(ref mut a) => &mut Arc::make_mut(a)[..],
Junctions::X8(ref mut a) => &mut Arc::make_mut(a)[..],
}
}
pub fn remove_network_id(&mut self) {
self.for_each_mut(Junction::remove_network_id);
}
pub fn invert_target(&self, target: &Location) -> Result<Location, ()> {
let mut itself = self.clone();
let mut junctions = Self::Here;
for _ in 0..target.parent_count() {
junctions = junctions
.pushed_front_with(itself.take_last().unwrap_or(Junction::OnlyChild))
.map_err(|_| ())?;
}
let parents = target.interior().len() as u8;
Ok(Location::new(parents, junctions))
}
pub fn for_each_mut(&mut self, x: impl FnMut(&mut Junction)) {
self.as_slice_mut().iter_mut().for_each(x)
}
pub fn global_consensus(&self) -> Result<NetworkId, ()> {
if let Some(Junction::GlobalConsensus(network)) = self.first() {
Ok(*network)
} else {
Err(())
}
}
pub fn split_global(self) -> Result<(NetworkId, Junctions), ()> {
match self.split_first() {
(location, Some(Junction::GlobalConsensus(network))) => Ok((network, location)),
_ => return Err(()),
}
}
pub fn within_global(mut self, relative: Location) -> Result<Self, ()> {
if self.len() <= relative.parent_count() as usize {
return Err(())
}
for _ in 0..relative.parent_count() {
self.take_last();
}
for j in relative.interior() {
self.push(*j).map_err(|_| ())?;
}
Ok(self)
}
pub fn relative_to(mut self, viewer: &Junctions) -> Location {
let mut i = 0;
while match (self.first(), viewer.at(i)) {
(Some(x), Some(y)) => x == y,
_ => false,
} {
self = self.split_first().0;
i += 1;
}
Location::new((viewer.len() - i) as u8, self)
}
pub fn first(&self) -> Option<&Junction> {
self.as_slice().first()
}
pub fn last(&self) -> Option<&Junction> {
self.as_slice().last()
}
pub fn split_first(self) -> (Junctions, Option<Junction>) {
match self {
Junctions::Here => (Junctions::Here, None),
Junctions::X1(xs) => {
let [a] = *xs;
(Junctions::Here, Some(a))
},
Junctions::X2(xs) => {
let [a, b] = *xs;
([b].into(), Some(a))
},
Junctions::X3(xs) => {
let [a, b, c] = *xs;
([b, c].into(), Some(a))
},
Junctions::X4(xs) => {
let [a, b, c, d] = *xs;
([b, c, d].into(), Some(a))
},
Junctions::X5(xs) => {
let [a, b, c, d, e] = *xs;
([b, c, d, e].into(), Some(a))
},
Junctions::X6(xs) => {
let [a, b, c, d, e, f] = *xs;
([b, c, d, e, f].into(), Some(a))
},
Junctions::X7(xs) => {
let [a, b, c, d, e, f, g] = *xs;
([b, c, d, e, f, g].into(), Some(a))
},
Junctions::X8(xs) => {
let [a, b, c, d, e, f, g, h] = *xs;
([b, c, d, e, f, g, h].into(), Some(a))
},
}
}
pub fn split_last(self) -> (Junctions, Option<Junction>) {
match self {
Junctions::Here => (Junctions::Here, None),
Junctions::X1(xs) => {
let [a] = *xs;
(Junctions::Here, Some(a))
},
Junctions::X2(xs) => {
let [a, b] = *xs;
([a].into(), Some(b))
},
Junctions::X3(xs) => {
let [a, b, c] = *xs;
([a, b].into(), Some(c))
},
Junctions::X4(xs) => {
let [a, b, c, d] = *xs;
([a, b, c].into(), Some(d))
},
Junctions::X5(xs) => {
let [a, b, c, d, e] = *xs;
([a, b, c, d].into(), Some(e))
},
Junctions::X6(xs) => {
let [a, b, c, d, e, f] = *xs;
([a, b, c, d, e].into(), Some(f))
},
Junctions::X7(xs) => {
let [a, b, c, d, e, f, g] = *xs;
([a, b, c, d, e, f].into(), Some(g))
},
Junctions::X8(xs) => {
let [a, b, c, d, e, f, g, h] = *xs;
([a, b, c, d, e, f, g].into(), Some(h))
},
}
}
pub fn take_first(&mut self) -> Option<Junction> {
let mut d = Junctions::Here;
mem::swap(&mut *self, &mut d);
let (tail, head) = d.split_first();
*self = tail;
head
}
pub fn take_last(&mut self) -> Option<Junction> {
let mut d = Junctions::Here;
mem::swap(&mut *self, &mut d);
let (head, tail) = d.split_last();
*self = head;
tail
}
pub fn push(&mut self, new: impl Into<Junction>) -> result::Result<(), Junction> {
let new = new.into();
let mut dummy = Junctions::Here;
mem::swap(self, &mut dummy);
match dummy.pushed_with(new) {
Ok(s) => {
*self = s;
Ok(())
},
Err((s, j)) => {
*self = s;
Err(j)
},
}
}
pub fn push_front(&mut self, new: impl Into<Junction>) -> result::Result<(), Junction> {
let new = new.into();
let mut dummy = Junctions::Here;
mem::swap(self, &mut dummy);
match dummy.pushed_front_with(new) {
Ok(s) => {
*self = s;
Ok(())
},
Err((s, j)) => {
*self = s;
Err(j)
},
}
}
pub fn pushed_with(self, new: impl Into<Junction>) -> result::Result<Self, (Self, Junction)> {
let new = new.into();
Ok(match self {
Junctions::Here => [new].into(),
Junctions::X1(xs) => {
let [a] = *xs;
[a, new].into()
},
Junctions::X2(xs) => {
let [a, b] = *xs;
[a, b, new].into()
},
Junctions::X3(xs) => {
let [a, b, c] = *xs;
[a, b, c, new].into()
},
Junctions::X4(xs) => {
let [a, b, c, d] = *xs;
[a, b, c, d, new].into()
},
Junctions::X5(xs) => {
let [a, b, c, d, e] = *xs;
[a, b, c, d, e, new].into()
},
Junctions::X6(xs) => {
let [a, b, c, d, e, f] = *xs;
[a, b, c, d, e, f, new].into()
},
Junctions::X7(xs) => {
let [a, b, c, d, e, f, g] = *xs;
[a, b, c, d, e, f, g, new].into()
},
s => Err((s, new))?,
})
}
pub fn pushed_front_with(
self,
new: impl Into<Junction>,
) -> result::Result<Self, (Self, Junction)> {
let new = new.into();
Ok(match self {
Junctions::Here => [new].into(),
Junctions::X1(xs) => {
let [a] = *xs;
[new, a].into()
},
Junctions::X2(xs) => {
let [a, b] = *xs;
[new, a, b].into()
},
Junctions::X3(xs) => {
let [a, b, c] = *xs;
[new, a, b, c].into()
},
Junctions::X4(xs) => {
let [a, b, c, d] = *xs;
[new, a, b, c, d].into()
},
Junctions::X5(xs) => {
let [a, b, c, d, e] = *xs;
[new, a, b, c, d, e].into()
},
Junctions::X6(xs) => {
let [a, b, c, d, e, f] = *xs;
[new, a, b, c, d, e, f].into()
},
Junctions::X7(xs) => {
let [a, b, c, d, e, f, g] = *xs;
[new, a, b, c, d, e, f, g].into()
},
s => Err((s, new))?,
})
}
pub fn append_with(&mut self, suffix: impl Into<Junctions>) -> Result<(), Junctions> {
let suffix = suffix.into();
if self.len().saturating_add(suffix.len()) > MAX_JUNCTIONS {
return Err(suffix)
}
for j in suffix.into_iter() {
self.push(j).expect("Already checked the sum of the len()s; qed")
}
Ok(())
}
pub fn len(&self) -> usize {
self.as_slice().len()
}
pub fn at(&self, i: usize) -> Option<&Junction> {
self.as_slice().get(i)
}
pub fn at_mut(&mut self, i: usize) -> Option<&mut Junction> {
self.as_slice_mut().get_mut(i)
}
pub fn iter(&self) -> JunctionsRefIterator {
JunctionsRefIterator { junctions: self, range: 0..self.len() }
}
pub fn match_and_split(&self, prefix: &Junctions) -> Option<&Junction> {
if prefix.len() + 1 != self.len() {
return None
}
for i in 0..prefix.len() {
if prefix.at(i) != self.at(i) {
return None
}
}
return self.at(prefix.len())
}
pub fn starts_with(&self, prefix: &Junctions) -> bool {
prefix.len() <= self.len() && prefix.iter().zip(self.iter()).all(|(x, y)| x == y)
}
}
impl TryFrom<Location> for Junctions {
type Error = Location;
fn try_from(x: Location) -> result::Result<Self, Location> {
if x.parent_count() > 0 {
Err(x)
} else {
Ok(x.interior().clone())
}
}
}
impl<T: Into<Junction>> From<T> for Junctions {
fn from(x: T) -> Self {
[x.into()].into()
}
}
impl From<[Junction; 0]> for Junctions {
fn from(_: [Junction; 0]) -> Self {
Self::Here
}
}
impl From<()> for Junctions {
fn from(_: ()) -> Self {
Self::Here
}
}
xcm_procedural::impl_conversion_functions_for_junctions_v5!();
#[cfg(test)]
mod tests {
use super::{super::prelude::*, *};
#[test]
fn inverting_works() {
let context: InteriorLocation = (Parachain(1000), PalletInstance(42)).into();
let target = (Parent, PalletInstance(69)).into();
let expected = (Parent, PalletInstance(42)).into();
let inverted = context.invert_target(&target).unwrap();
assert_eq!(inverted, expected);
let context: InteriorLocation =
(Parachain(1000), PalletInstance(42), GeneralIndex(1)).into();
let target = (Parent, Parent, PalletInstance(69), GeneralIndex(2)).into();
let expected = (Parent, Parent, PalletInstance(42), GeneralIndex(1)).into();
let inverted = context.invert_target(&target).unwrap();
assert_eq!(inverted, expected);
}
#[test]
fn relative_to_works() {
use NetworkId::*;
assert_eq!(
Junctions::from([Polkadot.into()]).relative_to(&Junctions::from([Kusama.into()])),
(Parent, Polkadot).into()
);
let base = Junctions::from([Kusama.into(), Parachain(1), PalletInstance(1)]);
assert_eq!(Here.relative_to(&base), (Parent, Parent, Parent).into());
assert_eq!(Junctions::from([Kusama.into()]).relative_to(&base), (Parent, Parent).into());
assert_eq!(
Junctions::from([Kusama.into(), Parachain(1)]).relative_to(&base),
(Parent,).into()
);
assert_eq!(
Junctions::from([Kusama.into(), Parachain(1), PalletInstance(1)]).relative_to(&base),
Here.into()
);
assert_eq!(
Junctions::from([Polkadot.into()]).relative_to(&base),
(Parent, Parent, Parent, Polkadot).into()
);
assert_eq!(
Junctions::from([Kusama.into(), Parachain(2)]).relative_to(&base),
(Parent, Parent, Parachain(2)).into()
);
assert_eq!(
Junctions::from([Kusama.into(), Parachain(1), PalletInstance(2)]).relative_to(&base),
(Parent, PalletInstance(2)).into()
);
assert_eq!(
Junctions::from([Kusama.into(), Parachain(1), PalletInstance(1), [1u8; 32].into()])
.relative_to(&base),
([1u8; 32],).into()
);
assert_eq!(
Junctions::from([Polkadot.into(), Parachain(1)]).relative_to(&base),
(Parent, Parent, Parent, Polkadot, Parachain(1)).into()
);
assert_eq!(
Junctions::from([Kusama.into(), Parachain(2), PalletInstance(1)]).relative_to(&base),
(Parent, Parent, Parachain(2), PalletInstance(1)).into()
);
assert_eq!(
Junctions::from([Kusama.into(), Parachain(1), PalletInstance(2), [1u8; 32].into()])
.relative_to(&base),
(Parent, PalletInstance(2), [1u8; 32]).into()
);
assert_eq!(
Junctions::from([
Kusama.into(),
Parachain(1),
PalletInstance(1),
[1u8; 32].into(),
1u128.into()
])
.relative_to(&base),
([1u8; 32], 1u128).into()
);
}
#[test]
fn global_consensus_works() {
use NetworkId::*;
assert_eq!(Junctions::from([Polkadot.into()]).global_consensus(), Ok(Polkadot));
assert_eq!(Junctions::from([Kusama.into(), 1u64.into()]).global_consensus(), Ok(Kusama));
assert_eq!(Here.global_consensus(), Err(()));
assert_eq!(Junctions::from([1u64.into()]).global_consensus(), Err(()));
assert_eq!(Junctions::from([1u64.into(), Kusama.into()]).global_consensus(), Err(()));
}
#[test]
fn test_conversion() {
use super::{Junction::*, NetworkId::*};
let x: Junctions = GlobalConsensus(Polkadot).into();
assert_eq!(x, Junctions::from([GlobalConsensus(Polkadot)]));
let x: Junctions = Polkadot.into();
assert_eq!(x, Junctions::from([GlobalConsensus(Polkadot)]));
let x: Junctions = (Polkadot, Kusama).into();
assert_eq!(x, Junctions::from([GlobalConsensus(Polkadot), GlobalConsensus(Kusama)]));
}
#[test]
fn encode_decode_junctions_works() {
let original = Junctions::from([
Polkadot.into(),
Kusama.into(),
1u64.into(),
GlobalConsensus(Polkadot),
Parachain(123),
PalletInstance(45),
]);
let encoded = original.encode();
assert_eq!(encoded, &[6, 9, 2, 9, 3, 2, 0, 4, 9, 2, 0, 237, 1, 4, 45]);
let decoded = Junctions::decode(&mut &encoded[..]).unwrap();
assert_eq!(decoded, original);
}
}