`eae22fa8eb0b`

3 files changed

modifiedtests/src/xcm/lowLevelXcmUnique.test.tsdiff before after both

17import {IKeyringPair} from '@polkadot/types/types';17import {IKeyringPair} from '@polkadot/types/types';
18import config from '../config';18import config from '../config';
19import {itSub, expect, describeXCM, usingPlaygrounds, usingAcalaPlaygrounds, usingMoonbeamPlaygrounds, usingAstarPlaygrounds, usingPolkadexPlaygrounds} from '../util';19import {itSub, expect, describeXCM, usingPlaygrounds, usingAcalaPlaygrounds, usingMoonbeamPlaygrounds, usingAstarPlaygrounds, usingPolkadexPlaygrounds} from '../util';
20import {DevUniqueHelper, Event} from '../util/playgrounds/unique.dev';20import {Event} from '../util/playgrounds/unique.dev';
21import {nToBigInt} from '@polkadot/util';21import {nToBigInt} from '@polkadot/util';
22import {hexToString} from '@polkadot/util';22import {hexToString} from '@polkadot/util';
23
24const UNIQUE_CHAIN = +(process.env.RELAY_UNIQUE_ID || 2037);23import {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';
25const ACALA_CHAIN = +(process.env.RELAY_ACALA_ID || 2000);24
26const MOONBEAM_CHAIN = +(process.env.RELAY_MOONBEAM_ID || 2004);
27const ASTAR_CHAIN = +(process.env.RELAY_ASTAR_ID || 2006);
28const POLKADEX_CHAIN = +(process.env.RELAY_POLKADEX_ID || 2040);
29
30
31
32const acalaUrl = config.acalaUrl;
33const moonbeamUrl = config.moonbeamUrl;
34const astarUrl = config.astarUrl;
35const polkadexUrl = config.polkadexUrl;
36
37const ASTAR_DECIMALS = 18n;
38const UNQ_DECIMALS = 18n;
3925
40const TRANSFER_AMOUNT = 2000000_000_000_000_000_000_000n;26const TRANSFER_AMOUNT = 2000000_000_000_000_000_000_000n;
41const SENDER_BUDGET = 2n * TRANSFER_AMOUNT;27const SENDER_BUDGET = 2n * TRANSFER_AMOUNT;
42const SENDBACK_AMOUNT = TRANSFER_AMOUNT / 2n;28const SENDBACK_AMOUNT = TRANSFER_AMOUNT / 2n;
43const STAYED_ON_TARGET_CHAIN = TRANSFER_AMOUNT - SENDBACK_AMOUNT;29const STAYED_ON_TARGET_CHAIN = TRANSFER_AMOUNT - SENDBACK_AMOUNT;
44const TARGET_CHAIN_TOKEN_TRANSFER_AMOUNT = 100_000_000_000n;30const TARGET_CHAIN_TOKEN_TRANSFER_AMOUNT = 100_000_000_000n;
45
46const SAFE_XCM_VERSION = 2;
47const maxWaitBlocks = 6;
48
49const uniqueMultilocation = {
50  V2: {
51    parents: 1,
52    interior: {
53      X1: {
54        Parachain: UNIQUE_CHAIN,
55      },
56    },
57  },
58};
5931
60let balanceUniqueTokenInit: bigint;32let balanceUniqueTokenInit: bigint;
61let balanceUniqueTokenMiddle: bigint;33let balanceUniqueTokenMiddle: bigint;
62let balanceUniqueTokenFinal: bigint;34let balanceUniqueTokenFinal: bigint;
63let unqFees: bigint;35let unqFees: bigint;
64
65const expectFailedToTransact = async (helper: DevUniqueHelper, messageSent: any) => {
66  await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == messageSent.messageHash
67        && event.outcome.isFailedToTransactAsset);
68};
69const expectUntrustedReserveLocationFail = async (helper: DevUniqueHelper, messageSent: any) => {
70  await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == messageSent.messageHash
71         && event.outcome.isUntrustedReserveLocation);
72};
73
74const NETWORKS = {
75  acala: usingAcalaPlaygrounds,
76  astar: usingAstarPlaygrounds,
77  polkadex: usingPolkadexPlaygrounds,
78  moonbeam: usingMoonbeamPlaygrounds,
79} as const;
80
81function mapToChainId(networkName: keyof typeof NETWORKS) {
82  switch (networkName) {
83    case 'acala':
84      return ACALA_CHAIN;
85    case 'astar':
86      return ASTAR_CHAIN;
87    case 'moonbeam':
88      return MOONBEAM_CHAIN;
89    case 'polkadex':
90      return POLKADEX_CHAIN;
91  }
92}
93
94function mapToChainUrl(networkName: keyof typeof NETWORKS): string {
95  switch (networkName) {
96    case 'acala':
97      return acalaUrl;
98    case 'astar':
99      return astarUrl;
100    case 'moonbeam':
101      return moonbeamUrl;
102    case 'polkadex':
103      return polkadexUrl;
104  }
105}
106
107function getDevPlayground<T extends keyof typeof NETWORKS>(name: T) {
108  return NETWORKS[name];
109}
11036
11137
112async function genericSendUnqTo(38async function genericSendUnqTo(
227153
228    await targetPlayground(networkUrl, async (helper) => {154    await targetPlayground(networkUrl, async (helper) => {
229      if('getSudo' in helper) {155      if('getSudo' in helper) {
230        await helper.getSudo().xcm.send(sudoer, uniqueMultilocation, xcmProgram);156        await helper.getSudo().xcm.send(sudoer, uniqueVersionedMultilocation, xcmProgram);
231        xcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);157        xcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
232      } else if('fastDemocracy' in helper) {158      } else if('fastDemocracy' in helper) {
233        const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueMultilocation, xcmProgram]);159        const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueVersionedMultilocation, xcmProgram]);
234        // Needed to bypass the call filter.160        // Needed to bypass the call filter.
235        const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);161        const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);
236        await helper.fastDemocracy.executeProposal('sending MoonBeam -> Unique via XCM program', batchCall);162        await helper.fastDemocracy.executeProposal(`sending ${networkName} -> Unique via XCM program`, batchCall);
237        xcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);163        xcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
238      }164      }
239    });165    });
279205
280    await targetPlayground(networkUrl, async (helper) => {206    await targetPlayground(networkUrl, async (helper) => {
281      if('getSudo' in helper) {207      if('getSudo' in helper) {
282        await helper.getSudo().xcm.send(sudoer, uniqueMultilocation, maliciousXcmProgram);208        await helper.getSudo().xcm.send(sudoer, uniqueVersionedMultilocation, maliciousXcmProgram);
283        maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);209        maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
284      } else if('fastDemocracy' in helper) {210      } else if('fastDemocracy' in helper) {
285        const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueMultilocation, maliciousXcmProgram]);211        const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueVersionedMultilocation, maliciousXcmProgram]);
286        // Needed to bypass the call filter.212        // Needed to bypass the call filter.
287        const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);213        const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);
288        await helper.fastDemocracy.executeProposal('sending MoonBeam -> Unique via XCM program', batchCall);214        await helper.fastDemocracy.executeProposal(`sending ${networkName} -> Unique via XCM program`, batchCall);
289        maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);215        maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
290      }216      }
291    });217    });
338    // Try to trick Unique using full UNQ identification264    // Try to trick Unique using full UNQ identification
339    await targetPlayground(networkUrl, async (helper) => {265    await targetPlayground(networkUrl, async (helper) => {
340      if('getSudo' in helper) {266      if('getSudo' in helper) {
341        await helper.getSudo().xcm.send(sudoer, uniqueMultilocation, maliciousXcmProgramFullId);267        await helper.getSudo().xcm.send(sudoer, uniqueVersionedMultilocation, maliciousXcmProgramFullId);
342        maliciousXcmProgramFullIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);268        maliciousXcmProgramFullIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
343      }269      }
344      // Moonbeam case270      // Moonbeam case
345      else if('fastDemocracy' in helper) {271      else if('fastDemocracy' in helper) {
346        const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueMultilocation, maliciousXcmProgramFullId]);272        const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueVersionedMultilocation, maliciousXcmProgramFullId]);
347
348        // Needed to bypass the call filter.273        // Needed to bypass the call filter.
349        const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);274        const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);
350        await helper.fastDemocracy.executeProposal('try to act like a reserve location for UNQ using path asset identification', batchCall);275        await helper.fastDemocracy.executeProposal(`${netwokrName} try to act like a reserve location for UNQ using path asset identification`,batchCall);
351276
352        maliciousXcmProgramFullIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);277        maliciousXcmProgramFullIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
353      }278      }
362    // Try to trick Unique using shortened UNQ identification287    // Try to trick Unique using shortened UNQ identification
363    await targetPlayground(networkUrl, async (helper) => {288    await targetPlayground(networkUrl, async (helper) => {
364      if('getSudo' in helper) {289      if('getSudo' in helper) {
365        await helper.getSudo().xcm.send(sudoer, uniqueMultilocation, maliciousXcmProgramHereId);290        await helper.getSudo().xcm.send(sudoer, uniqueVersionedMultilocation, maliciousXcmProgramHereId);
366        maliciousXcmProgramHereIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);291        maliciousXcmProgramHereIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
367      }292      }
368      else if('fastDemocracy' in helper) {293      else if('fastDemocracy' in helper) {
369        const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueMultilocation, maliciousXcmProgramHereId]);294        const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueVersionedMultilocation, maliciousXcmProgramHereId]);
370
371        // Needed to bypass the call filter.295        // Needed to bypass the call filter.
372        const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);296        const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);
373        await helper.fastDemocracy.executeProposal('try to act like a reserve location for UNQ using "here" asset identification', batchCall);297        await helper.fastDemocracy.executeProposal(`${netwokrName} try to act like a reserve location for UNQ using "here" asset identification`, batchCall);
374298
375        maliciousXcmProgramHereIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);299        maliciousXcmProgramHereIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
376      }300      }
405    );329    );
406    await targetPlayground(networkUrl, async (helper) => {330    await targetPlayground(networkUrl, async (helper) => {
407      if('getSudo' in helper) {331      if('getSudo' in helper) {
408        await helper.getSudo().xcm.send(sudoerOnTargetChain, uniqueMultilocation, maliciousXcmProgramFullId);332        await helper.getSudo().xcm.send(sudoerOnTargetChain, uniqueVersionedMultilocation, maliciousXcmProgramFullId);
409        messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);333        messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
410      } else if('fastDemocracy' in helper) {334      } else if('fastDemocracy' in helper) {
411        const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueMultilocation, maliciousXcmProgramFullId]);335        const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueVersionedMultilocation, maliciousXcmProgramFullId]);
412
413        // Needed to bypass the call filter.336        // Needed to bypass the call filter.
414        const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);337        const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);
415        await helper.fastDemocracy.executeProposal('sending native tokens to the Unique via fast democracy', batchCall);338        await helper.fastDemocracy.executeProposal(`${netwokrName} sending native tokens to the Unique via fast democracy`, batchCall);
416339
417        messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);340        messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
418      }341      }
493  let alice: IKeyringPair;415  let alice: IKeyringPair;
494  let randomAccount: IKeyringPair;416  let randomAccount: IKeyringPair;
495
496  const uniqueAssetId = {
497    Concrete: {
498      parents: 1,
499      interior: {
500        X1: {
501          Parachain: UNIQUE_CHAIN,
502        },
503      },
504    },
505  };
506417
507  before(async () => {418  before(async () => {
508    await usingPlaygrounds(async (helper, privateKey) => {419    await usingPlaygrounds(async (helper, privateKey) => {
523      if it is added again. Needed for debugging434      if it is added again. Needed for debugging
524      when this test is run multiple times.435      when this test is run multiple times.
525      */436      */
526      if(!isWhitelisted) {437      if(isWhitelisted) {
438        console.log('UNQ token is already whitelisted on Polkadex');
439      } else {
527        await helper.getSudo().xcmHelper.whitelistToken(alice, uniqueAssetId);440        await helper.getSudo().xcmHelper.whitelistToken(alice, uniqueAssetId);
528      }441      }
529442
639      const numAssetsWeightHint = 0;552      const numAssetsWeightHint = 0;
640553
641      if((await helper.assetManager.assetTypeId(uniqueAssetLocation)).toJSON()) {554      if((await helper.assetManager.assetTypeId(uniqueAssetLocation)).toJSON()) {
642        console.log('Unique asset already registered');555        console.log('Unique asset already registered on Moonbeam');
643      } else {556      } else {
644        const encodedProposal = helper.assetManager.makeRegisterForeignAssetProposal({557        const encodedProposal = helper.assetManager.makeRegisterForeignAssetProposal({
645          location: uniqueAssetLocation,558          location: uniqueAssetLocation,
750663
751        console.log('3. Set UNQ payment for XCM execution on Astar');664        console.log('3. Set UNQ payment for XCM execution on Astar');
752        await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.setAssetUnitsPerSecond', [assetLocation, unitsPerSecond]);665        await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.setAssetUnitsPerSecond', [assetLocation, unitsPerSecond]);
753      }666      } else {
667        console.log('UNQ is already registered on Astar');
668      }
754      console.log('4. Transfer 1 ASTR to recipient to create the account (needed due to existential balance)');669      console.log('4. Transfer 1 ASTR to recipient to create the account (needed due to existential balance)');
755      await helper.balance.transferToSubstrate(alice, randomAccount.address, astarInitialBalance);670      await helper.balance.transferToSubstrate(alice, randomAccount.address, astarInitialBalance);
756    });671    });

addedtests/src/xcm/xcm.types.tsdiff before after both

no changes

modifiedtests/src/xcm/xcmUnique.test.tsdiff before after both

17import {IKeyringPair} from '@polkadot/types/types';17import {IKeyringPair} from '@polkadot/types/types';
18import config from '../config';18import config from '../config';
19import {itSub, expect, describeXCM, usingPlaygrounds, usingAcalaPlaygrounds, usingRelayPlaygrounds, usingMoonbeamPlaygrounds, usingStatemintPlaygrounds, usingAstarPlaygrounds, usingPolkadexPlaygrounds} from '../util';19import {itSub, expect, describeXCM, usingPlaygrounds, usingAcalaPlaygrounds, usingRelayPlaygrounds, usingMoonbeamPlaygrounds, usingStatemintPlaygrounds, usingAstarPlaygrounds, usingPolkadexPlaygrounds} from '../util';
20import {DevUniqueHelper, Event} from '../util/playgrounds/unique.dev';20import {Event} from '../util/playgrounds/unique.dev';
21import {hexToString, nToBigInt} from '@polkadot/util';21import {hexToString, nToBigInt} from '@polkadot/util';
22
23const UNIQUE_CHAIN = +(process.env.RELAY_UNIQUE_ID || 2037);22import {ACALA_CHAIN, ASTAR_CHAIN, MOONBEAM_CHAIN, POLKADEX_CHAIN, SAFE_XCM_VERSION, STATEMINT_CHAIN, UNIQUE_CHAIN, expectFailedToTransact, expectUntrustedReserveLocationFail, uniqueAssetId, uniqueVersionedMultilocation} from './xcm.types';
24const STATEMINT_CHAIN = +(process.env.RELAY_STATEMINT_ID || 1000);23
25const ACALA_CHAIN = +(process.env.RELAY_ACALA_ID || 2000);
26const MOONBEAM_CHAIN = +(process.env.RELAY_MOONBEAM_ID || 2004);
27const ASTAR_CHAIN = +(process.env.RELAY_ASTAR_ID || 2006);
28const POLKADEX_CHAIN = +(process.env.RELAY_POLKADEX_ID || 2040);
2924
30const STATEMINT_PALLET_INSTANCE = 50;25const STATEMINT_PALLET_INSTANCE = 50;
3126
55const USDT_ASSET_METADATA_MINIMAL_BALANCE = 1n;50const USDT_ASSET_METADATA_MINIMAL_BALANCE = 1n;
56const USDT_ASSET_AMOUNT = 10_000_000_000_000_000_000_000_000n;51const USDT_ASSET_AMOUNT = 10_000_000_000_000_000_000_000_000n;
5752
58const SAFE_XCM_VERSION = 2;
59const maxWaitBlocks = 6;
60
61const uniqueMultilocation = {
62  V2: {
63    parents: 1,
64    interior: {
65      X1: {
66        Parachain: UNIQUE_CHAIN,
67      },
68    },
69  },
70};
71
72const expectFailedToTransact = async (helper: DevUniqueHelper, messageSent: any) => {
73  await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == messageSent.messageHash
74        && event.outcome.isFailedToTransactAsset);
75};
76const expectUntrustedReserveLocationFail = async (helper: DevUniqueHelper, messageSent: any) => {
77  await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == messageSent.messageHash
78         && event.outcome.isUntrustedReserveLocation);
79};
80describeXCM('[XCM] Integration test: Exchanging USDT with Statemint', () => {53describeXCM('[XCM] Integration test: Exchanging USDT with Statemint', () => {
81  let alice: IKeyringPair;54  let alice: IKeyringPair;
82  let bob: IKeyringPair;55  let bob: IKeyringPair;
704677
705    // Try to trick Unique678    // Try to trick Unique
706    await usingAcalaPlaygrounds(acalaUrl, async (helper) => {679    await usingAcalaPlaygrounds(acalaUrl, async (helper) => {
707      await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgram);680      await helper.getSudo().xcm.send(alice, uniqueVersionedMultilocation, maliciousXcmProgram);
708681
709      maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);682      maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
710    });683    });
729    );702    );
730703
731    await usingAcalaPlaygrounds(acalaUrl, async (helper) => {704    await usingAcalaPlaygrounds(acalaUrl, async (helper) => {
732      await helper.getSudo().xcm.send(alice, uniqueMultilocation, validXcmProgram);705      await helper.getSudo().xcm.send(alice, uniqueVersionedMultilocation, validXcmProgram);
733    });706    });
734707
735    await helper.wait.newBlocks(maxWaitBlocks);708    await helper.wait.newBlocks(maxWaitBlocks);
820  let balanceUniqueTokenFinal: bigint;793  let balanceUniqueTokenFinal: bigint;
821  const maxWaitBlocks = 6;794  const maxWaitBlocks = 6;
822
823  const uniqueAssetId = {
824    Concrete: {
825      parents: 1,
826      interior: {
827        X1: {
828          Parachain: UNIQUE_CHAIN,
829        },
830      },
831    },
832  };
833795
834  before(async () => {796  before(async () => {
835    await usingPlaygrounds(async (helper, privateKey) => {797    await usingPlaygrounds(async (helper, privateKey) => {
850      if it is added again. Needed for debugging812      if it is added again. Needed for debugging
851      when this test is run multiple times.813      when this test is run multiple times.
852      */814      */
853      if(!isWhitelisted) {815      if(isWhitelisted) {
816        console.log('UNQ token is already whitelisted on Polkadex');
817      } else {
854        await helper.getSudo().xcmHelper.whitelistToken(alice, uniqueAssetId);818        await helper.getSudo().xcmHelper.whitelistToken(alice, uniqueAssetId);
855      }819      }
856820
951915
952916
953    await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {917    await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {
954      await helper.getSudo().xcm.send(alice, uniqueMultilocation, xcmProgram);918      await helper.getSudo().xcm.send(alice, uniqueVersionedMultilocation, xcmProgram);
955919
956      xcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);920      xcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
957    });921    });
986950
987951
988    await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {952    await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {
989      await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgram);953      await helper.getSudo().xcm.send(alice, uniqueVersionedMultilocation, maliciousXcmProgram);
990954
991      maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);955      maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
992    });956    });
14651429
1466    // Try to trick Unique1430    // Try to trick Unique
1467    await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1431    await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {
1468      const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueMultilocation, maliciousXcmProgram]);1432      const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueVersionedMultilocation, maliciousXcmProgram]);
14691433
1470      // Needed to bypass the call filter.1434      // Needed to bypass the call filter.
1471      const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);1435      const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);
1494    );1458    );
14951459
1496    await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1460    await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {
1497      const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueMultilocation, validXcmProgram]);1461      const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueVersionedMultilocation, validXcmProgram]);
14981462
1499      // Needed to bypass the call filter.1463      // Needed to bypass the call filter.
1500      const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);1464      const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);
15431507
1544    // Try to trick Unique using full UNQ identification1508    // Try to trick Unique using full UNQ identification
1545    await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1509    await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {
1546      const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueMultilocation, maliciousXcmProgramFullId]);1510      const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueVersionedMultilocation, maliciousXcmProgramFullId]);
15471511
1548      // Needed to bypass the call filter.1512      // Needed to bypass the call filter.
1549      const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);1513      const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);
15601524
1561    // Try to trick Unique using shortened UNQ identification1525    // Try to trick Unique using shortened UNQ identification
1562    await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1526    await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {
1563      const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueMultilocation, maliciousXcmProgramHereId]);1527      const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueVersionedMultilocation, maliciousXcmProgramHereId]);
15641528
1565      // Needed to bypass the call filter.1529      // Needed to bypass the call filter.
1566      const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);1530      const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);
16411605
1642        console.log('3. Set UNQ payment for XCM execution on Astar');1606        console.log('3. Set UNQ payment for XCM execution on Astar');
1643        await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.setAssetUnitsPerSecond', [assetLocation, unitsPerSecond]);1607        await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.setAssetUnitsPerSecond', [assetLocation, unitsPerSecond]);
1644      }1608      } else {
1609        console.log('UNQ is already registered on Astar');
1610      }
1645      console.log('4. Transfer 1 ASTR to recipient to create the account (needed due to existential balance)');1611      console.log('4. Transfer 1 ASTR to recipient to create the account (needed due to existential balance)');
1646      await helper.balance.transferToSubstrate(alice, randomAccount.address, astarInitialBalance);1612      await helper.balance.transferToSubstrate(alice, randomAccount.address, astarInitialBalance);
1647    });1613    });
18151781
1816    // Try to trick Unique1782    // Try to trick Unique
1817    await usingAstarPlaygrounds(astarUrl, async (helper) => {1783    await usingAstarPlaygrounds(astarUrl, async (helper) => {
1818      await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgram);1784      await helper.getSudo().xcm.send(alice, uniqueVersionedMultilocation, maliciousXcmProgram);
18191785
1820      maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1786      maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
1821    });1787    });
1840    );1806    );
18411807
1842    await usingAstarPlaygrounds(astarUrl, async (helper) => {1808    await usingAstarPlaygrounds(astarUrl, async (helper) => {
1843      await helper.getSudo().xcm.send(alice, uniqueMultilocation, validXcmProgram);1809      await helper.getSudo().xcm.send(alice, uniqueVersionedMultilocation, validXcmProgram);
1844    });1810    });
18451811
1846    await helper.wait.newBlocks(maxWaitBlocks);1812    await helper.wait.newBlocks(maxWaitBlocks);
18851851
1886    // Try to trick Unique using full UNQ identification1852    // Try to trick Unique using full UNQ identification
1887    await usingAstarPlaygrounds(astarUrl, async (helper) => {1853    await usingAstarPlaygrounds(astarUrl, async (helper) => {
1888      await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgramFullId);1854      await helper.getSudo().xcm.send(alice, uniqueVersionedMultilocation, maliciousXcmProgramFullId);
18891855
1890      maliciousXcmProgramFullIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1856      maliciousXcmProgramFullIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
1891    });1857    });
18981864
1899    // Try to trick Unique using shortened UNQ identification1865    // Try to trick Unique using shortened UNQ identification
1900    await usingAstarPlaygrounds(astarUrl, async (helper) => {1866    await usingAstarPlaygrounds(astarUrl, async (helper) => {
1901      await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgramHereId);1867      await helper.getSudo().xcm.send(alice, uniqueVersionedMultilocation, maliciousXcmProgramHereId);
19021868
1903      maliciousXcmProgramHereIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1869      maliciousXcmProgramHereIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
1904    });1870    });