difftreelog
Merge pull request #1003 from UniqueNetwork/feature/llxcm-qtz
in: master
added `XcmTestHelper` + allow XCM Transact for Gov/Identity/System calls
14 files changed
.baedeker/.gitignorediffbeforeafterboth--- a/.baedeker/.gitignore
+++ b/.baedeker/.gitignore
@@ -1,4 +1,5 @@
/.bdk-env
-/rewrites.jsonnet
+/rewrites*.jsonnet
/vendor
/baedeker-library
+!/rewrites.example.jsonnet
\ No newline at end of file
.github/workflows/xcm.ymldiffbeforeafterboth--- a/.github/workflows/xcm.yml
+++ b/.github/workflows/xcm.yml
@@ -38,7 +38,7 @@
with:
matrix: |
network {opal}, relay_branch {${{ env.UNIQUEWEST_MAINNET_BRANCH }}}, acala_version {${{ env.ACALA_BUILD_BRANCH }}}, moonbeam_version {${{ env.MOONBEAM_BUILD_BRANCH }}}, cumulus_version {${{ env.WESTMINT_BUILD_BRANCH }}}, astar_version {${{ env.ASTAR_BUILD_BRANCH }}}, polkadex_version {${{ env.POLKADEX_BUILD_BRANCH }}}, runtest {testXcmOpal}, runtime_features {opal-runtime}
- network {quartz}, relay_branch {${{ env.KUSAMA_MAINNET_BRANCH }}}, acala_version {${{ env.KARURA_BUILD_BRANCH }}}, moonbeam_version {${{ env.MOONRIVER_BUILD_BRANCH }}}, cumulus_version {${{ env.STATEMINE_BUILD_BRANCH }}}, astar_version {${{ env.SHIDEN_BUILD_BRANCH }}}, polkadex_version {${{ env.POLKADEX_BUILD_BRANCH }}}, runtest {testXcmQuartz}, runtime_features {quartz-runtime}
+ network {quartz}, relay_branch {${{ env.KUSAMA_MAINNET_BRANCH }}}, acala_version {${{ env.KARURA_BUILD_BRANCH }}}, moonbeam_version {${{ env.MOONRIVER_BUILD_BRANCH }}}, cumulus_version {${{ env.STATEMINE_BUILD_BRANCH }}}, astar_version {${{ env.SHIDEN_BUILD_BRANCH }}}, polkadex_version {${{ env.POLKADEX_BUILD_BRANCH }}}, runtest {testFullXcmQuartz}, runtime_features {quartz-runtime}
network {unique}, relay_branch {${{ env.POLKADOT_MAINNET_BRANCH }}}, acala_version {${{ env.ACALA_BUILD_BRANCH }}}, moonbeam_version {${{ env.MOONBEAM_BUILD_BRANCH }}}, cumulus_version {${{ env.STATEMINT_BUILD_BRANCH }}}, astar_version {${{ env.ASTAR_BUILD_BRANCH }}}, polkadex_version {${{ env.POLKADEX_BUILD_BRANCH }}}, runtest {testFullXcmUnique}, runtime_features {unique-runtime}
xcm:
runtime/common/config/xcm/mod.rsdiffbeforeafterboth--- a/runtime/common/config/xcm/mod.rs
+++ b/runtime/common/config/xcm/mod.rs
@@ -15,7 +15,7 @@
// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
use frame_support::{
- traits::{Everything, Nothing, Get, ConstU32, ProcessMessageError},
+ traits::{Everything, Nothing, Get, ConstU32, ProcessMessageError, Contains},
parameter_types,
};
use frame_system::EnsureRoot;
@@ -162,6 +162,54 @@
pub type Weigher = FixedWeightBounds<UnitWeightCost, RuntimeCall, MaxInstructions>;
+pub struct XcmCallFilter;
+impl XcmCallFilter {
+ fn allow_gov_and_sys_call(call: &RuntimeCall) -> bool {
+ match call {
+ RuntimeCall::System(..) => true,
+
+ #[cfg(feature = "governance")]
+ RuntimeCall::Identity(..)
+ | RuntimeCall::Preimage(..)
+ | RuntimeCall::Democracy(..)
+ | RuntimeCall::Council(..)
+ | RuntimeCall::TechnicalCommittee(..)
+ | RuntimeCall::CouncilMembership(..)
+ | RuntimeCall::TechnicalCommitteeMembership(..)
+ | RuntimeCall::FellowshipCollective(..)
+ | RuntimeCall::FellowshipReferenda(..) => true,
+ _ => false,
+ }
+ }
+
+ fn allow_utility_call(call: &RuntimeCall) -> bool {
+ match call {
+ RuntimeCall::Utility(pallet_utility::Call::batch { calls, .. }) => {
+ calls.iter().all(Self::allow_gov_and_sys_call)
+ }
+ RuntimeCall::Utility(pallet_utility::Call::batch_all { calls, .. }) => {
+ calls.iter().all(Self::allow_gov_and_sys_call)
+ }
+ RuntimeCall::Utility(pallet_utility::Call::as_derivative { call, .. }) => {
+ Self::allow_gov_and_sys_call(call)
+ }
+ RuntimeCall::Utility(pallet_utility::Call::dispatch_as { call, .. }) => {
+ Self::allow_gov_and_sys_call(call)
+ }
+ RuntimeCall::Utility(pallet_utility::Call::force_batch { calls, .. }) => {
+ calls.iter().all(Self::allow_gov_and_sys_call)
+ }
+ _ => false,
+ }
+ }
+}
+
+impl Contains<RuntimeCall> for XcmCallFilter {
+ fn contains(call: &RuntimeCall) -> bool {
+ Self::allow_gov_and_sys_call(call) || Self::allow_utility_call(call)
+ }
+}
+
pub struct XcmExecutorConfig<T>(PhantomData<T>);
impl<T> xcm_executor::Config for XcmExecutorConfig<T>
where
@@ -191,9 +239,7 @@
type MessageExporter = ();
type UniversalAliases = Nothing;
type CallDispatcher = RuntimeCall;
-
- // Deny all XCM Transacts.
- type SafeCallFilter = Nothing;
+ type SafeCallFilter = XcmCallFilter;
}
#[cfg(feature = "runtime-benchmarks")]
runtime/opal/src/xcm_barrier.rsdiffbeforeafterboth--- a/runtime/opal/src/xcm_barrier.rs
+++ b/runtime/opal/src/xcm_barrier.rs
@@ -14,7 +14,18 @@
// You should have received a copy of the GNU General Public License
// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
-use frame_support::traits::Everything;
-use xcm_builder::{AllowTopLevelPaidExecutionFrom, TakeWeightCredit};
+use frame_support::{match_types, traits::Everything};
+use xcm::latest::{Junctions::*, MultiLocation};
+use xcm_builder::{AllowTopLevelPaidExecutionFrom, TakeWeightCredit, AllowExplicitUnpaidExecutionFrom};
-pub type Barrier = (TakeWeightCredit, AllowTopLevelPaidExecutionFrom<Everything>);
+match_types! {
+ pub type ParentOnly: impl Contains<MultiLocation> = {
+ MultiLocation { parents: 1, interior: Here }
+ };
+}
+
+pub type Barrier = (
+ TakeWeightCredit,
+ AllowExplicitUnpaidExecutionFrom<ParentOnly>,
+ AllowTopLevelPaidExecutionFrom<Everything>,
+);
runtime/quartz/src/xcm_barrier.rsdiffbeforeafterboth--- a/runtime/quartz/src/xcm_barrier.rs
+++ b/runtime/quartz/src/xcm_barrier.rs
@@ -18,12 +18,16 @@
use xcm::latest::{Junctions::*, MultiLocation};
use xcm_builder::{
AllowKnownQueryResponses, AllowSubscriptionsFrom, TakeWeightCredit,
- AllowTopLevelPaidExecutionFrom,
+ AllowTopLevelPaidExecutionFrom, AllowExplicitUnpaidExecutionFrom,
};
use crate::PolkadotXcm;
match_types! {
+ pub type ParentOnly: impl Contains<MultiLocation> = {
+ MultiLocation { parents: 1, interior: Here }
+ };
+
pub type ParentOrSiblings: impl Contains<MultiLocation> = {
MultiLocation { parents: 1, interior: Here } |
MultiLocation { parents: 1, interior: X1(_) }
@@ -32,6 +36,7 @@
pub type Barrier = (
TakeWeightCredit,
+ AllowExplicitUnpaidExecutionFrom<ParentOnly>,
AllowTopLevelPaidExecutionFrom<Everything>,
// Expected responses are OK.
AllowKnownQueryResponses<PolkadotXcm>,
runtime/unique/src/xcm_barrier.rsdiffbeforeafterboth--- a/runtime/unique/src/xcm_barrier.rs
+++ b/runtime/unique/src/xcm_barrier.rs
@@ -18,12 +18,16 @@
use xcm::latest::{Junctions::*, MultiLocation};
use xcm_builder::{
AllowKnownQueryResponses, AllowSubscriptionsFrom, TakeWeightCredit,
- AllowTopLevelPaidExecutionFrom,
+ AllowTopLevelPaidExecutionFrom, AllowExplicitUnpaidExecutionFrom,
};
use crate::PolkadotXcm;
match_types! {
+ pub type ParentOnly: impl Contains<MultiLocation> = {
+ MultiLocation { parents: 1, interior: Here }
+ };
+
pub type ParentOrSiblings: impl Contains<MultiLocation> = {
MultiLocation { parents: 1, interior: Here } |
MultiLocation { parents: 1, interior: X1(_) }
@@ -32,6 +36,7 @@
pub type Barrier = (
TakeWeightCredit,
+ AllowExplicitUnpaidExecutionFrom<ParentOnly>,
AllowTopLevelPaidExecutionFrom<Everything>,
// Expected responses are OK.
AllowKnownQueryResponses<PolkadotXcm>,
tests/package.jsondiffbeforeafterboth--- a/tests/package.json
+++ b/tests/package.json
@@ -117,6 +117,8 @@
"testXcmUnique": "RUN_XCM_TESTS=1 yarn _test ./**/xcm/xcmUnique.test.ts",
"testFullXcmUnique": "RUN_XCM_TESTS=1 yarn _test ./**/xcm/*Unique.test.ts",
"testXcmQuartz": "RUN_XCM_TESTS=1 yarn _test ./**/xcm/xcmQuartz.test.ts",
+ "testLowLevelXcmQuartz": "RUN_XCM_TESTS=1 yarn _test ./**/xcm/lowLevelXcmQuartz.test.ts",
+ "testFullXcmQuartz": "RUN_XCM_TESTS=1 yarn _test ./**/xcm/*Quartz.test.ts",
"testXcmOpal": "RUN_XCM_TESTS=1 yarn _test ./**/xcm/xcmOpal.test.ts",
"testXcmTransferAcala": "yarn _test ./**/xcm/xcmTransferAcala.test.ts acalaId=2000 uniqueId=5000",
"testXcmTransferStatemine": "yarn _test ./**/xcm/xcmTransferStatemine.test.ts statemineId=1000 uniqueId=5000",
tests/src/util/playgrounds/unique.dev.tsdiffbeforeafterboth--- a/tests/src/util/playgrounds/unique.dev.ts
+++ b/tests/src/util/playgrounds/unique.dev.ts
@@ -9,7 +9,7 @@
import {IKeyringPair} from '@polkadot/types/types';
import {EventRecord} from '@polkadot/types/interfaces';
import {ICrossAccountId, ILogger, IPovInfo, ISchedulerOptions, ITransactionResult, TSigner} from './types';
-import {FrameSystemEventRecord, XcmV2TraitsError} from '@polkadot/types/lookup';
+import {FrameSystemEventRecord, XcmV2TraitsError, XcmV3TraitsOutcome} from '@polkadot/types/lookup';
import {SignerOptions, VoidFn} from '@polkadot/api/types';
import {Pallets} from '..';
import {spawnSync} from 'child_process';
@@ -260,6 +260,12 @@
outcome: eventData<XcmV2TraitsError>(data, 1),
}));
};
+
+ static DmpQueue = class extends EventSection('dmpQueue') {
+ static ExecutedDownward = this.Method('ExecutedDownward', data => ({
+ outcome: eventData<XcmV3TraitsOutcome>(data, 1),
+ }));
+ };
}
// eslint-disable-next-line @typescript-eslint/naming-convention
@@ -559,6 +565,12 @@
super(logger, options);
this.wait = new WaitGroup(this);
}
+
+ getSudo() {
+ // eslint-disable-next-line @typescript-eslint/naming-convention
+ const SudoHelperType = SudoHelper(this.helperBase);
+ return this.clone(SudoHelperType) as DevRelayHelper;
+ }
}
export class DevWestmintHelper extends WestmintHelper {
@@ -968,6 +980,31 @@
],
};
}
+
+ makeUnpaidSudoTransactProgram(info: {weightMultiplier: number, call: string}) {
+ return {
+ V3: [
+ {
+ UnpaidExecution: {
+ weightLimit: 'Unlimited',
+ checkOrigin: null,
+ },
+ },
+ {
+ Transact: {
+ originKind: 'Superuser',
+ requireWeightAtMost: {
+ refTime: info.weightMultiplier * 200000000,
+ proofSize: info.weightMultiplier * 3000,
+ },
+ call: {
+ encoded: info.call,
+ },
+ },
+ },
+ ],
+ };
+ }
}
class MoonbeamAccountGroup {
@@ -1501,4 +1538,4 @@
);
}
};
-}
\ No newline at end of file
+}
tests/src/util/playgrounds/unique.xcm.tsdiffbeforeafterboth--- a/tests/src/util/playgrounds/unique.xcm.ts
+++ b/tests/src/util/playgrounds/unique.xcm.ts
@@ -240,19 +240,19 @@
}
export class AssetsGroup<T extends ChainHelperBase> extends HelperGroup<T> {
- async create(signer: TSigner, assetId: number, admin: string, minimalBalance: bigint) {
+ async create(signer: TSigner, assetId: number | bigint, admin: string, minimalBalance: bigint) {
await this.helper.executeExtrinsic(signer, 'api.tx.assets.create', [assetId, admin, minimalBalance], true);
}
- async setMetadata(signer: TSigner, assetId: number, name: string, symbol: string, decimals: number) {
+ async setMetadata(signer: TSigner, assetId: number | bigint, name: string, symbol: string, decimals: number) {
await this.helper.executeExtrinsic(signer, 'api.tx.assets.setMetadata', [assetId, name, symbol, decimals], true);
}
- async mint(signer: TSigner, assetId: number, beneficiary: string, amount: bigint) {
+ async mint(signer: TSigner, assetId: number | bigint, beneficiary: string, amount: bigint) {
await this.helper.executeExtrinsic(signer, 'api.tx.assets.mint', [assetId, beneficiary, amount], true);
}
- async account(assetId: string | number, address: string) {
+ async account(assetId: string | number | bigint, address: string) {
const accountAsset = (
await this.helper.callRpc('api.query.assets.account', [assetId, address])
).toJSON()! as any;
tests/src/xcm/lowLevelXcmQuartz.test.tsdiffbeforeafterboth--- /dev/null
+++ b/tests/src/xcm/lowLevelXcmQuartz.test.ts
@@ -0,0 +1,364 @@
+// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
+// This file is part of Unique Network.
+
+// Unique Network 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.
+
+// Unique Network 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 Unique Network. If not, see <http://www.gnu.org/licenses/>.
+
+import {IKeyringPair} from '@polkadot/types/types';
+import {itSub, describeXCM, usingPlaygrounds, usingKaruraPlaygrounds, usingMoonriverPlaygrounds, usingShidenPlaygrounds, usingRelayPlaygrounds} from '../util';
+import {QUARTZ_CHAIN, QTZ_DECIMALS, SHIDEN_DECIMALS, karuraUrl, moonriverUrl, shidenUrl, SAFE_XCM_VERSION, XcmTestHelper, TRANSFER_AMOUNT, SENDER_BUDGET, relayUrl} from './xcm.types';
+import {hexToString} from '@polkadot/util';
+
+const testHelper = new XcmTestHelper('quartz');
+
+describeXCM('[XCMLL] Integration test: Exchanging tokens with Karura', () => {
+ let alice: IKeyringPair;
+ let randomAccount: IKeyringPair;
+
+ before(async () => {
+ await usingPlaygrounds(async (helper, privateKey) => {
+ alice = await privateKey('//Alice');
+ [randomAccount] = await helper.arrange.createAccounts([0n], alice);
+
+ // Set the default version to wrap the first message to other chains.
+ await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);
+ });
+
+ await usingKaruraPlaygrounds(karuraUrl, async (helper) => {
+ const destination = {
+ V2: {
+ parents: 1,
+ interior: {
+ X1: {
+ Parachain: QUARTZ_CHAIN,
+ },
+ },
+ },
+ };
+
+ const metadata = {
+ name: 'Quartz',
+ symbol: 'QTZ',
+ decimals: 18,
+ minimalBalance: 1000000000000000000n,
+ };
+
+ const assets = (await (helper.callRpc('api.query.assetRegistry.assetMetadatas.entries'))).map(([_k, v]: [any, any]) =>
+ hexToString(v.toJSON()['symbol'])) as string[];
+
+ if(!assets.includes('QTZ')) {
+ await helper.getSudo().assetRegistry.registerForeignAsset(alice, destination, metadata);
+ } else {
+ console.log('QTZ token already registered on Karura assetRegistry pallet');
+ }
+ await helper.balance.transferToSubstrate(alice, randomAccount.address, 10000000000000n);
+ });
+
+ await usingPlaygrounds(async (helper) => {
+ await helper.balance.transferToSubstrate(alice, randomAccount.address, SENDER_BUDGET);
+ });
+ });
+
+ itSub('Should connect and send QTZ to Karura', async () => {
+ await testHelper.sendUnqTo('karura', randomAccount);
+ });
+
+ itSub('Should connect to Karura and send QTZ back', async () => {
+ await testHelper.sendUnqBack('karura', alice, randomAccount);
+ });
+
+ itSub('Karura can send only up to its balance', async () => {
+ await testHelper.sendOnlyOwnedBalance('karura', alice);
+ });
+});
+// These tests are relevant only when
+// the the corresponding foreign assets are not registered
+describeXCM('[XCMLL] Integration test: Quartz rejects non-native tokens', () => {
+ let alice: IKeyringPair;
+
+
+ before(async () => {
+ await usingPlaygrounds(async (helper, privateKey) => {
+ alice = await privateKey('//Alice');
+
+
+
+ // Set the default version to wrap the first message to other chains.
+ await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);
+ });
+ });
+
+ itSub('Quartz rejects KAR tokens from Karura', async () => {
+ await testHelper.rejectNativeTokensFrom('karura', alice);
+ });
+
+ itSub('Quartz rejects MOVR tokens from Moonriver', async () => {
+ await testHelper.rejectNativeTokensFrom('moonriver', alice);
+ });
+
+ itSub('Quartz rejects SDN tokens from Shiden', async () => {
+ await testHelper.rejectNativeTokensFrom('shiden', alice);
+ });
+});
+
+describeXCM('[XCMLL] Integration test: Exchanging QTZ with Moonriver', () => {
+ // Quartz constants
+ let alice: IKeyringPair;
+ let quartzAssetLocation;
+
+ let randomAccountQuartz: IKeyringPair;
+ let randomAccountMoonriver: IKeyringPair;
+
+ // Moonriver constants
+ let assetId: string;
+
+ const quartzAssetMetadata = {
+ name: 'xcQuartz',
+ symbol: 'xcQTZ',
+ decimals: 18,
+ isFrozen: false,
+ minimalBalance: 1n,
+ };
+
+
+ before(async () => {
+ await usingPlaygrounds(async (helper, privateKey) => {
+ alice = await privateKey('//Alice');
+ [randomAccountQuartz] = await helper.arrange.createAccounts([0n], alice);
+
+
+ // Set the default version to wrap the first message to other chains.
+ await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);
+ });
+
+ await usingMoonriverPlaygrounds(moonriverUrl, async (helper) => {
+ const alithAccount = helper.account.alithAccount();
+ const baltatharAccount = helper.account.baltatharAccount();
+ const dorothyAccount = helper.account.dorothyAccount();
+
+ randomAccountMoonriver = helper.account.create();
+
+ // >>> Sponsoring Dorothy >>>
+ console.log('Sponsoring Dorothy.......');
+ await helper.balance.transferToEthereum(alithAccount, dorothyAccount.address, 11_000_000_000_000_000_000n);
+ console.log('Sponsoring Dorothy.......DONE');
+ // <<< Sponsoring Dorothy <<<
+
+ quartzAssetLocation = {
+ XCM: {
+ parents: 1,
+ interior: {X1: {Parachain: QUARTZ_CHAIN}},
+ },
+ };
+ const existentialDeposit = 1n;
+ const isSufficient = true;
+ const unitsPerSecond = 1n;
+ const numAssetsWeightHint = 0;
+ if((await helper.assetManager.assetTypeId(quartzAssetLocation)).toJSON()) {
+ console.log('Quartz asset already registered on Moonriver');
+ } else {
+ const encodedProposal = helper.assetManager.makeRegisterForeignAssetProposal({
+ location: quartzAssetLocation,
+ metadata: quartzAssetMetadata,
+ existentialDeposit,
+ isSufficient,
+ unitsPerSecond,
+ numAssetsWeightHint,
+ });
+
+ console.log('Encoded proposal for registerForeignAsset & setAssetUnitsPerSecond is %s', encodedProposal);
+
+ await helper.fastDemocracy.executeProposal('register QTZ foreign asset', encodedProposal);
+ }
+ // >>> Acquire Quartz AssetId Info on Moonriver >>>
+ console.log('Acquire Quartz AssetId Info on Moonriver.......');
+
+ assetId = (await helper.assetManager.assetTypeId(quartzAssetLocation)).toString();
+
+ console.log('QTZ asset ID is %s', assetId);
+ console.log('Acquire Quartz AssetId Info on Moonriver.......DONE');
+ // >>> Acquire Quartz AssetId Info on Moonriver >>>
+
+ // >>> Sponsoring random Account >>>
+ console.log('Sponsoring random Account.......');
+ await helper.balance.transferToEthereum(baltatharAccount, randomAccountMoonriver.address, 11_000_000_000_000_000_000n);
+ console.log('Sponsoring random Account.......DONE');
+ // <<< Sponsoring random Account <<<
+ });
+
+ await usingPlaygrounds(async (helper) => {
+ await helper.balance.transferToSubstrate(alice, randomAccountQuartz.address, 10n * TRANSFER_AMOUNT);
+ });
+ });
+
+ itSub('Should connect and send QTZ to Moonriver', async () => {
+ await testHelper.sendUnqTo('moonriver', randomAccountQuartz, randomAccountMoonriver);
+ });
+
+ itSub('Should connect to Moonriver and send QTZ back', async () => {
+ await testHelper.sendUnqBack('moonriver', alice, randomAccountQuartz);
+ });
+
+ itSub('Moonriver can send only up to its balance', async () => {
+ await testHelper.sendOnlyOwnedBalance('moonriver', alice);
+ });
+
+ itSub('Should not accept reserve transfer of QTZ from Moonriver', async () => {
+ await testHelper.rejectReserveTransferUNQfrom('moonriver', alice);
+ });
+});
+
+describeXCM('[XCMLL] Integration test: Exchanging tokens with Shiden', () => {
+ let alice: IKeyringPair;
+ let randomAccount: IKeyringPair;
+
+ const QTZ_ASSET_ID_ON_SHIDEN = 18_446_744_073_709_551_633n; // The value is taken from the live Shiden
+ const QTZ_MINIMAL_BALANCE_ON_SHIDEN = 1n; // The value is taken from the live Shiden
+
+ // Quartz -> Shiden
+ const shidenInitialBalance = 1n * (10n ** SHIDEN_DECIMALS); // 1 SHD, existential deposit required to actually create the account on Shiden
+ const unitsPerSecond = 500_451_000_000_000_000_000n; // The value is taken from the live Shiden
+
+ before(async () => {
+ await usingPlaygrounds(async (helper, privateKey) => {
+ alice = await privateKey('//Alice');
+ randomAccount = helper.arrange.createEmptyAccount();
+ await helper.balance.transferToSubstrate(alice, randomAccount.address, SENDER_BUDGET);
+ console.log('sender: ', randomAccount.address);
+
+ // Set the default version to wrap the first message to other chains.
+ await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);
+ });
+
+ await usingShidenPlaygrounds(shidenUrl, async (helper) => {
+ if(!(await helper.callRpc('api.query.assets.asset', [QTZ_ASSET_ID_ON_SHIDEN])).toJSON()) {
+ console.log('1. Create foreign asset and metadata');
+ await helper.assets.create(
+ alice,
+ QTZ_ASSET_ID_ON_SHIDEN,
+ alice.address,
+ QTZ_MINIMAL_BALANCE_ON_SHIDEN,
+ );
+
+ await helper.assets.setMetadata(
+ alice,
+ QTZ_ASSET_ID_ON_SHIDEN,
+ 'Quartz',
+ 'QTZ',
+ Number(QTZ_DECIMALS),
+ );
+
+ console.log('2. Register asset location on Shiden');
+ const assetLocation = {
+ V2: {
+ parents: 1,
+ interior: {
+ X1: {
+ Parachain: QUARTZ_CHAIN,
+ },
+ },
+ },
+ };
+
+ await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.registerAssetLocation', [assetLocation, QTZ_ASSET_ID_ON_SHIDEN]);
+
+ console.log('3. Set QTZ payment for XCM execution on Shiden');
+ await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.setAssetUnitsPerSecond', [assetLocation, unitsPerSecond]);
+ } else {
+ console.log('QTZ is already registered on Shiden');
+ }
+ console.log('4. Transfer 1 SDN to recipient to create the account (needed due to existential balance)');
+ await helper.balance.transferToSubstrate(alice, randomAccount.address, shidenInitialBalance);
+ });
+ });
+
+ itSub('Should connect and send QTZ to Shiden', async () => {
+ await testHelper.sendUnqTo('shiden', randomAccount);
+ });
+
+ itSub('Should connect to Shiden and send QTZ back', async () => {
+ await testHelper.sendUnqBack('shiden', alice, randomAccount);
+ });
+
+ itSub('Shiden can send only up to its balance', async () => {
+ await testHelper.sendOnlyOwnedBalance('shiden', alice);
+ });
+
+ itSub('Should not accept reserve transfer of QTZ from Shiden', async () => {
+ await testHelper.rejectReserveTransferUNQfrom('shiden', alice);
+ });
+});
+
+describeXCM('[XCMLL] Integration test: The relay can do some root ops', () => {
+ let sudoer: IKeyringPair;
+
+ before(async function () {
+ await usingRelayPlaygrounds(relayUrl, async (_, privateKey) => {
+ sudoer = await privateKey('//Alice');
+ });
+ });
+
+ // At the moment there is no reliable way
+ // to establish the correspondence between the `ExecutedDownward` event
+ // and the relay's sent message due to `SetTopic` instruction
+ // containing an unpredictable topic silently added by the relay's messages on the router level.
+ // This changes the message hash on arrival to our chain.
+ //
+ // See:
+ // * The relay's router: https://github.com/paritytech/polkadot-sdk/blob/f60318f68687e601c47de5ad5ca88e2c3f8139a7/polkadot/runtime/westend/src/xcm_config.rs#L83
+ // * The `WithUniqueTopic` helper: https://github.com/paritytech/polkadot-sdk/blob/945ebbbcf66646be13d5b1d1bc26c8b0d3296d9e/polkadot/xcm/xcm-builder/src/routing.rs#L36
+ //
+ // Because of this, we insert time gaps between tests so
+ // different `ExecutedDownward` events won't interfere with each other.
+ afterEach(async () => {
+ await usingPlaygrounds(async (helper) => {
+ await helper.wait.newBlocks(3);
+ });
+ });
+
+ itSub('The relay can set storage', async () => {
+ await testHelper.relayIsPermittedToSetStorage(sudoer, 'plain');
+ });
+
+ itSub('The relay can batch set storage', async () => {
+ await testHelper.relayIsPermittedToSetStorage(sudoer, 'batch');
+ });
+
+ itSub('The relay can batchAll set storage', async () => {
+ await testHelper.relayIsPermittedToSetStorage(sudoer, 'batchAll');
+ });
+
+ itSub('The relay can forceBatch set storage', async () => {
+ await testHelper.relayIsPermittedToSetStorage(sudoer, 'forceBatch');
+ });
+
+ itSub('[negative] The relay cannot set balance', async () => {
+ await testHelper.relayIsNotPermittedToSetBalance(sudoer, 'plain');
+ });
+
+ itSub('[negative] The relay cannot set balance via batch', async () => {
+ await testHelper.relayIsNotPermittedToSetBalance(sudoer, 'batch');
+ });
+
+ itSub('[negative] The relay cannot set balance via batchAll', async () => {
+ await testHelper.relayIsNotPermittedToSetBalance(sudoer, 'batchAll');
+ });
+
+ itSub('[negative] The relay cannot set balance via forceBatch', async () => {
+ await testHelper.relayIsNotPermittedToSetBalance(sudoer, 'forceBatch');
+ });
+
+ itSub('[negative] The relay cannot set balance via dispatchAs', async () => {
+ await testHelper.relayIsNotPermittedToSetBalance(sudoer, 'dispatchAs');
+ });
+});
tests/src/xcm/lowLevelXcmUnique.test.tsdiffbeforeafterboth--- a/tests/src/xcm/lowLevelXcmUnique.test.ts
+++ b/tests/src/xcm/lowLevelXcmUnique.test.ts
@@ -16,317 +16,14 @@
import {IKeyringPair} from '@polkadot/types/types';
import config from '../config';
-import {itSub, expect, describeXCM, usingPlaygrounds, usingAcalaPlaygrounds, usingMoonbeamPlaygrounds, usingAstarPlaygrounds, usingPolkadexPlaygrounds} from '../util';
-import {Event} from '../util/playgrounds/unique.dev';
+import {itSub, describeXCM, usingPlaygrounds, usingAcalaPlaygrounds, usingMoonbeamPlaygrounds, usingAstarPlaygrounds, usingPolkadexPlaygrounds, usingRelayPlaygrounds} from '../util';
import {nToBigInt} from '@polkadot/util';
import {hexToString} from '@polkadot/util';
-import {ASTAR_DECIMALS, NETWORKS, SAFE_XCM_VERSION, UNIQUE_CHAIN, UNQ_DECIMALS, acalaUrl, astarUrl, expectFailedToTransact, expectUntrustedReserveLocationFail, getDevPlayground, mapToChainId, mapToChainUrl, maxWaitBlocks, moonbeamUrl, polkadexUrl, uniqueAssetId, uniqueVersionedMultilocation} from './xcm.types';
-
-
-const TRANSFER_AMOUNT = 2000000_000_000_000_000_000_000n;
-const SENDER_BUDGET = 2n * TRANSFER_AMOUNT;
-const SENDBACK_AMOUNT = TRANSFER_AMOUNT / 2n;
-const STAYED_ON_TARGET_CHAIN = TRANSFER_AMOUNT - SENDBACK_AMOUNT;
-const TARGET_CHAIN_TOKEN_TRANSFER_AMOUNT = 100_000_000_000n;
-
-let balanceUniqueTokenInit: bigint;
-let balanceUniqueTokenMiddle: bigint;
-let balanceUniqueTokenFinal: bigint;
-let unqFees: bigint;
-
-
-async function genericSendUnqTo(
- networkName: keyof typeof NETWORKS,
- randomAccount: IKeyringPair,
- randomAccountOnTargetChain = randomAccount,
-) {
- const networkUrl = mapToChainUrl(networkName);
- const targetPlayground = getDevPlayground(networkName);
- await usingPlaygrounds(async (helper) => {
- balanceUniqueTokenInit = await helper.balance.getSubstrate(randomAccount.address);
- const destination = {
- V2: {
- parents: 1,
- interior: {
- X1: {
- Parachain: mapToChainId(networkName),
- },
- },
- },
- };
-
- const beneficiary = {
- V2: {
- parents: 0,
- interior: {
- X1: (
- networkName == 'moonbeam' ?
- {
- AccountKey20: {
- network: 'Any',
- key: randomAccountOnTargetChain.address,
- },
- }
- :
- {
- AccountId32: {
- network: 'Any',
- id: randomAccountOnTargetChain.addressRaw,
- },
- }
- ),
- },
- },
- };
-
- const assets = {
- V2: [
- {
- id: {
- Concrete: {
- parents: 0,
- interior: 'Here',
- },
- },
- fun: {
- Fungible: TRANSFER_AMOUNT,
- },
- },
- ],
- };
- const feeAssetItem = 0;
-
- await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, 'Unlimited');
- const messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
- balanceUniqueTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);
-
- unqFees = balanceUniqueTokenInit - balanceUniqueTokenMiddle - TRANSFER_AMOUNT;
- console.log('[Unique -> %s] transaction fees on Unique: %s UNQ', networkName, helper.util.bigIntToDecimals(unqFees));
- expect(unqFees > 0n, 'Negative fees UNQ, looks like nothing was transferred').to.be.true;
-
- await targetPlayground(networkUrl, async (helper) => {
- /*
- Since only the parachain part of the Polkadex
- infrastructure is launched (without their
- solochain validators), processing incoming
- assets will lead to an error.
- This error indicates that the Polkadex chain
- received a message from the Unique network,
- since the hash is being checked to ensure
- it matches what was sent.
- */
- if(networkName == 'polkadex') {
- await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == messageSent.messageHash);
- } else {
- await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Success, event => event.messageHash == messageSent.messageHash);
- }
- });
-
- });
-}
-
-async function genericSendUnqBack(
- networkName: keyof typeof NETWORKS,
- sudoer: IKeyringPair,
- randomAccountOnUnq: IKeyringPair,
-) {
- const networkUrl = mapToChainUrl(networkName);
-
- const targetPlayground = getDevPlayground(networkName);
- await usingPlaygrounds(async (helper) => {
-
- const xcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(
- randomAccountOnUnq.addressRaw,
- uniqueAssetId,
- SENDBACK_AMOUNT,
- );
-
- let xcmProgramSent: any;
-
-
- await targetPlayground(networkUrl, async (helper) => {
- if('getSudo' in helper) {
- await helper.getSudo().xcm.send(sudoer, uniqueVersionedMultilocation, xcmProgram);
- xcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
- } else if('fastDemocracy' in helper) {
- const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueVersionedMultilocation, xcmProgram]);
- // Needed to bypass the call filter.
- const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);
- await helper.fastDemocracy.executeProposal(`sending ${networkName} -> Unique via XCM program`, batchCall);
- xcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
- }
- });
-
- await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Success, event => event.messageHash == xcmProgramSent.messageHash);
-
- balanceUniqueTokenFinal = await helper.balance.getSubstrate(randomAccountOnUnq.address);
-
- expect(balanceUniqueTokenFinal).to.be.equal(balanceUniqueTokenInit - unqFees - STAYED_ON_TARGET_CHAIN);
-
- });
-}
-
-async function genericSendOnlyOwnedBalance(
- networkName: keyof typeof NETWORKS,
- sudoer: IKeyringPair,
-) {
- const networkUrl = mapToChainUrl(networkName);
- const targetPlayground = getDevPlayground(networkName);
-
- const targetChainBalance = 10000n * (10n ** UNQ_DECIMALS);
-
- await usingPlaygrounds(async (helper) => {
- const targetChainSovereignAccount = helper.address.paraSiblingSovereignAccount(mapToChainId(networkName));
- await helper.getSudo().balance.setBalanceSubstrate(sudoer, targetChainSovereignAccount, targetChainBalance);
- const moreThanTargetChainHas = 2n * targetChainBalance;
-
- const targetAccount = helper.arrange.createEmptyAccount();
-
- const maliciousXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(
- targetAccount.addressRaw,
- {
- Concrete: {
- parents: 0,
- interior: 'Here',
- },
- },
- moreThanTargetChainHas,
- );
-
- let maliciousXcmProgramSent: any;
-
-
- await targetPlayground(networkUrl, async (helper) => {
- if('getSudo' in helper) {
- await helper.getSudo().xcm.send(sudoer, uniqueVersionedMultilocation, maliciousXcmProgram);
- maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
- } else if('fastDemocracy' in helper) {
- const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueVersionedMultilocation, maliciousXcmProgram]);
- // Needed to bypass the call filter.
- const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);
- await helper.fastDemocracy.executeProposal(`sending ${networkName} -> Unique via XCM program`, batchCall);
- maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
- }
- });
-
- await expectFailedToTransact(helper, maliciousXcmProgramSent);
-
- const targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);
- expect(targetAccountBalance).to.be.equal(0n);
- });
-}
-
-async function genericReserveTransferUNQfrom(netwokrName: keyof typeof NETWORKS, sudoer: IKeyringPair) {
- const networkUrl = mapToChainUrl(netwokrName);
- const targetPlayground = getDevPlayground(netwokrName);
-
- await usingPlaygrounds(async (helper) => {
- const testAmount = 10_000n * (10n ** UNQ_DECIMALS);
- const targetAccount = helper.arrange.createEmptyAccount();
-
- const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(
- targetAccount.addressRaw,
- uniqueAssetId,
- testAmount,
- );
-
- const maliciousXcmProgramHereId = helper.arrange.makeXcmProgramReserveAssetDeposited(
- targetAccount.addressRaw,
- {
- Concrete: {
- parents: 0,
- interior: 'Here',
- },
- },
- testAmount,
- );
-
- let maliciousXcmProgramFullIdSent: any;
- let maliciousXcmProgramHereIdSent: any;
- const maxWaitBlocks = 3;
-
- // Try to trick Unique using full UNQ identification
- await targetPlayground(networkUrl, async (helper) => {
- if('getSudo' in helper) {
- await helper.getSudo().xcm.send(sudoer, uniqueVersionedMultilocation, maliciousXcmProgramFullId);
- maliciousXcmProgramFullIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
- }
- // Moonbeam case
- else if('fastDemocracy' in helper) {
- const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueVersionedMultilocation, maliciousXcmProgramFullId]);
- // Needed to bypass the call filter.
- const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);
- await helper.fastDemocracy.executeProposal(`${netwokrName} try to act like a reserve location for UNQ using path asset identification`,batchCall);
-
- maliciousXcmProgramFullIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
- }
- });
-
-
- await expectUntrustedReserveLocationFail(helper, maliciousXcmProgramFullIdSent);
-
- let accountBalance = await helper.balance.getSubstrate(targetAccount.address);
- expect(accountBalance).to.be.equal(0n);
-
- // Try to trick Unique using shortened UNQ identification
- await targetPlayground(networkUrl, async (helper) => {
- if('getSudo' in helper) {
- await helper.getSudo().xcm.send(sudoer, uniqueVersionedMultilocation, maliciousXcmProgramHereId);
- maliciousXcmProgramHereIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
- }
- else if('fastDemocracy' in helper) {
- const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueVersionedMultilocation, maliciousXcmProgramHereId]);
- // Needed to bypass the call filter.
- const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);
- await helper.fastDemocracy.executeProposal(`${netwokrName} try to act like a reserve location for UNQ using "here" asset identification`, batchCall);
-
- maliciousXcmProgramHereIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
- }
- });
-
- await expectUntrustedReserveLocationFail(helper, maliciousXcmProgramHereIdSent);
+import {ASTAR_DECIMALS, SAFE_XCM_VERSION, SENDER_BUDGET, UNIQUE_CHAIN, UNQ_DECIMALS, XcmTestHelper, acalaUrl, astarUrl, moonbeamUrl, polkadexUrl, relayUrl, uniqueAssetId} from './xcm.types';
- accountBalance = await helper.balance.getSubstrate(targetAccount.address);
- expect(accountBalance).to.be.equal(0n);
- });
-}
+const testHelper = new XcmTestHelper('unique');
-async function genericRejectNativeTokensFrom(networkName: keyof typeof NETWORKS, sudoerOnTargetChain: IKeyringPair) {
- const networkUrl = mapToChainUrl(networkName);
- const targetPlayground = getDevPlayground(networkName);
- let messageSent: any;
- await usingPlaygrounds(async (helper) => {
- const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(
- helper.arrange.createEmptyAccount().addressRaw,
- {
- Concrete: {
- parents: 1,
- interior: {
- X1: {
- Parachain: mapToChainId(networkName),
- },
- },
- },
- },
- TARGET_CHAIN_TOKEN_TRANSFER_AMOUNT,
- );
- await targetPlayground(networkUrl, async (helper) => {
- if('getSudo' in helper) {
- await helper.getSudo().xcm.send(sudoerOnTargetChain, uniqueVersionedMultilocation, maliciousXcmProgramFullId);
- messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
- } else if('fastDemocracy' in helper) {
- const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueVersionedMultilocation, maliciousXcmProgramFullId]);
- // Needed to bypass the call filter.
- const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);
- await helper.fastDemocracy.executeProposal(`${networkName} sending native tokens to the Unique via fast democracy`, batchCall);
-
- messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
- }
- });
- await expectFailedToTransact(helper, messageSent);
- });
-}
describeXCM('[XCMLL] Integration test: Exchanging tokens with Acala', () => {
@@ -374,24 +71,23 @@
await usingPlaygrounds(async (helper) => {
await helper.balance.transferToSubstrate(alice, randomAccount.address, SENDER_BUDGET);
- balanceUniqueTokenInit = await helper.balance.getSubstrate(randomAccount.address);
});
});
itSub('Should connect and send UNQ to Acala', async () => {
- await genericSendUnqTo('acala', randomAccount);
+ await testHelper.sendUnqTo('acala', randomAccount);
});
itSub('Should connect to Acala and send UNQ back', async () => {
- await genericSendUnqBack('acala', alice, randomAccount);
+ await testHelper.sendUnqBack('acala', alice, randomAccount);
});
itSub('Acala can send only up to its balance', async () => {
- await genericSendOnlyOwnedBalance('acala', alice);
+ await testHelper.sendOnlyOwnedBalance('acala', alice);
});
itSub('Should not accept reserve transfer of UNQ from Acala', async () => {
- await genericReserveTransferUNQfrom('acala', alice);
+ await testHelper.rejectReserveTransferUNQfrom('acala', alice);
});
});
@@ -429,25 +125,24 @@
await usingPlaygrounds(async (helper) => {
await helper.balance.transferToSubstrate(alice, randomAccount.address, SENDER_BUDGET);
- balanceUniqueTokenInit = await helper.balance.getSubstrate(randomAccount.address);
});
});
itSub('Should connect and send UNQ to Polkadex', async () => {
- await genericSendUnqTo('polkadex', randomAccount);
+ await testHelper.sendUnqTo('polkadex', randomAccount);
});
itSub('Should connect to Polkadex and send UNQ back', async () => {
- await genericSendUnqBack('polkadex', alice, randomAccount);
+ await testHelper.sendUnqBack('polkadex', alice, randomAccount);
});
itSub('Polkadex can send only up to its balance', async () => {
- await genericSendOnlyOwnedBalance('polkadex', alice);
+ await testHelper.sendOnlyOwnedBalance('polkadex', alice);
});
itSub('Should not accept reserve transfer of UNQ from Polkadex', async () => {
- await genericReserveTransferUNQfrom('polkadex', alice);
+ await testHelper.rejectReserveTransferUNQfrom('polkadex', alice);
});
});
@@ -466,19 +161,19 @@
});
itSub('Unique rejects ACA tokens from Acala', async () => {
- await genericRejectNativeTokensFrom('acala', alice);
+ await testHelper.rejectNativeTokensFrom('acala', alice);
});
itSub('Unique rejects GLMR tokens from Moonbeam', async () => {
- await genericRejectNativeTokensFrom('moonbeam', alice);
+ await testHelper.rejectNativeTokensFrom('moonbeam', alice);
});
itSub('Unique rejects ASTR tokens from Astar', async () => {
- await genericRejectNativeTokensFrom('astar', alice);
+ await testHelper.rejectNativeTokensFrom('astar', alice);
});
itSub('Unique rejects PDX tokens from Polkadex', async () => {
- await genericRejectNativeTokensFrom('polkadex', alice);
+ await testHelper.rejectNativeTokensFrom('polkadex', alice);
});
});
@@ -569,24 +264,23 @@
await usingPlaygrounds(async (helper) => {
await helper.balance.transferToSubstrate(alice, randomAccountUnique.address, SENDER_BUDGET);
- balanceUniqueTokenInit = await helper.balance.getSubstrate(randomAccountUnique.address);
});
});
itSub('Should connect and send UNQ to Moonbeam', async () => {
- await genericSendUnqTo('moonbeam', randomAccountUnique, randomAccountMoonbeam);
+ await testHelper.sendUnqTo('moonbeam', randomAccountUnique, randomAccountMoonbeam);
});
itSub('Should connect to Moonbeam and send UNQ back', async () => {
- await genericSendUnqBack('moonbeam', alice, randomAccountUnique);
+ await testHelper.sendUnqBack('moonbeam', alice, randomAccountUnique);
});
itSub('Moonbeam can send only up to its balance', async () => {
- await genericSendOnlyOwnedBalance('moonbeam', alice);
+ await testHelper.sendOnlyOwnedBalance('moonbeam', alice);
});
itSub('Should not accept reserve transfer of UNQ from Moonbeam', async () => {
- await genericReserveTransferUNQfrom('moonbeam', alice);
+ await testHelper.rejectReserveTransferUNQfrom('moonbeam', alice);
});
});
@@ -594,12 +288,12 @@
let alice: IKeyringPair;
let randomAccount: IKeyringPair;
- const UNQ_ASSET_ID_ON_ASTAR = 1;
- const UNQ_MINIMAL_BALANCE_ON_ASTAR = 1n;
+ const UNQ_ASSET_ID_ON_ASTAR = 18_446_744_073_709_551_631n; // The value is taken from the live Astar
+ const UNQ_MINIMAL_BALANCE_ON_ASTAR = 1n; // The value is taken from the live Astar
// Unique -> Astar
const astarInitialBalance = 1n * (10n ** ASTAR_DECIMALS); // 1 ASTR, existential deposit required to actually create the account on Astar.
- const unitsPerSecond = 228_000_000_000n; // This is Phala's value. What will be ours?
+ const unitsPerSecond = 9_451_000_000_000_000_000n; // The value is taken from the live Astar
before(async () => {
await usingPlaygrounds(async (helper, privateKey) => {
@@ -615,7 +309,6 @@
await usingAstarPlaygrounds(astarUrl, async (helper) => {
if(!(await helper.callRpc('api.query.assets.asset', [UNQ_ASSET_ID_ON_ASTAR])).toJSON()) {
console.log('1. Create foreign asset and metadata');
- // TODO update metadata with values from production
await helper.assets.create(
alice,
UNQ_ASSET_ID_ON_ASTAR,
@@ -626,8 +319,8 @@
await helper.assets.setMetadata(
alice,
UNQ_ASSET_ID_ON_ASTAR,
- 'Cross chain UNQ',
- 'xcUNQ',
+ 'Unique Network',
+ 'UNQ',
Number(UNQ_DECIMALS),
);
@@ -656,18 +349,82 @@
});
itSub('Should connect and send UNQ to Astar', async () => {
- await genericSendUnqTo('astar', randomAccount);
+ await testHelper.sendUnqTo('astar', randomAccount);
});
itSub('Should connect to Astar and send UNQ back', async () => {
- await genericSendUnqBack('astar', alice, randomAccount);
+ await testHelper.sendUnqBack('astar', alice, randomAccount);
});
itSub('Astar can send only up to its balance', async () => {
- await genericSendOnlyOwnedBalance('astar', alice);
+ await testHelper.sendOnlyOwnedBalance('astar', alice);
});
itSub('Should not accept reserve transfer of UNQ from Astar', async () => {
- await genericReserveTransferUNQfrom('astar', alice);
+ await testHelper.rejectReserveTransferUNQfrom('astar', alice);
+ });
+});
+
+describeXCM('[XCMLL] Integration test: The relay can do some root ops', () => {
+ let sudoer: IKeyringPair;
+
+ before(async function () {
+ await usingRelayPlaygrounds(relayUrl, async (_, privateKey) => {
+ sudoer = await privateKey('//Alice');
+ });
+ });
+
+ // At the moment there is no reliable way
+ // to establish the correspondence between the `ExecutedDownward` event
+ // and the relay's sent message due to `SetTopic` instruction
+ // containing an unpredictable topic silently added by the relay's messages on the router level.
+ // This changes the message hash on arrival to our chain.
+ //
+ // See:
+ // * The relay's router: https://github.com/paritytech/polkadot-sdk/blob/f60318f68687e601c47de5ad5ca88e2c3f8139a7/polkadot/runtime/westend/src/xcm_config.rs#L83
+ // * The `WithUniqueTopic` helper: https://github.com/paritytech/polkadot-sdk/blob/945ebbbcf66646be13d5b1d1bc26c8b0d3296d9e/polkadot/xcm/xcm-builder/src/routing.rs#L36
+ //
+ // Because of this, we insert time gaps between tests so
+ // different `ExecutedDownward` events won't interfere with each other.
+ afterEach(async () => {
+ await usingPlaygrounds(async (helper) => {
+ await helper.wait.newBlocks(3);
+ });
+ });
+
+ itSub('The relay can set storage', async () => {
+ await testHelper.relayIsPermittedToSetStorage(sudoer, 'plain');
+ });
+
+ itSub('The relay can batch set storage', async () => {
+ await testHelper.relayIsPermittedToSetStorage(sudoer, 'batch');
+ });
+
+ itSub('The relay can batchAll set storage', async () => {
+ await testHelper.relayIsPermittedToSetStorage(sudoer, 'batchAll');
+ });
+
+ itSub('The relay can forceBatch set storage', async () => {
+ await testHelper.relayIsPermittedToSetStorage(sudoer, 'forceBatch');
+ });
+
+ itSub('[negative] The relay cannot set balance', async () => {
+ await testHelper.relayIsNotPermittedToSetBalance(sudoer, 'plain');
+ });
+
+ itSub('[negative] The relay cannot set balance via batch', async () => {
+ await testHelper.relayIsNotPermittedToSetBalance(sudoer, 'batch');
+ });
+
+ itSub('[negative] The relay cannot set balance via batchAll', async () => {
+ await testHelper.relayIsNotPermittedToSetBalance(sudoer, 'batchAll');
+ });
+
+ itSub('[negative] The relay cannot set balance via forceBatch', async () => {
+ await testHelper.relayIsNotPermittedToSetBalance(sudoer, 'forceBatch');
+ });
+
+ itSub('[negative] The relay cannot set balance via dispatchAs', async () => {
+ await testHelper.relayIsNotPermittedToSetBalance(sudoer, 'dispatchAs');
});
});
tests/src/xcm/xcm.types.tsdiffbeforeafterboth--- a/tests/src/xcm/xcm.types.ts
+++ b/tests/src/xcm/xcm.types.ts
@@ -1,4 +1,6 @@
-import {usingAcalaPlaygrounds, usingAstarPlaygrounds, usingMoonbeamPlaygrounds, usingPolkadexPlaygrounds} from '../util';
+import {IKeyringPair} from '@polkadot/types/types';
+import {hexToString} from '@polkadot/util';
+import {expect, usingAcalaPlaygrounds, usingAstarPlaygrounds, usingKaruraPlaygrounds, usingMoonbeamPlaygrounds, usingMoonriverPlaygrounds, usingPlaygrounds, usingPolkadexPlaygrounds, usingRelayPlaygrounds, usingShidenPlaygrounds} from '../util';
import {DevUniqueHelper, Event} from '../util/playgrounds/unique.dev';
import config from '../config';
@@ -9,19 +11,39 @@
export const ASTAR_CHAIN = +(process.env.RELAY_ASTAR_ID || 2006);
export const POLKADEX_CHAIN = +(process.env.RELAY_POLKADEX_ID || 2040);
+export const QUARTZ_CHAIN = +(process.env.RELAY_QUARTZ_ID || 2095);
+export const STATEMINE_CHAIN = +(process.env.RELAY_STATEMINE_ID || 1000);
+export const KARURA_CHAIN = +(process.env.RELAY_KARURA_ID || 2000);
+export const MOONRIVER_CHAIN = +(process.env.RELAY_MOONRIVER_ID || 2023);
+export const SHIDEN_CHAIN = +(process.env.RELAY_SHIDEN_ID || 2007);
+
+export const relayUrl = config.relayUrl;
+export const statemintUrl = config.statemintUrl;
+export const statemineUrl = config.statemineUrl;
+
export const acalaUrl = config.acalaUrl;
export const moonbeamUrl = config.moonbeamUrl;
export const astarUrl = config.astarUrl;
export const polkadexUrl = config.polkadexUrl;
+export const karuraUrl = config.karuraUrl;
+export const moonriverUrl = config.moonriverUrl;
+export const shidenUrl = config.shidenUrl;
+
export const SAFE_XCM_VERSION = 3;
-export const maxWaitBlocks = 6;
+export const RELAY_DECIMALS = 12;
+export const STATEMINE_DECIMALS = 12;
+export const KARURA_DECIMALS = 12;
+export const SHIDEN_DECIMALS = 18n;
+export const QTZ_DECIMALS = 18n;
export const ASTAR_DECIMALS = 18n;
export const UNQ_DECIMALS = 18n;
+export const maxWaitBlocks = 6;
+
export const uniqueMultilocation = {
parents: 1,
interior: {
@@ -47,14 +69,30 @@
&& event.outcome.isUntrustedReserveLocation);
};
+export const expectDownwardXcmNoPermission = async (helper: DevUniqueHelper) => {
+ // The correct messageHash for downward messages can't be reliably obtained
+ await helper.wait.expectEvent(maxWaitBlocks, Event.DmpQueue.ExecutedDownward, event => event.outcome.asIncomplete[1].isNoPermission);
+};
+
+export const expectDownwardXcmComplete = async (helper: DevUniqueHelper) => {
+ // The correct messageHash for downward messages can't be reliably obtained
+ await helper.wait.expectEvent(maxWaitBlocks, Event.DmpQueue.ExecutedDownward, event => event.outcome.isComplete);
+};
+
export const NETWORKS = {
acala: usingAcalaPlaygrounds,
astar: usingAstarPlaygrounds,
polkadex: usingPolkadexPlaygrounds,
moonbeam: usingMoonbeamPlaygrounds,
+ moonriver: usingMoonriverPlaygrounds,
+ karura: usingKaruraPlaygrounds,
+ shiden: usingShidenPlaygrounds,
} as const;
+type NetworkNames = keyof typeof NETWORKS;
+
+type NativeRuntime = 'opal' | 'quartz' | 'unique';
-export function mapToChainId(networkName: keyof typeof NETWORKS) {
+export function mapToChainId(networkName: keyof typeof NETWORKS): number {
switch (networkName) {
case 'acala':
return ACALA_CHAIN;
@@ -64,10 +102,16 @@
return MOONBEAM_CHAIN;
case 'polkadex':
return POLKADEX_CHAIN;
+ case 'moonriver':
+ return MOONRIVER_CHAIN;
+ case 'karura':
+ return KARURA_CHAIN;
+ case 'shiden':
+ return SHIDEN_CHAIN;
}
}
-export function mapToChainUrl(networkName: keyof typeof NETWORKS): string {
+export function mapToChainUrl(networkName: NetworkNames): string {
switch (networkName) {
case 'acala':
return acalaUrl;
@@ -77,9 +121,501 @@
return moonbeamUrl;
case 'polkadex':
return polkadexUrl;
+ case 'moonriver':
+ return moonriverUrl;
+ case 'karura':
+ return karuraUrl;
+ case 'shiden':
+ return shidenUrl;
}
}
-export function getDevPlayground<T extends keyof typeof NETWORKS>(name: T) {
+export function getDevPlayground(name: NetworkNames) {
return NETWORKS[name];
-}
\ No newline at end of file
+}
+
+export const TRANSFER_AMOUNT = 2000000_000_000_000_000_000_000n;
+export const SENDER_BUDGET = 2n * TRANSFER_AMOUNT;
+export const SENDBACK_AMOUNT = TRANSFER_AMOUNT / 2n;
+export const STAYED_ON_TARGET_CHAIN = TRANSFER_AMOUNT - SENDBACK_AMOUNT;
+export const TARGET_CHAIN_TOKEN_TRANSFER_AMOUNT = 100_000_000_000n;
+
+export class XcmTestHelper {
+ private _balanceUniqueTokenInit: bigint = 0n;
+ private _balanceUniqueTokenMiddle: bigint = 0n;
+ private _balanceUniqueTokenFinal: bigint = 0n;
+ private _unqFees: bigint = 0n;
+ private _nativeRuntime: NativeRuntime;
+
+ constructor(runtime: NativeRuntime) {
+ this._nativeRuntime = runtime;
+ }
+
+ private _getNativeId() {
+ switch (this._nativeRuntime) {
+ case 'opal':
+ // To-Do
+ return 1001;
+ case 'quartz':
+ return QUARTZ_CHAIN;
+ case 'unique':
+ return UNIQUE_CHAIN;
+ }
+ }
+
+ private _isAddress20FormatFor(network: NetworkNames) {
+ switch (network) {
+ case 'moonbeam':
+ case 'moonriver':
+ return true;
+ default:
+ return false;
+ }
+ }
+
+ private _runtimeVersionedMultilocation() {
+ return {
+ V3: {
+ parents: 1,
+ interior: {
+ X1: {
+ Parachain: this._getNativeId(),
+ },
+ },
+ },
+ };
+ }
+
+ private _uniqueChainMultilocationForRelay() {
+ return {
+ V3: {
+ parents: 0,
+ interior: {
+ X1: {Parachain: this._getNativeId()},
+ },
+ },
+ };
+ }
+
+ async sendUnqTo(
+ networkName: keyof typeof NETWORKS,
+ randomAccount: IKeyringPair,
+ randomAccountOnTargetChain = randomAccount,
+ ) {
+ const networkUrl = mapToChainUrl(networkName);
+ const targetPlayground = getDevPlayground(networkName);
+ await usingPlaygrounds(async (helper) => {
+ this._balanceUniqueTokenInit = await helper.balance.getSubstrate(randomAccount.address);
+ const destination = {
+ V2: {
+ parents: 1,
+ interior: {
+ X1: {
+ Parachain: mapToChainId(networkName),
+ },
+ },
+ },
+ };
+
+ const beneficiary = {
+ V2: {
+ parents: 0,
+ interior: {
+ X1: (
+ this._isAddress20FormatFor(networkName) ?
+ {
+ AccountKey20: {
+ network: 'Any',
+ key: randomAccountOnTargetChain.address,
+ },
+ }
+ :
+ {
+ AccountId32: {
+ network: 'Any',
+ id: randomAccountOnTargetChain.addressRaw,
+ },
+ }
+ ),
+ },
+ },
+ };
+
+ const assets = {
+ V2: [
+ {
+ id: {
+ Concrete: {
+ parents: 0,
+ interior: 'Here',
+ },
+ },
+ fun: {
+ Fungible: TRANSFER_AMOUNT,
+ },
+ },
+ ],
+ };
+ const feeAssetItem = 0;
+
+ await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, 'Unlimited');
+ const messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
+ this._balanceUniqueTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);
+
+ this._unqFees = this._balanceUniqueTokenInit - this._balanceUniqueTokenMiddle - TRANSFER_AMOUNT;
+ console.log('[%s -> %s] transaction fees: %s', this._nativeRuntime, networkName, helper.util.bigIntToDecimals(this._unqFees));
+ expect(this._unqFees > 0n, 'Negative fees, looks like nothing was transferred').to.be.true;
+
+ await targetPlayground(networkUrl, async (helper) => {
+ /*
+ Since only the parachain part of the Polkadex
+ infrastructure is launched (without their
+ solochain validators), processing incoming
+ assets will lead to an error.
+ This error indicates that the Polkadex chain
+ received a message from the Unique network,
+ since the hash is being checked to ensure
+ it matches what was sent.
+ */
+ if(networkName == 'polkadex') {
+ await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == messageSent.messageHash);
+ } else {
+ await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Success, event => event.messageHash == messageSent.messageHash);
+ }
+ });
+
+ });
+ }
+
+ async sendUnqBack(
+ networkName: keyof typeof NETWORKS,
+ sudoer: IKeyringPair,
+ randomAccountOnUnq: IKeyringPair,
+ ) {
+ const networkUrl = mapToChainUrl(networkName);
+
+ const targetPlayground = getDevPlayground(networkName);
+ await usingPlaygrounds(async (helper) => {
+
+ const xcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(
+ randomAccountOnUnq.addressRaw,
+ {
+ Concrete: {
+ parents: 1,
+ interior: {
+ X1: {Parachain: this._getNativeId()},
+ },
+ },
+ },
+ SENDBACK_AMOUNT,
+ );
+
+ let xcmProgramSent: any;
+
+
+ await targetPlayground(networkUrl, async (helper) => {
+ if('getSudo' in helper) {
+ await helper.getSudo().xcm.send(sudoer, this._runtimeVersionedMultilocation(), xcmProgram);
+ xcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
+ } else if('fastDemocracy' in helper) {
+ const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [this._runtimeVersionedMultilocation(), xcmProgram]);
+ // Needed to bypass the call filter.
+ const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);
+ await helper.fastDemocracy.executeProposal(`sending ${networkName} -> Unique via XCM program`, batchCall);
+ xcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
+ }
+ });
+
+ await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Success, event => event.messageHash == xcmProgramSent.messageHash);
+
+ this._balanceUniqueTokenFinal = await helper.balance.getSubstrate(randomAccountOnUnq.address);
+
+ expect(this._balanceUniqueTokenFinal).to.be.equal(this._balanceUniqueTokenInit - this._unqFees - STAYED_ON_TARGET_CHAIN);
+
+ });
+ }
+
+ async sendOnlyOwnedBalance(
+ networkName: keyof typeof NETWORKS,
+ sudoer: IKeyringPair,
+ ) {
+ const networkUrl = mapToChainUrl(networkName);
+ const targetPlayground = getDevPlayground(networkName);
+
+ const targetChainBalance = 10000n * (10n ** UNQ_DECIMALS);
+
+ await usingPlaygrounds(async (helper) => {
+ const targetChainSovereignAccount = helper.address.paraSiblingSovereignAccount(mapToChainId(networkName));
+ await helper.getSudo().balance.setBalanceSubstrate(sudoer, targetChainSovereignAccount, targetChainBalance);
+ const moreThanTargetChainHas = 2n * targetChainBalance;
+
+ const targetAccount = helper.arrange.createEmptyAccount();
+
+ const maliciousXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(
+ targetAccount.addressRaw,
+ {
+ Concrete: {
+ parents: 0,
+ interior: 'Here',
+ },
+ },
+ moreThanTargetChainHas,
+ );
+
+ let maliciousXcmProgramSent: any;
+
+
+ await targetPlayground(networkUrl, async (helper) => {
+ if('getSudo' in helper) {
+ await helper.getSudo().xcm.send(sudoer, this._runtimeVersionedMultilocation(), maliciousXcmProgram);
+ maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
+ } else if('fastDemocracy' in helper) {
+ const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [this._runtimeVersionedMultilocation(), maliciousXcmProgram]);
+ // Needed to bypass the call filter.
+ const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);
+ await helper.fastDemocracy.executeProposal(`sending ${networkName} -> Unique via XCM program`, batchCall);
+ maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
+ }
+ });
+
+ await expectFailedToTransact(helper, maliciousXcmProgramSent);
+
+ const targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);
+ expect(targetAccountBalance).to.be.equal(0n);
+ });
+ }
+
+ async rejectReserveTransferUNQfrom(networkName: keyof typeof NETWORKS, sudoer: IKeyringPair) {
+ const networkUrl = mapToChainUrl(networkName);
+ const targetPlayground = getDevPlayground(networkName);
+
+ await usingPlaygrounds(async (helper) => {
+ const testAmount = 10_000n * (10n ** UNQ_DECIMALS);
+ const targetAccount = helper.arrange.createEmptyAccount();
+
+ const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(
+ targetAccount.addressRaw,
+ {
+ Concrete: {
+ parents: 1,
+ interior: {
+ X1: {
+ Parachain: this._getNativeId(),
+ },
+ },
+ },
+ },
+ testAmount,
+ );
+
+ const maliciousXcmProgramHereId = helper.arrange.makeXcmProgramReserveAssetDeposited(
+ targetAccount.addressRaw,
+ {
+ Concrete: {
+ parents: 0,
+ interior: 'Here',
+ },
+ },
+ testAmount,
+ );
+
+ let maliciousXcmProgramFullIdSent: any;
+ let maliciousXcmProgramHereIdSent: any;
+ const maxWaitBlocks = 3;
+
+ // Try to trick Unique using full UNQ identification
+ await targetPlayground(networkUrl, async (helper) => {
+ if('getSudo' in helper) {
+ await helper.getSudo().xcm.send(sudoer, this._runtimeVersionedMultilocation(), maliciousXcmProgramFullId);
+ maliciousXcmProgramFullIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
+ }
+ // Moonbeam case
+ else if('fastDemocracy' in helper) {
+ const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [this._runtimeVersionedMultilocation(), maliciousXcmProgramFullId]);
+ // Needed to bypass the call filter.
+ const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);
+ await helper.fastDemocracy.executeProposal(`${networkName} try to act like a reserve location for UNQ using path asset identification`,batchCall);
+
+ maliciousXcmProgramFullIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
+ }
+ });
+
+
+ await expectUntrustedReserveLocationFail(helper, maliciousXcmProgramFullIdSent);
+
+ let accountBalance = await helper.balance.getSubstrate(targetAccount.address);
+ expect(accountBalance).to.be.equal(0n);
+
+ // Try to trick Unique using shortened UNQ identification
+ await targetPlayground(networkUrl, async (helper) => {
+ if('getSudo' in helper) {
+ await helper.getSudo().xcm.send(sudoer, this._runtimeVersionedMultilocation(), maliciousXcmProgramHereId);
+ maliciousXcmProgramHereIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
+ }
+ else if('fastDemocracy' in helper) {
+ const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [this._runtimeVersionedMultilocation(), maliciousXcmProgramHereId]);
+ // Needed to bypass the call filter.
+ const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);
+ await helper.fastDemocracy.executeProposal(`${networkName} try to act like a reserve location for UNQ using "here" asset identification`, batchCall);
+
+ maliciousXcmProgramHereIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
+ }
+ });
+
+ await expectUntrustedReserveLocationFail(helper, maliciousXcmProgramHereIdSent);
+
+ accountBalance = await helper.balance.getSubstrate(targetAccount.address);
+ expect(accountBalance).to.be.equal(0n);
+ });
+ }
+
+ async rejectNativeTokensFrom(networkName: keyof typeof NETWORKS, sudoerOnTargetChain: IKeyringPair) {
+ const networkUrl = mapToChainUrl(networkName);
+ const targetPlayground = getDevPlayground(networkName);
+ let messageSent: any;
+
+ await usingPlaygrounds(async (helper) => {
+ const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(
+ helper.arrange.createEmptyAccount().addressRaw,
+ {
+ Concrete: {
+ parents: 1,
+ interior: {
+ X1: {
+ Parachain: mapToChainId(networkName),
+ },
+ },
+ },
+ },
+ TARGET_CHAIN_TOKEN_TRANSFER_AMOUNT,
+ );
+ await targetPlayground(networkUrl, async (helper) => {
+ if('getSudo' in helper) {
+ await helper.getSudo().xcm.send(sudoerOnTargetChain, this._runtimeVersionedMultilocation(), maliciousXcmProgramFullId);
+ messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
+ } else if('fastDemocracy' in helper) {
+ const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [this._runtimeVersionedMultilocation(), maliciousXcmProgramFullId]);
+ // Needed to bypass the call filter.
+ const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);
+ await helper.fastDemocracy.executeProposal(`${networkName} sending native tokens to the Unique via fast democracy`, batchCall);
+
+ messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
+ }
+ });
+ await expectFailedToTransact(helper, messageSent);
+ });
+ }
+
+ private async _relayXcmTransactSetStorage(variant: 'plain' | 'batch' | 'batchAll' | 'forceBatch') {
+ // eslint-disable-next-line require-await
+ return await usingPlaygrounds(async (helper) => {
+ const relayForceKV = () => {
+ const random = Math.random();
+ const key = `relay-forced-key (instance: ${random})`;
+ const val = `relay-forced-value (instance: ${random})`;
+ const call = helper.constructApiCall('api.tx.system.setStorage', [[[key, val]]]).method.toHex();
+
+ return {
+ call,
+ key,
+ val,
+ };
+ };
+
+ if(variant == 'plain') {
+ const kv = relayForceKV();
+ return {
+ program: helper.arrange.makeUnpaidSudoTransactProgram({
+ weightMultiplier: 1,
+ call: kv.call,
+ }),
+ kvs: [kv],
+ };
+ } else {
+ const kv0 = relayForceKV();
+ const kv1 = relayForceKV();
+
+ const batchCall = helper.constructApiCall(`api.tx.utility.${variant}`, [[kv0.call, kv1.call]]).method.toHex();
+ return {
+ program: helper.arrange.makeUnpaidSudoTransactProgram({
+ weightMultiplier: 2,
+ call: batchCall,
+ }),
+ kvs: [kv0, kv1],
+ };
+ }
+ });
+ }
+
+ async relayIsPermittedToSetStorage(relaySudoer: IKeyringPair, variant: 'plain' | 'batch' | 'batchAll' | 'forceBatch') {
+ const {program, kvs} = await this._relayXcmTransactSetStorage(variant);
+
+ await usingRelayPlaygrounds(relayUrl, async (helper) => {
+ await helper.getSudo().executeExtrinsic(relaySudoer, 'api.tx.xcmPallet.send', [
+ this._uniqueChainMultilocationForRelay(),
+ program,
+ ]);
+ });
+
+ await usingPlaygrounds(async (helper) => {
+ await expectDownwardXcmComplete(helper);
+
+ for(const kv of kvs) {
+ const forcedValue = await helper.callRpc('api.rpc.state.getStorage', [kv.key]);
+ expect(hexToString(forcedValue.toHex())).to.be.equal(kv.val);
+ }
+ });
+ }
+
+ private async _relayXcmTransactSetBalance(variant: 'plain' | 'batch' | 'batchAll' | 'forceBatch' | 'dispatchAs') {
+ // eslint-disable-next-line require-await
+ return await usingPlaygrounds(async (helper) => {
+ const emptyAccount = helper.arrange.createEmptyAccount().address;
+
+ const forceSetBalanceCall = helper.constructApiCall('api.tx.balances.forceSetBalance', [emptyAccount, 10_000n]).method.toHex();
+
+ let call;
+
+ if(variant == 'plain') {
+ call = forceSetBalanceCall;
+
+ } else if(variant == 'dispatchAs') {
+ call = helper.constructApiCall('api.tx.utility.dispatchAs', [
+ {
+ system: 'Root',
+ },
+ forceSetBalanceCall,
+ ]).method.toHex();
+ } else {
+ call = helper.constructApiCall(`api.tx.utility.${variant}`, [[forceSetBalanceCall]]).method.toHex();
+ }
+
+ return {
+ program: helper.arrange.makeUnpaidSudoTransactProgram({
+ weightMultiplier: 1,
+ call,
+ }),
+ emptyAccount,
+ };
+ });
+ }
+
+ async relayIsNotPermittedToSetBalance(
+ relaySudoer: IKeyringPair,
+ variant: 'plain' | 'batch' | 'batchAll' | 'forceBatch' | 'dispatchAs',
+ ) {
+ const {program, emptyAccount} = await this._relayXcmTransactSetBalance(variant);
+
+ await usingRelayPlaygrounds(relayUrl, async (helper) => {
+ await helper.getSudo().executeExtrinsic(relaySudoer, 'api.tx.xcmPallet.send', [
+ this._uniqueChainMultilocationForRelay(),
+ program,
+ ]);
+ });
+
+ await usingPlaygrounds(async (helper) => {
+ await expectDownwardXcmNoPermission(helper);
+ expect(await helper.balance.getSubstrate(emptyAccount)).to.be.equal(0n);
+ });
+ }
+}
tests/src/xcm/xcmQuartz.test.tsdiffbeforeafterboth--- a/tests/src/xcm/xcmQuartz.test.ts
+++ b/tests/src/xcm/xcmQuartz.test.ts
@@ -15,30 +15,15 @@
// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
import {IKeyringPair} from '@polkadot/types/types';
-import config from '../config';
import {itSub, expect, describeXCM, usingPlaygrounds, usingKaruraPlaygrounds, usingRelayPlaygrounds, usingMoonriverPlaygrounds, usingStateminePlaygrounds, usingShidenPlaygrounds} from '../util';
import {DevUniqueHelper, Event} from '../util/playgrounds/unique.dev';
+import {STATEMINE_CHAIN, QUARTZ_CHAIN, KARURA_CHAIN, MOONRIVER_CHAIN, SHIDEN_CHAIN, STATEMINE_DECIMALS, KARURA_DECIMALS, QTZ_DECIMALS, RELAY_DECIMALS, SHIDEN_DECIMALS, karuraUrl, moonriverUrl, relayUrl, shidenUrl, statemineUrl} from './xcm.types';
+import {hexToString} from '@polkadot/util';
-const QUARTZ_CHAIN = +(process.env.RELAY_QUARTZ_ID || 2095);
-const STATEMINE_CHAIN = +(process.env.RELAY_STATEMINE_ID || 1000);
-const KARURA_CHAIN = +(process.env.RELAY_KARURA_ID || 2000);
-const MOONRIVER_CHAIN = +(process.env.RELAY_MOONRIVER_ID || 2023);
-const SHIDEN_CHAIN = +(process.env.RELAY_SHIDEN_ID || 2007);
-const STATEMINE_PALLET_INSTANCE = 50;
-const relayUrl = config.relayUrl;
-const statemineUrl = config.statemineUrl;
-const karuraUrl = config.karuraUrl;
-const moonriverUrl = config.moonriverUrl;
-const shidenUrl = config.shidenUrl;
+const STATEMINE_PALLET_INSTANCE = 50;
-const RELAY_DECIMALS = 12;
-const STATEMINE_DECIMALS = 12;
-const KARURA_DECIMALS = 12;
-const SHIDEN_DECIMALS = 18n;
-const QTZ_DECIMALS = 18n;
-
const TRANSFER_AMOUNT = 2000000000000000000000000n;
const FUNDING_AMOUNT = 3_500_000_0000_000_000n;
@@ -499,7 +484,14 @@
minimalBalance: 1000000000000000000n,
};
- await helper.getSudo().assetRegistry.registerForeignAsset(alice, destination, metadata);
+ const assets = (await (helper.callRpc('api.query.assetRegistry.assetMetadatas.entries'))).map(([_k, v]: [any, any]) =>
+ hexToString(v.toJSON()['symbol'])) as string[];
+
+ if(!assets.includes('QTZ')) {
+ await helper.getSudo().assetRegistry.registerForeignAsset(alice, destination, metadata);
+ } else {
+ console.log('QTZ token already registered on Karura assetRegistry pallet');
+ }
await helper.balance.transferToSubstrate(alice, randomAccount.address, 10000000000000n);
balanceKaruraTokenInit = await helper.balance.getSubstrate(randomAccount.address);
balanceQuartzForeignTokenInit = await helper.tokens.accounts(randomAccount.address, {ForeignAsset: 0});
@@ -985,19 +977,22 @@
const unitsPerSecond = 1n;
const numAssetsWeightHint = 0;
- const encodedProposal = helper.assetManager.makeRegisterForeignAssetProposal({
- location: quartzAssetLocation,
- metadata: quartzAssetMetadata,
- existentialDeposit,
- isSufficient,
- unitsPerSecond,
- numAssetsWeightHint,
- });
+ if((await helper.assetManager.assetTypeId(quartzAssetLocation)).toJSON()) {
+ console.log('Quartz asset already registered on Moonriver');
+ } else {
+ const encodedProposal = helper.assetManager.makeRegisterForeignAssetProposal({
+ location: quartzAssetLocation,
+ metadata: quartzAssetMetadata,
+ existentialDeposit,
+ isSufficient,
+ unitsPerSecond,
+ numAssetsWeightHint,
+ });
- console.log('Encoded proposal for registerForeignAsset & setAssetUnitsPerSecond is %s', encodedProposal);
-
- await helper.fastDemocracy.executeProposal('register QTZ foreign asset', encodedProposal);
+ console.log('Encoded proposal for registerForeignAsset & setAssetUnitsPerSecond is %s', encodedProposal);
+ await helper.fastDemocracy.executeProposal('register QTZ foreign asset', encodedProposal);
+ }
// >>> Acquire Quartz AssetId Info on Moonriver >>>
console.log('Acquire Quartz AssetId Info on Moonriver.......');
@@ -1288,12 +1283,12 @@
let alice: IKeyringPair;
let sender: IKeyringPair;
- const QTZ_ASSET_ID_ON_SHIDEN = 1;
- const QTZ_MINIMAL_BALANCE_ON_SHIDEN = 1n;
+ const QTZ_ASSET_ID_ON_SHIDEN = 18_446_744_073_709_551_633n; // The value is taken from the live Shiden
+ const QTZ_MINIMAL_BALANCE_ON_SHIDEN = 1n; // The value is taken from the live Shiden
// Quartz -> Shiden
const shidenInitialBalance = 1n * (10n ** SHIDEN_DECIMALS); // 1 SHD, existential deposit required to actually create the account on Shiden
- const unitsPerSecond = 228_000_000_000n; // This is Phala's value. What will be ours?
+ const unitsPerSecond = 500_451_000_000_000_000_000n; // The value is taken from the live Shiden
const qtzToShidenTransferred = 10n * (10n ** QTZ_DECIMALS); // 10 QTZ
const qtzToShidenArrived = 9_999_999_999_088_000_000n; // 9.999 ... QTZ, Shiden takes a commision in foreign tokens
@@ -1314,40 +1309,42 @@
});
await usingShidenPlaygrounds(shidenUrl, async (helper) => {
- console.log('1. Create foreign asset and metadata');
- // TODO update metadata with values from production
- await helper.assets.create(
- alice,
- QTZ_ASSET_ID_ON_SHIDEN,
- alice.address,
- QTZ_MINIMAL_BALANCE_ON_SHIDEN,
- );
+ if(!(await helper.callRpc('api.query.assets.asset', [QTZ_ASSET_ID_ON_SHIDEN])).toJSON()) {
+ console.log('1. Create foreign asset and metadata');
+ await helper.assets.create(
+ alice,
+ QTZ_ASSET_ID_ON_SHIDEN,
+ alice.address,
+ QTZ_MINIMAL_BALANCE_ON_SHIDEN,
+ );
- await helper.assets.setMetadata(
- alice,
- QTZ_ASSET_ID_ON_SHIDEN,
- 'Cross chain QTZ',
- 'xcQTZ',
- Number(QTZ_DECIMALS),
- );
+ await helper.assets.setMetadata(
+ alice,
+ QTZ_ASSET_ID_ON_SHIDEN,
+ 'Quartz',
+ 'QTZ',
+ Number(QTZ_DECIMALS),
+ );
- console.log('2. Register asset location on Shiden');
- const assetLocation = {
- V2: {
- parents: 1,
- interior: {
- X1: {
- Parachain: QUARTZ_CHAIN,
+ console.log('2. Register asset location on Shiden');
+ const assetLocation = {
+ V2: {
+ parents: 1,
+ interior: {
+ X1: {
+ Parachain: QUARTZ_CHAIN,
+ },
},
},
- },
- };
+ };
- await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.registerAssetLocation', [assetLocation, QTZ_ASSET_ID_ON_SHIDEN]);
+ await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.registerAssetLocation', [assetLocation, QTZ_ASSET_ID_ON_SHIDEN]);
- console.log('3. Set QTZ payment for XCM execution on Shiden');
- await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.setAssetUnitsPerSecond', [assetLocation, unitsPerSecond]);
-
+ console.log('3. Set QTZ payment for XCM execution on Shiden');
+ await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.setAssetUnitsPerSecond', [assetLocation, unitsPerSecond]);
+ } else {
+ console.log('QTZ is already registered on Shiden');
+ }
console.log('4. Transfer 1 SDN to recipient to create the account (needed due to existential balance)');
await helper.balance.transferToSubstrate(alice, sender.address, shidenInitialBalance);
});
tests/src/xcm/xcmUnique.test.tsdiffbeforeafterboth1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617import {IKeyringPair} from '@polkadot/types/types';18import config from '../config';19import {itSub, expect, describeXCM, usingPlaygrounds, usingAcalaPlaygrounds, usingRelayPlaygrounds, usingMoonbeamPlaygrounds, usingStatemintPlaygrounds, usingAstarPlaygrounds, usingPolkadexPlaygrounds} from '../util';20import {Event} from '../util/playgrounds/unique.dev';21import {hexToString, nToBigInt} from '@polkadot/util';22import {ACALA_CHAIN, ASTAR_CHAIN, MOONBEAM_CHAIN, POLKADEX_CHAIN, SAFE_XCM_VERSION, STATEMINT_CHAIN, UNIQUE_CHAIN, expectFailedToTransact, expectUntrustedReserveLocationFail, uniqueAssetId, uniqueVersionedMultilocation} from './xcm.types';232425const STATEMINT_PALLET_INSTANCE = 50;2627const relayUrl = config.relayUrl;28const statemintUrl = config.statemintUrl;29const acalaUrl = config.acalaUrl;30const moonbeamUrl = config.moonbeamUrl;31const astarUrl = config.astarUrl;32const polkadexUrl = config.polkadexUrl;3334const RELAY_DECIMALS = 12;35const STATEMINT_DECIMALS = 12;36const ACALA_DECIMALS = 12;37const ASTAR_DECIMALS = 18n;38const UNQ_DECIMALS = 18n;3940const TRANSFER_AMOUNT = 2000000000000000000000000n;4142const FUNDING_AMOUNT = 3_500_000_0000_000_000n;4344const TRANSFER_AMOUNT_RELAY = 50_000_000_000_000_000n;4546const USDT_ASSET_ID = 100;47const USDT_ASSET_METADATA_DECIMALS = 18;48const USDT_ASSET_METADATA_NAME = 'USDT';49const USDT_ASSET_METADATA_DESCRIPTION = 'USDT';50const USDT_ASSET_METADATA_MINIMAL_BALANCE = 1n;51const USDT_ASSET_AMOUNT = 10_000_000_000_000_000_000_000_000n;5253describeXCM('[XCM] Integration test: Exchanging USDT with Statemint', () => {54 let alice: IKeyringPair;55 let bob: IKeyringPair;5657 let balanceStmnBefore: bigint;58 let balanceStmnAfter: bigint;5960 let balanceUniqueBefore: bigint;61 let balanceUniqueAfter: bigint;62 let balanceUniqueFinal: bigint;6364 let balanceBobBefore: bigint;65 let balanceBobAfter: bigint;66 let balanceBobFinal: bigint;6768 let balanceBobRelayTokenBefore: bigint;69 let balanceBobRelayTokenAfter: bigint;707172 before(async () => {73 await usingPlaygrounds(async (helper, privateKey) => {74 alice = await privateKey('//Alice');75 bob = await privateKey('//Bob'); // sovereign account on Statemint funds donor7677 // Set the default version to wrap the first message to other chains.78 await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);79 });8081 await usingRelayPlaygrounds(relayUrl, async (helper) => {82 // Fund accounts on Statemint83 await helper.xcm.teleportNativeAsset(alice, STATEMINT_CHAIN, alice.addressRaw, FUNDING_AMOUNT);84 await helper.xcm.teleportNativeAsset(alice, STATEMINT_CHAIN, bob.addressRaw, FUNDING_AMOUNT);85 });8687 await usingStatemintPlaygrounds(statemintUrl, async (helper) => {88 const sovereignFundingAmount = 3_500_000_000n;8990 await helper.assets.create(91 alice,92 USDT_ASSET_ID,93 alice.address,94 USDT_ASSET_METADATA_MINIMAL_BALANCE,95 );96 await helper.assets.setMetadata(97 alice,98 USDT_ASSET_ID,99 USDT_ASSET_METADATA_NAME,100 USDT_ASSET_METADATA_DESCRIPTION,101 USDT_ASSET_METADATA_DECIMALS,102 );103 await helper.assets.mint(104 alice,105 USDT_ASSET_ID,106 alice.address,107 USDT_ASSET_AMOUNT,108 );109110 // funding parachain sovereing account on Statemint.111 // The sovereign account should be created before any action112 // (the assets pallet on Statemint check if the sovereign account exists)113 const parachainSovereingAccount = helper.address.paraSiblingSovereignAccount(UNIQUE_CHAIN);114 await helper.balance.transferToSubstrate(bob, parachainSovereingAccount, sovereignFundingAmount);115 });116117118 await usingPlaygrounds(async (helper) => {119 const location = {120 V2: {121 parents: 1,122 interior: {X3: [123 {124 Parachain: STATEMINT_CHAIN,125 },126 {127 PalletInstance: STATEMINT_PALLET_INSTANCE,128 },129 {130 GeneralIndex: USDT_ASSET_ID,131 },132 ]},133 },134 };135136 const metadata =137 {138 name: USDT_ASSET_ID,139 symbol: USDT_ASSET_METADATA_NAME,140 decimals: USDT_ASSET_METADATA_DECIMALS,141 minimalBalance: USDT_ASSET_METADATA_MINIMAL_BALANCE,142 };143 await helper.getSudo().foreignAssets.register(alice, alice.address, location, metadata);144 balanceUniqueBefore = await helper.balance.getSubstrate(alice.address);145 });146147148 // Providing the relay currency to the unique sender account149 // (fee for USDT XCM are paid in relay tokens)150 await usingRelayPlaygrounds(relayUrl, async (helper) => {151 const destination = {152 V2: {153 parents: 0,154 interior: {X1: {155 Parachain: UNIQUE_CHAIN,156 },157 },158 }};159160 const beneficiary = {161 V2: {162 parents: 0,163 interior: {X1: {164 AccountId32: {165 network: 'Any',166 id: alice.addressRaw,167 },168 }},169 },170 };171172 const assets = {173 V2: [174 {175 id: {176 Concrete: {177 parents: 0,178 interior: 'Here',179 },180 },181 fun: {182 Fungible: TRANSFER_AMOUNT_RELAY,183 },184 },185 ],186 };187188 const feeAssetItem = 0;189190 await helper.xcm.limitedReserveTransferAssets(alice, destination, beneficiary, assets, feeAssetItem, 'Unlimited');191 });192193 });194195 itSub('Should connect and send USDT from Statemint to Unique', async ({helper}) => {196 await usingStatemintPlaygrounds(statemintUrl, async (helper) => {197 const dest = {198 V2: {199 parents: 1,200 interior: {X1: {201 Parachain: UNIQUE_CHAIN,202 },203 },204 }};205206 const beneficiary = {207 V2: {208 parents: 0,209 interior: {X1: {210 AccountId32: {211 network: 'Any',212 id: alice.addressRaw,213 },214 }},215 },216 };217218 const assets = {219 V2: [220 {221 id: {222 Concrete: {223 parents: 0,224 interior: {225 X2: [226 {227 PalletInstance: STATEMINT_PALLET_INSTANCE,228 },229 {230 GeneralIndex: USDT_ASSET_ID,231 },232 ]},233 },234 },235 fun: {236 Fungible: TRANSFER_AMOUNT,237 },238 },239 ],240 };241242 const feeAssetItem = 0;243244 balanceStmnBefore = await helper.balance.getSubstrate(alice.address);245 await helper.xcm.limitedReserveTransferAssets(alice, dest, beneficiary, assets, feeAssetItem, 'Unlimited');246247 balanceStmnAfter = await helper.balance.getSubstrate(alice.address);248249 // common good parachain take commission in it native token250 console.log(251 '[Statemint -> Unique] transaction fees on Statemint: %s WND',252 helper.util.bigIntToDecimals(balanceStmnBefore - balanceStmnAfter, STATEMINT_DECIMALS),253 );254 expect(balanceStmnBefore > balanceStmnAfter).to.be.true;255256 });257258259 // ensure that asset has been delivered260 await helper.wait.newBlocks(3);261262 // expext collection id will be with id 1263 const free = await helper.ft.getBalance(1, {Substrate: alice.address});264265 balanceUniqueAfter = await helper.balance.getSubstrate(alice.address);266267 console.log(268 '[Statemint -> Unique] transaction fees on Unique: %s USDT',269 helper.util.bigIntToDecimals(TRANSFER_AMOUNT - free, USDT_ASSET_METADATA_DECIMALS),270 );271 console.log(272 '[Statemint -> Unique] transaction fees on Unique: %s UNQ',273 helper.util.bigIntToDecimals(balanceUniqueAfter - balanceUniqueBefore),274 );275 // commission has not paid in USDT token276 expect(free).to.be.equal(TRANSFER_AMOUNT);277 // ... and parachain native token278 expect(balanceUniqueAfter == balanceUniqueBefore).to.be.true;279 });280281 itSub('Should connect and send USDT from Unique to Statemint back', async ({helper}) => {282 const destination = {283 V2: {284 parents: 1,285 interior: {X2: [286 {287 Parachain: STATEMINT_CHAIN,288 },289 {290 AccountId32: {291 network: 'Any',292 id: alice.addressRaw,293 },294 },295 ]},296 },297 };298299 const relayFee = 400_000_000_000_000n;300 const currencies: [any, bigint][] = [301 [302 {303 ForeignAssetId: 0,304 },305 TRANSFER_AMOUNT,306 ],307 [308 {309 NativeAssetId: 'Parent',310 },311 relayFee,312 ],313 ];314315 const feeItem = 1;316317 await helper.xTokens.transferMulticurrencies(alice, currencies, feeItem, destination, 'Unlimited');318319 // the commission has been paid in parachain native token320 balanceUniqueFinal = await helper.balance.getSubstrate(alice.address);321 console.log('[Unique -> Statemint] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(balanceUniqueAfter - balanceUniqueFinal));322 expect(balanceUniqueAfter > balanceUniqueFinal).to.be.true;323324 await usingStatemintPlaygrounds(statemintUrl, async (helper) => {325 await helper.wait.newBlocks(3);326327 // The USDT token never paid fees. Its amount not changed from begin value.328 // Also check that xcm transfer has been succeeded329 expect((await helper.assets.account(USDT_ASSET_ID, alice.address))! == USDT_ASSET_AMOUNT).to.be.true;330 });331 });332333 itSub('Should connect and send Relay token to Unique', async ({helper}) => {334 balanceBobBefore = await helper.balance.getSubstrate(bob.address);335 balanceBobRelayTokenBefore = await helper.tokens.accounts(bob.address, {NativeAssetId: 'Parent'});336337 await usingRelayPlaygrounds(relayUrl, async (helper) => {338 const destination = {339 V2: {340 parents: 0,341 interior: {X1: {342 Parachain: UNIQUE_CHAIN,343 },344 },345 }};346347 const beneficiary = {348 V2: {349 parents: 0,350 interior: {X1: {351 AccountId32: {352 network: 'Any',353 id: bob.addressRaw,354 },355 }},356 },357 };358359 const assets = {360 V2: [361 {362 id: {363 Concrete: {364 parents: 0,365 interior: 'Here',366 },367 },368 fun: {369 Fungible: TRANSFER_AMOUNT_RELAY,370 },371 },372 ],373 };374375 const feeAssetItem = 0;376377 await helper.xcm.limitedReserveTransferAssets(bob, destination, beneficiary, assets, feeAssetItem, 'Unlimited');378 });379380 await helper.wait.newBlocks(3);381382 balanceBobAfter = await helper.balance.getSubstrate(bob.address);383 balanceBobRelayTokenAfter = await helper.tokens.accounts(bob.address, {NativeAssetId: 'Parent'});384385 const wndFeeOnUnique = balanceBobRelayTokenAfter - TRANSFER_AMOUNT_RELAY - balanceBobRelayTokenBefore;386 const wndDiffOnUnique = balanceBobRelayTokenAfter - balanceBobRelayTokenBefore;387 console.log(388 '[Relay (Westend) -> Unique] transaction fees: %s UNQ',389 helper.util.bigIntToDecimals(balanceBobAfter - balanceBobBefore),390 );391 console.log(392 '[Relay (Westend) -> Unique] transaction fees: %s WND',393 helper.util.bigIntToDecimals(wndFeeOnUnique, STATEMINT_DECIMALS),394 );395 console.log('[Relay (Westend) -> Unique] actually delivered: %s WND', wndDiffOnUnique);396 expect(wndFeeOnUnique == 0n, 'No incoming WND fees should be taken').to.be.true;397 expect(balanceBobBefore == balanceBobAfter, 'No incoming UNQ fees should be taken').to.be.true;398 });399400 itSub('Should connect and send Relay token back', async ({helper}) => {401 let relayTokenBalanceBefore: bigint;402 let relayTokenBalanceAfter: bigint;403 await usingRelayPlaygrounds(relayUrl, async (helper) => {404 relayTokenBalanceBefore = await helper.balance.getSubstrate(bob.address);405 });406407 const destination = {408 V2: {409 parents: 1,410 interior: {411 X1:{412 AccountId32: {413 network: 'Any',414 id: bob.addressRaw,415 },416 },417 },418 },419 };420421 const currencies: any = [422 [423 {424 NativeAssetId: 'Parent',425 },426 TRANSFER_AMOUNT_RELAY,427 ],428 ];429430 const feeItem = 0;431432 await helper.xTokens.transferMulticurrencies(bob, currencies, feeItem, destination, 'Unlimited');433434 balanceBobFinal = await helper.balance.getSubstrate(bob.address);435 console.log('[Unique -> Relay (Westend)] transaction fees: %s UNQ', helper.util.bigIntToDecimals(balanceBobAfter - balanceBobFinal));436437 await usingRelayPlaygrounds(relayUrl, async (helper) => {438 await helper.wait.newBlocks(10);439 relayTokenBalanceAfter = await helper.balance.getSubstrate(bob.address);440441 const diff = relayTokenBalanceAfter - relayTokenBalanceBefore;442 console.log('[Unique -> Relay (Westend)] actually delivered: %s WND', helper.util.bigIntToDecimals(diff, RELAY_DECIMALS));443 expect(diff > 0, 'Relay tokens was not delivered back').to.be.true;444 });445 });446});447448describeXCM('[XCM] Integration test: Exchanging tokens with Acala', () => {449 let alice: IKeyringPair;450 let randomAccount: IKeyringPair;451452 let balanceUniqueTokenInit: bigint;453 let balanceUniqueTokenMiddle: bigint;454 let balanceUniqueTokenFinal: bigint;455 let balanceAcalaTokenInit: bigint;456 let balanceAcalaTokenMiddle: bigint;457 let balanceAcalaTokenFinal: bigint;458 let balanceUniqueForeignTokenInit: bigint;459 let balanceUniqueForeignTokenMiddle: bigint;460 let balanceUniqueForeignTokenFinal: bigint;461462 // computed by a test transfer from prod Unique to prod Acala.463 // 2 UNQ sent https://unique.subscan.io/xcm_message/polkadot-bad0b68847e2398af25d482e9ee6f9c1f9ec2a48464 // 1.898970000000000000 UNQ received (you can check Acala's chain state in the corresponding block)465 const expectedAcalaIncomeFee = 2000000000000000000n - 1898970000000000000n;466 const acalaEps = 8n * 10n ** 16n;467468 let acalaBackwardTransferAmount: bigint;469470 before(async () => {471 await usingPlaygrounds(async (helper, privateKey) => {472 alice = await privateKey('//Alice');473 [randomAccount] = await helper.arrange.createAccounts([0n], alice);474475 // Set the default version to wrap the first message to other chains.476 await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);477 });478479 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {480 const destination = {481 V2: {482 parents: 1,483 interior: {484 X1: {485 Parachain: UNIQUE_CHAIN,486 },487 },488 },489 };490491 const metadata = {492 name: 'Unique Network',493 symbol: 'UNQ',494 decimals: 18,495 minimalBalance: 1250000000000000000n,496 };497 const assets = (await (helper.callRpc('api.query.assetRegistry.assetMetadatas.entries'))).map(([_k, v] : [any, any]) =>498 hexToString(v.toJSON()['symbol'])) as string[];499500 if(!assets.includes('UNQ')) {501 await helper.getSudo().assetRegistry.registerForeignAsset(alice, destination, metadata);502 } else {503 console.log('UNQ token already registered on Acala assetRegistry pallet');504 }505 await helper.balance.transferToSubstrate(alice, randomAccount.address, 10000000000000n);506 balanceAcalaTokenInit = await helper.balance.getSubstrate(randomAccount.address);507 balanceUniqueForeignTokenInit = await helper.tokens.accounts(randomAccount.address, {ForeignAsset: 0});508 });509510 await usingPlaygrounds(async (helper) => {511 await helper.balance.transferToSubstrate(alice, randomAccount.address, 10n * TRANSFER_AMOUNT);512 balanceUniqueTokenInit = await helper.balance.getSubstrate(randomAccount.address);513 });514 });515516 itSub('Should connect and send UNQ to Acala', async ({helper}) => {517518 const destination = {519 V2: {520 parents: 1,521 interior: {522 X1: {523 Parachain: ACALA_CHAIN,524 },525 },526 },527 };528529 const beneficiary = {530 V2: {531 parents: 0,532 interior: {533 X1: {534 AccountId32: {535 network: 'Any',536 id: randomAccount.addressRaw,537 },538 },539 },540 },541 };542543 const assets = {544 V2: [545 {546 id: {547 Concrete: {548 parents: 0,549 interior: 'Here',550 },551 },552 fun: {553 Fungible: TRANSFER_AMOUNT,554 },555 },556 ],557 };558559 const feeAssetItem = 0;560561 await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, 'Unlimited');562 balanceUniqueTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);563564 const unqFees = balanceUniqueTokenInit - balanceUniqueTokenMiddle - TRANSFER_AMOUNT;565 console.log('[Unique -> Acala] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));566 expect(unqFees > 0n, 'Negative fees UNQ, looks like nothing was transferred').to.be.true;567568 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {569 await helper.wait.newBlocks(3);570571 balanceUniqueForeignTokenMiddle = await helper.tokens.accounts(randomAccount.address, {ForeignAsset: 0});572 balanceAcalaTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);573574 const acaFees = balanceAcalaTokenInit - balanceAcalaTokenMiddle;575 const unqIncomeTransfer = balanceUniqueForeignTokenMiddle - balanceUniqueForeignTokenInit;576 acalaBackwardTransferAmount = unqIncomeTransfer;577578 const acaUnqFees = TRANSFER_AMOUNT - unqIncomeTransfer;579580 console.log(581 '[Unique -> Acala] transaction fees on Acala: %s ACA',582 helper.util.bigIntToDecimals(acaFees, ACALA_DECIMALS),583 );584 console.log(585 '[Unique -> Acala] transaction fees on Acala: %s UNQ',586 helper.util.bigIntToDecimals(acaUnqFees),587 );588 console.log('[Unique -> Acala] income %s UNQ', helper.util.bigIntToDecimals(unqIncomeTransfer));589 expect(acaFees == 0n).to.be.true;590591 const bigintAbs = (n: bigint) => (n < 0n) ? -n : n;592593 expect(594 bigintAbs(acaUnqFees - expectedAcalaIncomeFee) < acalaEps,595 'Acala took different income fee, check the Acala foreign asset config',596 ).to.be.true;597 });598 });599600 itSub('Should connect to Acala and send UNQ back', async ({helper}) => {601 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {602 const destination = {603 V2: {604 parents: 1,605 interior: {606 X2: [607 {Parachain: UNIQUE_CHAIN},608 {609 AccountId32: {610 network: 'Any',611 id: randomAccount.addressRaw,612 },613 },614 ],615 },616 },617 };618619 const id = {620 ForeignAsset: 0,621 };622623 await helper.xTokens.transfer(randomAccount, id, acalaBackwardTransferAmount, destination, 'Unlimited');624 balanceAcalaTokenFinal = await helper.balance.getSubstrate(randomAccount.address);625 balanceUniqueForeignTokenFinal = await helper.tokens.accounts(randomAccount.address, id);626627 const acaFees = balanceAcalaTokenMiddle - balanceAcalaTokenFinal;628 const unqOutcomeTransfer = balanceUniqueForeignTokenMiddle - balanceUniqueForeignTokenFinal;629630 console.log(631 '[Acala -> Unique] transaction fees on Acala: %s ACA',632 helper.util.bigIntToDecimals(acaFees, ACALA_DECIMALS),633 );634 console.log('[Acala -> Unique] outcome %s UNQ', helper.util.bigIntToDecimals(unqOutcomeTransfer));635636 expect(acaFees > 0, 'Negative fees ACA, looks like nothing was transferred').to.be.true;637 expect(unqOutcomeTransfer == acalaBackwardTransferAmount).to.be.true;638 });639640 await helper.wait.newBlocks(3);641642 balanceUniqueTokenFinal = await helper.balance.getSubstrate(randomAccount.address);643 const actuallyDelivered = balanceUniqueTokenFinal - balanceUniqueTokenMiddle;644 expect(actuallyDelivered > 0).to.be.true;645646 console.log('[Acala -> Unique] actually delivered %s UNQ', helper.util.bigIntToDecimals(actuallyDelivered));647648 const unqFees = acalaBackwardTransferAmount - actuallyDelivered;649 console.log('[Acala -> Unique] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));650 expect(unqFees == 0n).to.be.true;651 });652653 itSub('Acala can send only up to its balance', async ({helper}) => {654 // set Acala's sovereign account's balance655 const acalaBalance = 10000n * (10n ** UNQ_DECIMALS);656 const acalaSovereignAccount = helper.address.paraSiblingSovereignAccount(ACALA_CHAIN);657 await helper.getSudo().balance.setBalanceSubstrate(alice, acalaSovereignAccount, acalaBalance);658659 const moreThanAcalaHas = acalaBalance * 2n;660661 let targetAccountBalance = 0n;662 const [targetAccount] = await helper.arrange.createAccounts([targetAccountBalance], alice);663664 const maliciousXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(665 targetAccount.addressRaw,666 {667 Concrete: {668 parents: 0,669 interior: 'Here',670 },671 },672 moreThanAcalaHas,673 );674675 let maliciousXcmProgramSent: any;676 const maxWaitBlocks = 3;677678 // Try to trick Unique679 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {680 await helper.getSudo().xcm.send(alice, uniqueVersionedMultilocation, maliciousXcmProgram);681682 maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);683 });684685 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramSent.messageHash686 && event.outcome.isFailedToTransactAsset);687688 targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);689 expect(targetAccountBalance).to.be.equal(0n);690691 // But Acala still can send the correct amount692 const validTransferAmount = acalaBalance / 2n;693 const validXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(694 targetAccount.addressRaw,695 {696 Concrete: {697 parents: 0,698 interior: 'Here',699 },700 },701 validTransferAmount,702 );703704 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {705 await helper.getSudo().xcm.send(alice, uniqueVersionedMultilocation, validXcmProgram);706 });707708 await helper.wait.newBlocks(maxWaitBlocks);709710 targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);711 expect(targetAccountBalance).to.be.equal(validTransferAmount);712 });713714 itSub('Should not accept reserve transfer of UNQ from Acala', async ({helper}) => {715 const testAmount = 10_000n * (10n ** UNQ_DECIMALS);716 const [targetAccount] = await helper.arrange.createAccounts([0n], alice);717718 const uniqueMultilocation = {719 V2: {720 parents: 1,721 interior: {722 X1: {723 Parachain: UNIQUE_CHAIN,724 },725 },726 },727 };728729 const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(730 targetAccount.addressRaw,731 uniqueAssetId,732 testAmount,733 );734735 const maliciousXcmProgramHereId = helper.arrange.makeXcmProgramReserveAssetDeposited(736 targetAccount.addressRaw,737 {738 Concrete: {739 parents: 0,740 interior: 'Here',741 },742 },743 testAmount,744 );745746 let maliciousXcmProgramFullIdSent: any;747 let maliciousXcmProgramHereIdSent: any;748 const maxWaitBlocks = 3;749750 // Try to trick Unique using full UNQ identification751 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {752 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgramFullId);753754 maliciousXcmProgramFullIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);755 });756757 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramFullIdSent.messageHash758 && event.outcome.isUntrustedReserveLocation);759760 let accountBalance = await helper.balance.getSubstrate(targetAccount.address);761 expect(accountBalance).to.be.equal(0n);762763 // Try to trick Unique using shortened UNQ identification764 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {765 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgramHereId);766767 maliciousXcmProgramHereIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);768 });769770 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramHereIdSent.messageHash771 && event.outcome.isUntrustedReserveLocation);772773 accountBalance = await helper.balance.getSubstrate(targetAccount.address);774 expect(accountBalance).to.be.equal(0n);775 });776});777778describeXCM('[XCM] Integration test: Exchanging tokens with Polkadex', () => {779 let alice: IKeyringPair;780 let randomAccount: IKeyringPair;781 let unqFees: bigint;782 let balanceUniqueTokenInit: bigint;783 let balanceUniqueTokenMiddle: bigint;784 let balanceUniqueTokenFinal: bigint;785 const maxWaitBlocks = 6;786787 before(async () => {788 await usingPlaygrounds(async (helper, privateKey) => {789 alice = await privateKey('//Alice');790 [randomAccount] = await helper.arrange.createAccounts([0n], alice);791792 // Set the default version to wrap the first message to other chains.793 await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);794 });795796 await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {797 const isWhitelisted = ((await helper.callRpc('api.query.xcmHelper.whitelistedTokens', []))798 .toJSON() as [])799 .map(nToBigInt).length != 0;800 /*801 Check whether the Unique token has been added802 to the whitelist, since an error will occur803 if it is added again. Needed for debugging804 when this test is run multiple times.805 */806 if(isWhitelisted) {807 console.log('UNQ token is already whitelisted on Polkadex');808 } else {809 await helper.getSudo().xcmHelper.whitelistToken(alice, uniqueAssetId);810 }811812 await helper.balance.transferToSubstrate(alice, randomAccount.address, 10000000000000n);813 });814815 await usingPlaygrounds(async (helper) => {816 await helper.balance.transferToSubstrate(alice, randomAccount.address, 10n * TRANSFER_AMOUNT);817 balanceUniqueTokenInit = await helper.balance.getSubstrate(randomAccount.address);818 });819 });820821 itSub('Should connect and send UNQ to Polkadex', async ({helper}) => {822823 const destination = {824 V2: {825 parents: 1,826 interior: {827 X1: {828 Parachain: POLKADEX_CHAIN,829 },830 },831 },832 };833834 const beneficiary = {835 V2: {836 parents: 0,837 interior: {838 X1: {839 AccountId32: {840 network: 'Any',841 id: randomAccount.addressRaw,842 },843 },844 },845 },846 };847848 const assets = {849 V2: [850 {851 id: {852 Concrete: {853 parents: 0,854 interior: 'Here',855 },856 },857 fun: {858 Fungible: TRANSFER_AMOUNT,859 },860 },861 ],862 };863864 const feeAssetItem = 0;865866 await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, 'Unlimited');867 const messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);868 balanceUniqueTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);869870 unqFees = balanceUniqueTokenInit - balanceUniqueTokenMiddle - TRANSFER_AMOUNT;871 console.log('[Unique -> Polkadex] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));872 expect(unqFees > 0n, 'Negative fees UNQ, looks like nothing was transferred').to.be.true;873874 await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {875 /*876 Since only the parachain part of the Polkadex877 infrastructure is launched (without their878 solochain validators), processing incoming879 assets will lead to an error.880 This error indicates that the Polkadex chain881 received a message from the Unique network,882 since the hash is being checked to ensure883 it matches what was sent.884 */885 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == messageSent.messageHash);886 });887 });888889890 itSub('Should connect to Polkadex and send UNQ back', async ({helper}) => {891892 const xcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(893 randomAccount.addressRaw,894 uniqueAssetId,895 TRANSFER_AMOUNT,896 );897898 let xcmProgramSent: any;899900901 await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {902 await helper.getSudo().xcm.send(alice, uniqueVersionedMultilocation, xcmProgram);903904 xcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);905 });906907 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Success, event => event.messageHash == xcmProgramSent.messageHash);908909 balanceUniqueTokenFinal = await helper.balance.getSubstrate(randomAccount.address);910911 expect(balanceUniqueTokenFinal).to.be.equal(balanceUniqueTokenInit - unqFees);912 });913914 itSub('Polkadex can send only up to its balance', async ({helper}) => {915 const polkadexBalance = 10000n * (10n ** UNQ_DECIMALS);916 const polkadexSovereignAccount = helper.address.paraSiblingSovereignAccount(POLKADEX_CHAIN);917 await helper.getSudo().balance.setBalanceSubstrate(alice, polkadexSovereignAccount, polkadexBalance);918 const moreThanPolkadexHas = 2n * polkadexBalance;919920 const targetAccount = helper.arrange.createEmptyAccount();921922 const maliciousXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(923 targetAccount.addressRaw,924 {925 Concrete: {926 parents: 0,927 interior: 'Here',928 },929 },930 moreThanPolkadexHas,931 );932933 let maliciousXcmProgramSent: any;934935936 await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {937 await helper.getSudo().xcm.send(alice, uniqueVersionedMultilocation, maliciousXcmProgram);938939 maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);940 });941942 await expectFailedToTransact(helper, maliciousXcmProgramSent);943944 const targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);945 expect(targetAccountBalance).to.be.equal(0n);946 });947948 itSub('Should not accept reserve transfer of UNQ from Polkadex', async ({helper}) => {949 const testAmount = 10_000n * (10n ** UNQ_DECIMALS);950 const targetAccount = helper.arrange.createEmptyAccount();951952 const uniqueMultilocation = {953 V2: {954 parents: 1,955 interior: {956 X1: {957 Parachain: UNIQUE_CHAIN,958 },959 },960 },961 };962963 const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(964 targetAccount.addressRaw,965 uniqueAssetId,966 testAmount,967 );968969 const maliciousXcmProgramHereId = helper.arrange.makeXcmProgramReserveAssetDeposited(970 targetAccount.addressRaw,971 {972 Concrete: {973 parents: 0,974 interior: 'Here',975 },976 },977 testAmount,978 );979980 let maliciousXcmProgramFullIdSent: any;981 let maliciousXcmProgramHereIdSent: any;982 const maxWaitBlocks = 3;983984 // Try to trick Unique using full UNQ identification985 await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {986 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgramFullId);987988 maliciousXcmProgramFullIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);989 });990991 await expectUntrustedReserveLocationFail(helper, maliciousXcmProgramFullIdSent);992993 let accountBalance = await helper.balance.getSubstrate(targetAccount.address);994 expect(accountBalance).to.be.equal(0n);995996 // Try to trick Unique using shortened UNQ identification997 await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {998 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgramHereId);9991000 maliciousXcmProgramHereIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1001 });10021003 await expectUntrustedReserveLocationFail(helper, maliciousXcmProgramHereIdSent);10041005 accountBalance = await helper.balance.getSubstrate(targetAccount.address);1006 expect(accountBalance).to.be.equal(0n);1007 });1008});10091010// These tests are relevant only when1011// the the corresponding foreign assets are not registered1012describeXCM('[XCM] Integration test: Unique rejects non-native tokens', () => {1013 let alice: IKeyringPair;1014 let alith: IKeyringPair;10151016 const testAmount = 100_000_000_000n;1017 let uniqueParachainJunction;1018 let uniqueAccountJunction;10191020 let uniqueParachainMultilocation: any;1021 let uniqueAccountMultilocation: any;1022 let uniqueCombinedMultilocation: any;1023 let uniqueCombinedMultilocationAcala: any; // TODO remove when Acala goes V210241025 let messageSent: any;10261027 const maxWaitBlocks = 3;10281029 before(async () => {1030 await usingPlaygrounds(async (helper, privateKey) => {1031 alice = await privateKey('//Alice');10321033 uniqueParachainJunction = {Parachain: UNIQUE_CHAIN};1034 uniqueAccountJunction = {1035 AccountId32: {1036 network: 'Any',1037 id: alice.addressRaw,1038 },1039 };10401041 uniqueParachainMultilocation = {1042 V2: {1043 parents: 1,1044 interior: {1045 X1: uniqueParachainJunction,1046 },1047 },1048 };10491050 uniqueAccountMultilocation = {1051 V2: {1052 parents: 0,1053 interior: {1054 X1: uniqueAccountJunction,1055 },1056 },1057 };10581059 uniqueCombinedMultilocation = {1060 V2: {1061 parents: 1,1062 interior: {1063 X2: [uniqueParachainJunction, uniqueAccountJunction],1064 },1065 },1066 };10671068 uniqueCombinedMultilocationAcala = {1069 V2: {1070 parents: 1,1071 interior: {1072 X2: [uniqueParachainJunction, uniqueAccountJunction],1073 },1074 },1075 };10761077 // Set the default version to wrap the first message to other chains.1078 await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);1079 });10801081 // eslint-disable-next-line require-await1082 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1083 alith = helper.account.alithAccount();1084 });1085 });1086108710881089 itSub('Unique rejects ACA tokens from Acala', async ({helper}) => {1090 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {1091 const id = {1092 Token: 'ACA',1093 };1094 const destination = uniqueCombinedMultilocationAcala;1095 await helper.xTokens.transfer(alice, id, testAmount, destination, 'Unlimited');10961097 messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1098 });10991100 await expectFailedToTransact(helper, messageSent);1101 });11021103 itSub('Unique rejects GLMR tokens from Moonbeam', async ({helper}) => {1104 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1105 const id = 'SelfReserve';1106 const destination = uniqueCombinedMultilocation;1107 await helper.xTokens.transfer(alith, id, testAmount, destination, 'Unlimited');11081109 messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1110 });11111112 await expectFailedToTransact(helper, messageSent);1113 });11141115 itSub('Unique rejects ASTR tokens from Astar', async ({helper}) => {1116 await usingAstarPlaygrounds(astarUrl, async (helper) => {1117 const destinationParachain = uniqueParachainMultilocation;1118 const beneficiary = uniqueAccountMultilocation;1119 const assets = {1120 V2: [{1121 id: {1122 Concrete: {1123 parents: 0,1124 interior: 'Here',1125 },1126 },1127 fun: {1128 Fungible: testAmount,1129 },1130 }],1131 };1132 const feeAssetItem = 0;11331134 await helper.executeExtrinsic(alice, 'api.tx.polkadotXcm.reserveWithdrawAssets', [1135 destinationParachain,1136 beneficiary,1137 assets,1138 feeAssetItem,1139 ]);11401141 messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1142 });11431144 await expectFailedToTransact(helper, messageSent);1145 });11461147 itSub('Unique rejects PDX tokens from Polkadex', async ({helper}) => {11481149 const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(1150 helper.arrange.createEmptyAccount().addressRaw,1151 {1152 Concrete: {1153 parents: 1,1154 interior: {1155 X1: {1156 Parachain: POLKADEX_CHAIN,1157 },1158 },1159 },1160 },1161 testAmount,1162 );11631164 await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {1165 await helper.getSudo().xcm.send(alice, uniqueParachainMultilocation, maliciousXcmProgramFullId);1166 messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1167 });11681169 await expectFailedToTransact(helper, messageSent);1170 });1171});11721173describeXCM('[XCM] Integration test: Exchanging UNQ with Moonbeam', () => {1174 // Unique constants1175 let alice: IKeyringPair;1176 let uniqueAssetLocation;11771178 let randomAccountUnique: IKeyringPair;1179 let randomAccountMoonbeam: IKeyringPair;11801181 // Moonbeam constants1182 let assetId: string;11831184 const uniqueAssetMetadata = {1185 name: 'xcUnique',1186 symbol: 'xcUNQ',1187 decimals: 18,1188 isFrozen: false,1189 minimalBalance: 1n,1190 };11911192 let balanceUniqueTokenInit: bigint;1193 let balanceUniqueTokenMiddle: bigint;1194 let balanceUniqueTokenFinal: bigint;1195 let balanceForeignUnqTokenInit: bigint;1196 let balanceForeignUnqTokenMiddle: bigint;1197 let balanceForeignUnqTokenFinal: bigint;1198 let balanceGlmrTokenInit: bigint;1199 let balanceGlmrTokenMiddle: bigint;1200 let balanceGlmrTokenFinal: bigint;12011202 before(async () => {1203 await usingPlaygrounds(async (helper, privateKey) => {1204 alice = await privateKey('//Alice');1205 [randomAccountUnique] = await helper.arrange.createAccounts([0n], alice);12061207 balanceForeignUnqTokenInit = 0n;12081209 // Set the default version to wrap the first message to other chains.1210 await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);1211 });12121213 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1214 const alithAccount = helper.account.alithAccount();1215 const baltatharAccount = helper.account.baltatharAccount();1216 const dorothyAccount = helper.account.dorothyAccount();12171218 randomAccountMoonbeam = helper.account.create();12191220 // >>> Sponsoring Dorothy >>>1221 console.log('Sponsoring Dorothy.......');1222 await helper.balance.transferToEthereum(alithAccount, dorothyAccount.address, 11_000_000_000_000_000_000n);1223 console.log('Sponsoring Dorothy.......DONE');1224 // <<< Sponsoring Dorothy <<<12251226 uniqueAssetLocation = {1227 XCM: {1228 parents: 1,1229 interior: {X1: {Parachain: UNIQUE_CHAIN}},1230 },1231 };1232 const existentialDeposit = 1n;1233 const isSufficient = true;1234 const unitsPerSecond = 1n;1235 const numAssetsWeightHint = 0;12361237 if((await helper.assetManager.assetTypeId(uniqueAssetLocation)).toJSON()) {1238 console.log('Unique asset is already registered on MoonBeam');1239 } else {1240 const encodedProposal = helper.assetManager.makeRegisterForeignAssetProposal({1241 location: uniqueAssetLocation,1242 metadata: uniqueAssetMetadata,1243 existentialDeposit,1244 isSufficient,1245 unitsPerSecond,1246 numAssetsWeightHint,1247 });12481249 console.log('Encoded proposal for registerForeignAsset & setAssetUnitsPerSecond is %s', encodedProposal);12501251 await helper.fastDemocracy.executeProposal('register UNQ foreign asset', encodedProposal);1252 }12531254 // >>> Acquire Unique AssetId Info on Moonbeam >>>1255 console.log('Acquire Unique AssetId Info on Moonbeam.......');12561257 assetId = (await helper.assetManager.assetTypeId(uniqueAssetLocation)).toString();1258 console.log('UNQ asset ID is %s', assetId);1259 console.log('Acquire Unique AssetId Info on Moonbeam.......DONE');1260 // >>> Acquire Unique AssetId Info on Moonbeam >>>12611262 // >>> Sponsoring random Account >>>1263 console.log('Sponsoring random Account.......');1264 await helper.balance.transferToEthereum(baltatharAccount, randomAccountMoonbeam.address, 11_000_000_000_000_000_000n);1265 console.log('Sponsoring random Account.......DONE');1266 // <<< Sponsoring random Account <<<12671268 balanceGlmrTokenInit = await helper.balance.getEthereum(randomAccountMoonbeam.address);1269 });12701271 await usingPlaygrounds(async (helper) => {1272 await helper.balance.transferToSubstrate(alice, randomAccountUnique.address, 10n * TRANSFER_AMOUNT);1273 balanceUniqueTokenInit = await helper.balance.getSubstrate(randomAccountUnique.address);1274 });1275 });12761277 itSub('Should connect and send UNQ to Moonbeam', async ({helper}) => {1278 const currencyId = {1279 NativeAssetId: 'Here',1280 };1281 const dest = {1282 V2: {1283 parents: 1,1284 interior: {1285 X2: [1286 {Parachain: MOONBEAM_CHAIN},1287 {AccountKey20: {network: 'Any', key: randomAccountMoonbeam.address}},1288 ],1289 },1290 },1291 };1292 const amount = TRANSFER_AMOUNT;12931294 await helper.xTokens.transfer(randomAccountUnique, currencyId, amount, dest, 'Unlimited');12951296 balanceUniqueTokenMiddle = await helper.balance.getSubstrate(randomAccountUnique.address);1297 expect(balanceUniqueTokenMiddle < balanceUniqueTokenInit).to.be.true;12981299 const transactionFees = balanceUniqueTokenInit - balanceUniqueTokenMiddle - TRANSFER_AMOUNT;1300 console.log('[Unique -> Moonbeam] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(transactionFees));1301 expect(transactionFees > 0, 'Negative fees UNQ, looks like nothing was transferred').to.be.true;13021303 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1304 await helper.wait.newBlocks(3);1305 balanceGlmrTokenMiddle = await helper.balance.getEthereum(randomAccountMoonbeam.address);13061307 const glmrFees = balanceGlmrTokenInit - balanceGlmrTokenMiddle;1308 console.log('[Unique -> Moonbeam] transaction fees on Moonbeam: %s GLMR', helper.util.bigIntToDecimals(glmrFees));1309 expect(glmrFees == 0n).to.be.true;13101311 balanceForeignUnqTokenMiddle = (await helper.assets.account(assetId, randomAccountMoonbeam.address))!;13121313 const unqIncomeTransfer = balanceForeignUnqTokenMiddle - balanceForeignUnqTokenInit;1314 console.log('[Unique -> Moonbeam] income %s UNQ', helper.util.bigIntToDecimals(unqIncomeTransfer));1315 expect(unqIncomeTransfer == TRANSFER_AMOUNT).to.be.true;1316 });1317 });13181319 itSub('Should connect to Moonbeam and send UNQ back', async ({helper}) => {1320 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1321 const asset = {1322 V2: {1323 id: {1324 Concrete: {1325 parents: 1,1326 interior: {1327 X1: {Parachain: UNIQUE_CHAIN},1328 },1329 },1330 },1331 fun: {1332 Fungible: TRANSFER_AMOUNT,1333 },1334 },1335 };1336 const destination = {1337 V2: {1338 parents: 1,1339 interior: {1340 X2: [1341 {Parachain: UNIQUE_CHAIN},1342 {AccountId32: {network: 'Any', id: randomAccountUnique.addressRaw}},1343 ],1344 },1345 },1346 };13471348 await helper.xTokens.transferMultiasset(randomAccountMoonbeam, asset, destination, 'Unlimited');13491350 balanceGlmrTokenFinal = await helper.balance.getEthereum(randomAccountMoonbeam.address);13511352 const glmrFees = balanceGlmrTokenMiddle - balanceGlmrTokenFinal;1353 console.log('[Moonbeam -> Unique] transaction fees on Moonbeam: %s GLMR', helper.util.bigIntToDecimals(glmrFees));1354 expect(glmrFees > 0, 'Negative fees GLMR, looks like nothing was transferred').to.be.true;13551356 const unqRandomAccountAsset = await helper.assets.account(assetId, randomAccountMoonbeam.address);13571358 expect(unqRandomAccountAsset).to.be.null;13591360 balanceForeignUnqTokenFinal = 0n;13611362 const unqOutcomeTransfer = balanceForeignUnqTokenMiddle - balanceForeignUnqTokenFinal;1363 console.log('[Unique -> Moonbeam] outcome %s UNQ', helper.util.bigIntToDecimals(unqOutcomeTransfer));1364 expect(unqOutcomeTransfer == TRANSFER_AMOUNT).to.be.true;1365 });13661367 await helper.wait.newBlocks(3);13681369 balanceUniqueTokenFinal = await helper.balance.getSubstrate(randomAccountUnique.address);1370 const actuallyDelivered = balanceUniqueTokenFinal - balanceUniqueTokenMiddle;1371 expect(actuallyDelivered > 0).to.be.true;13721373 console.log('[Moonbeam -> Unique] actually delivered %s UNQ', helper.util.bigIntToDecimals(actuallyDelivered));13741375 const unqFees = TRANSFER_AMOUNT - actuallyDelivered;1376 console.log('[Moonbeam -> Unique] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));1377 expect(unqFees == 0n).to.be.true;1378 });13791380 itSub('Moonbeam can send only up to its balance', async ({helper}) => {1381 // set Moonbeam's sovereign account's balance1382 const moonbeamBalance = 10000n * (10n ** UNQ_DECIMALS);1383 const moonbeamSovereignAccount = helper.address.paraSiblingSovereignAccount(MOONBEAM_CHAIN);1384 await helper.getSudo().balance.setBalanceSubstrate(alice, moonbeamSovereignAccount, moonbeamBalance);13851386 const moreThanMoonbeamHas = moonbeamBalance * 2n;13871388 let targetAccountBalance = 0n;1389 const [targetAccount] = await helper.arrange.createAccounts([targetAccountBalance], alice);13901391 const maliciousXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(1392 targetAccount.addressRaw,1393 {1394 Concrete: {1395 parents: 0,1396 interior: 'Here',1397 },1398 },1399 moreThanMoonbeamHas,1400 );14011402 let maliciousXcmProgramSent: any;1403 const maxWaitBlocks = 3;14041405 // Try to trick Unique1406 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1407 const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueVersionedMultilocation, maliciousXcmProgram]);14081409 // Needed to bypass the call filter.1410 const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);1411 await helper.fastDemocracy.executeProposal('try to spend more UNQ than Moonbeam has', batchCall);14121413 maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1414 });14151416 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramSent.messageHash1417 && event.outcome.isFailedToTransactAsset);14181419 targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);1420 expect(targetAccountBalance).to.be.equal(0n);14211422 // But Moonbeam still can send the correct amount1423 const validTransferAmount = moonbeamBalance / 2n;1424 const validXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(1425 targetAccount.addressRaw,1426 {1427 Concrete: {1428 parents: 0,1429 interior: 'Here',1430 },1431 },1432 validTransferAmount,1433 );14341435 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1436 const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueVersionedMultilocation, validXcmProgram]);14371438 // Needed to bypass the call filter.1439 const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);1440 await helper.fastDemocracy.executeProposal('Spend the correct amount of UNQ', batchCall);1441 });14421443 await helper.wait.newBlocks(maxWaitBlocks);14441445 targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);1446 expect(targetAccountBalance).to.be.equal(validTransferAmount);1447 });14481449 itSub('Should not accept reserve transfer of UNQ from Moonbeam', async ({helper}) => {1450 const testAmount = 10_000n * (10n ** UNQ_DECIMALS);1451 const [targetAccount] = await helper.arrange.createAccounts([0n], alice);14521453 const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(1454 targetAccount.addressRaw,1455 uniqueAssetId,1456 testAmount,1457 );14581459 const maliciousXcmProgramHereId = helper.arrange.makeXcmProgramReserveAssetDeposited(1460 targetAccount.addressRaw,1461 {1462 Concrete: {1463 parents: 0,1464 interior: 'Here',1465 },1466 },1467 testAmount,1468 );14691470 let maliciousXcmProgramFullIdSent: any;1471 let maliciousXcmProgramHereIdSent: any;1472 const maxWaitBlocks = 3;14731474 // Try to trick Unique using full UNQ identification1475 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1476 const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueVersionedMultilocation, maliciousXcmProgramFullId]);14771478 // Needed to bypass the call filter.1479 const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);1480 await helper.fastDemocracy.executeProposal('try to act like a reserve location for UNQ using path asset identification', batchCall);14811482 maliciousXcmProgramFullIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1483 });14841485 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramFullIdSent.messageHash1486 && event.outcome.isUntrustedReserveLocation);14871488 let accountBalance = await helper.balance.getSubstrate(targetAccount.address);1489 expect(accountBalance).to.be.equal(0n);14901491 // Try to trick Unique using shortened UNQ identification1492 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1493 const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueVersionedMultilocation, maliciousXcmProgramHereId]);14941495 // Needed to bypass the call filter.1496 const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);1497 await helper.fastDemocracy.executeProposal('try to act like a reserve location for UNQ using "here" asset identification', batchCall);14981499 maliciousXcmProgramHereIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1500 });15011502 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramHereIdSent.messageHash1503 && event.outcome.isUntrustedReserveLocation);15041505 accountBalance = await helper.balance.getSubstrate(targetAccount.address);1506 expect(accountBalance).to.be.equal(0n);1507 });1508});15091510describeXCM('[XCM] Integration test: Exchanging tokens with Astar', () => {1511 let alice: IKeyringPair;1512 let randomAccount: IKeyringPair;15131514 const UNQ_ASSET_ID_ON_ASTAR = 1;1515 const UNQ_MINIMAL_BALANCE_ON_ASTAR = 1n;15161517 // Unique -> Astar1518 const astarInitialBalance = 1n * (10n ** ASTAR_DECIMALS); // 1 ASTR, existential deposit required to actually create the account on Astar.1519 const unitsPerSecond = 228_000_000_000n; // This is Phala's value. What will be ours?1520 const unqToAstarTransferred = 10n * (10n ** UNQ_DECIMALS); // 10 UNQ1521 const unqToAstarArrived = 9_999_999_999_088_000_000n; // 9.999 ... UNQ, Astar takes a commision in foreign tokens15221523 // Astar -> Unique1524 const unqFromAstarTransfered = 5n * (10n ** UNQ_DECIMALS); // 5 UNQ1525 const unqOnAstarLeft = unqToAstarArrived - unqFromAstarTransfered; // 4.999_999_999_088_000_000n UNQ15261527 let balanceAfterUniqueToAstarXCM: bigint;15281529 before(async () => {1530 await usingPlaygrounds(async (helper, privateKey) => {1531 alice = await privateKey('//Alice');1532 [randomAccount] = await helper.arrange.createAccounts([100n], alice);1533 console.log('randomAccount', randomAccount.address);15341535 // Set the default version to wrap the first message to other chains.1536 await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);1537 });15381539 await usingAstarPlaygrounds(astarUrl, async (helper) => {1540 if(!(await helper.callRpc('api.query.assets.asset', [UNQ_ASSET_ID_ON_ASTAR])).toJSON()) {1541 console.log('1. Create foreign asset and metadata');1542 // TODO update metadata with values from production1543 await helper.assets.create(1544 alice,1545 UNQ_ASSET_ID_ON_ASTAR,1546 alice.address,1547 UNQ_MINIMAL_BALANCE_ON_ASTAR,1548 );15491550 await helper.assets.setMetadata(1551 alice,1552 UNQ_ASSET_ID_ON_ASTAR,1553 'Cross chain UNQ',1554 'xcUNQ',1555 Number(UNQ_DECIMALS),1556 );15571558 console.log('2. Register asset location on Astar');1559 const assetLocation = {1560 V2: {1561 parents: 1,1562 interior: {1563 X1: {1564 Parachain: UNIQUE_CHAIN,1565 },1566 },1567 },1568 };15691570 await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.registerAssetLocation', [assetLocation, UNQ_ASSET_ID_ON_ASTAR]);15711572 console.log('3. Set UNQ payment for XCM execution on Astar');1573 await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.setAssetUnitsPerSecond', [assetLocation, unitsPerSecond]);1574 } else {1575 console.log('UNQ is already registered on Astar');1576 }1577 console.log('4. Transfer 1 ASTR to recipient to create the account (needed due to existential balance)');1578 await helper.balance.transferToSubstrate(alice, randomAccount.address, astarInitialBalance);1579 });1580 });15811582 itSub('Should connect and send UNQ to Astar', async ({helper}) => {1583 const destination = {1584 V2: {1585 parents: 1,1586 interior: {1587 X1: {1588 Parachain: ASTAR_CHAIN,1589 },1590 },1591 },1592 };15931594 const beneficiary = {1595 V2: {1596 parents: 0,1597 interior: {1598 X1: {1599 AccountId32: {1600 network: 'Any',1601 id: randomAccount.addressRaw,1602 },1603 },1604 },1605 },1606 };16071608 const assets = {1609 V2: [1610 {1611 id: {1612 Concrete: {1613 parents: 0,1614 interior: 'Here',1615 },1616 },1617 fun: {1618 Fungible: unqToAstarTransferred,1619 },1620 },1621 ],1622 };16231624 // Initial balance is 100 UNQ1625 const balanceBefore = await helper.balance.getSubstrate(randomAccount.address);1626 console.log(`Initial balance is: ${balanceBefore}`);16271628 const feeAssetItem = 0;1629 await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, 'Unlimited');16301631 // Balance after reserve transfer is less than 901632 balanceAfterUniqueToAstarXCM = await helper.balance.getSubstrate(randomAccount.address);1633 console.log(`UNQ Balance on Unique after XCM is: ${balanceAfterUniqueToAstarXCM}`);1634 console.log(`Unique's UNQ commission is: ${balanceBefore-balanceAfterUniqueToAstarXCM}`);1635 expect(balanceBefore - balanceAfterUniqueToAstarXCM > 0).to.be.true;16361637 await usingAstarPlaygrounds(astarUrl, async (helper) => {1638 await helper.wait.newBlocks(3);1639 const xcUNQbalance = await helper.assets.account(UNQ_ASSET_ID_ON_ASTAR, randomAccount.address);1640 const astarBalance = await helper.balance.getSubstrate(randomAccount.address);16411642 console.log(`xcUNQ balance on Astar after XCM is: ${xcUNQbalance}`);1643 console.log(`Astar's UNQ commission is: ${unqToAstarTransferred-xcUNQbalance!}`);16441645 expect(xcUNQbalance).to.eq(unqToAstarArrived);1646 // Astar balance does not changed1647 expect(astarBalance).to.eq(astarInitialBalance);1648 });1649 });16501651 itSub('Should connect to Astar and send UNQ back', async ({helper}) => {1652 await usingAstarPlaygrounds(astarUrl, async (helper) => {1653 const destination = {1654 V2: {1655 parents: 1,1656 interior: {1657 X1: {1658 Parachain: UNIQUE_CHAIN,1659 },1660 },1661 },1662 };16631664 const beneficiary = {1665 V2: {1666 parents: 0,1667 interior: {1668 X1: {1669 AccountId32: {1670 network: 'Any',1671 id: randomAccount.addressRaw,1672 },1673 },1674 },1675 },1676 };16771678 const assets = {1679 V2: [1680 {1681 id: {1682 Concrete: {1683 parents: 1,1684 interior: {1685 X1: {1686 Parachain: UNIQUE_CHAIN,1687 },1688 },1689 },1690 },1691 fun: {1692 Fungible: unqFromAstarTransfered,1693 },1694 },1695 ],1696 };16971698 // Initial balance is 1 ASTR1699 const balanceASTRbefore = await helper.balance.getSubstrate(randomAccount.address);1700 console.log(`ASTR balance is: ${balanceASTRbefore}, it does not changed`);1701 expect(balanceASTRbefore).to.eq(astarInitialBalance);17021703 const feeAssetItem = 0;1704 // this is non-standard polkadotXcm extension for Astar only. It calls InitiateReserveWithdraw1705 await helper.executeExtrinsic(randomAccount, 'api.tx.polkadotXcm.reserveWithdrawAssets', [destination, beneficiary, assets, feeAssetItem]);17061707 const xcUNQbalance = await helper.assets.account(UNQ_ASSET_ID_ON_ASTAR, randomAccount.address);1708 const balanceAstar = await helper.balance.getSubstrate(randomAccount.address);1709 console.log(`xcUNQ balance on Astar after XCM is: ${xcUNQbalance}`);17101711 // Assert: xcUNQ balance correctly decreased1712 expect(xcUNQbalance).to.eq(unqOnAstarLeft);1713 // Assert: ASTR balance is 0.996...1714 expect(balanceAstar / (10n ** (ASTAR_DECIMALS - 3n))).to.eq(996n);1715 });17161717 await helper.wait.newBlocks(3);1718 const balanceUNQ = await helper.balance.getSubstrate(randomAccount.address);1719 console.log(`UNQ Balance on Unique after XCM is: ${balanceUNQ}`);1720 expect(balanceUNQ).to.eq(balanceAfterUniqueToAstarXCM + unqFromAstarTransfered);1721 });17221723 itSub('Astar can send only up to its balance', async ({helper}) => {1724 // set Astar's sovereign account's balance1725 const astarBalance = 10000n * (10n ** UNQ_DECIMALS);1726 const astarSovereignAccount = helper.address.paraSiblingSovereignAccount(ASTAR_CHAIN);1727 await helper.getSudo().balance.setBalanceSubstrate(alice, astarSovereignAccount, astarBalance);17281729 const moreThanAstarHas = astarBalance * 2n;17301731 let targetAccountBalance = 0n;1732 const [targetAccount] = await helper.arrange.createAccounts([targetAccountBalance], alice);17331734 const maliciousXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(1735 targetAccount.addressRaw,1736 {1737 Concrete: {1738 parents: 0,1739 interior: 'Here',1740 },1741 },1742 moreThanAstarHas,1743 );17441745 let maliciousXcmProgramSent: any;1746 const maxWaitBlocks = 3;17471748 // Try to trick Unique1749 await usingAstarPlaygrounds(astarUrl, async (helper) => {1750 await helper.getSudo().xcm.send(alice, uniqueVersionedMultilocation, maliciousXcmProgram);17511752 maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1753 });17541755 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramSent.messageHash1756 && event.outcome.isFailedToTransactAsset);17571758 targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);1759 expect(targetAccountBalance).to.be.equal(0n);17601761 // But Astar still can send the correct amount1762 const validTransferAmount = astarBalance / 2n;1763 const validXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(1764 targetAccount.addressRaw,1765 {1766 Concrete: {1767 parents: 0,1768 interior: 'Here',1769 },1770 },1771 validTransferAmount,1772 );17731774 await usingAstarPlaygrounds(astarUrl, async (helper) => {1775 await helper.getSudo().xcm.send(alice, uniqueVersionedMultilocation, validXcmProgram);1776 });17771778 await helper.wait.newBlocks(maxWaitBlocks);17791780 targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);1781 expect(targetAccountBalance).to.be.equal(validTransferAmount);1782 });17831784 itSub('Should not accept reserve transfer of UNQ from Astar', async ({helper}) => {1785 const testAmount = 10_000n * (10n ** UNQ_DECIMALS);1786 const [targetAccount] = await helper.arrange.createAccounts([0n], alice);17871788 const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(1789 targetAccount.addressRaw,1790 uniqueAssetId,1791 testAmount,1792 );17931794 const maliciousXcmProgramHereId = helper.arrange.makeXcmProgramReserveAssetDeposited(1795 targetAccount.addressRaw,1796 {1797 Concrete: {1798 parents: 0,1799 interior: 'Here',1800 },1801 },1802 testAmount,1803 );18041805 let maliciousXcmProgramFullIdSent: any;1806 let maliciousXcmProgramHereIdSent: any;1807 const maxWaitBlocks = 3;18081809 // Try to trick Unique using full UNQ identification1810 await usingAstarPlaygrounds(astarUrl, async (helper) => {1811 await helper.getSudo().xcm.send(alice, uniqueVersionedMultilocation, maliciousXcmProgramFullId);18121813 maliciousXcmProgramFullIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1814 });18151816 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramFullIdSent.messageHash1817 && event.outcome.isUntrustedReserveLocation);18181819 let accountBalance = await helper.balance.getSubstrate(targetAccount.address);1820 expect(accountBalance).to.be.equal(0n);18211822 // Try to trick Unique using shortened UNQ identification1823 await usingAstarPlaygrounds(astarUrl, async (helper) => {1824 await helper.getSudo().xcm.send(alice, uniqueVersionedMultilocation, maliciousXcmProgramHereId);18251826 maliciousXcmProgramHereIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1827 });18281829 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramHereIdSent.messageHash1830 && event.outcome.isUntrustedReserveLocation);18311832 accountBalance = await helper.balance.getSubstrate(targetAccount.address);1833 expect(accountBalance).to.be.equal(0n);1834 });1835});