Unverified Commit 3a71a078 authored by Alexander Popiak's avatar Alexander Popiak Committed by GitHub
Browse files

add integration tests to xcm-builder (#3537)



* add integration tests to xcm-builder

* add an integration test for reserve_transfer_assets

* add query holding and teleport tests

* formatting

* add to barrier doc comments and fix doc tests warnings

* use more realistic barrier for integration tests

* improve imports

* adjust base xcm weight and existential deposit to be in line with Kusama

* remove AnyNetwork
Co-authored-by: default avatarAmar Singh <asinghchrony@protonmail.com>

* add more comments and remove unnecessary code

* move mock into separate file

* reduce imports

* update cargo.lock

* remove reserve transfer test from xcm builder integration tests

* reword barrier doc comment

* elaborate on QueryHolding test scenario

* add an integration test for reserve based transfers from parachain to parachain

* add teleport tests

* fix failing teleport filter tests

* Update xcm/xcm-builder/src/integration_tests.rs
Co-authored-by: default avatarKian Paimani <5588131+kianenigma@users.noreply.github.com>

* Update xcm/xcm-builder/src/integration_tests.rs
Co-authored-by: default avatarKian Paimani <5588131+kianenigma@users.noreply.github.com>

* Update xcm/xcm-builder/src/integration_tests.rs
Co-authored-by: default avatarKian Paimani <5588131+kianenigma@users.noreply.github.com>

* Move integration tests to tests/ directory

* Fix merge

* Replace All wildcard with a concrete seed amount

* Rename SEED_AMOUNT to REGISTER_AMOUNT

* Fix compilation error

* Check for teleport destination first before checking out assets

* Fix unit test

* Do not run tests in integration mock

* Add a permissive assets filter for teleportation

* Remove check for teleport location in InitiateTeleport XCM

* Remove defunct test

* Apply suggestions from code review
Co-authored-by: default avatarKian Paimani <5588131+kianenigma@users.noreply.github.com>

* Reword comment
Co-authored-by: default avatarAmar Singh <asinghchrony@protonmail.com>
Co-authored-by: default avatarKian Paimani <5588131+kianenigma@users.noreply.github.com>
Co-authored-by: Keith Yeung's avatarKeith Yeung <kungfukeith11@gmail.com>
parent dc213bd2
Pipeline #153193 failed with stages
in 8 minutes and 33 seconds
......@@ -11845,10 +11845,14 @@ dependencies = [
"frame-support",
"frame-system",
"impl-trait-for-tuples",
"pallet-balances",
"pallet-transaction-payment",
"pallet-xcm",
"parity-scale-codec",
"polkadot-parachain",
"polkadot-runtime-parachains",
"sp-arithmetic",
"sp-core",
"sp-io",
"sp-runtime",
"sp-std",
......
......@@ -25,7 +25,7 @@ use xcm::{
opaque::latest::{Error as XcmError, MultiAsset, Result as XcmResult, SendXcm, Xcm},
};
use xcm_builder::{
AccountId32Aliases, AllowTopLevelPaidExecutionFrom, ChildParachainAsNative,
AccountId32Aliases, AllowTopLevelPaidExecutionFrom, Case, ChildParachainAsNative,
ChildParachainConvertsVia, ChildSystemParachainAsSuperuser,
CurrencyAdapter as XcmCurrencyAdapter, FixedRateOfFungible, FixedWeightBounds, IsConcrete,
LocationInverter, SignedAccountId32AsNative, SignedToAccountId32, SovereignSignedViaLocation,
......@@ -151,6 +151,7 @@ type LocalOriginConverter = (
parameter_types! {
pub const BaseXcmWeight: Weight = 1_000;
pub CurrencyPerSecond: (AssetId, u128) = (Concrete(RelayLocation::get()), 1);
pub TrustedAssets: (MultiAssetFilter, MultiLocation) = (All.into(), Here.into());
}
pub type Barrier = (TakeWeightCredit, AllowTopLevelPaidExecutionFrom<Everything>);
......@@ -162,7 +163,7 @@ impl xcm_executor::Config for XcmConfig {
type AssetTransactor = LocalAssetTransactor;
type OriginConverter = LocalOriginConverter;
type IsReserve = ();
type IsTeleporter = ();
type IsTeleporter = Case<TrustedAssets>;
type LocationInverter = LocationInverter<Ancestry>;
type Barrier = Barrier;
type Weigher = FixedWeightBounds<BaseXcmWeight, Call>;
......
......@@ -21,6 +21,11 @@ pallet-transaction-payment = { git = "https://github.com/paritytech/substrate",
# Polkadot dependencies
polkadot-parachain = { path = "../../parachain", default-features = false }
[dev-dependencies]
sp-core = { git = "https://github.com/paritytech/substrate", branch = "master" }
pallet-balances = { git = "https://github.com/paritytech/substrate", branch = "master" }
pallet-xcm = { path = "../pallet-xcm" }
polkadot-runtime-parachains = { path = "../../runtime/parachains" }
[features]
default = ["std"]
runtime-benchmarks = []
......
......@@ -23,6 +23,10 @@ use xcm::latest::{Junction, Junctions, MultiLocation, Order, Xcm};
use xcm_executor::traits::{OnResponse, ShouldExecute};
/// Execution barrier that just takes `shallow_weight` from `weight_credit`.
///
/// Useful to allow XCM execution by local chain users via extrinsics.
/// E.g. `pallet_xcm::reserve_asset_transfer` to transfer a reserve asset
/// out of the local chain to another one.
pub struct TakeWeightCredit;
impl ShouldExecute for TakeWeightCredit {
fn should_execute<Call>(
......@@ -39,6 +43,9 @@ impl ShouldExecute for TakeWeightCredit {
/// Allows execution from `origin` if it is contained in `T` (i.e. `T::Contains(origin)`) taking payments into
/// account.
///
/// Only allows for `TeleportAsset`, `WithdrawAsset` and `ReserveAssetDeposit` XCMs because they are the only ones
/// that place assets in the Holding Register to pay for execution.
pub struct AllowTopLevelPaidExecutionFrom<T>(PhantomData<T>);
impl<T: Contains<MultiLocation>> ShouldExecute for AllowTopLevelPaidExecutionFrom<T> {
fn should_execute<Call>(
......
......@@ -61,8 +61,8 @@ impl From<Error> for XcmError {
///
/// /// Our relay chain's location.
/// parameter_types! {
/// RelayChain: MultiLocation = Parent.into();
/// CheckingAccount: AccountId = Default::default();
/// pub RelayChain: MultiLocation = Parent.into();
/// pub CheckingAccount: AccountId = Default::default();
/// }
///
/// /// Some items that implement `Convert<MultiLocation, AccountId>`. Can be more, but for now we just assume we accept
......
......@@ -119,8 +119,8 @@ thread_local! {
pub fn assets(who: u64) -> Vec<MultiAsset> {
ASSETS.with(|a| a.borrow().get(&who).map_or(vec![], |a| a.clone().into()))
}
pub fn add_asset(who: u64, what: MultiAsset) {
ASSETS.with(|a| a.borrow_mut().entry(who).or_insert(Assets::new()).subsume(what));
pub fn add_asset<AssetArg: Into<MultiAsset>>(who: u64, what: AssetArg) {
ASSETS.with(|a| a.borrow_mut().entry(who).or_insert(Assets::new()).subsume(what.into()));
}
pub struct TestAssetTransactor;
......
......@@ -223,7 +223,7 @@ fn transfer_should_work() {
// we'll let them have message execution for free.
AllowUnpaidFrom::set(vec![X1(Parachain(1)).into()]);
// Child parachain #1 owns 1000 tokens held by us in reserve.
add_asset(1001, (Here, 1000).into());
add_asset(1001, (Here, 1000));
// They want to transfer 100 of them to their sibling parachain #2
let r = XcmExecutor::<TestConfig>::execute_xcm(
Parachain(1).into(),
......@@ -243,7 +243,7 @@ fn transfer_should_work() {
fn reserve_transfer_should_work() {
AllowUnpaidFrom::set(vec![X1(Parachain(1)).into()]);
// Child parachain #1 owns 1000 tokens held by us in reserve.
add_asset(1001, (Here, 1000).into());
add_asset(1001, (Here, 1000));
// The remote account owned by gav.
let three: MultiLocation = X1(AccountIndex64 { index: 3, network: Any }).into();
......@@ -330,7 +330,7 @@ fn transacting_should_refund_weight() {
fn paid_transacting_should_refund_payment_for_unused_weight() {
let one: MultiLocation = X1(AccountIndex64 { index: 1, network: Any }).into();
AllowPaidFrom::set(vec![one.clone()]);
add_asset(1, (Parent, 100).into());
add_asset(1, (Parent, 100));
WeightPrice::set((Parent.into(), 1_000_000_000_000));
let origin = one.clone();
......
// Copyright 2021 Parity Technologies (UK) Ltd.
// This file is part of Polkadot.
// Polkadot is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// Polkadot is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with Polkadot. If not, see <http://www.gnu.org/licenses/>.
use frame_support::{construct_runtime, parameter_types, traits::Everything, weights::Weight};
use sp_core::H256;
use sp_runtime::{testing::Header, traits::IdentityLookup, AccountId32};
use sp_std::cell::RefCell;
use polkadot_parachain::primitives::Id as ParaId;
use polkadot_runtime_parachains::{configuration, origin, shared};
use xcm::latest::{opaque, prelude::*};
use xcm_executor::XcmExecutor;
use xcm_builder::{
AccountId32Aliases, AllowTopLevelPaidExecutionFrom, AllowUnpaidExecutionFrom,
ChildParachainAsNative, ChildParachainConvertsVia, ChildSystemParachainAsSuperuser,
CurrencyAdapter as XcmCurrencyAdapter, FixedRateOfFungible, FixedWeightBounds,
IsChildSystemParachain, IsConcrete, LocationInverter, SignedAccountId32AsNative,
SignedToAccountId32, SovereignSignedViaLocation, TakeWeightCredit,
};
pub type AccountId = AccountId32;
pub type Balance = u128;
thread_local! {
pub static SENT_XCM: RefCell<Vec<(MultiLocation, opaque::Xcm)>> = RefCell::new(Vec::new());
}
pub fn sent_xcm() -> Vec<(MultiLocation, opaque::Xcm)> {
SENT_XCM.with(|q| (*q.borrow()).clone())
}
pub struct TestSendXcm;
impl SendXcm for TestSendXcm {
fn send_xcm(dest: MultiLocation, msg: opaque::Xcm) -> XcmResult {
SENT_XCM.with(|q| q.borrow_mut().push((dest, msg)));
Ok(())
}
}
// copied from kusama constants
pub const UNITS: Balance = 1_000_000_000_000;
pub const CENTS: Balance = UNITS / 30_000;
parameter_types! {
pub const BlockHashCount: u64 = 250;
}
impl frame_system::Config for Runtime {
type Origin = Origin;
type Call = Call;
type Index = u64;
type BlockNumber = u64;
type Hash = H256;
type Hashing = ::sp_runtime::traits::BlakeTwo256;
type AccountId = AccountId;
type Lookup = IdentityLookup<Self::AccountId>;
type Header = Header;
type Event = Event;
type BlockHashCount = BlockHashCount;
type BlockWeights = ();
type BlockLength = ();
type Version = ();
type PalletInfo = PalletInfo;
type AccountData = pallet_balances::AccountData<Balance>;
type OnNewAccount = ();
type OnKilledAccount = ();
type DbWeight = ();
type BaseCallFilter = Everything;
type SystemWeightInfo = ();
type SS58Prefix = ();
type OnSetCode = ();
}
parameter_types! {
pub ExistentialDeposit: Balance = 1 * CENTS;
pub const MaxLocks: u32 = 50;
pub const MaxReserves: u32 = 50;
}
impl pallet_balances::Config for Runtime {
type MaxLocks = MaxLocks;
type Balance = Balance;
type Event = Event;
type DustRemoval = ();
type ExistentialDeposit = ExistentialDeposit;
type AccountStore = System;
type WeightInfo = ();
type MaxReserves = MaxReserves;
type ReserveIdentifier = [u8; 8];
}
impl shared::Config for Runtime {}
impl configuration::Config for Runtime {}
// aims to closely emulate the Kusama XcmConfig
parameter_types! {
pub const KsmLocation: MultiLocation = MultiLocation::here();
pub const KusamaNetwork: NetworkId = NetworkId::Kusama;
pub Ancestry: MultiLocation = Here.into();
pub CheckAccount: AccountId = XcmPallet::check_account();
}
pub type SovereignAccountOf =
(ChildParachainConvertsVia<ParaId, AccountId>, AccountId32Aliases<KusamaNetwork, AccountId>);
pub type LocalAssetTransactor = XcmCurrencyAdapter<
Balances,
IsConcrete<KsmLocation>,
SovereignAccountOf,
AccountId,
CheckAccount,
>;
type LocalOriginConverter = (
SovereignSignedViaLocation<SovereignAccountOf, Origin>,
ChildParachainAsNative<origin::Origin, Origin>,
SignedAccountId32AsNative<KusamaNetwork, Origin>,
ChildSystemParachainAsSuperuser<ParaId, Origin>,
);
parameter_types! {
pub const BaseXcmWeight: Weight = 1_000_000_000;
pub KsmPerSecond: (AssetId, u128) = (KsmLocation::get().into(), 1);
}
pub type Barrier = (
TakeWeightCredit,
AllowTopLevelPaidExecutionFrom<Everything>,
// Unused/Untested
AllowUnpaidExecutionFrom<IsChildSystemParachain<ParaId>>,
);
parameter_types! {
pub const KusamaForStatemint: (MultiAssetFilter, MultiLocation) =
(MultiAssetFilter::Wild(WildMultiAsset::AllOf { id: Concrete(MultiLocation::here()), fun: WildFungible }), X1(Parachain(1000)).into());
}
pub type TrustedTeleporters = (xcm_builder::Case<KusamaForStatemint>,);
pub struct XcmConfig;
impl xcm_executor::Config for XcmConfig {
type Call = Call;
type XcmSender = TestSendXcm;
type AssetTransactor = LocalAssetTransactor;
type OriginConverter = LocalOriginConverter;
type IsReserve = ();
type IsTeleporter = TrustedTeleporters;
type LocationInverter = LocationInverter<Ancestry>;
type Barrier = Barrier;
type Weigher = FixedWeightBounds<BaseXcmWeight, Call>;
type Trader = FixedRateOfFungible<KsmPerSecond, ()>;
type ResponseHandler = ();
}
pub type LocalOriginToLocation = SignedToAccountId32<Origin, AccountId, KusamaNetwork>;
impl pallet_xcm::Config for Runtime {
type Event = Event;
type LocationInverter = LocationInverter<Ancestry>;
type SendXcmOrigin = xcm_builder::EnsureXcmOrigin<Origin, LocalOriginToLocation>;
type XcmRouter = TestSendXcm;
// Anyone can execute XCM messages locally...
type ExecuteXcmOrigin = xcm_builder::EnsureXcmOrigin<Origin, LocalOriginToLocation>;
type XcmExecuteFilter = ();
type XcmExecutor = XcmExecutor<XcmConfig>;
type XcmTeleportFilter = Everything;
type XcmReserveTransferFilter = Everything;
type Weigher = FixedWeightBounds<BaseXcmWeight, Call>;
}
impl origin::Config for Runtime {}
type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic<Runtime>;
type Block = frame_system::mocking::MockBlock<Runtime>;
construct_runtime!(
pub enum Runtime where
Block = Block,
NodeBlock = Block,
UncheckedExtrinsic = UncheckedExtrinsic,
{
System: frame_system::{Pallet, Call, Storage, Config, Event<T>},
Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
ParasOrigin: origin::{Pallet, Origin},
XcmPallet: pallet_xcm::{Pallet, Call, Storage, Event<T>},
}
);
pub fn kusama_like_with_balances(balances: Vec<(AccountId, Balance)>) -> sp_io::TestExternalities {
let mut t = frame_system::GenesisConfig::default().build_storage::<Runtime>().unwrap();
pallet_balances::GenesisConfig::<Runtime> { balances }
.assimilate_storage(&mut t)
.unwrap();
let mut ext = sp_io::TestExternalities::new(t);
ext.execute_with(|| System::set_block_number(1));
ext
}
// Copyright 2020 Parity Technologies (UK) Ltd.
// This file is part of Polkadot.
// Polkadot is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// Polkadot is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with Polkadot. If not, see <http://www.gnu.org/licenses/>.
mod mock;
use frame_support::weights::Weight;
use mock::{
kusama_like_with_balances, AccountId, Balance, Balances, BaseXcmWeight, XcmConfig, CENTS,
};
use polkadot_parachain::primitives::Id as ParaId;
use sp_runtime::traits::AccountIdConversion;
use xcm::latest::prelude::*;
use xcm_executor::XcmExecutor;
pub const ALICE: AccountId = AccountId::new([0u8; 32]);
pub const PARA_ID: u32 = 2000;
pub const INITIAL_BALANCE: u128 = 100_000_000_000;
pub const REGISTER_AMOUNT: Balance = 10 * CENTS;
// Construct a `BuyExecution` order.
fn buy_execution<C>(debt: Weight) -> Order<C> {
use xcm::latest::prelude::*;
Order::BuyExecution {
fees: (Here, REGISTER_AMOUNT).into(),
weight: 0,
debt,
halt_on_error: false,
orders: vec![],
instructions: vec![],
}
}
/// Scenario:
/// A parachain transfers funds on the relaychain to another parachain's account.
///
/// Asserts that the parachain accounts are updated as expected.
#[test]
fn withdraw_and_deposit_works() {
let para_acc: AccountId = ParaId::from(PARA_ID).into_account();
let balances = vec![(ALICE, INITIAL_BALANCE), (para_acc.clone(), INITIAL_BALANCE)];
kusama_like_with_balances(balances).execute_with(|| {
let other_para_id = 3000;
let amount = REGISTER_AMOUNT;
let weight = 3 * BaseXcmWeight::get();
let r = XcmExecutor::<XcmConfig>::execute_xcm(
Parachain(PARA_ID).into(),
Xcm::WithdrawAsset {
assets: vec![(Here, amount).into()].into(),
effects: vec![
buy_execution(weight),
Order::DepositAsset {
assets: All.into(),
max_assets: 1,
beneficiary: Parachain(other_para_id).into(),
},
],
},
weight,
);
assert_eq!(r, Outcome::Complete(weight));
let other_para_acc: AccountId = ParaId::from(other_para_id).into_account();
assert_eq!(Balances::free_balance(para_acc), INITIAL_BALANCE - amount);
assert_eq!(Balances::free_balance(other_para_acc), amount);
});
}
/// Scenario:
/// A parachain wants to be notified that a transfer worked correctly.
/// It includes a `QueryHolding` order after the deposit to get notified on success.
/// This somewhat abuses `QueryHolding` as an indication of execution success. It works because
/// order execution halts on error (so no `QueryResponse` will be sent if the previous order failed).
/// The inner response sent due to the query is not used.
///
/// Asserts that the balances are updated correctly and the expected XCM is sent.
#[test]
fn query_holding_works() {
use xcm::opaque::latest::prelude::*;
let para_acc: AccountId = ParaId::from(PARA_ID).into_account();
let balances = vec![(ALICE, INITIAL_BALANCE), (para_acc.clone(), INITIAL_BALANCE)];
kusama_like_with_balances(balances).execute_with(|| {
let other_para_id = 3000;
let amount = REGISTER_AMOUNT;
let query_id = 1234;
let weight = 4 * BaseXcmWeight::get();
let r = XcmExecutor::<XcmConfig>::execute_xcm(
Parachain(PARA_ID).into(),
Xcm::WithdrawAsset {
assets: vec![(Here, amount).into()].into(),
effects: vec![
buy_execution(weight),
Order::DepositAsset {
assets: All.into(),
max_assets: 1,
beneficiary: OnlyChild.into(), // invalid destination
},
// is not triggered becasue the deposit fails
Order::QueryHolding {
query_id,
dest: Parachain(PARA_ID).into(),
assets: All.into(),
},
],
},
weight,
);
assert_eq!(
r,
Outcome::Incomplete(
weight,
XcmError::FailedToTransactAsset("AccountIdConversionFailed")
)
);
// there should be no query response sent for the failed deposit
assert_eq!(mock::sent_xcm(), vec![]);
assert_eq!(Balances::free_balance(para_acc.clone()), INITIAL_BALANCE - amount);
// now do a successful transfer
let r = XcmExecutor::<XcmConfig>::execute_xcm(
Parachain(PARA_ID).into(),
Xcm::WithdrawAsset {
assets: vec![(Here, amount).into()].into(),
effects: vec![
buy_execution(weight),
Order::DepositAsset {
assets: All.into(),
max_assets: 1,
beneficiary: Parachain(other_para_id).into(),
},
// used to get a notification in case of success
Order::QueryHolding {
query_id,
dest: Parachain(PARA_ID).into(),
assets: All.into(),
},
],
},
weight,
);
assert_eq!(r, Outcome::Complete(weight));
let other_para_acc: AccountId = ParaId::from(other_para_id).into_account();
assert_eq!(Balances::free_balance(other_para_acc), amount);
assert_eq!(Balances::free_balance(para_acc), INITIAL_BALANCE - 2 * amount);
assert_eq!(
mock::sent_xcm(),
vec![(
Parachain(PARA_ID).into(),
Xcm::QueryResponse { query_id, response: Response::Assets(vec![].into()) }
)]
);
});
}
/// Scenario:
/// A parachain wants to move KSM from Kusama to Statemine.
/// The parachain sends an XCM to withdraw funds combined with a teleport to the destination.
///
/// This way of moving funds from a relay to a parachain will only work for trusted chains.
/// Reserve based transfer should be used to move KSM to a community parachain.
///
/// Asserts that the balances are updated accordingly and the correct XCM is sent.
#[test]
fn teleport_to_statemine_works() {
use xcm::opaque::latest::prelude::*;
let para_acc: AccountId = ParaId::from(PARA_ID).into_account();
let balances = vec![(ALICE, INITIAL_BALANCE), (para_acc.clone(), INITIAL_BALANCE)];
kusama_like_with_balances(balances).execute_with(|| {
let statemine_id = 1000;
let other_para_id = 3000;
let amount = REGISTER_AMOUNT;
let teleport_effects = vec![
buy_execution(5), // unchecked mock value
Order::DepositAsset {
assets: All.into(),
max_assets: 1,
beneficiary: (1, Parachain(PARA_ID)).into(),
},
];
let weight = 3 * BaseXcmWeight::get();
// teleports are allowed to community chains, even in the absence of trust from their side.
let r = XcmExecutor::<XcmConfig>::execute_xcm(
Parachain(PARA_ID).into(),
Xcm::WithdrawAsset {
assets: vec![(Here, amount).into()].into(),
effects: vec![
buy_execution(weight),
Order::InitiateTeleport {
assets: All.into(),
dest: Parachain(other_para_id).into(),
effects: teleport_effects.clone(),
},
],
},
weight,
);
assert_eq!(r, Outcome::Complete(weight));
assert_eq!(
mock::sent_xcm(),
vec![(
Parachain(other_para_id).into(),
Xcm::ReceiveTeleportedAsset {
assets: vec![(Parent, amount).into()].into(),
effects: teleport_effects.clone(),
}
)]
);
// teleports are allowed from statemine to kusama.
let r = XcmExecutor::<XcmConfig>::execute_xcm(
Parachain(PARA_ID).into(),
Xcm::WithdrawAsset {
assets: vec![(Here, amount).into()].into(),
effects: vec![
buy_execution(weight),
Order::InitiateTeleport {
assets: All.into(),
dest: Parachain(statemine_id).into(),
effects: teleport_effects.clone(),
},
],
},
weight,
);
assert_eq!(r, Outcome::Complete(weight));
// 2 * amount because of the other teleport above
assert_eq!(Balances::free_balance(para_acc), INITIAL_BALANCE - 2 * amount);
assert_eq!(
mock::sent_xcm(),
vec![
(
Parachain(other_para_id).into(),
Xcm::ReceiveTeleportedAsset {
assets: vec![(Parent, amount).into()].into(),
effects: teleport_effects.clone(),
}
),
(
Parachain(statemine_id).into(),
Xcm::ReceiveTeleportedAsset {
assets: vec![(Parent, amount).into()].into(),
effects: teleport_effects,
}
)
]
);
});