use crate::universal_exports::ensure_is_remote;
use alloc::vec::Vec;
use codec::{Compact, Decode, Encode};
use core::marker::PhantomData;
use frame_support::traits::Get;
use sp_io::hashing::blake2_256;
use sp_runtime::traits::{AccountIdConversion, TrailingZeroInput, TryConvert};
use xcm::latest::prelude::*;
use xcm_executor::traits::ConvertLocation;
pub trait DescribeLocation {
fn describe_location(location: &Location) -> Option<Vec<u8>>;
}
#[impl_trait_for_tuples::impl_for_tuples(30)]
impl DescribeLocation for Tuple {
fn describe_location(l: &Location) -> Option<Vec<u8>> {
for_tuples!( #(
match Tuple::describe_location(l) {
Some(result) => return Some(result),
None => {},
}
)* );
None
}
}
pub struct DescribeTerminus;
impl DescribeLocation for DescribeTerminus {
fn describe_location(l: &Location) -> Option<Vec<u8>> {
match l.unpack() {
(0, []) => Some(Vec::new()),
_ => return None,
}
}
}
pub struct DescribePalletTerminal;
impl DescribeLocation for DescribePalletTerminal {
fn describe_location(l: &Location) -> Option<Vec<u8>> {
match l.unpack() {
(0, [PalletInstance(i)]) => Some((b"Pallet", Compact::<u32>::from(*i as u32)).encode()),
_ => return None,
}
}
}
pub struct DescribeAccountId32Terminal;
impl DescribeLocation for DescribeAccountId32Terminal {
fn describe_location(l: &Location) -> Option<Vec<u8>> {
match l.unpack() {
(0, [AccountId32 { id, .. }]) => Some((b"AccountId32", id).encode()),
_ => return None,
}
}
}
pub struct DescribeAccountKey20Terminal;
impl DescribeLocation for DescribeAccountKey20Terminal {
fn describe_location(l: &Location) -> Option<Vec<u8>> {
match l.unpack() {
(0, [AccountKey20 { key, .. }]) => Some((b"AccountKey20", key).encode()),
_ => return None,
}
}
}
pub struct DescribeTreasuryVoiceTerminal;
impl DescribeLocation for DescribeTreasuryVoiceTerminal {
fn describe_location(location: &Location) -> Option<Vec<u8>> {
match location.unpack() {
(0, [Plurality { id: BodyId::Treasury, part: BodyPart::Voice }]) =>
Some((b"Treasury", b"Voice").encode()),
_ => None,
}
}
}
pub type DescribeAccountIdTerminal = (DescribeAccountId32Terminal, DescribeAccountKey20Terminal);
pub struct DescribeBodyTerminal;
impl DescribeLocation for DescribeBodyTerminal {
fn describe_location(l: &Location) -> Option<Vec<u8>> {
match l.unpack() {
(0, [Plurality { id, part }]) => Some((b"Body", id, part).encode()),
_ => return None,
}
}
}
pub type DescribeAllTerminal = (
DescribeTerminus,
DescribePalletTerminal,
DescribeAccountId32Terminal,
DescribeAccountKey20Terminal,
DescribeTreasuryVoiceTerminal,
DescribeBodyTerminal,
);
pub struct DescribeFamily<DescribeInterior>(PhantomData<DescribeInterior>);
impl<Suffix: DescribeLocation> DescribeLocation for DescribeFamily<Suffix> {
fn describe_location(l: &Location) -> Option<Vec<u8>> {
match (l.parent_count(), l.first_interior()) {
(0, Some(Parachain(index))) => {
let tail = l.clone().split_first_interior().0;
let interior = Suffix::describe_location(&tail.into())?;
Some((b"ChildChain", Compact::<u32>::from(*index), interior).encode())
},
(1, Some(Parachain(index))) => {
let tail_junctions = l.interior().clone().split_first().0;
let tail = Location::new(0, tail_junctions);
let interior = Suffix::describe_location(&tail)?;
Some((b"SiblingChain", Compact::<u32>::from(*index), interior).encode())
},
(1, _) => {
let tail = l.interior().clone().into();
let interior = Suffix::describe_location(&tail)?;
Some((b"ParentChain", interior).encode())
},
_ => return None,
}
}
}
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())
}
}
pub struct LegacyDescribeForeignChainAccount;
impl DescribeLocation for LegacyDescribeForeignChainAccount {
fn describe_location(location: &Location) -> Option<Vec<u8>> {
Some(match location.unpack() {
(0, [Parachain(para_id), AccountId32 { id, .. }]) =>
LegacyDescribeForeignChainAccount::from_para_32(para_id, id, 0),
(0, [Parachain(para_id), AccountKey20 { key, .. }]) =>
LegacyDescribeForeignChainAccount::from_para_20(para_id, key, 0),
(1, [Parachain(para_id), AccountId32 { id, .. }]) =>
LegacyDescribeForeignChainAccount::from_para_32(para_id, id, 1),
(1, [Parachain(para_id), AccountKey20 { key, .. }]) =>
LegacyDescribeForeignChainAccount::from_para_20(para_id, key, 1),
(1, [AccountId32 { id, .. }]) =>
LegacyDescribeForeignChainAccount::from_relay_32(id, 1),
_ => return None,
})
}
}
pub const FOREIGN_CHAIN_PREFIX_PARA_32: [u8; 37] = *b"ForeignChainAliasAccountPrefix_Para32";
pub const FOREIGN_CHAIN_PREFIX_PARA_20: [u8; 37] = *b"ForeignChainAliasAccountPrefix_Para20";
pub const FOREIGN_CHAIN_PREFIX_RELAY: [u8; 36] = *b"ForeignChainAliasAccountPrefix_Relay";
impl LegacyDescribeForeignChainAccount {
fn from_para_32(para_id: &u32, id: &[u8; 32], parents: u8) -> Vec<u8> {
(FOREIGN_CHAIN_PREFIX_PARA_32, para_id, id, parents).encode()
}
fn from_para_20(para_id: &u32, id: &[u8; 20], parents: u8) -> Vec<u8> {
(FOREIGN_CHAIN_PREFIX_PARA_20, para_id, id, parents).encode()
}
fn from_relay_32(id: &[u8; 32], parents: u8) -> Vec<u8> {
(FOREIGN_CHAIN_PREFIX_RELAY, id, parents).encode()
}
}
#[deprecated = "Use `HashedDescription<AccountId, LegacyDescribeForeignChainAccount>` instead"]
pub type ForeignChainAliasAccount<AccountId> =
HashedDescription<AccountId, LegacyDescribeForeignChainAccount>;
pub struct Account32Hash<Network, AccountId>(PhantomData<(Network, AccountId)>);
impl<Network: Get<Option<NetworkId>>, AccountId: From<[u8; 32]> + Into<[u8; 32]> + Clone>
ConvertLocation<AccountId> for Account32Hash<Network, AccountId>
{
fn convert_location(location: &Location) -> Option<AccountId> {
Some(("multiloc", location).using_encoded(blake2_256).into())
}
}
pub struct ParentIsPreset<AccountId>(PhantomData<AccountId>);
impl<AccountId: Decode + Eq + Clone> ConvertLocation<AccountId> for ParentIsPreset<AccountId> {
fn convert_location(location: &Location) -> Option<AccountId> {
if location.contains_parents_only(1) {
Some(
b"Parent"
.using_encoded(|b| AccountId::decode(&mut TrailingZeroInput::new(b)))
.expect("infinite length input; no invalid inputs for type; qed"),
)
} else {
None
}
}
}
pub struct ChildParachainConvertsVia<ParaId, AccountId>(PhantomData<(ParaId, AccountId)>);
impl<ParaId: From<u32> + Into<u32> + AccountIdConversion<AccountId>, AccountId: Clone>
ConvertLocation<AccountId> for ChildParachainConvertsVia<ParaId, AccountId>
{
fn convert_location(location: &Location) -> Option<AccountId> {
match location.unpack() {
(0, [Parachain(id)]) => Some(ParaId::from(*id).into_account_truncating()),
_ => None,
}
}
}
pub struct SiblingParachainConvertsVia<ParaId, AccountId>(PhantomData<(ParaId, AccountId)>);
impl<ParaId: From<u32> + Into<u32> + AccountIdConversion<AccountId>, AccountId: Clone>
ConvertLocation<AccountId> for SiblingParachainConvertsVia<ParaId, AccountId>
{
fn convert_location(location: &Location) -> Option<AccountId> {
match location.unpack() {
(1, [Parachain(id)]) => Some(ParaId::from(*id).into_account_truncating()),
_ => None,
}
}
}
pub struct AccountId32Aliases<Network, AccountId>(PhantomData<(Network, AccountId)>);
impl<Network: Get<Option<NetworkId>>, AccountId: From<[u8; 32]> + Into<[u8; 32]> + Clone>
ConvertLocation<AccountId> for AccountId32Aliases<Network, AccountId>
{
fn convert_location(location: &Location) -> Option<AccountId> {
let id = match location.unpack() {
(0, [AccountId32 { id, network: None }]) => id,
(0, [AccountId32 { id, network }]) if *network == Network::get() => id,
_ => return None,
};
Some((*id).into())
}
}
pub struct LocalTreasuryVoiceConvertsVia<TreasuryAccount, AccountId>(
PhantomData<(TreasuryAccount, AccountId)>,
);
impl<TreasuryAccount: Get<AccountId>, AccountId: From<[u8; 32]> + Into<[u8; 32]> + Clone>
ConvertLocation<AccountId> for LocalTreasuryVoiceConvertsVia<TreasuryAccount, AccountId>
{
fn convert_location(location: &Location) -> Option<AccountId> {
match location.unpack() {
(0, [Plurality { id: BodyId::Treasury, part: BodyPart::Voice }]) =>
Some((TreasuryAccount::get().into() as [u8; 32]).into()),
_ => None,
}
}
}
pub struct AliasesIntoAccountId32<Network, AccountId>(PhantomData<(Network, AccountId)>);
impl<'a, Network: Get<Option<NetworkId>>, AccountId: Clone + Into<[u8; 32]> + Clone>
TryConvert<&'a AccountId, Location> for AliasesIntoAccountId32<Network, AccountId>
{
fn try_convert(who: &AccountId) -> Result<Location, &AccountId> {
Ok(AccountId32 { network: Network::get(), id: who.clone().into() }.into())
}
}
pub struct AccountKey20Aliases<Network, AccountId>(PhantomData<(Network, AccountId)>);
impl<Network: Get<Option<NetworkId>>, AccountId: From<[u8; 20]> + Into<[u8; 20]> + Clone>
ConvertLocation<AccountId> for AccountKey20Aliases<Network, AccountId>
{
fn convert_location(location: &Location) -> Option<AccountId> {
let key = match location.unpack() {
(0, [AccountKey20 { key, network: None }]) => key,
(0, [AccountKey20 { key, network }]) if *network == Network::get() => key,
_ => return None,
};
Some((*key).into())
}
}
pub struct GlobalConsensusConvertsFor<UniversalLocation, AccountId>(
PhantomData<(UniversalLocation, AccountId)>,
);
impl<UniversalLocation: Get<InteriorLocation>, AccountId: From<[u8; 32]> + Clone>
ConvertLocation<AccountId> for GlobalConsensusConvertsFor<UniversalLocation, AccountId>
{
fn convert_location(location: &Location) -> Option<AccountId> {
let universal_source = UniversalLocation::get();
log::trace!(
target: "xcm::location_conversion",
"GlobalConsensusConvertsFor universal_source: {:?}, location: {:?}",
universal_source, location,
);
let (remote_network, remote_location) =
ensure_is_remote(universal_source, location.clone()).ok()?;
match remote_location {
Here => Some(AccountId::from(Self::from_params(&remote_network))),
_ => None,
}
}
}
impl<UniversalLocation, AccountId> GlobalConsensusConvertsFor<UniversalLocation, AccountId> {
fn from_params(network: &NetworkId) -> [u8; 32] {
(b"glblcnsnss_", network).using_encoded(blake2_256)
}
}
pub struct GlobalConsensusParachainConvertsFor<UniversalLocation, AccountId>(
PhantomData<(UniversalLocation, AccountId)>,
);
impl<UniversalLocation: Get<InteriorLocation>, AccountId: From<[u8; 32]> + Clone>
ConvertLocation<AccountId> for GlobalConsensusParachainConvertsFor<UniversalLocation, AccountId>
{
fn convert_location(location: &Location) -> Option<AccountId> {
let universal_source = UniversalLocation::get();
log::trace!(
target: "xcm::location_conversion",
"GlobalConsensusParachainConvertsFor universal_source: {:?}, location: {:?}",
universal_source, location,
);
let devolved = ensure_is_remote(universal_source, location.clone()).ok()?;
let (remote_network, remote_location) = devolved;
match remote_location.as_slice() {
[Parachain(remote_network_para_id)] =>
Some(AccountId::from(Self::from_params(&remote_network, &remote_network_para_id))),
_ => None,
}
}
}
impl<UniversalLocation, AccountId>
GlobalConsensusParachainConvertsFor<UniversalLocation, AccountId>
{
fn from_params(network: &NetworkId, para_id: &u32) -> [u8; 32] {
(b"glblcnsnss/prchn_", network, para_id).using_encoded(blake2_256)
}
}
#[cfg(test)]
mod tests {
use super::*;
use alloc::vec;
use polkadot_primitives::AccountId;
pub type ForeignChainAliasAccount<AccountId> =
HashedDescription<AccountId, LegacyDescribeForeignChainAccount>;
pub type ForeignChainAliasTreasuryAccount<AccountId> =
HashedDescription<AccountId, DescribeFamily<DescribeTreasuryVoiceTerminal>>;
use frame_support::parameter_types;
use xcm::latest::Junction;
fn account20() -> Junction {
AccountKey20 { network: None, key: Default::default() }
}
fn account32() -> Junction {
AccountId32 { network: None, id: Default::default() }
}
#[test]
fn inverter_works_in_tree() {
parameter_types! {
pub UniversalLocation: InteriorLocation = [Parachain(1), account20(), account20()].into();
}
let input = Location::new(3, [Parachain(2), account32()]);
let inverted = UniversalLocation::get().invert_target(&input).unwrap();
assert_eq!(inverted, Location::new(2, [Parachain(1), account20(), account20()]));
}
#[test]
fn inverter_uses_context_as_inverted_location() {
parameter_types! {
pub UniversalLocation: InteriorLocation = [account20(), account20()].into();
}
let input = Location::new(2, Here);
let inverted = UniversalLocation::get().invert_target(&input).unwrap();
assert_eq!(inverted, [account20(), account20()].into());
}
#[test]
fn inverter_uses_only_child_on_missing_context() {
parameter_types! {
pub UniversalLocation: InteriorLocation = PalletInstance(5).into();
}
let input = Location::new(2, Here);
let inverted = UniversalLocation::get().invert_target(&input).unwrap();
assert_eq!(inverted, (OnlyChild, PalletInstance(5)).into());
}
#[test]
fn inverter_errors_when_location_is_too_large() {
parameter_types! {
pub UniversalLocation: InteriorLocation = Here;
}
let input = Location { parents: 99, interior: [Parachain(88)].into() };
let inverted = UniversalLocation::get().invert_target(&input);
assert_eq!(inverted, Err(()));
}
#[test]
fn global_consensus_converts_for_works() {
parameter_types! {
pub UniversalLocationInNetwork1: InteriorLocation = [GlobalConsensus(ByGenesis([1; 32])), Parachain(1234)].into();
pub UniversalLocationInNetwork2: InteriorLocation = [GlobalConsensus(ByGenesis([2; 32])), Parachain(1234)].into();
}
let network_1 = UniversalLocationInNetwork1::get().global_consensus().expect("NetworkId");
let network_2 = UniversalLocationInNetwork2::get().global_consensus().expect("NetworkId");
let network_3 = ByGenesis([3; 32]);
let network_4 = ByGenesis([4; 32]);
let network_5 = ByGenesis([5; 32]);
let test_data = vec![
(Location::parent(), false),
(Location::new(0, Here), false),
(Location::new(0, [GlobalConsensus(network_1)]), false),
(Location::new(1, [GlobalConsensus(network_1)]), false),
(Location::new(2, [GlobalConsensus(network_1)]), false),
(Location::new(0, [GlobalConsensus(network_2)]), false),
(Location::new(1, [GlobalConsensus(network_2)]), false),
(Location::new(2, [GlobalConsensus(network_2)]), true),
(Location::new(0, [GlobalConsensus(network_2), Parachain(1000)]), false),
(Location::new(1, [GlobalConsensus(network_2), Parachain(1000)]), false),
(Location::new(2, [GlobalConsensus(network_2), Parachain(1000)]), false),
];
for (location, expected_result) in test_data {
let result =
GlobalConsensusConvertsFor::<UniversalLocationInNetwork1, [u8; 32]>::convert_location(
&location,
);
match result {
Some(account) => {
assert_eq!(
true, expected_result,
"expected_result: {}, but conversion passed: {:?}, location: {:?}",
expected_result, account, location
);
match location.unpack() {
(_, [GlobalConsensus(network)]) =>
assert_eq!(
account,
GlobalConsensusConvertsFor::<UniversalLocationInNetwork1, [u8; 32]>::from_params(network),
"expected_result: {}, but conversion passed: {:?}, location: {:?}", expected_result, account, location
),
_ => panic!("expected_result: {}, conversion passed: {:?}, but Location does not match expected pattern, location: {:?}", expected_result, account, location)
}
},
None => {
assert_eq!(
false, expected_result,
"expected_result: {} - but conversion failed, location: {:?}",
expected_result, location
);
},
}
}
let res_1_gc_network_3 =
GlobalConsensusConvertsFor::<UniversalLocationInNetwork1, [u8; 32]>::convert_location(
&Location::new(2, [GlobalConsensus(network_3)]),
)
.expect("conversion is ok");
let res_2_gc_network_3 =
GlobalConsensusConvertsFor::<UniversalLocationInNetwork2, [u8; 32]>::convert_location(
&Location::new(2, [GlobalConsensus(network_3)]),
)
.expect("conversion is ok");
let res_1_gc_network_4 =
GlobalConsensusConvertsFor::<UniversalLocationInNetwork1, [u8; 32]>::convert_location(
&Location::new(2, [GlobalConsensus(network_4)]),
)
.expect("conversion is ok");
let res_2_gc_network_4 =
GlobalConsensusConvertsFor::<UniversalLocationInNetwork2, [u8; 32]>::convert_location(
&Location::new(2, [GlobalConsensus(network_4)]),
)
.expect("conversion is ok");
let res_1_gc_network_5 =
GlobalConsensusConvertsFor::<UniversalLocationInNetwork1, [u8; 32]>::convert_location(
&Location::new(2, [GlobalConsensus(network_5)]),
)
.expect("conversion is ok");
let res_2_gc_network_5 =
GlobalConsensusConvertsFor::<UniversalLocationInNetwork2, [u8; 32]>::convert_location(
&Location::new(2, [GlobalConsensus(network_5)]),
)
.expect("conversion is ok");
assert_ne!(res_1_gc_network_3, res_1_gc_network_4);
assert_ne!(res_1_gc_network_4, res_1_gc_network_5);
assert_ne!(res_1_gc_network_3, res_1_gc_network_5);
assert_eq!(res_1_gc_network_3, res_2_gc_network_3);
assert_eq!(res_1_gc_network_4, res_2_gc_network_4);
assert_eq!(res_1_gc_network_5, res_2_gc_network_5);
}
#[test]
fn global_consensus_parachain_converts_for_works() {
parameter_types! {
pub UniversalLocation: InteriorLocation = [GlobalConsensus(ByGenesis([9; 32])), Parachain(1234)].into();
}
let test_data = vec![
(Location::parent(), false),
(Location::new(0, [Parachain(1000)]), false),
(Location::new(1, [Parachain(1000)]), false),
(
Location::new(
2,
[
GlobalConsensus(ByGenesis([0; 32])),
Parachain(1000),
AccountId32 { network: None, id: [1; 32].into() },
],
),
false,
),
(Location::new(2, [GlobalConsensus(ByGenesis([0; 32]))]), false),
(Location::new(0, [GlobalConsensus(ByGenesis([0; 32])), Parachain(1000)]), false),
(Location::new(1, [GlobalConsensus(ByGenesis([0; 32])), Parachain(1000)]), false),
(Location::new(2, [GlobalConsensus(ByGenesis([0; 32])), Parachain(1000)]), true),
(Location::new(3, [GlobalConsensus(ByGenesis([0; 32])), Parachain(1000)]), false),
(Location::new(9, [GlobalConsensus(ByGenesis([0; 32])), Parachain(1000)]), false),
];
for (location, expected_result) in test_data {
let result =
GlobalConsensusParachainConvertsFor::<UniversalLocation, [u8; 32]>::convert_location(
&location,
);
match result {
Some(account) => {
assert_eq!(
true, expected_result,
"expected_result: {}, but conversion passed: {:?}, location: {:?}",
expected_result, account, location
);
match location.unpack() {
(_, [GlobalConsensus(network), Parachain(para_id)]) =>
assert_eq!(
account,
GlobalConsensusParachainConvertsFor::<UniversalLocation, [u8; 32]>::from_params(network, para_id),
"expected_result: {}, but conversion passed: {:?}, location: {:?}", expected_result, account, location
),
_ => assert_eq!(
true,
expected_result,
"expected_result: {}, conversion passed: {:?}, but Location does not match expected pattern, location: {:?}", expected_result, account, location
)
}
},
None => {
assert_eq!(
false, expected_result,
"expected_result: {} - but conversion failed, location: {:?}",
expected_result, location
);
},
}
}
let res_gc_a_p1000 =
GlobalConsensusParachainConvertsFor::<UniversalLocation, [u8; 32]>::convert_location(
&Location::new(2, [GlobalConsensus(ByGenesis([3; 32])), Parachain(1000)]),
)
.expect("conversion is ok");
let res_gc_a_p1001 =
GlobalConsensusParachainConvertsFor::<UniversalLocation, [u8; 32]>::convert_location(
&Location::new(2, [GlobalConsensus(ByGenesis([3; 32])), Parachain(1001)]),
)
.expect("conversion is ok");
let res_gc_b_p1000 =
GlobalConsensusParachainConvertsFor::<UniversalLocation, [u8; 32]>::convert_location(
&Location::new(2, [GlobalConsensus(ByGenesis([4; 32])), Parachain(1000)]),
)
.expect("conversion is ok");
let res_gc_b_p1001 =
GlobalConsensusParachainConvertsFor::<UniversalLocation, [u8; 32]>::convert_location(
&Location::new(2, [GlobalConsensus(ByGenesis([4; 32])), Parachain(1001)]),
)
.expect("conversion is ok");
assert_ne!(res_gc_a_p1000, res_gc_a_p1001);
assert_ne!(res_gc_a_p1000, res_gc_b_p1000);
assert_ne!(res_gc_a_p1000, res_gc_b_p1001);
assert_ne!(res_gc_b_p1000, res_gc_b_p1001);
assert_ne!(res_gc_b_p1000, res_gc_a_p1001);
assert_ne!(res_gc_b_p1001, res_gc_a_p1001);
}
#[test]
fn remote_account_convert_on_para_sending_para_32() {
let mul = Location {
parents: 1,
interior: [Parachain(1), AccountId32 { network: None, id: [0u8; 32] }].into(),
};
let rem_1 = ForeignChainAliasAccount::<[u8; 32]>::convert_location(&mul).unwrap();
assert_eq!(
[
181, 186, 132, 152, 52, 210, 226, 199, 8, 235, 213, 242, 94, 70, 250, 170, 19, 163,
196, 102, 245, 14, 172, 184, 2, 148, 108, 87, 230, 163, 204, 32
],
rem_1
);
let mul = Location {
parents: 1,
interior: [
Parachain(1),
AccountId32 { network: Some(NetworkId::Polkadot), id: [0u8; 32] },
]
.into(),
};
assert_eq!(ForeignChainAliasAccount::<[u8; 32]>::convert_location(&mul).unwrap(), rem_1);
let mul = Location {
parents: 1,
interior: [Parachain(2), AccountId32 { network: None, id: [0u8; 32] }].into(),
};
let rem_2 = ForeignChainAliasAccount::<[u8; 32]>::convert_location(&mul).unwrap();
assert_eq!(
[
183, 188, 66, 169, 82, 250, 45, 30, 142, 119, 184, 55, 177, 64, 53, 114, 12, 147,
128, 10, 60, 45, 41, 193, 87, 18, 86, 49, 127, 233, 243, 143
],
rem_2
);
assert_ne!(rem_1, rem_2);
}
#[test]
fn remote_account_convert_on_para_sending_para_20() {
let mul = Location {
parents: 1,
interior: [Parachain(1), AccountKey20 { network: None, key: [0u8; 20] }].into(),
};
let rem_1 = ForeignChainAliasAccount::<[u8; 32]>::convert_location(&mul).unwrap();
assert_eq!(
[
210, 60, 37, 255, 116, 38, 221, 26, 85, 82, 252, 125, 220, 19, 41, 91, 185, 69,
102, 83, 120, 63, 15, 212, 74, 141, 82, 203, 187, 212, 77, 120
],
rem_1
);
let mul = Location {
parents: 1,
interior: [
Parachain(1),
AccountKey20 { network: Some(NetworkId::Polkadot), key: [0u8; 20] },
]
.into(),
};
assert_eq!(ForeignChainAliasAccount::<[u8; 32]>::convert_location(&mul).unwrap(), rem_1);
let mul = Location {
parents: 1,
interior: [Parachain(2), AccountKey20 { network: None, key: [0u8; 20] }].into(),
};
let rem_2 = ForeignChainAliasAccount::<[u8; 32]>::convert_location(&mul).unwrap();
assert_eq!(
[
197, 16, 31, 199, 234, 80, 166, 55, 178, 135, 95, 48, 19, 128, 9, 167, 51, 99, 215,
147, 94, 171, 28, 157, 29, 107, 240, 22, 10, 104, 99, 186
],
rem_2
);
assert_ne!(rem_1, rem_2);
}
#[test]
fn remote_account_convert_on_para_sending_relay() {
let mul = Location {
parents: 1,
interior: [AccountId32 { network: None, id: [0u8; 32] }].into(),
};
let rem_1 = ForeignChainAliasAccount::<[u8; 32]>::convert_location(&mul).unwrap();
assert_eq!(
[
227, 12, 152, 241, 220, 53, 26, 27, 1, 167, 167, 214, 61, 161, 255, 96, 56, 16,
221, 59, 47, 45, 40, 193, 88, 92, 4, 167, 164, 27, 112, 99
],
rem_1
);
let mul = Location {
parents: 1,
interior: [AccountId32 { network: Some(NetworkId::Polkadot), id: [0u8; 32] }].into(),
};
assert_eq!(ForeignChainAliasAccount::<[u8; 32]>::convert_location(&mul).unwrap(), rem_1);
let mul = Location {
parents: 1,
interior: [AccountId32 { network: None, id: [1u8; 32] }].into(),
};
let rem_2 = ForeignChainAliasAccount::<[u8; 32]>::convert_location(&mul).unwrap();
assert_eq!(
[
143, 195, 87, 73, 129, 2, 163, 211, 239, 51, 55, 235, 82, 173, 162, 206, 158, 237,
166, 73, 254, 62, 131, 6, 170, 241, 209, 116, 105, 69, 29, 226
],
rem_2
);
assert_ne!(rem_1, rem_2);
}
#[test]
fn remote_account_convert_on_relay_sending_para_20() {
let mul = Location {
parents: 0,
interior: [Parachain(1), AccountKey20 { network: None, key: [0u8; 20] }].into(),
};
let rem_1 = ForeignChainAliasAccount::<[u8; 32]>::convert_location(&mul).unwrap();
assert_eq!(
[
25, 251, 15, 92, 148, 141, 236, 238, 50, 108, 133, 56, 118, 11, 250, 122, 81, 160,
104, 160, 97, 200, 210, 49, 208, 142, 64, 144, 24, 110, 246, 101
],
rem_1
);
let mul = Location {
parents: 0,
interior: [Parachain(2), AccountKey20 { network: None, key: [0u8; 20] }].into(),
};
let rem_2 = ForeignChainAliasAccount::<[u8; 32]>::convert_location(&mul).unwrap();
assert_eq!(
[
88, 157, 224, 235, 76, 88, 201, 143, 206, 227, 14, 192, 177, 245, 75, 62, 41, 10,
107, 182, 61, 57, 239, 112, 43, 151, 58, 111, 150, 153, 234, 189
],
rem_2
);
assert_ne!(rem_1, rem_2);
}
#[test]
fn remote_account_convert_on_relay_sending_para_32() {
let mul = Location {
parents: 0,
interior: [Parachain(1), AccountId32 { network: None, id: [0u8; 32] }].into(),
};
let rem_1 = ForeignChainAliasAccount::<[u8; 32]>::convert_location(&mul).unwrap();
assert_eq!(
[
45, 120, 232, 0, 226, 49, 106, 48, 65, 181, 184, 147, 224, 235, 198, 152, 183, 156,
67, 57, 67, 67, 187, 104, 171, 23, 140, 21, 183, 152, 63, 20
],
rem_1
);
let mul = Location {
parents: 0,
interior: [
Parachain(1),
AccountId32 { network: Some(NetworkId::Polkadot), id: [0u8; 32] },
]
.into(),
};
assert_eq!(ForeignChainAliasAccount::<[u8; 32]>::convert_location(&mul).unwrap(), rem_1);
let mul = Location {
parents: 0,
interior: [Parachain(2), AccountId32 { network: None, id: [0u8; 32] }].into(),
};
let rem_2 = ForeignChainAliasAccount::<[u8; 32]>::convert_location(&mul).unwrap();
assert_eq!(
[
97, 119, 110, 66, 239, 113, 96, 234, 127, 92, 66, 204, 53, 129, 33, 119, 213, 192,
171, 100, 139, 51, 39, 62, 196, 163, 16, 213, 160, 44, 100, 228
],
rem_2
);
assert_ne!(rem_1, rem_2);
}
#[test]
fn remote_account_fails_with_bad_location() {
let mul = Location {
parents: 1,
interior: [AccountKey20 { network: None, key: [0u8; 20] }].into(),
};
assert!(ForeignChainAliasAccount::<[u8; 32]>::convert_location(&mul).is_none());
}
#[test]
fn remote_account_convert_on_para_sending_from_remote_para_treasury() {
let relay_treasury_to_para_location =
Location::new(1, [Plurality { id: BodyId::Treasury, part: BodyPart::Voice }]);
let actual_description = ForeignChainAliasTreasuryAccount::<[u8; 32]>::convert_location(
&relay_treasury_to_para_location,
)
.unwrap();
assert_eq!(
[
18, 84, 93, 74, 187, 212, 254, 71, 192, 127, 112, 51, 3, 42, 54, 24, 220, 185, 161,
67, 205, 154, 108, 116, 108, 166, 226, 211, 29, 11, 244, 115
],
actual_description
);
let para_to_para_treasury_location = Location::new(
1,
[Parachain(1001), Plurality { id: BodyId::Treasury, part: BodyPart::Voice }],
);
let actual_description = ForeignChainAliasTreasuryAccount::<[u8; 32]>::convert_location(
¶_to_para_treasury_location,
)
.unwrap();
assert_eq!(
[
202, 52, 249, 30, 7, 99, 135, 128, 153, 139, 176, 141, 138, 234, 163, 150, 7, 36,
204, 92, 220, 137, 87, 57, 73, 91, 243, 189, 245, 200, 217, 204
],
actual_description
);
}
#[test]
fn local_account_convert_on_para_from_relay_treasury() {
let location =
Location::new(0, [Plurality { id: BodyId::Treasury, part: BodyPart::Voice }]);
parameter_types! {
pub TreasuryAccountId: AccountId = AccountId::new([42u8; 32]);
}
let actual_description =
LocalTreasuryVoiceConvertsVia::<TreasuryAccountId, [u8; 32]>::convert_location(
&location,
)
.unwrap();
assert_eq!(
[
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42
],
actual_description
);
}
}